donobu 5.55.0 → 5.57.0

package/dist/esm/lib/test/utils/TestFileUpdater.js

@@ -91,6 +91,55 @@ class TestFileUpdater {
             return false;
         }
     }
+    /**
+     * Updates a test file based on a Playwright JSON reporter output.
+     *
+     * @param jsonReportPath Path to the Playwright JSON report
+     * @param testFilePath Path to the test file to update (if not specified, will be extracted from the report)
+     * @param newTestCode The new test code
+     * @returns True if the update was successful, false otherwise
+     */
+    static async updateFromPlaywrightReport(jsonReportPath, newTestCode, testFilePath) {
+        try {
+            // Read and parse the Playwright report
+            const reportContent = await fs.promises.readFile(jsonReportPath, 'utf8');
+            const testResults = JSON.parse(reportContent);
+            // Extract failed test information
+            const failedTests = [];
+            for (const suite of testResults.suites || []) {
+                const file = suite.file;
+                for (const spec of suite.specs || []) {
+                    if (!spec.ok) {
+                        for (const test of spec.tests || []) {
+                            if (!test.ok) {
+                                failedTests.push({
+                                    file,
+                                    title: `${spec.title} ${test.title}`.trim(),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            if (failedTests.length === 0) {
+                Logger_1.appLogger.warn('No failed tests found in the report');
+                return false;
+            }
+            // If test file path is not specified, use the first failed test's file
+            const targetTestFilePath = testFilePath || failedTests[0].file;
+            const targetTestName = failedTests[0].title;
+            if (!targetTestFilePath) {
+                Logger_1.appLogger.error('Could not determine test file path from report');
+                return false;
+            }
+            // Update the test file
+            return await this.updateTestCase(targetTestFilePath, targetTestName, newTestCode);
+        }
+        catch (error) {
+            Logger_1.appLogger.error(`Error updating from Playwright report:`, error);
+            return false;
+        }
+    }
     /**
      * Extracts a specific test case from source code.
      *
@@ -173,55 +222,6 @@ class TestFileUpdater {
     static testTitleMatches(title, testName) {
         return (title === testName || testName.includes(title) || title.includes(testName));
     }
-    /**
-     * Updates a test file based on a Playwright JSON reporter output.
-     *
-     * @param jsonReportPath Path to the Playwright JSON report
-     * @param testFilePath Path to the test file to update (if not specified, will be extracted from the report)
-     * @param newTestCode The new test code
-     * @returns True if the update was successful, false otherwise
-     */
-    static async updateFromPlaywrightReport(jsonReportPath, newTestCode, testFilePath) {
-        try {
-            // Read and parse the Playwright report
-            const reportContent = await fs.promises.readFile(jsonReportPath, 'utf8');
-            const testResults = JSON.parse(reportContent);
-            // Extract failed test information
-            const failedTests = [];
-            for (const suite of testResults.suites || []) {
-                const file = suite.file;
-                for (const spec of suite.specs || []) {
-                    if (!spec.ok) {
-                        for (const test of spec.tests || []) {
-                            if (!test.ok) {
-                                failedTests.push({
-                                    file,
-                                    title: `${spec.title} ${test.title}`.trim(),
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            if (failedTests.length === 0) {
-                Logger_1.appLogger.warn('No failed tests found in the report');
-                return false;
-            }
-            // If test file path is not specified, use the first failed test's file
-            const targetTestFilePath = testFilePath || failedTests[0].file;
-            const targetTestName = failedTests[0].title;
-            if (!targetTestFilePath) {
-                Logger_1.appLogger.error('Could not determine test file path from report');
-                return false;
-            }
-            // Update the test file
-            return await this.updateTestCase(targetTestFilePath, targetTestName, newTestCode);
-        }
-        catch (error) {
-            Logger_1.appLogger.error(`Error updating from Playwright report:`, error);
-            return false;
-        }
-    }
 }
 exports.TestFileUpdater = TestFileUpdater;
 //# sourceMappingURL=TestFileUpdater.js.map

package/dist/esm/main.d.ts

@@ -43,6 +43,7 @@ export * from './models/FlowMetadata';
 export type * from './models/FocusedTarget';
 export type * from './models/GptMessage';
 export * from './models/InteractableElement';
+export type * from './models/Observation';
 export type { PaginatedResult } from './models/PaginatedResult';
 export * from './models/ProposedToolCall';
 export * from './models/Provenance';
@@ -61,6 +62,7 @@ export type { FlowsPersistence } from './persistence/flows/FlowsPersistence';
 export { type PersistencePlugin, PersistencePluginRegistry, } from './persistence/PersistencePlugin';
 export type { SuitesPersistence } from './persistence/suites/SuitesPersistence';
 export type { TestsPersistence } from './persistence/tests/TestsPersistence';
+export type * from './targets/TargetProvider';
 export type { TargetRuntime } from './targets/TargetRuntime';
 export { type TargetRuntimeParams, type TargetRuntimePlugin, TargetRuntimePluginRegistry, } from './targets/TargetRuntimePlugin';
 export * from './tools/ReplayableInteraction';

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

@@ -43,6 +43,7 @@ import type { DonobuDeploymentEnvironment } from '../models/DonobuDeploymentEnvi
 export declare class AdminApiController {
     private readonly app;
     private server?;
+    private constructor();
     /**
      * Creates a new instance.
      *
@@ -60,22 +61,6 @@ export declare class AdminApiController {
      *   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' | '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
-     * listening. If the given port is 0, a random port is assigned. Rejects on
-     * bind errors (e.g. EADDRINUSE) so callers — particularly those doing a
-     * stop/start bounce — can recover instead of crashing on an uncaught
-     * 'error' event.
-     */
-    start(port: number): Promise<void>;
-    /**
-     * Stops accepting new connections and forcibly tears down any in-flight
-     * ones, then resolves. Forceful close keeps bounces predictable — a slow
-     * or stuck client request can't hold the port open. Callers that want to
-     * let in-flight work drain should do so before invoking stop().
-     */
-    stop(): Promise<void>;
     private static setupExpressFramework;
     /**
      * Sets up URL error handler middleware to catch URL parsing/decoding errors.
@@ -124,5 +109,20 @@ export declare class AdminApiController {
      */
     private static registerUtilityRoutes;
     private static asyncHandler;
+    /**
+     * Binds the API/web-asset server to `port` and resolves once the socket is
+     * listening. If the given port is 0, a random port is assigned. Rejects on
+     * bind errors (e.g. EADDRINUSE) so callers — particularly those doing a
+     * stop/start bounce — can recover instead of crashing on an uncaught
+     * 'error' event.
+     */
+    start(port: number): Promise<void>;
+    /**
+     * Stops accepting new connections and forcibly tears down any in-flight
+     * ones, then resolves. Forceful close keeps bounces predictable — a slow
+     * or stuck client request can't hold the port open. Callers that want to
+     * let in-flight work drain should do so before invoking stop().
+     */
+    stop(): Promise<void>;
 }
 //# sourceMappingURL=AdminApiController.d.ts.map

package/dist/esm/managers/AdminApiController.js

@@ -63,6 +63,9 @@ const DonobuStack_1 = require("./DonobuStack");
  * - **Development vs Production**: Enhanced error details in development environments
  */
 class AdminApiController {
+    constructor(app) {
+        this.app = app;
+    }
     /**
      * Creates a new instance.
      *
@@ -83,41 +86,6 @@ class AdminApiController {
         const expressApp = await this.setupExpressFramework(donobuDeploymentEnvironment, controlPanelFactory, environ);
         return new AdminApiController(expressApp);
     }
-    constructor(app) {
-        this.app = app;
-    }
-    /**
-     * Binds the API/web-asset server to `port` and resolves once the socket is
-     * listening. If the given port is 0, a random port is assigned. Rejects on
-     * bind errors (e.g. EADDRINUSE) so callers — particularly those doing a
-     * stop/start bounce — can recover instead of crashing on an uncaught
-     * 'error' event.
-     */
-    async start(port) {
-        Logger_1.appLogger.debug(`Starting AdminController on port ${port}`);
-        await new Promise((resolve, reject) => {
-            this.server = this.app.listen(port, () => resolve());
-            this.server.once('error', reject);
-        });
-    }
-    /**
-     * Stops accepting new connections and forcibly tears down any in-flight
-     * ones, then resolves. Forceful close keeps bounces predictable — a slow
-     * or stuck client request can't hold the port open. Callers that want to
-     * let in-flight work drain should do so before invoking stop().
-     */
-    async stop() {
-        if (this.server) {
-            const address = this.server.address();
-            const port = typeof address === 'string' ? address : address?.port;
-            Logger_1.appLogger.debug(`Stopping AdminController on port ${port}`);
-            const server = this.server;
-            await new Promise((resolve, reject) => {
-                server.close((err) => (err ? reject(err) : resolve()));
-                server.closeAllConnections();
-            });
-        }
-    }
     static async setupExpressFramework(donobuDeploymentEnvironment, controlPanelFactory, environ) {
         const app = (0, express_1.default)();
         const donobuStack = await (0, DonobuStack_1.setupDonobuStack)(donobuDeploymentEnvironment, controlPanelFactory, undefined, environ);
@@ -377,6 +345,38 @@ class AdminApiController {
             Promise.resolve(fn(req, res, next)).catch(next);
         };
     }
+    /**
+     * Binds the API/web-asset server to `port` and resolves once the socket is
+     * listening. If the given port is 0, a random port is assigned. Rejects on
+     * bind errors (e.g. EADDRINUSE) so callers — particularly those doing a
+     * stop/start bounce — can recover instead of crashing on an uncaught
+     * 'error' event.
+     */
+    async start(port) {
+        Logger_1.appLogger.debug(`Starting AdminController on port ${port}`);
+        await new Promise((resolve, reject) => {
+            this.server = this.app.listen(port, () => resolve());
+            this.server.once('error', reject);
+        });
+    }
+    /**
+     * Stops accepting new connections and forcibly tears down any in-flight
+     * ones, then resolves. Forceful close keeps bounces predictable — a slow
+     * or stuck client request can't hold the port open. Callers that want to
+     * let in-flight work drain should do so before invoking stop().
+     */
+    async stop() {
+        if (this.server) {
+            const address = this.server.address();
+            const port = typeof address === 'string' ? address : address?.port;
+            Logger_1.appLogger.debug(`Stopping AdminController on port ${port}`);
+            const server = this.server;
+            await new Promise((resolve, reject) => {
+                server.close((err) => (err ? reject(err) : resolve()));
+                server.closeAllConnections();
+            });
+        }
+    }
 }
 exports.AdminApiController = AdminApiController;
 //# sourceMappingURL=AdminApiController.js.map

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

@@ -3,16 +3,14 @@ import type { GptClient } from '../clients/GptClient';
 import type { AiQuery } from '../models/AiQuery';
 import type { ControlPanel, UserAction } from '../models/ControlPanel';
 import type { FlowMetadata } from '../models/FlowMetadata';
-import type { GptMessage, StructuredOutputMessage, TextItem } from '../models/GptMessage';
+import type { GptMessage, StructuredOutputMessage } from '../models/GptMessage';
 import type { SystemMessage } from '../models/GptMessage';
-import type { InteractableElement } from '../models/InteractableElement';
 import type { ProposedToolCall } from '../models/ProposedToolCall';
 import type { ToolCall } from '../models/ToolCall';
 import type { FlowsPersistence } from '../persistence/flows/FlowsPersistence';
+import type { TargetProvider } from '../targets/TargetProvider';
 import type { DonobuFlowsManager } from './DonobuFlowsManager';
 import type { InteractionVisualizer } from './InteractionVisualizer';
-import type { TargetInspectorBase } from './TargetInspector';
-import type { TargetInspector } from './TargetInspector';
 import type { ToolManager } from './ToolManager';
 /**
  * Return an object conforming to the given JSON-schema. The object will be
@@ -35,10 +33,9 @@ export declare class DonobuFlow {
     readonly proposedToolCalls: ProposedToolCall[];
     readonly invokedToolCalls: ToolCall[];
     readonly gptMessages: GptMessage[];
-    readonly targetInspector: TargetInspector;
+    readonly provider: TargetProvider | null;
     readonly metadata: FlowMetadata;
     readonly controlPanel: ControlPanel;
-    private static readonly MAIN_MESSAGE_ELEMENT_LIST_MARKER;
     static readonly USER_INTERRUPT_MARKER = "[User interruption while flow was paused, this MUST be acknowledged]";
     static readonly REJECTION_MARKER = "[The user rejected your previously proposed action(s). Do NOT repeat them. Propose a different next action, taking the following feedback into account]";
     inProgressToolCall: ToolCall | null;
@@ -57,7 +54,38 @@ export declare class DonobuFlow {
      * panel, so both surfaces drive the flow through the same code path.
      */
     private readonly userActionInbox;
-    constructor(flowsManager: DonobuFlowsManager, envData: Record<string, string>, persistence: FlowsPersistence, gptClient: GptClient | null, toolManager: ToolManager, interactionVisualizer: InteractionVisualizer, proposedToolCalls: ProposedToolCall[], invokedToolCalls: ToolCall[], gptMessages: GptMessage[], targetInspector: TargetInspector, metadata: FlowMetadata, controlPanel: ControlPanel);
+    /** The target's lifecycle capability (connection/recovery/session), if any. */
+    private get lifecycle();
+    /** The target's per-turn observer, if any. */
+    private get observer();
+    /** Whether the attached target's connection is currently alive. */
+    private get anyConnected();
+    constructor(flowsManager: DonobuFlowsManager, envData: Record<string, string>, persistence: FlowsPersistence, gptClient: GptClient | null, toolManager: ToolManager, interactionVisualizer: InteractionVisualizer, proposedToolCalls: ProposedToolCall[], invokedToolCalls: ToolCall[], gptMessages: GptMessage[], provider: TargetProvider | null, metadata: FlowMetadata, controlPanel: ControlPanel);
+    /**
+     * @internal - Exposed for testing purposes only
+     */
+    static createSystemMessageForOverallObjective(envVars: string[] | null, overallObjective: string | null, provider: TargetProvider | null): SystemMessage;
+    /**
+     * Returns a size-optimized GPT message history by stripping images and text
+     * from old messages.
+     *
+     * @internal - Exposed for testing purposes only
+     */
+    static createOptimizedHistoryForGptCall(currentHistory: GptMessage[]): GptMessage[];
+    /**
+     * 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
+     * if the POST fails for any reason; this is a best-effort 1-shot try.
+     */
+    private static invokeFlowFinishedCallback;
+    /** Target-agnostic sleep (replaces Playwright's waitForTimeout). */
+    private static sleep;
+    /**
+     * Cancel the flow: mark it for failure and interrupt any in-flight target
+     * operation so the run loop observes the cancellation at once. This does not
+     * release target resources — that happens during the flow's normal teardown.
+     */
+    cancel(): Promise<void>;
     /**
      * Drives the entire Donobu flow state-machine until it reaches a
      * terminal state.
@@ -106,6 +134,10 @@ export declare class DonobuFlow {
      * docs.)
      */
     submitUserAction(action: UserAction): void;
+    /** Whether a thrown error means the attached target closed. */
+    private isTargetClosedError;
+    /** Location recorded on tool calls — the target's location. */
+    private getCurrentLocation;
     /**
      * Returns and clears the next pending user action, preferring out-of-band
      * actions (REST) over the control panel. Both sources feed the same
@@ -113,8 +145,8 @@ export declare class DonobuFlow {
      */
     private popUserAction;
     /**
-     * Delegates to the inspector to attempt recovery after the target is
-     * closed. If recovery fails, the flow is marked as failed.
+     * Attempt to recover after a target's connection closes. If any attached
+     * target cannot recover, the flow is marked as failed.
      */
     private onTargetClosed;
     /**
@@ -134,6 +166,14 @@ export declare class DonobuFlow {
      * Note that this *bypasses* the normal state transition logic!
      */
     private onUserInterruption;
+    /**
+     * Incorporates the compose-field text from a ▶/⏩ action: if the flow has no
+     * standing goal yet, the text becomes the `overallObjective`; otherwise it's
+     * added as extra guidance. Either way it's injected into the LLM history (the
+     * system prompt was built at init, possibly before any objective existed) and
+     * recorded in the timeline. No-op for empty text.
+     */
+    private applyComposeInstruction;
     /**
      * Closes out the currently-proposed AI tool call(s) without executing them:
      * emits a `tool_call_result` for each (so the LLM message history stays
@@ -163,11 +203,16 @@ export declare class DonobuFlow {
     private applyRunModeChange;
     /**
      * Whether the flow can hand control to the AI: it needs both a GPT client and
-     * an overall objective for the agent to pursue. Surfaced to the UI (as
-     * `canUseAi`) so the autonomy selector can disable the AI modes when they
-     * wouldn't work — e.g. a Playwright-imported test with no objective.
+     * a goal to pursue.
      */
     private canHandOffToAi;
+    /**
+     * Whether there is a standing goal for the AI to pursue (a non-empty
+     * `overallObjective`). Surfaced to the UI as `hasGoal` to drive the
+     * transport: ⏩ Fast-forward (autonomous run) is only offered with a goal,
+     * and ▶ Play needs either a goal or a typed instruction.
+     */
+    private hasGoal;
     /**
      * This method is called if there is an unhandled unexpected exception. This
      * method will mark the flow as a failure.
@@ -202,13 +247,6 @@ export declare class DonobuFlow {
      * 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
-     * if the POST fails for any reason; this is a best-effort 1-shot try.
-     */
-    private static invokeFlowFinishedCallback;
-    private onDialog;
     /**
      * Transitions the flow to its next state. After this method completes, the
      * `this.metadata.state` will have been updated and the
@@ -282,22 +320,5 @@ export declare class DonobuFlow {
      * up to an internally specified maximum number of attempts.
      */
     private queryGptWithRetry;
-    /** Target-agnostic sleep (replaces Playwright's waitForTimeout). */
-    private static sleep;
-    /**
-     * @internal - Exposed for testing purposes only
-     */
-    static createSystemMessageForOverallObjective(envVars: string[] | null, overallObjective: string | null, inspector: TargetInspectorBase): SystemMessage;
-    /**
-     * @internal - Exposed for testing purposes only
-     */
-    static createMainUserMessage(inspector: TargetInspectorBase, interactableElements: InteractableElement[]): TextItem;
-    /**
-     * Returns a size-optimized GPT message history by stripping images and text
-     * from old messages.
-     *
-     * @internal - Exposed for testing purposes only
-     */
-    static createOptimizedHistoryForGptCall(currentHistory: GptMessage[]): GptMessage[];
 }
 //# sourceMappingURL=DonobuFlow.d.ts.map