flowstride 1.0.20-rc.6 → 1.0.20

package/dist/adapters/web/playwright.js

@@ -52,6 +52,21 @@ class WebAdapter {
     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;
+        }
+    }
     constructor(config) {
         this.config = config;
     }
@@ -61,6 +76,7 @@ class WebAdapter {
         return this.page;
     }
     async initialise(audioInjectionPath) {
+        await this.clearSessionStorageRestore();
         const launchArgs = this.config.headless
             ? [
                 "--use-fake-ui-for-media-stream",
@@ -183,9 +199,26 @@ class WebAdapter {
         await this.page.bringToFront();
         await this.page.waitForLoadState("domcontentloaded").catch(() => { });
     }
-    async injectStorage(cookies, localStorage, fallbackDomain) {
+    async injectStorage(cookies, localStorage, fallbackDomain, sessionStorage, storageOrigin) {
         if (!this.context || !this.page)
             return;
+        await this.clearSessionStorageRestore();
+        const page = this.page;
+        const originOf = (value) => {
+            try {
+                const url = new URL(value || '');
+                return ['http:', 'https:'].includes(url.protocol) ? url.origin : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        const hasSessionStorage = !!sessionStorage && Object.keys(sessionStorage).length > 0;
+        const origin = storageOrigin !== undefined ? originOf(storageOrigin)
+            : originOf(page.url()) || originOf(this.config.baseUrl);
+        if (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) {
             const formattedCookies = [];
             for (const cookie of cookies) {
@@ -232,6 +265,32 @@ class WebAdapter {
                 }, localStorage);
             }
         }
+        if (hasSessionStorage) {
+            const restore = (data) => {
+                if (window !== window.top || window.location.origin !== data.origin)
+                    return;
+                for (const [key, value] of Object.entries(data.values))
+                    window.sessionStorage.setItem(key, value);
+            };
+            const data = { origin: origin, values: sessionStorage };
+            if (originOf(page.url()) === origin) {
+                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.
+                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.');
+                    });
+                };
+                this.pendingSessionStorageRestore = { page, script, onNavigation };
+                page.on('framenavigated', onNavigation);
+            }
+        }
     }
     async getState() {
         const cookies = (await this.context?.cookies()) || [];
@@ -250,7 +309,14 @@ class WebAdapter {
                 console.warn("Warning: Could not access storage. Ensure page is loaded.");
             }
         }
-        return { cookies, localStorage, sessionStorage };
+        let storageOrigin;
+        try {
+            const url = new URL(this.page?.url() || '');
+            if (['http:', 'https:'].includes(url.protocol))
+                storageOrigin = url.origin;
+        }
+        catch { }
+        return { cookies, localStorage, sessionStorage, storageOrigin };
     }
     getCurrentUrl() {
         return this.page ? this.page.url() : "about:blank";
@@ -1196,6 +1262,7 @@ class WebAdapter {
     }
     async shutdown(videoTargetPath) {
         try {
+            await this.clearSessionStorageRestore();
             const video = this.page?.video();
             if (this.context) {
                 await this.context.close();

package/dist/cli/index.js

@@ -63,7 +63,7 @@ let API_BASE = (0, cloud_1.cloudApiBase)(process.env);
 program
     .name("flowstride")
     .description("Flowstride: The Enterprise Flow-First Automation CLI")
-    .version("1.0.20-rc.6");
+    .version("1.0.20");
 program
     .command("init")
     .description("Initialise a new Flowstride workspace in the current directory")

package/dist/runner/flow_worker.js

@@ -37,6 +37,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowWorker = void 0;
+const deadline_1 = require("../ci/deadline");
+const replayRequest_1 = require("../utils/replayRequest");
 const projectPaths_1 = require("../utils/projectPaths");
 const redaction_1 = require("../security/redaction");
 const fs = __importStar(require("fs"));
@@ -282,6 +284,7 @@ class FlowWorker extends events_1.EventEmitter {
             url: cleanUrl,
             requestHeaders: formattedHeaders,
             requestBody: parsedReqBody,
+            rawReplayRequest: { method: method.toUpperCase(), url: cleanUrl, headers: formattedHeaders, body: rawBodyString },
             responseStatus: state.status,
             responseHeaders: state.headers,
             responseBody: state.body,
@@ -304,33 +307,11 @@ class FlowWorker extends events_1.EventEmitter {
         });
     }
     async handleReplayRequest(payload) {
+        const requestId = typeof payload?.requestId === 'string' ? payload.requestId : undefined;
         try {
-            let parsedHeaders = undefined;
-            let parsedBody = undefined;
-            try {
-                if (payload.headers)
-                    parsedHeaders = JSON.parse(payload.headers);
-            }
-            catch (e) { }
-            try {
-                if (payload.body)
-                    parsedBody = JSON.parse(payload.body);
-            }
-            catch (e) {
-                parsedBody = payload.body;
-            }
-            const fetchOptions = {
-                method: payload.method,
-                headers: parsedHeaders,
-            };
-            if (parsedBody && payload.method !== "GET" && payload.method !== "HEAD") {
-                fetchOptions.body =
-                    typeof parsedBody === "string"
-                        ? parsedBody
-                        : JSON.stringify(parsedBody);
-            }
-            const response = await fetch(payload.url, fetchOptions);
-            const status = response.status;
+            const { url, options } = (0, replayRequest_1.buildReplayRequest)(payload);
+            options.signal = AbortSignal.timeout(this.config.timeout || 30000);
+            const response = await fetch(url, options);
             const text = await response.text();
             let responseBody;
             try {
@@ -339,17 +320,18 @@ class FlowWorker extends events_1.EventEmitter {
             catch {
                 responseBody = text;
             }
-            this.broadcast("REPLAY_RES", {
-                status,
-                responseBody,
+            this.broadcast('REPLAY_RES', {
+                status: response.status, responseBody, error: null, requestId,
                 fileName: this.currentFileName,
             });
         }
         catch (error) {
-            this.broadcast("REPLAY_RES", {
-                status: 500,
-                responseBody: { error: error.message },
-                fileName: this.currentFileName,
+            const code = error instanceof replayRequest_1.ReplayRequestError ? 'REPLAY_INVALID_REQUEST'
+                : error?.name === 'TimeoutError' ? 'REPLAY_TIMEOUT' : 'REPLAY_NETWORK_ERROR';
+            const message = (0, redaction_1.redactText)(String(error?.message || 'Replay request failed'), [this.config.machineToken || '']);
+            this.broadcast('REPLAY_RES', {
+                status: null, error: code, requestId,
+                responseBody: { error: message, code }, fileName: this.currentFileName,
             });
         }
     }
@@ -872,6 +854,7 @@ class FlowWorker extends events_1.EventEmitter {
                         localStorage: stateToSave.localStorage || {},
                         sessionStorage: stateToSave.sessionStorage || {},
                         fallbackDomain,
+                        storageOrigin: stateToSave.storageOrigin,
                     };
                     if (payload.isGlobal) {
                         FlowWorker.globalBrowserSessions[payload.name] = hybridState;
@@ -920,7 +903,7 @@ class FlowWorker extends events_1.EventEmitter {
                     }
                     if (!loadedState)
                         throw new Error(`State Error: The session "${payload.name}" does not exist in memory or on disk.`);
-                    await this.web.injectStorage(loadedState.cookies, loadedState.localStorage, loadedState.fallbackDomain);
+                    await this.web.injectStorage(loadedState.cookies, loadedState.localStorage, loadedState.fallbackDomain, loadedState.sessionStorage, loadedState.storageOrigin);
                 }
                 break;
             case "open":
@@ -1170,6 +1153,27 @@ class FlowWorker extends events_1.EventEmitter {
                     await this.web.expectText(payload.selector, payload.fuzzy, payload.elementType);
                 else if (expectType === "value")
                     await this.web.expectValue(payload.selector, payload.text, payload.elementType);
+                else if (expectType === "attribute") {
+                    const deadline = Date.now() + this.config.timeout;
+                    let actual = null;
+                    const failure = () => `Attribute assertion failed: ${payload.attribute} on ${payload.selector}. Expected ${payload.fuzzy ? 'to contain ' : ''}${JSON.stringify(payload.text)}, received ${JSON.stringify(actual)}.`;
+                    while (true) {
+                        const remaining = deadline - Date.now();
+                        if (remaining <= 0)
+                            throw new Error(failure());
+                        try {
+                            actual = await (0, deadline_1.withDeadline)(this.web.getAttribute(payload.selector, payload.attribute, payload.elementType), remaining);
+                        }
+                        catch (error) {
+                            throw new Error(`${failure()}\n${error instanceof Error ? error.message : String(error)}`, { cause: error });
+                        }
+                        if (actual !== null && (payload.fuzzy ? actual.includes(payload.text) : actual === payload.text))
+                            break;
+                        if (Date.now() >= deadline)
+                            throw new Error(failure());
+                        await new Promise(resolve => setTimeout(resolve, Math.max(0, Math.min(50, deadline - Date.now()))));
+                    }
+                }
                 else if (expectType === "transcript")
                     await this.web.expectTranscript(payload.text);
                 break;
@@ -1211,6 +1215,7 @@ class FlowWorker extends events_1.EventEmitter {
                 url: request.url(),
                 requestHeaders: requestHeaders,
                 requestBody: requestBody,
+                rawReplayRequest: { method: request.method(), url: request.url(), headers: requestHeaders, body: rawPostData },
                 responseStatus: response.status(),
                 responseHeaders: response.headers(),
                 responseBody: responseBody,

package/dist/security/redaction.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.redactText = redactText;
 exports.redactPayload = redactPayload;
 exports.redactWorkerPayload = redactWorkerPayload;
-const sensitive = /password|passcode|secret|token|authorization|cookie|api.?key|master.?key|otp|email|curlString|strippedDom/i;
+const sensitive = /password|passcode|secret|token|authorization|cookie|api.?key|master.?key|otp|email|curlString|rawReplayRequest|strippedDom/i;
 function redactText(input, secrets = []) {
     let value = String(input);
     for (const secret of secrets.filter(s => typeof s === 'string' && s.length >= 4).sort((a, b) => b.length - a.length))
@@ -44,6 +44,8 @@ function redactWorkerPayload(type, payload, secrets, localDebug = false) {
         return result;
     if (type === 'LOG_EVENT' && ['REST', 'GRAPHQL'].includes(payload.type) && typeof payload.details?.curlString === 'string') {
         result.details.rawCurlString = payload.details.curlString;
+        if (payload.details.rawReplayRequest)
+            result.details.rawReplayRequest = payload.details.rawReplayRequest;
     }
     return result;
 }

package/dist/sessions/manager.js

@@ -35,7 +35,7 @@ class SessionManager {
         data.lastUsedAt = Date.now();
         this.vault.save(`session_${name}`, data);
         this.activeSession = data;
-        await this.web.injectStorage(data.cookies, data.localStorage);
+        await this.web.injectStorage(data.cookies, data.localStorage, undefined, data.sessionStorage, data.storageOrigin);
         const definition = this.definitions.get(name);
         if (definition?.inject?.api) {
             const { headerName, template } = definition.inject.api;
@@ -64,6 +64,8 @@ class SessionManager {
             tokens: this.activeSession?.tokens || {},
             cookies: state.cookies,
             localStorage: state.localStorage,
+            sessionStorage: state.sessionStorage,
+            storageOrigin: state.storageOrigin,
             createdAt: Date.now(),
             lastUsedAt: Date.now(),
             persist,

package/dist/types/index.d.ts

@@ -53,6 +53,8 @@ export interface SessionData {
     tokens: Record<string, any>;
     cookies?: any[];
     localStorage?: Record<string, string>;
+    sessionStorage?: Record<string, string>;
+    storageOrigin?: string;
     createdAt: number;
     lastUsedAt: number;
     persist: boolean;

package/dist/utils/replayRequest.d.ts

@@ -0,0 +1,8 @@
+export declare class ReplayRequestError extends Error {
+    constructor(message: string);
+}
+/** Browser protocol metadata is not a portable set of Fetch request headers. */
+export declare function buildReplayRequest(payload: any): {
+    url: string;
+    options: RequestInit;
+};

package/dist/utils/replayRequest.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayRequestError = void 0;
+exports.buildReplayRequest = buildReplayRequest;
+class ReplayRequestError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ReplayRequestError';
+    }
+}
+exports.ReplayRequestError = ReplayRequestError;
+/** Browser protocol metadata is not a portable set of Fetch request headers. */
+function buildReplayRequest(payload) {
+    let url;
+    try {
+        url = new URL(payload?.url);
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password)
+            throw new Error();
+    }
+    catch {
+        throw new ReplayRequestError('Replay URL must use HTTP or HTTPS without embedded credentials.');
+    }
+    const method = typeof payload?.method === 'string' ? payload.method.toUpperCase() : 'GET';
+    if (!/^[!#$%&'*+.^_`|~0-9A-Z-]+$/.test(method) || ['CONNECT', 'TRACE', 'TRACK'].includes(method)) {
+        throw new ReplayRequestError('Replay method is not supported.');
+    }
+    let supplied = payload?.headers;
+    if (typeof supplied === 'string') {
+        try {
+            supplied = supplied.trim() ? JSON.parse(supplied) : {};
+        }
+        catch {
+            throw new ReplayRequestError('Replay headers must be a valid JSON object.');
+        }
+    }
+    if (supplied === undefined)
+        supplied = {};
+    if (!supplied || typeof supplied !== 'object' || Array.isArray(supplied)) {
+        throw new ReplayRequestError('Replay headers must be a JSON object of string values.');
+    }
+    // Fetch owns the destination, framing and supported compression. Recompute
+    // Content-Length after edits and remove all Connection-nominated fields too.
+    const excluded = new Set([
+        'host', 'content-length', 'accept-encoding', 'connection', 'keep-alive',
+        'proxy-connection', 'proxy-authenticate', 'proxy-authorization', 'te',
+        'trailer', 'transfer-encoding', 'upgrade', 'expect',
+    ]);
+    for (const [name, value] of Object.entries(supplied)) {
+        if (name.toLowerCase() === 'connection' && typeof value === 'string') {
+            for (const field of value.split(','))
+                excluded.add(field.trim().toLowerCase());
+        }
+    }
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(supplied)) {
+        if (name.startsWith(':') || excluded.has(name.toLowerCase()))
+            continue;
+        if (typeof value !== 'string')
+            throw new ReplayRequestError('Replay header values must be strings.');
+        try {
+            headers.append(name, value);
+        }
+        catch {
+            throw new ReplayRequestError('Replay headers contain an invalid name or value.');
+        }
+    }
+    const options = { method, headers };
+    if (!['GET', 'HEAD'].includes(method) && payload?.body !== undefined && payload.body !== null) {
+        try {
+            options.body = typeof payload.body === 'string' ? payload.body : JSON.stringify(payload.body);
+        }
+        catch {
+            throw new ReplayRequestError('Replay body cannot be serialized.');
+        }
+    }
+    return { url: url.href, options };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowstride",
-  "version": "1.0.20-rc.6",
+  "version": "1.0.20",
   "description": "An opensource flowfirst test automation framework",
   "workspaces": [
     "packages/flowstride_report"
@@ -27,8 +27,10 @@
     "verify:candidate": "node scripts/verify-candidate.cjs",
     "test:dashboard:unit": "node --test tests/dashboard/store.test.cjs",
     "test:dashboard": "node --test --test-concurrency=1 tests/dashboard/*.test.cjs",
-    "test:unit": "node --test tests/native/core.test.cjs tests/native/combined.test.cjs tests/native/curl.test.cjs tests/native/upload.test.cjs tests/dashboard/store.test.cjs",
-    "test:security": "node --test tests/manual-security.test.cjs tests/native/curl.test.cjs tests/native/combined.test.cjs"
+    "test:unit": "node --test tests/native/core.test.cjs tests/native/combined.test.cjs tests/native/curl.test.cjs tests/native/upload.test.cjs tests/dashboard/store.test.cjs tests/native/replay.test.cjs tests/dashboard/replay.test.cjs tests/native/assertions-sessions.test.cjs",
+    "test:security": "node --test tests/manual-security.test.cjs tests/native/curl.test.cjs tests/native/combined.test.cjs tests/native/replay.test.cjs tests/native/assertions-sessions.test.cjs",
+    "test:replay": "node --test tests/native/replay.test.cjs tests/dashboard/replay.test.cjs tests/dashboard/curl.browser.test.cjs",
+    "test:assertions-sessions": "node --test --test-concurrency=1 tests/native/assertions-sessions*.test.cjs"
   },
   "keywords": [
     "automation",
@@ -69,6 +71,6 @@
     "@rolldown/binding-darwin-arm64": "^0.15.1"
   },
   "publishConfig": {
-    "tag": "next"
+    "tag": "latest"
   }
 }