flowstride 1.0.0

package/dist/cli/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initAction(): Promise<void>;

package/dist/cli/commands/init.js

@@ -0,0 +1,77 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAction = initAction;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+async function initAction() {
+    const root = process.cwd();
+    const folders = ["flows", "reports", "plugins"];
+    const sampleFlowPath = path.join(root, "flows", "welcome.flow");
+    console.log(chalk_1.default.cyan("\n🚀 Flowstride: Initialising new workspace..."));
+    folders.forEach((folder) => {
+        const dirPath = path.join(root, folder);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath);
+            console.log(`${chalk_1.default.green("✔")} Created ${folder}/`);
+        }
+        else {
+            console.log(`${chalk_1.default.yellow("ℹ")} ${folder}/ already exists, skipping.`);
+        }
+    });
+    const welcomeContent = `Feature: Getting Started
+
+Scenario: Verify Flowstride is Ready
+
+Given "User lands on the sample page";
+  flow.open "https://example.com";
+
+When "User confirms Welcome!";
+  flow.expect text "Welcome!";
+
+Then "Verify the main heading is visible";
+  flow.expect visible "h1";
+`;
+    if (!fs.existsSync(sampleFlowPath)) {
+        fs.writeFileSync(sampleFlowPath, welcomeContent);
+        console.log(`${chalk_1.default.green("✔")} Created flows/welcome.flow`);
+    }
+    console.log(chalk_1.default.bold.green("\n✨ Workspace ready!"));
+    console.log(`Try running: ${chalk_1.default.cyan("flowstride run flows/welcome.flow")}\n`);
+}

package/dist/cli/commands/report.d.ts

@@ -0,0 +1 @@
+export declare function reportAction(): Promise<void>;

package/dist/cli/commands/report.js

@@ -0,0 +1,78 @@
+"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.reportAction = reportAction;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+async function reportAction() {
+    console.log("📊 Flowstride: Launching Debug Dashboard...");
+    const targetProjectPath = process.cwd();
+    const latestReportPath = path.join(targetProjectPath, "reports", "latest");
+    const cliInstallPath = path.resolve(__dirname, "../../..");
+    const reportPackagePath = path.join(cliInstallPath, "packages", "flowstride_report");
+    const publicPath = path.join(reportPackagePath, "public");
+    const runDataPath = path.join(latestReportPath, "run-data.json");
+    if (!fs.existsSync(runDataPath)) {
+        console.error('❌ Error: No run data found. Run "flowstride run" first to generate a report.');
+        return;
+    }
+    if (!fs.existsSync(publicPath)) {
+        fs.mkdirSync(publicPath, { recursive: true });
+    }
+    fs.copyFileSync(runDataPath, path.join(publicPath, "run-data.json"));
+    const sourceScreenshots = path.join(latestReportPath, "screenshots");
+    const targetScreenshots = path.join(publicPath, "screenshots");
+    if (fs.existsSync(sourceScreenshots)) {
+        if (!fs.existsSync(targetScreenshots)) {
+            fs.mkdirSync(targetScreenshots, { recursive: true });
+        }
+        const files = fs.readdirSync(sourceScreenshots);
+        for (const file of files) {
+            fs.copyFileSync(path.join(sourceScreenshots, file), path.join(targetScreenshots, file));
+        }
+        console.log(`📸 Synced ${files.length} screenshots to dashboard.`);
+    }
+    try {
+        console.log("Serving report at http://localhost:5173...");
+        (0, child_process_1.execSync)("npm run dev", {
+            cwd: reportPackagePath,
+            stdio: "inherit",
+        });
+    }
+    catch (error) {
+        console.error("❌ CLI Error: Could not launch report dashboard.");
+    }
+}

package/dist/cli/commands/run.d.ts

@@ -0,0 +1 @@
+export declare function runAction(targetPath: string | undefined, options: Record<string, any>): Promise<void>;

package/dist/cli/commands/run.js

