flowstride 1.0.11 → 1.0.13

package/dist/adapters/web/playwright.d.ts

@@ -26,6 +26,7 @@ export declare class WebAdapter {
     private checkAmbiguity;
     close(targetText: string): Promise<void>;
     click(selector: string, elementType?: string): Promise<void>;
+    hover(selector: string, elementType?: string): Promise<void>;
     type(selector: string, value: string, elementType?: string): Promise<void>;
     passcode(selector: string, value: string, elementType?: string): Promise<void>;
     check(selector: string, elementType?: string): Promise<void>;

package/dist/adapters/web/playwright.js

@@ -397,6 +397,66 @@ class WebAdapter {
         await targetLoc.scrollIntoViewIfNeeded();
         await targetLoc.click();
     }
+    async hover(selector, elementType) {
+        const loc = await this.getLocator(selector, elementType, false, false);
+        const targetLoc = await this.checkAmbiguity(loc, selector);
+        await targetLoc.waitFor({ state: "visible" });
+        await targetLoc.scrollIntoViewIfNeeded();
+        // 1. Accessibility WAI-ARIA Hack (Focus)
+        await targetLoc.focus({ timeout: 3000 }).catch(() => { });
+        await targetLoc
+            .evaluate((node) => {
+            if (typeof node.focus === "function")
+                node.focus();
+        })
+            .catch(() => { });
+        // 2. Get Exact Center Coordinates for Physical Move
+        let box = null;
+        try {
+            box = await targetLoc.boundingBox({ timeout: 3000 });
+        }
+        catch (e) { } // Catch in case it mutated instantly during focus
+        if (box) {
+            const centerX = box.x + box.width / 2;
+            const centerY = box.y + box.height / 2;
+            // Physically drag the mouse to the element to satisfy Hover Intent APIs
+            await this.page.mouse.move(centerX, centerY, { steps: 5 });
+        }
+        // 3. Playwright Native Hover Backup (Caught to prevent mutation crashes)
+        await targetLoc.hover({ force: true, timeout: 3000 }).catch(() => { });
+        // 4. The Ultimate Wakeup Call: Synthesize Full Coordinate-Loaded Events
+        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(() => { });
+        // 5. We perform a programmatic click that won't trigger W3C navigation if handled by React toggles
+        await targetLoc
+            .click({ delay: 50, force: true, timeout: 3000 })
+            .catch(() => { });
+        // 6. The Paint Buffer
+        await this.page.waitForTimeout(600);
+    }
     async type(selector, value, elementType) {
         const loc = await this.getLocator(selector, elementType, false, false);
         const targetLoc = await this.checkAmbiguity(loc, selector);

package/dist/cli/index.js

@@ -54,7 +54,7 @@ const API_BASE = process.env.FLOWSTRIDE_API_URL || "https://cloud.flowstride.io"
 program
     .name("flowstride")
     .description("Flowstride: The Enterprise Flow-First Automation CLI")
-    .version("1.0.11");
+    .version("1.0.13");
 program
     .command("init")
     .description("Initialise a new Flowstride workspace in the current directory")

package/dist/parser/lexer.js

@@ -129,7 +129,9 @@ class Lexer {
                     tokens.push({ type: TokenType.LET, value: ident, line: this.line });
                     continue;
                 }
-                if (lowerIdent === "feature" || lowerIdent === "scenario") {
+                if (lowerIdent === "feature" ||
+                    lowerIdent === "scenario" ||
+                    lowerIdent === "only.scenario") {
                     let tempPos = this.position;
                     while (tempPos < this.input.length &&
                         (this.input[tempPos] === " " || this.input[tempPos] === "\t"))
@@ -205,6 +207,7 @@ class Lexer {
                         "autoheal",
                         "mail.getotp",
                         "extract",
+                        "hover",
                     ];
                     if (validNakedCommands.map((c) => c.toLowerCase()).includes(lowerIdent)) {
                         tokens.push({
@@ -226,7 +229,16 @@ class Lexer {
                         throw new SyntaxError(`Syntax Error on line ${this.line}: Expected an action command after 'flow.try', but found "${ident}".`);
                     }
                 }
-                if (["given", "when", "then", "and"].includes(lowerIdent)) {
+                if ([
+                    "given",
+                    "when",
+                    "then",
+                    "and",
+                    "stop.given",
+                    "stop.when",
+                    "stop.then",
+                    "stop.and",
+                ].includes(lowerIdent)) {
                     let tempPos = this.position;
                     while (tempPos < this.input.length &&
                         (this.input[tempPos] === " " || this.input[tempPos] === "\t"))
@@ -268,6 +280,7 @@ class Lexer {
                     "flow.autoheal",
                     "flow.mail.getotp",
                     "flow.extract",
+                    "flow.hover",
                 ]
                     .map((c) => c.toLowerCase())
                     .includes(lowerIdent)) {
@@ -290,14 +303,16 @@ class Lexer {
                     "contains",
                     "placeholder",
                     "status",
-                    "responsetime",
-                    "reqbody",
-                    "resbody",
-                    "reqheader",
-                    "resheader",
+                    "responseTime",
+                    "reqBody",
+                    "resBody",
+                    "reqHeader",
+                    "resHeader",
                     "cookie",
                     "global",
-                ].includes(lowerIdent)) {
+                ]
+                    .map((c) => c.toLowerCase())
+                    .includes(lowerIdent)) {
                     tokens.push({
                         type: TokenType.MODIFIER,
                         value: ident,
@@ -314,6 +329,8 @@ class Lexer {
                     "span",
                     "image",
                     "img",
+                    "burger",
+                    "hamburger",
                 ].includes(lowerIdent)) {
                     tokens.push({
                         type: TokenType.ELEMENT,

package/dist/parser/parser.d.ts

@@ -10,11 +10,13 @@ export interface StepNode {
     action: string;
     payload: any;
     line: number;
+    isStop?: boolean;
 }
 export interface ScenarioNode {
     name: string;
     declarations: DeclarationNode[];
     steps: StepNode[];
+    isOnly?: boolean;
 }
 export interface FeatureNode {
     name: string;
@@ -26,6 +28,10 @@ export declare class Parser {
     private position;
     private currentBlockDescription;
     private stepCounter;
+    private scenarioCounter;
+    private hasOnlyScenario;
+    private hasStopInCurrentScenario;
+    private currentBlockIsStop;
     constructor(tokens: Token[]);
     parse(): FeatureNode[];
     private parseDeclaration;

package/dist/parser/parser.js

@@ -7,6 +7,10 @@ class Parser {
     position = 0;
     currentBlockDescription = "";
     stepCounter = 1;
+    scenarioCounter = 0;
+    hasOnlyScenario = false;
+    hasStopInCurrentScenario = false;
+    currentBlockIsStop = false;
     constructor(tokens) {
         this.tokens = tokens;
     }
@@ -68,15 +72,25 @@ class Parser {
         };
     }
     parseScenario() {
-        this.advance();
+        const scenarioToken = this.advance();
+        const isOnly = scenarioToken.value.toLowerCase() === "only.scenario";
+        if (isOnly) {
+            if (this.hasOnlyScenario) {
+                throw new Error(`Line ${scenarioToken.line}: You cannot have more than one 'only.Scenario' in a single file.`);
+            }
+            this.hasOnlyScenario = true;
+        }
+        this.hasStopInCurrentScenario = false;
         const nameToken = this.consume(lexer_1.TokenType.STRING, "Scenario must have a description");
         const steps = [];
         const declarations = [];
+        this.scenarioCounter++;
         this.stepCounter = 1;
         let state = "START";
         let hasGiven = false, hasWhen = false, hasAnd = false, hasThen = false;
         let isLocked = false;
         let currentBlockType = "";
+        this.currentBlockIsStop = false;
         while (!this.isAtEnd() &&
             this.peek().type !== lexer_1.TokenType.SCENARIO &&
             this.peek().type !== lexer_1.TokenType.FEATURE) {
@@ -88,7 +102,19 @@ class Parser {
                 if (isLocked)
                     throw new Error(`Line ${token.line}: Terminal Lock Violation. No steps allowed after Then.`);
                 const blockToken = this.advance();
-                const blockType = blockToken.value.toLowerCase();
+                let rawBlockType = blockToken.value.toLowerCase();
+                if (rawBlockType.startsWith("stop.")) {
+                    if (this.hasStopInCurrentScenario) {
+                        throw new Error(`Line ${blockToken.line}: You cannot have more than one 'stop.' block in a single scenario.`);
+                    }
+                    this.hasStopInCurrentScenario = true;
+                    this.currentBlockIsStop = true;
+                    rawBlockType = rawBlockType.replace("stop.", "");
+                }
+                else {
+                    this.currentBlockIsStop = false;
+                }
+                const blockType = rawBlockType;
                 let description = this.peek().type === lexer_1.TokenType.STRING ? this.advance().value : "";
                 if (blockType === "given") {
                     if (state !== "START")
@@ -116,9 +142,10 @@ class Parser {
                     hasAnd = true;
                 }
                 currentBlockType = blockType;
+                const displayBlockName = blockType.charAt(0).toUpperCase() + blockType.slice(1);
                 this.currentBlockDescription = description
-                    ? `${blockToken.value} "${description}"`
-                    : blockToken.value;
+                    ? `${displayBlockName} "${description}"`
+                    : displayBlockName;
             }
             else if (token.type === lexer_1.TokenType.COMMAND ||
                 token.type === lexer_1.TokenType.ALIAS_COMMAND) {
@@ -126,6 +153,9 @@ class Parser {
                     throw new Error(`Line ${token.line}: Terminal Lock Violation.`);
                 }
                 const step = this.parseCommand();
+                if (this.currentBlockIsStop) {
+                    step.isStop = true;
+                }
                 if (currentBlockType === "and" &&
                     step.action !== "expect" &&
                     step.action !== "plugin") {
@@ -140,7 +170,15 @@ class Parser {
         if (!hasGiven || !hasWhen || !hasThen) {
             throw new Error(`Scenario "${nameToken.value}" is missing mandatory blocks.`);
         }
-        return { name: nameToken.value, declarations, steps };
+        const scenarioNode = {
+            name: nameToken.value,
+            declarations,
+            steps,
+        };
+        if (isOnly) {
+            scenarioNode.isOnly = true;
+        }
+        return scenarioNode;
     }
     parseSmartSelectorPayload() {
         let selector = "";
@@ -202,7 +240,7 @@ class Parser {
                 dataPayload = this.advance().value;
             }
             return {
-                id: `S${this.stepCounter++}`,
+                id: `scenario_${this.scenarioCounter}_S${this.stepCounter++}`,
                 blockDescription: this.currentBlockDescription,
                 action: "plugin",
                 payload: {
@@ -259,26 +297,32 @@ class Parser {
             autoheal: "autoHeal",
             "mail.getotp": "getOtp",
             extract: "extract",
+            hover: "hover",
         };
         const action = actionMap[actionBase] || actionBase;
         let payload = { optional: isOptional };
         switch (action) {
             case "extract":
                 const extTargetToken = this.consume(lexer_1.TokenType.MODIFIER, "Expected target after extract");
-                const extTarget = extTargetToken.value.toLowerCase();
-                let normalizedTarget = extTarget;
-                if (extTarget === "resbody")
-                    normalizedTarget = "resBody";
-                else if (extTarget === "reqbody")
-                    normalizedTarget = "reqBody";
-                else if (extTarget === "resheader")
-                    normalizedTarget = "resHeader";
-                else if (extTarget === "reqheader")
-                    normalizedTarget = "reqHeader";
-                if (!["resBody", "resHeader", "cookie"].includes(normalizedTarget)) {
+                const extTarget = extTargetToken.value;
+                if (extTarget.toLowerCase() === "resbody" && extTarget !== "resBody") {
+                    throw new Error(`Syntax Error on line ${extTargetToken.line}: Invalid keyword '${extTarget}'. Flowstride uses strict camelCase. Did you mean 'resBody'?`);
+                }
+                if (extTarget.toLowerCase() === "reqbody" && extTarget !== "reqBody") {
+                    throw new Error(`Syntax Error on line ${extTargetToken.line}: Invalid keyword '${extTarget}'. Flowstride uses strict camelCase. Did you mean 'reqBody'?`);
+                }
+                if (extTarget.toLowerCase() === "resheader" &&
+                    extTarget !== "resHeader") {
+                    throw new Error(`Syntax Error on line ${extTargetToken.line}: Invalid keyword '${extTarget}'. Flowstride uses strict camelCase. Did you mean 'resHeader'?`);
+                }
+                if (extTarget.toLowerCase() === "reqheader" &&
+                    extTarget !== "reqHeader") {
+                    throw new Error(`Syntax Error on line ${extTargetToken.line}: Invalid keyword '${extTarget}'. Flowstride uses strict camelCase. Did you mean 'reqHeader'?`);
+                }
+                if (!["resBody", "resHeader", "cookie"].includes(extTarget)) {
                     throw new Error(`Line ${extTargetToken.line}: Expected 'resBody', 'resHeader', or 'cookie' after extract`);
                 }
-                payload.target = normalizedTarget;
+                payload.target = extTarget;
                 payload.jsonPath = this.consume(lexer_1.TokenType.STRING, "JSONPath or Key expected").value;
                 const asToken = this.advance();
                 if (asToken.value.toLowerCase() !== "as") {
@@ -333,8 +377,19 @@ class Parser {
             case "forceClick":
             case "check":
             case "uncheck":
+            case "hover":
                 this.consumeOptionalElement(payload);
-                payload.selector = this.parseSmartSelectorPayload();
+                if (["burger", "hamburger"].includes(payload.elementType)) {
+                    if (!this.isAtEnd() && this.peek().type === lexer_1.TokenType.STRING) {
+                        payload.selector = this.parseSmartSelectorPayload();
+                    }
+                    else {
+                        payload.selector = "smart-burger-fallback";
+                    }
+                }
+                else {
+                    payload.selector = this.parseSmartSelectorPayload();
+                }
                 break;
             case "type":
             case "forceType":
@@ -426,16 +481,21 @@ class Parser {
                 break;
             case "expect":
                 const modToken = this.consume(lexer_1.TokenType.MODIFIER, "Modifier expected");
-                let mod = modToken.value.toLowerCase();
-                if (mod === "resbody")
-                    mod = "resBody";
-                if (mod === "resheader")
-                    mod = "resHeader";
+                const mod = modToken.value;
+                if (mod.toLowerCase() === "resbody" && mod !== "resBody") {
+                    throw new Error(`Syntax Error on line ${modToken.line}: Invalid keyword '${mod}'. Flowstride uses strict camelCase. Did you mean 'resBody'?`);
+                }
+                if (mod.toLowerCase() === "resheader" && mod !== "resHeader") {
+                    throw new Error(`Syntax Error on line ${modToken.line}: Invalid keyword '${mod}'. Flowstride uses strict camelCase. Did you mean 'resHeader'?`);
+                }
+                if (mod.toLowerCase() === "responsetime" && mod !== "responseTime") {
+                    throw new Error(`Syntax Error on line ${modToken.line}: Invalid keyword '${mod}'. Flowstride uses strict camelCase. Did you mean 'responseTime'?`);
+                }
                 payload.type = mod;
                 if (mod === "status") {
                     payload.statusCode = this.consume(lexer_1.TokenType.STRING, 'Status code expected (e.g., "200")').value;
                 }
-                else if (mod === "responsetime") {
+                else if (mod === "responseTime") {
                     const conditionToken = this.advance();
                     if (conditionToken.value.toLowerCase() !== "lessthan") {
                         throw new Error(`Line ${modToken.line}: Expected 'lessThan' after responseTime`);
@@ -502,7 +562,17 @@ class Parser {
                         payload.fuzzy = true;
                     }
                     this.consumeOptionalElement(payload);
-                    payload.selector = this.parseSmartSelectorPayload();
+                    if (["burger", "hamburger"].includes(payload.elementType)) {
+                        if (!this.isAtEnd() && this.peek().type === lexer_1.TokenType.STRING) {
+                            payload.selector = this.parseSmartSelectorPayload();
+                        }
+                        else {
+                            payload.selector = "smart-burger-fallback";
+                        }
+                    }
+                    else {
+                        payload.selector = this.parseSmartSelectorPayload();
+                    }
                 }
                 else if (mod === "value" || mod === "attribute") {
                     this.consumeOptionalElement(payload);
@@ -523,7 +593,7 @@ class Parser {
                 throw new Error(`Unknown command: ${action}`);
         }
         return {
-            id: `S${this.stepCounter++}`,
+            id: `scenario_${this.scenarioCounter}_S${this.stepCounter++}`,
             blockDescription: this.currentBlockDescription,
             action,
             payload,
@@ -537,13 +607,19 @@ class Parser {
             if (nextToken.type === lexer_1.TokenType.PREPOSITION && nextVal === "with") {
                 this.advance();
                 const targetToken = this.advance();
-                const target = targetToken.value.toLowerCase();
-                if (target === "reqheader") {
+                const target = targetToken.value;
+                if (target.toLowerCase() === "reqbody" && target !== "reqBody") {
+                    throw new Error(`Syntax Error on line ${targetToken.line}: Invalid keyword '${target}'. Flowstride uses strict camelCase. Did you mean 'reqBody'?`);
+                }
+                if (target.toLowerCase() === "reqheader" && target !== "reqHeader") {
+                    throw new Error(`Syntax Error on line ${targetToken.line}: Invalid keyword '${target}'. Flowstride uses strict camelCase. Did you mean 'reqHeader'?`);
+                }
+                if (target === "reqHeader") {
                     const hKey = this.consume(lexer_1.TokenType.STRING, "Header key expected").value;
                     const hVal = this.consume(lexer_1.TokenType.STRING, "Header value expected").value;
                     payload.headers.push({ key: hKey, value: hVal });
                 }
-                else if (target === "reqbody") {
+                else if (target === "reqBody") {
                     payload.body = this.consume(lexer_1.TokenType.STRING, "Body content expected").value;
                 }
                 else {

package/dist/runner/flow_orchestrator.d.ts

@@ -9,6 +9,7 @@ export declare class FlowOrchestrator {
     private globalTestScenarios;
     private stepStatusRegistry;
     private pdfGenerator;
+    private disconnectTimer;
     constructor(worker: FlowWorker, workerCount?: number, config?: FlowstrideConfig | undefined);
     private forwardToDashboard;
     private executeTestRun;

package/dist/runner/flow_orchestrator.js

@@ -53,6 +53,7 @@ class FlowOrchestrator {
     globalTestScenarios = [];
     stepStatusRegistry = new Map();
     pdfGenerator;
+    disconnectTimer = null;
     constructor(worker, workerCount = 1, config) {
         this.worker = worker;
         this.workerCount = workerCount;
@@ -222,6 +223,10 @@ class FlowOrchestrator {
             });
             this.wss = new ws_1.WebSocketServer({ server: this.httpServer });
             this.wss.on("connection", (ws) => {
+                if (this.disconnectTimer) {
+                    clearTimeout(this.disconnectTimer);
+                    this.disconnectTimer = null;
+                }
                 ws.on("message", async (message) => {
                     const data = JSON.parse(message.toString());
                     if (data.type === "EXPORT_PDF_REQ") {
@@ -255,6 +260,21 @@ class FlowOrchestrator {
                         this.forwardToDashboard("RUN_COMPLETE", { status: "aborted" });
                     }
                 });
+                ws.on("close", () => {
+                    if (this.wss && this.wss.clients.size === 0) {
+                        this.disconnectTimer = setTimeout(async () => {
+                            console.log(chalk_1.default.yellow("\n[Flowstride]: Dashboard disconnected. Shutting down framework..."));
+                            this.worker.abort();
+                            try {
+                                await this.worker.shutdown();
+                            }
+                            catch (e) { }
+                            this.wss?.close();
+                            this.httpServer?.close();
+                            process.exit(0);
+                        }, 3000);
+                    }
+                });
             });
             this.httpServer.listen(0, async () => {
                 const address = this.httpServer?.address();
@@ -273,11 +293,6 @@ class FlowOrchestrator {
                 console.log(chalk_1.default.green("[Dashboard]: Connected to UI!"));
                 await this.executeTestRun(targetPath);
             });
-            process.on("SIGINT", () => {
-                this.wss?.close();
-                this.httpServer?.close();
-                process.exit();
-            });
         }
         catch (e) {
             throw e;

package/dist/runner/flow_worker.d.ts

@@ -21,6 +21,7 @@ export declare class FlowWorker extends EventEmitter {
     private pluginManager?;
     private isSilent;
     private isAborted;
+    private isDebugHalted;
     private currentStepContext;
     private currentFileName;
     private activeAudioPath;