donobu 5.29.0 → 5.31.0

package/dist/esm/lib/test/testExtension.d.ts

@@ -1,4 +1,4 @@
-import type { PlaywrightWorkerOptions } from '@playwright/test';
+import type { PlaywrightWorkerOptions, TestInfo } from '@playwright/test';
 import type { GptClient } from '../../clients/GptClient';
 import type { BrowserStorageState } from '../../models/BrowserStorageState';
 import { FlowLogBuffer } from '../../utils/FlowLogBuffer';
@@ -9,6 +9,7 @@ export declare const test: import("@playwright/test").TestType<import("@playwrig
         flowId: string;
         logBuffer: FlowLogBuffer;
     };
+    pwApiStepLogger: void;
     storageState?: BrowserStorageState | Promise<BrowserStorageState>;
     gptClient?: GptClient;
     page: DonobuExtendedPage;
@@ -26,4 +27,33 @@ export declare const test: import("@playwright/test").TestType<import("@playwrig
      */
     donobuFileUploadDrainGuard: void;
 }>;
+export declare function emitPlaywrightStepLog(step: any): void;
+/** Reset the source-line cache. Test-only. */
+export declare function _resetSourceLineCacheForTests(): void;
+/**
+ * Monkey-patch `testInfo._callbacks.onStepEnd` so each Playwright step in
+ * the `pw:api` / `expect` categories emits an `appLogger.info` entry once
+ * Playwright signals the step has finished. Returns a teardown function
+ * that restores the original callback.
+ *
+ * Why patch `onStepEnd` and not `_addStep`:
+ * Playwright captures the step's source location with a stack walk inside
+ * `_addStep` (see playwright/lib/worker/testInfo.js). Patching `_addStep`
+ * inserts a Donobu library frame into that stack, and Playwright's
+ * built-in filter only excludes `@playwright/test` / `playwright-core`
+ * paths — so for steps that don't pre-set `data.location` (most notably
+ * `expect`), the captured location lands inside our wrapper in
+ * `node_modules/donobu/...`. The downstream node_modules filter would
+ * then drop the entry. `_callbacks.onStepEnd` runs AFTER the stack
+ * capture, so this hook is invisible to Playwright's location resolution.
+ *
+ * Verified against @playwright/test 1.57+. `_callbacks` / `_stepMap` and
+ * the step shape (category, title, params, endWallTime, error, location)
+ * are private Playwright internals — install and per-step logging are
+ * wrapped in try/catch so any shape drift degrades to a no-op rather than
+ * failing the test.
+ *
+ * Exported for unit testing.
+ */
+export declare function installPlaywrightStepLogger(testInfo: TestInfo): () => void;
 //# sourceMappingURL=testExtension.d.ts.map

package/dist/esm/lib/test/testExtension.js

@@ -18,6 +18,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.test = void 0;
+exports.emitPlaywrightStepLog = emitPlaywrightStepLog;
+exports._resetSourceLineCacheForTests = _resetSourceLineCacheForTests;
+exports.installPlaywrightStepLogger = installPlaywrightStepLogger;
 const test_1 = require("@playwright/test");
 const async_hooks_1 = require("async_hooks");
 const crypto_1 = require("crypto");
@@ -28,6 +31,7 @@ const v4_1 = require("zod/v4");
 const envVars_1 = require("../../envVars");
 const DonobuFlowsManager_1 = require("../../managers/DonobuFlowsManager");
 const fileUploadWorkerRegistry_1 = require("../../persistence/files/fileUploadWorkerRegistry");
+const ansi_1 = require("../../utils/ansi");
 const BrowserUtils_1 = require("../../utils/BrowserUtils");
 const FlowLogBuffer_1 = require("../../utils/FlowLogBuffer");
 const Logger_1 = require("../../utils/Logger");
@@ -257,6 +261,36 @@ exports.test = test_1.test.extend({
         },
         { scope: 'test', auto: true },
     ],
