flowstride 1.0.0

package/dist/runner/persistent_vault.d.ts

@@ -0,0 +1,12 @@
+export declare class PersistentVault {
+    vaultPath: string;
+    data: Record<string, any>;
+    constructor(projectRoot?: string);
+    initialiseVault(): void;
+    save(key: string, value: any): void;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    syncToDisk(): void;
+    clear(): void;
+    getAll(): Record<string, any>;
+}

package/dist/runner/persistent_vault.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentVault = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class PersistentVault {
+    vaultPath;
+    data = {};
+    constructor(projectRoot = process.cwd()) {
+        this.vaultPath = path.join(projectRoot, ".flowstride", "vault.json");
+        this.initialiseVault();
+    }
+    initialiseVault() {
+        const dir = path.dirname(this.vaultPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        if (fs.existsSync(this.vaultPath)) {
+            try {
+                const rawData = fs.readFileSync(this.vaultPath, "utf8");
+                this.data = JSON.parse(rawData);
+            }
+            catch {
+                this.data = {};
+            }
+        }
+    }
+    save(key, value) {
+        this.data[key] = value;
+        this.syncToDisk();
+    }
+    set(key, value) {
+        this.save(key, value);
+    }
+    get(key) {
+        return this.data[key];
+    }
+    syncToDisk() {
+        fs.writeFileSync(this.vaultPath, JSON.stringify(this.data, null, 2));
+    }
+    clear() {
+        this.data = {};
+        if (fs.existsSync(this.vaultPath)) {
+            fs.unlinkSync(this.vaultPath);
+        }
+    }
+    getAll() {
+        return { ...this.data };
+    }
+}
+exports.PersistentVault = PersistentVault;

package/dist/runner/plugin_manager.d.ts

@@ -0,0 +1,13 @@
+import { FlowstrideConfig } from "../types";
+import { ApiProxy } from "../sdk/api_proxy";
+import { TemporaryStore } from "./temporary_store";
+import { WebAdapter } from "../adapters/web/playwright";
+export declare class PluginManager {
+    private config;
+    private web;
+    private store;
+    private apiProxy;
+    private dbProxy;
+    constructor(config: FlowstrideConfig, web: WebAdapter, store: TemporaryStore, apiProxy: ApiProxy);
+    execute(actionName: string, args: any, saveAs?: string): Promise<any>;
+}

package/dist/runner/plugin_manager.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+const path = __importStar(require("path"));
+const db_proxy_1 = require("../sdk/db_proxy");
+class PluginManager {
+    config;
+    web;
+    store;
+    apiProxy;
+    dbProxy;
+    constructor(config, web, store, apiProxy) {
+        this.config = config;
+        this.web = web;
+        this.store = store;
+        this.apiProxy = apiProxy;
+        this.dbProxy = new db_proxy_1.DbProxy();
+    }
+    async execute(actionName, args, saveAs) {
+        const lastDotIndex = actionName.lastIndexOf(".");
+        if (lastDotIndex === -1) {
+            throw new Error(`Invalid plugin action format: "${actionName}". Expected "path.method"`);
+        }
+        const pluginFile = actionName.substring(0, lastDotIndex);
+        const functionName = actionName.substring(lastDotIndex + 1);
+        let fullPath;
+        if (pluginFile.includes("/") || pluginFile.includes("\\")) {
+            fullPath = path.resolve(process.cwd(), `${pluginFile}.ts`);
+        }
+        else {
+            const pluginsPath = this.config.pluginsDir || path.join(process.cwd(), "plugins");
+            fullPath = path.resolve(pluginsPath, `${pluginFile}.ts`);
+        }
+        try {
+            let module;
+            if (fullPath.endsWith(".ts")) {
+                require("ts-node").register({
+                    transpileOnly: true,
+                    compilerOptions: {
+                        module: "commonjs",
+                        esModuleInterop: true,
+                    },
+                });
+                module = require(fullPath);
+            }
+            else {
+                module = await import(fullPath);
+            }
+            const action = module[functionName];
+            if (!action) {
+                throw new Error(`Plugin function "${functionName}" not found in ${fullPath}`);
+            }
+            const sdk = {
+                api: {
+                    get: (url, headers) => this.apiProxy.get(url, headers),
+                    post: (url, body, headers) => this.apiProxy.post(url, body, headers),
+                    put: (url, body, headers) => this.apiProxy.put(url, body, headers),
+                    delete: (url, headers) => this.apiProxy.delete(url, headers),
+                },
+                ui: {
+                    click: (s) => this.web.click(s),
+                    type: (s, t) => this.web.type(s, t),
+                    isVisible: async (s) => {
+                        try {
+                            await this.web.expectVisible(s);
+                            return true;
+                        }
+                        catch {
+                            return false;
+                        }
+                    },
+                    getText: async (s) => {
+                        const page = this.web.getPage();
+                        const text = await page.locator(s).first().textContent();
+                        return text ? text.trim() : "";
+                    },
+                },
+                state: {
+                    get: (k) => this.store.get(k),
+                    set: (k, v) => this.store.set(k, v),
+                },
+                env: {
+                    get: (k) => process.env[k],
+                },
+                db: this.dbProxy,
+                otp: {
+                    generate: (secret) => `OTP_FOR_${secret}`,
+                },
+                log: (m) => console.log(`[Plugin Log]: ${m}`),
+                expect: {
+                    visible: async (s) => {
+                        try {
+                            await this.web.expectVisible(s);
+                            return true;
+                        }
+                        catch {
+                            throw new Error(`Assertion Failed: Expected element "${s}" to be visible.`);
+                        }
+                    },
+                    equals: (actual, expected, message) => {
+                        if (actual !== expected) {
+                            throw new Error(message ||
+                                `Assertion Failed: Expected "${expected}", but got "${actual}".`);
+                        }
+                    },
+                    contains: (actual, expected, message) => {
+                        if (!actual.includes(expected)) {
+                            throw new Error(message ||
+                                `Assertion Failed: Expected "${actual}" to contain "${expected}".`);
+                        }
+                    },
+                },
+                utils: {
+                    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+                    generateId: (length = 8) => Math.random()
+                        .toString(36)
+                        .substring(2, 2 + length),
+                },
+            };
+            const result = await action(sdk, args);
+            if (saveAs) {
+                this.store.set(saveAs, result);
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Plugin Execution Failed (${actionName}): ${error.message}`);
+        }
+    }
+}
+exports.PluginManager = PluginManager;

package/dist/runner/temporary_store.d.ts

@@ -0,0 +1,8 @@
+export declare class TemporaryStore {
+    private store;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    has(key: string): boolean;
+    clear(): void;
+    getAll(): Record<string, any>;
+}

package/dist/runner/temporary_store.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemporaryStore = void 0;
+class TemporaryStore {
+    store = new Map();
+    set(key, value) {
+        this.store.set(key, value);
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    has(key) {
+        return this.store.has(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+    getAll() {
+        return Object.fromEntries(this.store);
+    }
+}
+exports.TemporaryStore = TemporaryStore;

package/dist/runner/worker_entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runner/worker_entry.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flow_worker_1 = require("./flow_worker");
+const playwright_1 = require("../adapters/web/playwright");
+const undici_1 = require("../adapters/api/undici");
+const temporary_store_1 = require("./temporary_store");
+const manager_1 = require("../sessions/manager");
+const persistent_vault_1 = require("./persistent_vault");
+const plugin_manager_1 = require("./plugin_manager");
+const api_proxy_1 = require("../sdk/api_proxy");
+process.on("message", async (message) => {
+    if (message.type === "START_RUN") {
+        const { files, config } = message.payload;
+        try {
+            const web = new playwright_1.WebAdapter(config);
+            const api = new undici_1.ApiAdapter(config);
+            const store = new temporary_store_1.TemporaryStore();
+            const apiProxy = new api_proxy_1.ApiProxy(api);
+            const pluginManager = new plugin_manager_1.PluginManager(config, web, store, apiProxy);
+            const vault = new persistent_vault_1.PersistentVault(process.cwd());
+            const sessions = new manager_1.SessionManager(web, api, vault);
+            const worker = new flow_worker_1.FlowWorker(config, web, api, store, sessions, pluginManager);
+            const workerResults = [];
+            let currentFileName = "Unknown";
+            let currentScenarioName = "Unknown";
+            worker.on("worker_event", (data) => {
+                if (data.type === "RUN_START") {
+                    currentFileName = data.payload.fileName;
+                    currentScenarioName = data.payload.scenarioName;
+                }
+                if (data.type === "STEP_UPDATE") {
+                    let fileGroup = workerResults.find((r) => r.fileName === currentFileName);
+                    if (!fileGroup) {
+                        fileGroup = { fileName: currentFileName, steps: [] };
+                        workerResults.push(fileGroup);
+                    }
+                    fileGroup.steps.push({
+                        id: data.payload.id,
+                        status: data.payload.status,
+                    });
+                }
+                if (process.send) {
+                    process.send(data);
+                }
+            });
+            await worker.runBatch(files);
+            if (process.send) {
+                process.send({
+                    type: "WORKER_COMPLETE",
+                    payload: { status: "success", results: workerResults },
+                });
+            }
+        }
+        catch (error) {
+            if (process.send) {
+                process.send({
+                    type: "WORKER_COMPLETE",
+                    payload: { status: "error", error: error.message },
+                });
+            }
+        }
+    }
+});

package/dist/sdk/api_proxy.d.ts

@@ -0,0 +1,8 @@
+import { ApiAdapter } from "../adapters/api/undici";
+export declare class ApiProxy {
+    private adapter;
+    constructor(adapter: ApiAdapter);
+    private formatHeaders;
+    get(url: string, headers?: Record<string, string>): Promise<any>;
+    post(url: string, body: any, headers?: Record<string, string>): Promise<any>;
+}

package/dist/sdk/api_proxy.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiProxy = void 0;
+class ApiProxy {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    formatHeaders(headers) {
+        if (!headers)
+            return [];
+        return Object.entries(headers).map(([key, value]) => ({ key, value }));
+    }
+    async get(url, headers) {
+        const formattedHeaders = this.formatHeaders(headers);
+        await this.adapter.get(url, formattedHeaders);
+        const state = this.adapter.getState();
+        return state.body;
+    }
+    async post(url, body, headers) {
+        const formattedHeaders = this.formatHeaders(headers);
+        const stringifiedBody = typeof body === "string" ? body : JSON.stringify(body);
+        await this.adapter.post(url, formattedHeaders, stringifiedBody);
+        const state = this.adapter.getState();
+        return state.body;
+    }
+}
+exports.ApiProxy = ApiProxy;

package/dist/sdk/db_proxy.d.ts

@@ -0,0 +1,3 @@
+export declare class DbProxy {
+    connect(connectionString: string): any;
+}

package/dist/sdk/db_proxy.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbProxy = void 0;
+class DbProxy {
+    connect(connectionString) {
+        console.log(`Plugin establishing secure connection to: ${connectionString}`);
+        return {
+            queryOne: async (sql, params) => {
+                console.log(`Executing safe query: ${sql}`);
+                return {};
+            },
+        };
+    }
+}
+exports.DbProxy = DbProxy;

package/dist/sessions/manager.d.ts

@@ -0,0 +1,17 @@
+import { WebAdapter } from '../adapters/web/playwright';
+import { ApiAdapter } from '../adapters/api/undici';
+import { PersistentVault } from '../runner/persistent_vault';
+import { SessionDefinition } from '../types';
+export declare class SessionManager {
+    private web;
+    private api;
+    private vault;
+    private activeSession;
+    private definitions;
+    constructor(web: WebAdapter, api: ApiAdapter, vault: PersistentVault);
+    register(definition: SessionDefinition): void;
+    private handleUnauthorized;
+    private updateSessionData;
+    useSession(name: string): Promise<void>;
+    saveCurrentState(name: string, persist: boolean): Promise<void>;
+}

package/dist/sessions/manager.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+class SessionManager {
+    web;
+    api;
+    vault;
+    activeSession = null;
+    definitions = new Map();
+    constructor(web, api, vault) {
+        this.web = web;
+        this.api = api;
+        this.vault = vault;
+        this.api.setUnauthorizedHandler(() => this.handleUnauthorized());
+    }
+    register(definition) {
+        this.definitions.set(definition.name, definition);
+    }
+    async handleUnauthorized() {
+        if (!this.activeSession)
+            return;
+        const definition = this.definitions.get(this.activeSession.name);
+        if (definition?.refresh) {
+            const newTokens = await definition.refresh.action(this.activeSession.tokens);
+            await this.updateSessionData(this.activeSession.name, newTokens);
+        }
+    }
+    async updateSessionData(name, tokens) {
+        const data = this.vault.get(`session_${name}`) || {
+            name,
+            createdAt: Date.now(),
+            persist: true,
+        };
+        data.tokens = tokens;
+        data.lastUsedAt = Date.now();
+        this.vault.save(`session_${name}`, data);
+        this.activeSession = data;
+        await this.web.injectStorage(data.cookies, data.localStorage);
+        const definition = this.definitions.get(name);
+        if (definition?.inject?.api) {
+            const { headerName, template } = definition.inject.api;
+            const token = tokens.accessToken || tokens.idToken;
+            this.api.setGlobalHeader(headerName, template.replace('{{token}}', token));
+        }
+    }
+    async useSession(name) {
+        const definition = this.definitions.get(name);
+        if (!definition)
+            throw new Error(`Session "${name}" not defined.`);
+        let data = this.vault.get(`session_${name}`);
+        if (!data) {
+            const tokens = await definition.acquire();
+            await this.updateSessionData(name, tokens);
+        }
+        else {
+            this.activeSession = data;
+            await this.updateSessionData(name, data.tokens);
+        }
+    }
+    async saveCurrentState(name, persist) {
+        const state = await this.web.getState();
+        const data = {
+            name,
+            tokens: this.activeSession?.tokens || {},
+            cookies: state.cookies,
+            localStorage: state.localStorage,
+            createdAt: Date.now(),
+            lastUsedAt: Date.now(),
+            persist,
+        };
+        this.vault.save(`session_${name}`, data);
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/sessions/types.d.ts

@@ -0,0 +1,39 @@
+export interface FlowstrideConfig {
+    baseUrl?: string;
+    timeout: number;
+    headless: boolean;
+    network?: {
+        include?: string[];
+        exclude?: string[];
+        backgroundPatterns?: string[];
+    };
+}
+export interface SessionDefinition {
+    name: string;
+    acquire: () => Promise<Record<string, any>>;
+    inject?: {
+        api?: Record<string, string>;
+        ui?: {
+            localStorage?: Record<string, string>;
+            cookies?: Array<{
+                name: string;
+                value: string;
+                domain: string;
+            }>;
+        };
+    };
+    refresh?: {
+        onStatus: number[];
+        action: () => Promise<Record<string, any>>;
+    };
+}
+export interface Scenario {
+    name: string;
+    steps: any[];
+}
+export interface ScenarioResult {
+    name: string;
+    status: "PASS" | "FAIL" | "ERROR" | "SKIPPED" | "NOT TESTED";
+    duration: number;
+    error?: string;
+}

package/dist/sessions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sessions/vault.d.ts

@@ -0,0 +1,8 @@
+export declare class PersistentVault {
+    private vaultPath;
+    constructor();
+    private ensureVaultExists;
+    save(name: string, data: any): void;
+    load(name: string): any | null;
+    exists(name: string): boolean;
+}

package/dist/sessions/vault.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentVault = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class PersistentVault {
+    vaultPath;
+    constructor() {
+        this.vaultPath = path.join(process.cwd(), ".flowstride", "vault");
+        this.ensureVaultExists();
+    }
+    ensureVaultExists() {
+        if (!fs.existsSync(this.vaultPath)) {
+            fs.mkdirSync(this.vaultPath, { recursive: true });
+        }
+    }
+    save(name, data) {
+        const filePath = path.join(this.vaultPath, `${name}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    }
+    load(name) {
+        const filePath = path.join(this.vaultPath, `${name}.json`);
+        if (!fs.existsSync(filePath))
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(filePath, "utf8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    exists(name) {
+        return fs.existsSync(path.join(this.vaultPath, `${name}.json`));
+    }
+}
+exports.PersistentVault = PersistentVault;