donobu 5.52.1 → 5.52.2

package/dist/esm/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/esm/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/esm/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/esm/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/dist/lib/test/testExtension.js

@@ -333,8 +333,11 @@ exports.test = test_1.test.extend({
             }
             let initialActive;
             try {
-                const status = await (0, fileUploadWorkerRegistry_1.getFileUploadAggregateStatus)();
-                initialActive = status.totalPending + status.totalInFlight;
+                // Owned count only: pending + this process's own in-flight claims.
+                // Claims orphaned by other/crashed processes are excluded — this
+                // process can neither upload nor release them, so waiting on them
+                // would wedge worker teardown until the grace timeout force-kills it.
+                initialActive = await (0, fileUploadWorkerRegistry_1.getOwnedActiveUploadCount)();
             }
             catch (err) {
                 Logger_1.appLogger.warn(`donobuFileUploadDrainGuard: failed to read upload status; ` +

package/dist/lib/test/utils/donobuTestStack.js

@@ -20,7 +20,7 @@ function getEnvSnapshot() {
 }
 async function getOrCreateDonobuStack() {
     if (!donobuStack) {
-        donobuStack = await (0, DonobuStack_1.setupDonobuStack)('LOCAL', ControlPanel_1.NoOpControlPanelFactory, new EnvPersistenceVolatile_1.EnvPersistenceVolatile(getEnvSnapshot()), envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'));
+        donobuStack = await (0, DonobuStack_1.setupDonobuStack)('LOCAL', ControlPanel_1.NoOpControlPanelFactory, new EnvPersistenceVolatile_1.EnvPersistenceVolatile(getEnvSnapshot()), envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'DONOBU_UPLOADS_OWNED_BY_PARENT', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'));
         return donobuStack;
     }
     else {

package/dist/main.d.ts

@@ -105,6 +105,7 @@ export declare function startDonobuServer({ port, controlPanelHost, environ, }?:
         AWS_SECRET_ACCESS_KEY: z.ZodOptional<z.ZodString>;
         DONOBU_API_KEY: z.ZodOptional<z.ZodString>;
         DONOBU_PERSISTENCE_API_KEY: z.ZodOptional<z.ZodString>;
+        DONOBU_UPLOADS_OWNED_BY_PARENT: z.ZodOptional<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
     }, {
         BASE64_GPT_CONFIG?: string | undefined;
         BROWSERBASE_API_KEY?: string | undefined;
@@ -125,6 +126,7 @@ export declare function startDonobuServer({ port, controlPanelHost, environ, }?:
         AWS_SECRET_ACCESS_KEY?: string | undefined;
         DONOBU_API_KEY?: string | undefined;
         DONOBU_PERSISTENCE_API_KEY?: string | undefined;
+        DONOBU_UPLOADS_OWNED_BY_PARENT?: boolean | undefined;
     }> | undefined;
 }): Promise<void>;
 //# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -111,7 +111,7 @@ const DEFAULT_PORT = 31000;
  * Starts a Donobu API server at the given port. The server assumes that the
  * Playwright browsers have been installed.
  */
-async function startDonobuServer({ port = DEFAULT_PORT, controlPanelHost = ControlPanel_1.NoOpControlPanelFactory, environ = envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_DEPLOYMENT_ENVIRONMENT', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'), } = {}) {
+async function startDonobuServer({ port = DEFAULT_PORT, controlPanelHost = ControlPanel_1.NoOpControlPanelFactory, environ = envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_DEPLOYMENT_ENVIRONMENT', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'DONOBU_UPLOADS_OWNED_BY_PARENT', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'), } = {}) {
     try {
         const adminController = await AdminApiController_1.AdminApiController.create(environ.data.DONOBU_DEPLOYMENT_ENVIRONMENT ?? 'LOCAL', controlPanelHost, environ);
         await adminController.start(port);

package/dist/managers/AdminApiController.d.ts

@@ -59,7 +59,7 @@ export declare class AdminApiController {
      * - no checking for flow ownership is performed, as all flows are considered owned by the
      *   local environment.
      */
-    static create(donobuDeploymentEnvironment: DonobuDeploymentEnvironment, controlPanelFactory: ControlPanelFactory, environ: EnvPick<typeof env, 'ANTHROPIC_API_KEY' | 'ANTHROPIC_MODEL_NAME' | 'AWS_ACCESS_KEY_ID' | 'AWS_BEDROCK_MODEL_NAME' | 'AWS_SECRET_ACCESS_KEY' | 'BASE64_GPT_CONFIG' | 'BROWSERBASE_API_KEY' | 'BROWSERBASE_PROJECT_ID' | 'DONOBU_API_BASE_URL' | 'DONOBU_API_KEY' | 'DONOBU_PERSISTENCE_API_KEY' | 'GOOGLE_GENERATIVE_AI_API_KEY' | 'GOOGLE_GENERATIVE_AI_MODEL_NAME' | 'OLLAMA_API_URL' | 'OLLAMA_MODEL_NAME' | 'OPENAI_API_KEY' | 'OPENAI_API_MODEL_NAME' | 'PERSISTENCE_PRIORITY'>): Promise<AdminApiController>;
+    static create(donobuDeploymentEnvironment: DonobuDeploymentEnvironment, controlPanelFactory: ControlPanelFactory, environ: EnvPick<typeof env, 'ANTHROPIC_API_KEY' | 'ANTHROPIC_MODEL_NAME' | 'AWS_ACCESS_KEY_ID' | 'AWS_BEDROCK_MODEL_NAME' | 'AWS_SECRET_ACCESS_KEY' | 'BASE64_GPT_CONFIG' | 'BROWSERBASE_API_KEY' | 'BROWSERBASE_PROJECT_ID' | 'DONOBU_API_BASE_URL' | 'DONOBU_API_KEY' | 'DONOBU_PERSISTENCE_API_KEY' | 'DONOBU_UPLOADS_OWNED_BY_PARENT' | 'GOOGLE_GENERATIVE_AI_API_KEY' | 'GOOGLE_GENERATIVE_AI_MODEL_NAME' | 'OLLAMA_API_URL' | 'OLLAMA_MODEL_NAME' | 'OPENAI_API_KEY' | 'OPENAI_API_MODEL_NAME' | 'PERSISTENCE_PRIORITY'>): Promise<AdminApiController>;
     private constructor();
     /**
      * Binds the API/web-asset server to `port` and resolves once the socket is

package/dist/managers/DonobuStack.d.ts

@@ -61,6 +61,7 @@ export declare function setupDonobuStack(donobuDeploymentEnvironment: DonobuDepl
     AWS_SECRET_ACCESS_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
     DONOBU_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
     DONOBU_PERSISTENCE_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+    DONOBU_UPLOADS_OWNED_BY_PARENT: import("zod/v4").ZodOptional<import("zod/v4").ZodCodec<import("zod/v4").ZodString, import("zod/v4").ZodBoolean>>;
 }, {
     BASE64_GPT_CONFIG?: string | undefined;
     BROWSERBASE_API_KEY?: string | undefined;
@@ -80,5 +81,6 @@ export declare function setupDonobuStack(donobuDeploymentEnvironment: DonobuDepl
     AWS_SECRET_ACCESS_KEY?: string | undefined;
     DONOBU_API_KEY?: string | undefined;
     DONOBU_PERSISTENCE_API_KEY?: string | undefined;
+    DONOBU_UPLOADS_OWNED_BY_PARENT?: boolean | undefined;
 }>): Promise<DonobuStack>;
 //# sourceMappingURL=DonobuStack.d.ts.map

package/dist/managers/DonobuStack.js

@@ -33,7 +33,7 @@ const ToolRegistry_1 = require("./ToolRegistry");
  *       then having this snapshot is relevant so that tests can use normal
  *       environment variables.
  */
-async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory, envPersistenceVolatile, environ = envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY')) {
+async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory, envPersistenceVolatile, environ = envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'DONOBU_UPLOADS_OWNED_BY_PARENT', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY')) {
     const loadedPlugins = await loadDefaultPlugins();
     const resolvedToolRegistry = await (0, ToolRegistry_1.createDefaultToolRegistry)(loadedPlugins.tools);
     const persistencePlugins = new PersistencePlugin_1.PersistencePluginRegistry(loadedPlugins.persistencePlugins);

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

@@ -94,6 +94,22 @@ export declare class FileUploadCache {
      * active work even though `listPending` excludes it.
      */
     countActive(): Promise<number>;
+    /**
+     * Like {@link countActive}, but scoped to the work THIS worker is
+     * responsible for finishing before its process exits: files still
+     * `.pending` (which this worker will claim and upload) plus this worker's
+     * own `.uploading.<ownToken>` claims.
+     *
+     * Foreign `.uploading.<otherToken>` markers — in-flight claims owned by
+     * OTHER (possibly long-dead) processes — are deliberately EXCLUDED. A live
+     * peer is responsible for finishing its own claims, and claims orphaned by
+     * a crashed peer are recovered by {@link reclaimStaleClaims} on the next
+     * long-lived process. Counting them here is exactly what made an
+     * end-of-worker drain block for the full timeout on a crashed peer's
+     * orphaned claim (which this process can neither upload nor release),
+     * wedging Playwright worker teardown until it was force-killed.
+     */
+    countOwnedActive(ownToken: string): Promise<number>;
     /**
      * Returns a breakdown of marker counts on disk. Used by the admin
      * "uploads status" endpoint so the desktop app can show the user how

package/dist/persistence/files/FileUploadCache.js

@@ -178,6 +178,36 @@ class FileUploadCache {
         const counts = await this.getCounts();
         return counts.pending + counts.inFlight;
     }
+    /**
+     * Like {@link countActive}, but scoped to the work THIS worker is
+     * responsible for finishing before its process exits: files still
+     * `.pending` (which this worker will claim and upload) plus this worker's
+     * own `.uploading.<ownToken>` claims.
+     *
+     * Foreign `.uploading.<otherToken>` markers — in-flight claims owned by
+     * OTHER (possibly long-dead) processes — are deliberately EXCLUDED. A live
+     * peer is responsible for finishing its own claims, and claims orphaned by
+     * a crashed peer are recovered by {@link reclaimStaleClaims} on the next
+     * long-lived process. Counting them here is exactly what made an
+     * end-of-worker drain block for the full timeout on a crashed peer's
+     * orphaned claim (which this process can neither upload nor release),
+     * wedging Playwright worker teardown until it was force-killed.
+     */
+    async countOwnedActive(ownToken) {
+        const ownSuffix = `${UPLOADING_PREFIX}${ownToken}`;
+        let active = 0;
+        const flowDirs = await this.safeReaddir(this.platformDir);
+        for (const encFlow of flowDirs) {
+            const flowDir = path_1.default.join(this.platformDir, encFlow);
+            const names = await this.safeReaddir(flowDir);
+            for (const name of names) {
+                if (name.endsWith(PENDING_SUFFIX) || name.endsWith(ownSuffix)) {
+                    active += 1;
+                }
+            }
+        }
+        return active;
+    }
     /**
      * Returns a breakdown of marker counts on disk. Used by the admin
      * "uploads status" endpoint so the desktop app can show the user how

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;