+    /**
+     * Auto fixture that monkey-patches `testInfo._addStep` so each Playwright
+     * step in the `pw:api` (clicks, fills, navigations) and `expect`
+     * (assertions) categories emits an `appLogger.info` entry on completion.
+     * Routing native Playwright operations through the same per-flow
+     * `FlowLogBuffer` that AI tool-call logs populate makes the live
+     * `/api/flows/:id/logs` feed and persisted `logs.json` capture meaningful
+     * step-by-step data even for non-AI Playwright tests.
+     *
+     * Depends on `flowLoggingContext` so the ALS / `processLocalLogBuffer` are
+     * already set up by the time our patched `complete` fires.
+     *
+     * Verified against @playwright/test 1.57. `_addStep` and the TestStepImpl
+     * shape (category, title, params, wallTime, endWallTime, error, complete)
+     * are private Playwright internals — install and per-step logging are
+     * wrapped in try/catch so any shape drift degrades to a no-op rather than
+     * failing the test.
+     */
+    pwApiStepLogger: [
+        async ({ flowLoggingContext: _ }, use, testInfo) => {
+            const teardown = installPlaywrightStepLogger(testInfo);
+            try {
+                await use();
+            }
+            finally {
+                teardown();
+            }
+        },
+        { scope: 'test', auto: true },
+    ],
     /**
      * Drain in-flight file uploads (videos, screenshots, etc.) to Donobu
      * Cloud at the end of every Playwright worker's lifetime.
@@ -447,6 +481,245 @@ function collectNativeSteps(rawSteps) {
     result.sort((a, b) => a.endWallTime - b.endWallTime);
     return result;
 }
+// ---------------------------------------------------------------------------
+// Live Playwright step → appLogger pipeline
+// ---------------------------------------------------------------------------
+// Used by the `pwApiStepLogger` fixture above to surface native Playwright
+// operations (clicks, fills, navigations, expects) in the same per-flow
+// FlowLogBuffer that AI tool-call logs already populate.
+const LOGGED_STEP_CATEGORIES = new Set([
+    'pw:api',
+    'expect',
+]);
+const STEP_PARAM_ALLOWLIST = [
+    'url',
+    'selector',
+    'text',
+    'value',
+    'timeout',
+    'name',
+    'key',
+    // For expect steps Playwright stores the asserted value here
+    // (e.g., `expect(x).toBe('$51.00')` → params: { expected: '$51.00' }).
+    'expected',
+];
+/**
+ * Pull a small, JSON-safe subset of `step.params` for logging. Playwright's
+ * step.params can hold non-serializable values (Locator handles, Page refs,
+ * etc.) that would either cycle or bloat the log feed; we keep only known
+ * primitive fields.
+ */
+function pickStepParams(rawParams) {
+    if (!rawParams || typeof rawParams !== 'object') {
+        return undefined;
+    }
+    const result = {};
+    let hasAny = false;
+    for (const key of STEP_PARAM_ALLOWLIST) {
+        const value = rawParams[key];
+        if (value === undefined) {
+            continue;
+        }
+        const t = typeof value;
+        if (t === 'string' || t === 'number' || t === 'boolean') {
+            result[key] = value;
+            hasAny = true;
+        }
+    }
+    return hasAny ? result : undefined;
+}
+const NODE_MODULES_LOCATION_REGEX = /[\\/]node_modules[\\/]/;
+function emitPlaywrightStepLog(step) {
+    const category = step?.category ?? '';
+    if (!LOGGED_STEP_CATEGORIES.has(category)) {
+        return;
+    }
+    // Drop steps that originated inside a third-party (or Donobu library)
+    // package. The user's test code never lives in node_modules, so any step
+    // attributed there is plumbing — Donobu's own AssertTool, internal CDP
+    // wrappers, etc. — not the user's intent.
+    const locationFile = (step.location &&
+        typeof step.location === 'object' &&
+        typeof (step.location.file ?? step.location.fileName) === 'string' &&
+        (step.location.file ?? step.location.fileName)) ||
+        '';
+    if (locationFile && NODE_MODULES_LOCATION_REGEX.test(locationFile)) {
+        return;
+    }
+    const title = step.title ?? '';
+    const startedAt = typeof step.wallTime === 'number' ? step.wallTime : undefined;
+    const completedAt = typeof step.endWallTime === 'number' ? step.endWallTime : undefined;
+    const durationMs = startedAt !== undefined && completedAt !== undefined
+        ? completedAt - startedAt
+        : undefined;
+    const error = step.error && typeof step.error === 'object'
+        ? {
+            name: typeof step.error.name === 'string' ? step.error.name : 'Error',
+            // Playwright matchers emit ANSI-colored diff output. Strip it so
+            // raw escape sequences don't leak into the log feed.
+            message: (0, ansi_1.stripAnsi)(typeof step.error.message === 'string' ? step.error.message : ''),
+        }
+        : undefined;
+    const location = step.location && typeof step.location === 'object'
+        ? {
+            file: step.location.file ?? step.location.fileName ?? '',
+            line: step.location.line ?? 0,
+            column: step.location.column ?? 0,
+        }
+        : undefined;
+    const params = pickStepParams(step.params);
+    // Default message: Playwright's title verbatim, plus a primitive
+    // `expected` value for matchers Playwright didn't already inline.
+    let message = `${title}${formatExpectedSuffix(title, params?.expected)}`;
+    // For expect steps, prefer the actual user source line at
+    // location.file:line — `Expect "toBe"` is too bare; the source shows
+    // both the LHS being asserted and the matcher together
+    // (`expect(text).toBe('$51.01')`). Fall back to the matcher message if
+    // the source can't be read.
+    if (category === 'expect' && location?.file && location.line > 0) {
+        const sourceLine = readSourceLine(location.file, location.line);
+        if (sourceLine) {
+            message = sourceLine;
+        }
+    }
+    const meta = {
+        category,
+        title,
+        params,
+        durationMs,
+        startedAt,
+        completedAt,
+        error,
+        location,
+    };
+    // A populated `step.error` means Playwright reported the step as failed —
+    // surface it at error level so it stands out in the feed.
+    if (error) {
+        Logger_1.appLogger.error(message, meta);
+    }
+    else {
+        Logger_1.appLogger.info(message, meta);
+    }
+}
+function formatExpectedSuffix(title, expected) {
+    if (expected === undefined || expected === null) {
+        return '';
+    }
+    const t = typeof expected;
+    if (t !== 'string' && t !== 'number' && t !== 'boolean') {
+        return '';
+    }
+    const formatted = JSON.stringify(expected);
+    if (title.includes(formatted)) {
+        return '';
+    }
+    return ` ${formatted}`;
+}
+/**
+ * Per-worker cache of source file contents (split into lines), keyed by
+ * absolute file path. Source files don't change during a worker's
+ * lifetime, so one read per file is sufficient.
+ *
+ * `null` means a previous read failed; we cache that to avoid retrying.
+ */
+const sourceLineCache = new Map();
+/** Reset the source-line cache. Test-only. */
+function _resetSourceLineCacheForTests() {
+    sourceLineCache.clear();
+}
+/**
+ * Read the trimmed line at `file:line` (1-based), with a per-worker
+ * cache. Drops a trailing semicolon for cleanliness. Returns undefined
+ * if the file or line can't be read.
+ */
+function readSourceLine(file, line) {
+    let lines = sourceLineCache.get(file);
+    if (lines === undefined) {
+        try {
+            lines = (0, fs_1.readFileSync)(file, 'utf8').split('\n');
+        }
+        catch {
+            lines = null;
+        }
+        sourceLineCache.set(file, lines);
+    }
+    if (!lines) {
+        return undefined;
+    }
+    const raw = lines[line - 1];
+    if (typeof raw !== 'string') {
+        return undefined;
+    }
+    let trimmed = raw.trim();
+    if (trimmed.endsWith(';')) {
+        trimmed = trimmed.slice(0, -1);
+    }
+    return trimmed || undefined;
+}
+/**
+ * Monkey-patch `testInfo._callbacks.onStepEnd` so each Playwright step in
+ * the `pw:api` / `expect` categories emits an `appLogger.info` entry once
+ * Playwright signals the step has finished. Returns a teardown function
+ * that restores the original callback.
+ *
+ * Why patch `onStepEnd` and not `_addStep`:
+ * Playwright captures the step's source location with a stack walk inside
+ * `_addStep` (see playwright/lib/worker/testInfo.js). Patching `_addStep`
+ * inserts a Donobu library frame into that stack, and Playwright's
+ * built-in filter only excludes `@playwright/test` / `playwright-core`
+ * paths — so for steps that don't pre-set `data.location` (most notably
+ * `expect`), the captured location lands inside our wrapper in
+ * `node_modules/donobu/...`. The downstream node_modules filter would
+ * then drop the entry. `_callbacks.onStepEnd` runs AFTER the stack
+ * capture, so this hook is invisible to Playwright's location resolution.
+ *
+ * Verified against @playwright/test 1.57+. `_callbacks` / `_stepMap` and
+ * the step shape (category, title, params, endWallTime, error, location)
+ * are private Playwright internals — install and per-step logging are
+ * wrapped in try/catch so any shape drift degrades to a no-op rather than
+ * failing the test.
+ *
+ * Exported for unit testing.
+ */
+function installPlaywrightStepLogger(testInfo) {
+    const ti = testInfo;
+    const callbacks = ti._callbacks;
+    const stepMap = ti._stepMap;
+    const originalOnStepEnd = callbacks && typeof callbacks.onStepEnd === 'function'
+        ? callbacks.onStepEnd
+        : null;
+    if (!callbacks || !originalOnStepEnd || !stepMap) {
+        return () => { };
+    }
+    let installed = false;
+    try {
+        callbacks.onStepEnd = function patchedOnStepEnd(payload) {
+            const ret = originalOnStepEnd.call(this, payload);
+            try {
+                const stepId = payload?.stepId;
+                if (typeof stepId === 'string') {
+                    const step = stepMap.get(stepId);
+                    if (step && LOGGED_STEP_CATEGORIES.has(step.category)) {
+                        emitPlaywrightStepLog(step);
+                    }
+                }
+            }
+            catch (err) {
+                Logger_1.appLogger.debug('Failed to log Playwright step', err);
+            }
+            return ret;
+        };
+        installed = true;
+    }
+    catch (err) {
+        Logger_1.appLogger.warn('Failed to install Playwright step logger; native Playwright steps will not appear in flow logs', err);
+    }
+    return () => {
+        if (installed) {
+            callbacks.onStepEnd = originalOnStepEnd;
+        }
+    };
+}
 /**
  * Fetch tool-call screenshots from the flow's persistence layer and attach
  * them to the Playwright report. Each screenshot is attached as

package/dist/esm/managers/DonobuStack.js

@@ -49,7 +49,7 @@ async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory
     const envPersistenceFactory = await EnvPersistenceRegistry_1.EnvPersistenceRegistryImpl.fromEnvironment(envPersistenceVolatile ?? null, environ, persistencePlugins);
     const envDataManager = new EnvDataManager_1.EnvDataManager(envPersistenceFactory);
     const flowsManager = new DonobuFlowsManager_1.DonobuFlowsManager(donobuDeploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ, resolvedToolRegistry, targetRuntimePlugins);
-    const testsPersistenceRegistry = await TestsPersistenceRegistry_1.TestsPersistenceRegistryImpl.fromEnvironment(environ);
+    const testsPersistenceRegistry = await TestsPersistenceRegistry_1.TestsPersistenceRegistryImpl.fromEnvironment(environ, flowsPersistenceRegistry);
     const testsManager = new TestsManager_1.TestsManager(testsPersistenceRegistry, flowsManager);
     const suitesPersistenceRegistry = await SuitesPersistenceRegistry_1.SuitesPersistenceRegistryImpl.fromEnvironment(environ);
     const suitesManager = new SuitesManager_1.SuitesManager(suitesPersistenceRegistry, testsPersistenceRegistry);

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

@@ -1,7 +1,7 @@
 import type { CreateDonobuFlow } from '../models/CreateDonobuFlow';
 import type { CreateTest } from '../models/CreateTest';
 import type { PaginatedResult } from '../models/PaginatedResult';
-import type { TestMetadata, TestsQuery } from '../models/TestMetadata';
+import type { TestListItem, TestMetadata, TestsQuery } from '../models/TestMetadata';
 import type { TestsPersistenceRegistry } from '../persistence/tests/TestsPersistenceRegistry';
 import type { DonobuFlowsManager } from './DonobuFlowsManager';
 export declare class TestsManager {
@@ -10,7 +10,7 @@ export declare class TestsManager {
     constructor(testsPersistenceRegistry: TestsPersistenceRegistry, flowsManager: DonobuFlowsManager);
     createTest(params: CreateTest): Promise<TestMetadata>;
     getTestById(testId: string): Promise<TestMetadata>;
-    getTests(query: TestsQuery): Promise<PaginatedResult<TestMetadata>>;
+    getTests(query: TestsQuery): Promise<PaginatedResult<TestListItem>>;
     /**
      * Update a test in the persistence layer where it exists.
      * Iterates layers, updates in the first one that has it, ignores

package/dist/esm/managers/TestsManager.js

@@ -63,6 +63,13 @@ class TestsManager {
         // TestMetadata has no `created_at` field — fall back to "now" so newly
         // returned items sort to the most-recent end. For other sort columns,
         // map the snake_case API name to the camelCase JS field.
+        //
+        // `flow_count` and `latest_flow_created_at` are only known at the
+        // persistence layer (SQLite computes them via JOIN; the cloud handles
+        // them server-side). Returning 0 here means each layer's pre-sorted
+        // results stay in their own order during the federated merge, but
+        // ordering across layers degrades to "first seen wins" — fine for the
+        // common single-primary-layer case.
         const fieldFor = (test) => {
             switch (sortBy) {
                 case 'created_at':
@@ -73,6 +80,9 @@ class TestsManager {
                     return test.suiteId ?? '';
                 case 'next_run_mode':
                     return test.nextRunMode;
+                case 'flow_count':
+                case 'latest_flow_created_at':
+                    return 0;
                 default:
                     return '';
             }

package/dist/esm/models/PaginatedResult.d.ts

@@ -1,3 +1,18 @@
+import { z } from 'zod/v4';
+/**
+ * Create a schema to validate a paginated result.
+ *
+ * @param itemSchema - The Zod schema for the items in the result.
+ * @returns The Zod schema for the paginated result.
+ */
+export declare const createPaginatedResultSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    items: z.ZodArray<T>;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PaginatedResultSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodUnknown>;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
  * Result of a paginated query.
  */

package/dist/esm/models/PaginatedResult.js

@@ -1,6 +1,17 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginatedResultSchema = exports.createPaginatedResultSchema = void 0;
+const v4_1 = require("zod/v4");
 /**
- * Result of a paginated query.
+ * Create a schema to validate a paginated result.
+ *
+ * @param itemSchema - The Zod schema for the items in the result.
+ * @returns The Zod schema for the paginated result.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+const createPaginatedResultSchema = (itemSchema) => v4_1.z.object({
+    items: v4_1.z.array(itemSchema),
+    nextPageToken: v4_1.z.string().optional(),
+});
+exports.createPaginatedResultSchema = createPaginatedResultSchema;
+exports.PaginatedResultSchema = (0, exports.createPaginatedResultSchema)(v4_1.z.unknown());
 //# sourceMappingURL=PaginatedResult.js.map