@@ -0,0 +1,158 @@
+"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.runAction = runAction;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const dotenv = __importStar(require("dotenv"));
+const os = __importStar(require("os"));
+const flow_worker_1 = require("../../runner/flow_worker");
+const flow_orchestrator_1 = require("../../runner/flow_orchestrator");
+const playwright_1 = require("../../adapters/web/playwright");
+const undici_1 = require("../../adapters/api/undici");
+const temporary_store_1 = require("../../runner/temporary_store");
+const manager_1 = require("../../sessions/manager");
+const persistent_vault_1 = require("../../runner/persistent_vault");
+const plugin_manager_1 = require("../../runner/plugin_manager");
+const api_proxy_1 = require("../../sdk/api_proxy");
+async function runAction(targetPath, options) {
+    const root = process.cwd();
+    const profileEnvPath = options.env
+        ? path.resolve(root, `.env.${options.env}`)
+        : null;
+    const defaultEnvPath = path.resolve(root, ".env");
+    if (profileEnvPath) {
+        if (fs.existsSync(profileEnvPath)) {
+            dotenv.config({ path: profileEnvPath });
+            console.log(`[Environment]: Loaded profile "${options.env}"`);
+        }
+        else {
+            console.warn(`[Environment Warning]: --env ${options.env} was passed, but .env.${options.env} does not exist.`);
+        }
+    }
+    if (fs.existsSync(defaultEnvPath)) {
+        dotenv.config({ path: defaultEnvPath });
+        if (!options.env) {
+            console.log(`[Environment]: Loaded default .env file`);
+        }
+    }
+    const isCI = !!(process.env.CI ||
+        process.env.GITHUB_ACTIONS ||
+        process.env.GITLAB_CI ||
+        process.env.CIRCLECI ||
+        process.env.JENKINS_URL);
+    if (isCI) {
+        console.log("\n[CI/CD]: Environment detected. Engaging Smart Automation Behaviors...");
+    }
+    const resolvedPath = targetPath
+        ? path.resolve(root, targetPath)
+        : path.resolve(root, "flows");
+    if (!fs.existsSync(resolvedPath)) {
+        console.error(`\n[Error]: Cannot find target path "${resolvedPath}".`);
+        console.log(`[Info]: Try running 'flowstride init' to create a workspace first.\n`);
+        process.exit(1);
+    }
+    console.log(`\n[Flowstride]: Starting execution suite at "${resolvedPath}"...`);
+    const configPath = path.resolve(root, "flowstride.config.json");
+    let localConfig = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            const fileContent = fs.readFileSync(configPath, "utf-8");
+            localConfig = JSON.parse(fileContent);
+            console.log(`[Config]: Loaded project configuration from flowstride.config.json`);
+        }
+        catch (e) {
+            console.warn(`[Warning]: Could not parse flowstride.config.json: ${e.message}`);
+        }
+    }
+    const config = {
+        headless: isCI ? true : (options.headless ?? localConfig.headless ?? true),
+        timeout: localConfig.timeout ?? 30000,
+        bail: options.bail ?? localConfig.bail ?? false,
+        baseUrl: process.env.BASE_URL ?? localConfig.baseUrl,
+        defaultDialogBehavior: isCI
+            ? "dismiss"
+            : (localConfig.defaultDialogBehavior ?? "dismiss"),
+        pluginsDir: localConfig.pluginsDir,
+    };
+    if (isCI) {
+        console.log(`   > Headless Mode: ${config.headless ? "Forced ON" : "OFF"}`);
+        console.log(`   > Dialog Protection: ${(config.defaultDialogBehavior || "dismiss").toUpperCase()}`);
+        console.log(`   > Artifact Auto-Staging: ENABLED\n`);
+    }
+    let workerCount = options.workers ? parseInt(options.workers, 10) : 1;
+    if (isNaN(workerCount) || workerCount < 1) {
+        console.error(`\n[Error]: Invalid worker count "${options.workers}". Must be an integer greater than 0.`);
+        process.exit(1);
+    }
+    const maxSafeWorkers = Math.max(1, os.cpus().length - 1);
+    if (workerCount > maxSafeWorkers) {
+        console.log(`\n[Warning]: You requested ${workerCount} workers, but your CPU only safely supports ${maxSafeWorkers}.`);
+        console.log(`[Warning]: Auto-capping to ${maxSafeWorkers} workers to prevent system thrashing and crashes.\n`);
+        workerCount = maxSafeWorkers;
+    }
+    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(root);
+    const sessions = new manager_1.SessionManager(web, api, vault);
+    const worker = new flow_worker_1.FlowWorker(config, web, api, store, sessions, pluginManager);
+    const orchestrator = new flow_orchestrator_1.FlowOrchestrator(worker, workerCount, config);
+    try {
+        await orchestrator.start(resolvedPath);
+        console.log("\n[Flowstride]: Execution suite completed successfully.");
+        if (isCI) {
+            const artifactsDir = path.resolve(root, "flowstride-artifacts");
+            if (!fs.existsSync(artifactsDir)) {
+                fs.mkdirSync(artifactsDir, { recursive: true });
+            }
+            console.log(`[CI Artifacts]: Test environment artifacts auto-staged to ./flowstride-artifacts/`);
+            process.exit(0);
+        }
+        else {
+            console.log("\n[Dashboard]: Server remains active for Replay and Debugging. Press Ctrl+C to exit.");
+            await new Promise(() => { });
+        }
+    }
+    catch (error) {
+        console.error("\n[Fatal Error]:", error.message);
+        if (isCI) {
+            console.log(`[CI Alert]: Terminating pipeline with exit code 1 to block deployment.`);
+        }
+        process.exit(1);
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const run_1 = require("./commands/run");
+const report_1 = require("./commands/report");
+const init_1 = require("./commands/init");
+const program = new commander_1.Command();
+program
+    .name("flowstride")
+    .description("Flowstride: The Enterprise Flow-First Automation CLI")
+    .version("1.0.0");
+program
+    .command("init")
+    .description("Initialise a new Flowstride workspace in the current directory")
+    .action(async () => {
+    await (0, init_1.initAction)();
+});
+program
+    .command("run")
+    .description("Execute .flow automation journeys")
+    .argument("[path]", "Path to .flow files or directory (defaults to ./flows)")
+    .option("-b, --bail", "Stop execution on first failure", false)
+    .option("--headed", "Run browser in headed mode", false)
+    .option("--headless <boolean>", "Run browser in headless mode", (val) => val === "true", true)
+    .option("--workers <number>", "Number of parallel workers to spawn (Pro feature)")
+    .action(async (path, options) => {
+    if (options.headed) {
+        options.headless = false;
+    }
+    await (0, run_1.runAction)(path, options);
+});
+program
+    .command("report")
+    .description("Launch the interactive Debug Dashboard")
+    .action(async () => {
+    await (0, report_1.reportAction)();
+});
+program.parse(process.argv);

package/dist/parser/lexer.d.ts

@@ -0,0 +1,29 @@
+export declare enum TokenType {
+    FEATURE = "FEATURE",
+    SCENARIO = "SCENARIO",
+    BLOCK = "BLOCK",
+    COMMAND = "COMMAND",
+    MODIFIER = "MODIFIER",
+    SPATIAL = "SPATIAL",
+    PREPOSITION = "PREPOSITION",
+    ELEMENT = "ELEMENT",
+    STRING = "STRING",
+    LET = "LET",
+    ASSIGN = "ASSIGN",
+    ALIAS_COMMAND = "ALIAS_COMMAND",
+    JSON_PAYLOAD = "JSON_PAYLOAD",
+    IDENTIFIER = "IDENTIFIER",
+    EOF = "EOF"
+}
+export interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+}
+export declare class Lexer {
+    private position;
+    private line;
+    private input;
+    constructor(rawInput: string);
+    tokenise(): Token[];
+}