flowstride 1.0.20 → 1.0.22

package/dist/adapters/web/playwright.js

@@ -37,34 +37,195 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebAdapter = void 0;
-const projectPaths_1 = require("../../utils/projectPaths");
+const validation_1 = require("../../native/validation");
 const playwright_1 = require("playwright");
+const projectPaths_1 = require("../../utils/projectPaths");
+const playwright_2 = require("playwright");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const playwright_extra_1 = require("playwright-extra");
 const puppeteer_extra_plugin_stealth_1 = __importDefault(require("puppeteer-extra-plugin-stealth"));
-playwright_extra_1.chromium.use((0, puppeteer_extra_plugin_stealth_1.default)());
+const chromium = (0, playwright_extra_1.addExtra)(playwright_1.chromium);
+chromium.use((0, puppeteer_extra_plugin_stealth_1.default)());
 class WebAdapter {
     config;
+    activeProfile = 'default';
+    profiles = new Map();
+    contextOptions = {};
+    onPageChanged;
+    profileNames() { return [...this.profiles.keys()]; }
+    getContext() { if (!this.context)
+        throw new Error('Browser not initialised'); return this.context; }
+    async createProfile(profileName, options = {}) {
+        const key = validation_1.name.parse(profileName);
+        if (this.profiles.has(key))
+            throw new Error(`Browser profile already exists: ${key}`);
+        if (!this.browser)
+            throw new Error('Browser not initialised');
+        const { storageState: _defaultAuthentication, ...inherited } = this.contextOptions;
+        const settings = { ...inherited, ...(0, validation_1.validateContextOptions)(options, this.config.browser, this.config.projectRoot) };
+        if (this.config.har)
+            settings.recordHar = { path: (0, validation_1.evidencePath)(this.config, `${key}-${Date.now()}.har`), content: 'embed', mode: 'full' };
+        const context = await this.browser.newContext(settings);
+        context.setDefaultTimeout(this.config.timeout);
+        context.on('page', page => page.on('pageerror', error => this.pageErrors.push(error.message)));
+        context.on('dialog', async (dialog) => { if (this.dialogHandler)
+            await this.dialogHandler(dialog);
+        else if (this.config.defaultDialogBehavior === 'accept')
+            await dialog.accept().catch(() => { });
+        else
+            await dialog.dismiss().catch(() => { }); });
+        try {
+            const page = await context.newPage();
+            this.profiles.set(key, { context, page, options: settings, tracing: false });
+            if (this.config.trace)
+                await this.beginTrace(key);
+            await this.useProfile(key);
+        }
+        catch (error) {
+            await context.close();
+            this.profiles.delete(key);
+            throw error;
+        }
+    }
+    async useProfile(profileName) {
+        const profile = this.profiles.get(profileName);
+        if (!profile || profile.page.isClosed())
+            throw new Error(`Browser profile is not available: ${profileName}`);
+        const previous = this.profiles.get(this.activeProfile);
+        if (previous && this.page && !this.page.isClosed() && this.context === previous.context)
+            previous.page = this.page;
+        // Initializers belong to their own page, even while another profile is active.
+        this.context = profile.context;
+        this.page = profile.page;
+        this.activeProfile = profileName;
+        await this.page.bringToFront();
+        await this.onPageChanged?.();
+    }
+    async closeProfile(profileName) {
+        if (profileName === 'default')
+            throw new Error('The default profile remains available until file completion.');
+        const profile = this.profiles.get(profileName);
+        if (!profile)
+            throw new Error(`Unknown profile: ${profileName}`);
+        await this.finishProfile(profileName);
+        this.profiles.delete(profileName);
+        if (this.activeProfile === profileName)
+            await this.useProfile('default');
+    }
+    async beginTrace(profileName = this.activeProfile, file) {
+        const profile = this.profiles.get(profileName);
+        if (!profile || profile.tracing)
+            throw new Error('Profile missing or already tracing.');
+        await profile.context.tracing.start({ screenshots: true, snapshots: true, sources: false });
+        profile.tracing = true;
+        profile.tracePath = (0, validation_1.evidencePath)(this.config, file || `${profileName}-${Date.now()}-trace.zip`);
+    }
+    async endTrace(profileName = this.activeProfile) {
+        const profile = this.profiles.get(profileName);
+        if (!profile?.tracing || !profile.tracePath)
+            throw new Error('Trace is not active.');
+        await profile.context.tracing.stop({ path: profile.tracePath });
+        profile.tracing = false;
+        return profile.tracePath;
+    }
+    async finishProfile(key, videoTargetPath) {
+        const profile = this.profiles.get(key);
+        if (!profile)
+            return;
+        for (const page of profile.context.pages())
+            await this.clearSessionStorageRestore(page);
+        if (profile.tracing)
+            await this.endTrace(key);
+        const video = profile.page.video();
+        await profile.context.close();
+        if (video) {
+            const target = videoTargetPath || (key !== 'default' ? (0, validation_1.evidencePath)(this.config, `${key}-${Date.now()}.webm`) : undefined);
+            if (target)
+                await video.saveAs(target);
+        }
+    }
+    async checkpointProfiles() {
+        const result = { active: this.activeProfile, dialogHandler: this.dialogHandler, profiles: [] };
+        const current = this.profiles.get(this.activeProfile);
+        if (current && this.page)
+            current.page = this.page;
+        for (const [key, profile] of this.profiles) {
+            const pages = [];
+            for (const page of profile.context.pages())
+                pages.push({ url: page.url(), active: page === profile.page,
+                    sessionStorage: await page.evaluate(() => ({ ...window.sessionStorage })).catch(() => ({})) });
+            result.profiles.push({ key, options: profile.options, storageState: await profile.context.storageState({ indexedDB: true }), pages });
+        }
+        return result;
+    }
+    async restoreProfiles(snapshot) {
+        await this.clearSessionStorageRestore();
+        for (const [key] of this.profiles)
+            await this.finishProfile(key, (0, validation_1.evidencePath)(this.config, `${key}-${Date.now()}-attempt.webm`));
+        this.profiles.clear();
+        this.dialogHandler = snapshot.dialogHandler;
+        for (const saved of snapshot.profiles) {
+            const context = await this.browser.newContext({ ...saved.options, storageState: saved.storageState,
+                ...(this.config.har ? { recordHar: { path: (0, validation_1.evidencePath)(this.config, `${saved.key}-${Date.now()}-retry.har`), content: 'embed' } } : {}) });
+            context.setDefaultTimeout(this.config.timeout);
+            context.on('page', page => page.on('pageerror', error => this.pageErrors.push(error.message)));
+            context.on('dialog', async (dialog) => { if (this.dialogHandler)
+                await this.dialogHandler(dialog);
+            else if (this.config.defaultDialogBehavior === 'accept')
+                await dialog.accept().catch(() => { });
+            else
+                await dialog.dismiss().catch(() => { }); });
+            let selected;
+            for (const tab of saved.pages) {
+                const page = await context.newPage();
+                if (tab.active || !selected)
+                    selected = page;
+                if (/^https?:/.test(tab.url)) {
+                    const origin = new URL(tab.url).origin;
+                    const seed = await page.addInitScript(({ origin, values }) => { if (window === window.top && location.origin === origin)
+                        for (const [key, value] of Object.entries(values))
+                            sessionStorage.setItem(key, String(value)); }, { origin, values: tab.sessionStorage });
+                    try {
+                        await page.goto(tab.url, { waitUntil: 'domcontentloaded' });
+                    }
+                    finally {
+                        await seed.dispose();
+                    }
+                }
+            }
+            selected ||= await context.newPage();
+            this.profiles.set(saved.key, { context, page: selected, options: saved.options, tracing: false });
+            if (this.config.trace)
+                await this.beginTrace(saved.key);
+        }
+        this.context = null;
+        this.page = null;
+        await this.useProfile(snapshot.active);
+    }
     pageErrors = [];
     browser = null;
     context = null;
     page = null;
     discoveredPages = [];
     dialogHandler = null;
-    pendingSessionStorageRestore = null;
-    async clearSessionStorageRestore() {
-        const pending = this.pendingSessionStorageRestore;
-        this.pendingSessionStorageRestore = null;
-        if (!pending)
-            return;
-        pending.page.off('framenavigated', pending.onNavigation);
-        try {
-            await pending.script.dispose();
-        }
-        catch (error) {
-            if (!pending.page.isClosed())
-                throw error;
+    // One-shot initializers for both Web Storage types, owned by their exact page.
+    sessionStorageRestores = new Map();
+    get pendingSessionStorageRestore() { return this.sessionStorageRestores.values().next().value || null; }
+    async clearSessionStorageRestore(target) {
+        for (const [page, pending] of this.sessionStorageRestores) {
+            if (target && page !== target)
+                continue;
+            this.sessionStorageRestores.delete(page);
+            pending.page.off('framenavigated', pending.onNavigation);
+            pending.page.off('close', pending.onClose);
+            try {
+                await pending.script.dispose();
+            }
+            catch (error) {
+                if (!pending.page.isClosed())
+                    throw error;
+            }
         }
     }
     constructor(config) {
@@ -75,6 +236,11 @@ class WebAdapter {
             throw new Error("Browser not initialised");
         return this.page;
     }
+    getBrowserInfo() {
+        if (!this.browser)
+            throw new Error('Browser not initialised');
+        return { engine: this.browser.browserType().name(), version: this.browser.version(), headless: !!this.config.headless };
+    }
     async initialise(audioInjectionPath) {
         await this.clearSessionStorageRestore();
         const launchArgs = this.config.headless
@@ -92,23 +258,48 @@ class WebAdapter {
         if (audioInjectionPath) {
             launchArgs.push(`--use-file-for-fake-audio-capture=${audioInjectionPath}`);
         }
-        this.browser = await playwright_extra_1.chromium.launch({
+        let engine = this.config.browser === 'firefox' ? playwright_1.firefox : this.config.browser === 'webkit' ? playwright_1.webkit : chromium;
+        if ((!this.config.browser || this.config.browser === 'chromium') && this.config.browserOptions?.userAgent) {
+            const configuredChromium = (0, playwright_extra_1.addExtra)(playwright_1.chromium);
+            const stealth = (0, puppeteer_extra_plugin_stealth_1.default)();
+            stealth.enabledEvasions.delete('user-agent-override');
+            configuredChromium.use(stealth);
+            engine = configuredChromium;
+        }
+        if (audioInjectionPath && this.config.browser && this.config.browser !== 'chromium')
+            throw new Error('Audio file injection requires Chromium.');
+        this.profiles.clear();
+        this.activeProfile = 'default';
+        this.discoveredPages = [];
+        this.dialogHandler = null;
+        this.browser = await engine.launch({
             headless: this.config.headless,
             // Native CI finalizes videos before closing the browser on cancellation.
             ...(this.config.ci ? { handleSIGINT: false, handleSIGTERM: false } : {}),
-            args: launchArgs,
+            args: !this.config.browser || this.config.browser === 'chromium' ? launchArgs : [],
         });
+        if (this.browser.browserType().name() !== (this.config.browser || 'chromium')) {
+            await this.browser.close();
+            this.browser = null;
+            throw new Error('The launched browser does not match the requested browser.');
+        }
         const videoDir = (0, projectPaths_1.projectPath)(process.cwd(), path.join('.flowstride', 'videos'));
         if (!fs.existsSync(videoDir))
             fs.mkdirSync(videoDir, { recursive: true });
         const profile = this.config.device === 'phone' || this.config.device === 'landscape'
-            ? { ...playwright_1.devices['Pixel 7'], viewport: this.config.device === 'landscape' ? { width: 844, height: 390 } : { width: 390, height: 844 } }
+            ? { ...playwright_2.devices['Pixel 7'], viewport: this.config.device === 'landscape' ? { width: 844, height: 390 } : { width: 390, height: 844 } }
             : { viewport: { width: 1280, height: 800 }, userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36' };
+        if (this.config.browser && this.config.browser !== 'chromium')
+            delete profile.userAgent;
         const viewport = this.config.viewport || profile.viewport;
-        this.context = await this.browser.newContext({
+        this.contextOptions = {
             ...profile, viewport,
+            ...(this.config.browser === 'firefox' ? { isMobile: false } : {}),
+            ...(0, validation_1.validateContextOptions)(this.config.browserOptions, this.config.browser, this.config.projectRoot),
             ...(this.config.recordVideo === false ? {} : { recordVideo: { dir: videoDir, size: viewport } }),
-        });
+        };
+        this.context = await this.browser.newContext({ ...this.contextOptions,
+            ...(this.config.har ? { recordHar: { path: (0, validation_1.evidencePath)(this.config, `default-${Date.now()}.har`), content: 'embed', mode: 'full' } } : {}) });
         this.pageErrors = [];
         this.context.on('page', page => page.on('pageerror', error => this.pageErrors.push(error.message)));
         this.context.on("dialog", async (dialog) => {
@@ -130,6 +321,9 @@ class WebAdapter {
         });
         this.page = await this.context.newPage();
         this.page.setDefaultTimeout(this.config.timeout);
+        this.profiles.set('default', { context: this.context, page: this.page, options: this.contextOptions, tracing: false });
+        if (this.config.trace)
+            await this.beginTrace();
     }
     async acceptDialog() {
         this.dialogHandler = async (dialog) => {
@@ -202,7 +396,7 @@ class WebAdapter {
     async injectStorage(cookies, localStorage, fallbackDomain, sessionStorage, storageOrigin) {
         if (!this.context || !this.page)
             return;
-        await this.clearSessionStorageRestore();
+        await this.clearSessionStorageRestore(this.page);
         const page = this.page;
         const originOf = (value) => {
             try {
@@ -213,10 +407,11 @@ class WebAdapter {
                 return undefined;
             }
         };
+        const hasLocalStorage = !!localStorage && Object.keys(localStorage).length > 0;
         const hasSessionStorage = !!sessionStorage && Object.keys(sessionStorage).length > 0;
         const origin = storageOrigin !== undefined ? originOf(storageOrigin)
-            : originOf(page.url()) || originOf(this.config.baseUrl);
-        if (hasSessionStorage && !origin) {
+            : originOf(this.config.baseUrl) || originOf(page.url());
+        if ((hasLocalStorage || hasSessionStorage) && !origin) {
             throw new Error('Session storage restoration requires a saved HTTP(S) origin, an open application page, or baseUrl.');
         }
         if (cookies && cookies.length > 0) {
@@ -249,46 +444,36 @@ class WebAdapter {
             }
             await this.context.addCookies(formattedCookies);
         }
-        if (localStorage && Object.keys(localStorage).length > 0) {
-            await this.page.addInitScript((data) => {
-                for (const [k, v] of Object.entries(data)) {
-                    window.localStorage.setItem(k, v);
-                }
-            }, localStorage);
-            if (this.page.url() !== "about:blank") {
-                await this.page.evaluate((data) => {
-                    try {
-                        for (const [k, v] of Object.entries(data))
-                            window.localStorage.setItem(k, v);
-                    }
-                    catch (e) { }
-                }, localStorage);
-            }
-        }
-        if (hasSessionStorage) {
+        if (hasLocalStorage || hasSessionStorage) {
             const restore = (data) => {
+                // A matching iframe inside another site must never receive saved secrets.
                 if (window !== window.top || window.location.origin !== data.origin)
                     return;
-                for (const [key, value] of Object.entries(data.values))
+                for (const [key, value] of Object.entries(data.local))
+                    window.localStorage.setItem(key, value);
+                for (const [key, value] of Object.entries(data.session))
                     window.sessionStorage.setItem(key, value);
             };
-            const data = { origin: origin, values: sessionStorage };
+            const data = { origin: origin, local: localStorage || {}, session: sessionStorage || {} };
             if (originOf(page.url()) === origin) {
+                // Already on the saved origin: restore now without a persistent initializer.
                 await page.evaluate(restore, data);
             }
             else {
-                // Seed before application scripts run; remove the seed after the first
-                // matching document so reloads preserve later application changes.
+                // Seed before application scripts run; remove after the first matching
+                // main document so later reloads preserve application changes and logouts.
                 const script = await page.addInitScript(restore, data);
                 const onNavigation = (frame) => {
                     if (frame !== page.mainFrame() || originOf(frame.url()) !== origin)
                         return;
-                    void this.clearSessionStorageRestore().catch(() => {
-                        console.warn('[Session]: Could not remove the completed session storage initializer.');
+                    void this.clearSessionStorageRestore(page).catch(() => {
+                        console.warn('[Session]: Could not remove the completed storage initializer.');
                     });
                 };
-                this.pendingSessionStorageRestore = { page, script, onNavigation };
+                const onClose = () => { void this.clearSessionStorageRestore(page).catch(() => { }); };
+                this.sessionStorageRestores.set(page, { page, script, onNavigation, onClose });
                 page.on('framenavigated', onNavigation);
+                page.on('close', onClose);
             }
         }
     }
@@ -487,53 +672,9 @@ class WebAdapter {
         const targetLoc = await this.checkAmbiguity(loc, selector);
         await targetLoc.waitFor({ state: "visible" });
         await targetLoc.scrollIntoViewIfNeeded();
-        await targetLoc.focus({ timeout: 3000 }).catch(() => { });
-        await targetLoc
-            .evaluate((node) => {
-            if (typeof node.focus === "function")
-                node.focus();
-        })
-            .catch(() => { });
-        let box = null;
-        try {
-            box = await targetLoc.boundingBox({ timeout: 3000 });
-        }
-        catch (e) { }
-        if (box) {
-            const centerX = box.x + box.width / 2;
-            const centerY = box.y + box.height / 2;
-            await this.page.mouse.move(centerX, centerY, { steps: 5 });
-        }
-        await targetLoc.hover({ force: true, timeout: 3000 }).catch(() => { });
-        await targetLoc
-            .evaluate((node) => {
-            const rect = node.getBoundingClientRect();
-            const x = rect.left + rect.width / 2;
-            const y = rect.top + rect.height / 2;
-            const events = [
-                "pointerover",
-                "pointerenter",
-                "mouseover",
-                "mouseenter",
-                "mousemove",
-            ];
-            events.forEach((type) => {
-                node.dispatchEvent(new MouseEvent(type, {
-                    view: window,
-                    bubbles: true,
-                    cancelable: true,
-                    clientX: x,
-                    clientY: y,
-                    screenX: x,
-                    screenY: y,
-                }));
-            });
-        })
-            .catch(() => { });
-        await targetLoc
-            .click({ delay: 50, force: true, timeout: 3000 })
-            .catch(() => { });
-        await this.page.waitForTimeout(600);
+        // A real pointer hover preserves browser actionability checks and must not
+        // focus, click, or synthesize duplicate application events.
+        await targetLoc.hover();
     }
     async type(selector, value, elementType) {
         const loc = await this.getLocator(selector, elementType, false, false);
@@ -1261,24 +1402,30 @@ class WebAdapter {
         }, { id, text, status, error });
     }
     async shutdown(videoTargetPath) {
+        const failures = [];
         try {
             await this.clearSessionStorageRestore();
-            const video = this.page?.video();
-            if (this.context) {
-                await this.context.close();
-            }
-            if (video && videoTargetPath) {
-                await video.saveAs(videoTargetPath);
+            const active = this.profiles.get(this.activeProfile);
+            if (active && this.page)
+                active.page = this.page;
+            for (const [key] of this.profiles) {
+                try {
+                    await this.finishProfile(key, key === 'default' ? videoTargetPath : undefined);
+                }
+                catch (error) {
+                    failures.push(error);
+                }
             }
         }
-        catch (err) {
-            console.warn("[WebAdapter]: Warning during browser shutdown or video transfer.");
-        }
         finally {
-            if (this.browser) {
-                await this.browser.close().catch(() => { });
-            }
-        }
+            await this.browser?.close().catch(error => failures.push(error));
+            this.profiles.clear();
+            this.context = null;
+            this.page = null;
+            this.browser = null;
+        }
+        if (failures.length)
+            throw new AggregateError(failures, 'Browser evidence finalization failed.');
     }
 }
 exports.WebAdapter = WebAdapter;

package/dist/ci/config.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isCIEnvironment = isCIEnvironment;
 exports.loadNativeConfig = loadNativeConfig;
+const distribution_1 = require("./distribution");
+const validation_1 = require("../native/validation");
 const projectPaths_1 = require("../utils/projectPaths");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -22,13 +24,24 @@ function loadNativeConfig(root, options) {
     }
     else if (options.config)
         throw new Error(`Configuration not found: ${file}`);
-    const config = { ...input, projectRoot: node_path_1.default.resolve(root), timeout: input.timeout ?? 30000, headless: input.headless ?? true,
+    const config = { ...input, browser: options.browser ?? input.browser ?? "chromium", retries: input.retries ?? 0, shard: options.shard ?? input.shard, shardHistory: options.shardHistory ?? input.shardHistory, updateBaselines: !!options.updateBaselines, projectRoot: node_path_1.default.resolve(root), timeout: input.timeout ?? 30000, headless: input.headless ?? true,
         ci: !!options.ci || isCIEnvironment(), bail: options.bail || input.bail || false, device: options.device ?? input.device ?? 'desktop',
         artifactsDir: input.artifactsDir ?? 'flowstride-artifacts', testDir: input.testDir ?? 'flows',
         defaultDialogBehavior: input.defaultDialogBehavior ?? 'dismiss',
         recordVideo: input.recordVideo ?? true, browserErrors: input.browserErrors ?? 'fail',
         isCloudSyncActive: options.isCloudSyncActive ?? false, machineToken: options.machineToken ?? null,
         workspaceId: options.workspaceId ?? null, manifest: options.manifest ?? null };
+    if (!['chromium', 'firefox', 'webkit'].includes(config.browser))
+        throw new Error('browser must be chromium, firefox, or webkit.');
+    config.browserOptions = (0, validation_1.validateContextOptions)(input.browserOptions, config.browser, root);
+    if (!Number.isSafeInteger(config.retries) || config.retries < 0 || config.retries > 10)
+        throw new Error('retries must be an integer from 0 to 10.');
+    for (const key of ['trace', 'har', 'domSnapshots', 'failOnFlaky'])
+        if (config[key] !== undefined && typeof config[key] !== 'boolean')
+            throw new Error(`${key} must be boolean.`);
+    (0, distribution_1.parseShard)(config.shard);
+    if (config.ci && config.updateBaselines)
+        throw new Error('Baseline updates are not allowed in CI.');
     if (config.ci && input.cloudSync !== true)
         config.isCloudSyncActive = false;
     if (options.headless || config.ci)

package/dist/ci/distribution.d.ts

@@ -0,0 +1,38 @@
+import type { FlowstrideConfig } from '../types';
+export declare function parseShard(value?: string): {
+    index: number;
+    total: number;
+};
+export declare function executionPlan(target: string, config?: FlowstrideConfig): {
+    files: string[];
+    allFiles: string[];
+    setupFiles: string[];
+    suiteHash: string;
+    configHash: string;
+    shard: {
+        index: number;
+        total: number;
+    };
+    flowRoot: string;
+};
+export declare function mergeResults(summaries: string[], output?: string): {
+    protocol: number;
+    engine: any;
+    browser: any;
+    browsers: any[];
+    status: string;
+    metrics: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+        incomplete: number;
+    };
+    steps: any[];
+    attempts: any[];
+    errors: string[];
+    timings: Record<string, number>;
+    files: string[];
+    duration: number;
+    distribution: any;
+};