@apica-io/asm-playwright-runner 1.0.0-dev.6 → 1.0.0-dev.8

package/dist/playwright-script.spec.js

@@ -0,0 +1,61 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var test_1 = require("playwright/test");
+function example(page) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, page.goto("https://playwright.dev/")];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, test_1.expect)(page).toHaveTitle(/Playwright/)];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, page.getByRole("link", { name: "Get started" }).click()];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, (0, test_1.expect)(page.getByRole("heading", { name: "Installation" })).toBeVisible()];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.default = example;

package/dist/runner.js

@@ -234,26 +234,16 @@ class PlaywrightRunner {
         }
     }
     async detectScriptType(collectionPath) {
-        try {
-            const mod = await Promise.resolve(`${path_1.default.resolve(collectionPath)}`).then(s => __importStar(require(s)));
-            this.logger.debug("mod", mod, collectionPath);
-            if (typeof mod.default === "function") {
-                this.logger.debug("Detected plain Playwright script (default export).");
-                return runnerConfig_1.ScriptType.PLAYWRIGHT;
-            }
+        const fileContent = fs_1.default.readFileSync(collectionPath, "utf-8");
+        if (fileContent.includes("export default")) {
+            return runnerConfig_1.ScriptType.PLAYWRIGHT;
         }
-        catch {
-            this.logger.debug("Dynamic import failed, falling back to file content check.");
+        if (fileContent.includes("test(")) {
+            return runnerConfig_1.ScriptType.PLAYWRIGHT_TEST;
         }
         if (collectionPath.endsWith(".json")) {
-            this.logger.debug("Detected JSON flow.");
             return runnerConfig_1.ScriptType.JSON;
         }
-        const fileContent = fs_1.default.readFileSync(collectionPath, "utf-8");
-        if (fileContent.includes("test(")) {
-            this.logger.debug("Detected Playwright Test file.");
-            return runnerConfig_1.ScriptType.PLAYWRIGHT_TEST;
-        }
         return undefined;
     }
     async close() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apica-io/asm-playwright-runner",
-  "version": "1.0.0-dev.6",
+  "version": "1.0.0-dev.8",
   "description": "CLI wrapper for Playwright collections or scripts with dynamic actions, config, and test result models.",
   "main": "dist/cli/index.js",
   "bin": {

package/src/actions.js

@@ -0,0 +1,33 @@
+async function assertStringContains(source, expected) {
+    const value = await source();
+    if (!value?.includes(expected)) {
+        throw new Error(`Expected "${expected}" in "${value}"`);
+    }
+}
+export const actionRegistry = {
+    goto: async (page, step) => page.goto(step.url),
+    click: async (page, step) => page.click(step.selector),
+    type: async (page, step) => page.fill(step.selector, step.value),
+    screenshot: async (page, step) => page.screenshot({ path: step.path }),
+    reload: async (page) => page.reload(),
+    waitForSelector: async (page, step) => page.waitForSelector(step.selector),
+    hover: async (page, step) => page.hover(step.selector),
+    dblclick: async (page, step) => page.dblclick(step.selector),
+    check: async (page, step) => page.check(step.selector),
+    uncheck: async (page, step) => page.uncheck(step.selector),
+    selectOption: async (page, step) => page.selectOption(step.selector, step.value),
+    press: async (page, step) => page.press(step.selector, step.key),
+    waitForTimeout: async (page, step) => page.waitForTimeout(step.ms),
+    keyboardType: async (page, step) => page.keyboard.type(step.text),
+    keyboardPress: async (page, step) => page.keyboard.press(step.key),
+    assertText: async (page, step) => assertStringContains(() => page.textContent(step.selector), step.expected),
+    assertTitle: async (page, step) => assertStringContains(() => page.title(), step.expected),
+    uploadFile: async (page, step) => page.setInputFiles(step.selector, step.files),
+    waitForResponse: async (page, step) => page.waitForResponse(step.urlPattern),
+    assertVisible: async (page, step) => {
+        const isVisible = await page.isVisible(step.selector);
+        if (!isVisible) {
+            throw new Error(`Expected element "${step.selector}" to be visible`);
+        }
+    }
+};

package/src/cli/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { getPackageInfo } from "../lib/helper";
+import * as log4js from "log4js";
+import fs from "fs";
+import { PlaywrightRunner } from "../runner";
+const cliLogConfig = {
+    appenders: {
+        out: {
+            type: "stdout",
+        },
+    },
+    categories: {
+        default: { appenders: ["out"], level: "INFO" },
+    },
+};
+var pack = getPackageInfo();
+let version = pack.version || "version unknown";
+const program = new Command();
+let data;
+program
+    .name("asm-playwright-runner")
+    .description("CLI wrapper for Playwright collections or scripts")
+    .version(version)
+    .argument("<collection>", "Flow JSON file or Playwright script")
+    .option("-b, --browser <browser>", "Browser type (chromium|firefox|webkit)", "chromium")
+    .option("-v, --verbose", "Print collection information on stdout", false)
+    .option("--chromiumPath <path>", "Custom Chromium/Chrome executable path")
+    .option("--headless", "Run browser headless (default true)", false)
+    .option("-r, --resultDir <dir>", "Result directory")
+    .option("-l, --logLevel <logLevel>", "Log level", "info")
+    .option("--extraHTTPHeaders <headers>", "Extra HTTP headers as JSON string")
+    .option("--timeout <timeout>", "Test timeout in ms")
+    .option("-rv, --returnResult", "Return the full structured test result object to the caller instead of only logging output", false)
+    .option("--sslClientCert <path>", "Client certificate (PEM)")
+    .option("--sslClientKey <path>", "Client certificate private key")
+    .option("--sslClientPassphrase <passphrase>", "Client certificate passphrase");
+program.version(version);
+program.parse(process.argv);
+let log_level = program.opts().logLevel || "info";
+log_level = log_level.toUpperCase();
+cliLogConfig.categories.default.level =
+    ["DEBUG", "TRACE", "ERROR", "FATAL"].includes(log_level) ? log_level : "INFO";
+cliLogConfig.categories.default.level = log_level;
+log4js.configure(cliLogConfig);
+var logger = log4js.getLogger(pack.name);
+logger.info("%s (%s) started", pack.name, version);
+// now construct runner
+const runner = new PlaywrightRunner();
+(async () => {
+    const collection = program.args[0];
+    const options = program.opts();
+    if (!fs.existsSync(collection) || !fs.lstatSync(collection).isFile()) {
+        console.error("The specified collection file %s does not exist", collection);
+        process.exit(9);
+    }
+    await runner.init(collection, options);
+    await runner.run(collection, options);
+    await runner.close();
+})();

package/src/lib/helper.js

@@ -0,0 +1,67 @@
+import fs from "fs";
+import readline from "readline";
+import unzipper from 'unzipper';
+import path from "path";
+export function readJsonFile(pathName) {
+    try {
+        let content = fs.readFileSync(pathName);
+        return JSON.parse(content.toString());
+    }
+    catch (error) {
+        return {};
+    }
+}
+var packInfo;
+export function getPackageInfo() {
+    if (packInfo === undefined) {
+        packInfo = readJsonFile(`${__dirname}/../../package.json`);
+    }
+    return packInfo;
+}
+export async function traceZipToLines(tracePath) {
+    const directory = await unzipper.Open.file(tracePath);
+    const traceEntry = directory.files.find(file => file.path.endsWith("test.trace"));
+    const events = [];
+    if (!traceEntry) {
+        return events;
+    }
+    const stream = traceEntry.stream();
+    const rl = readline.createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        const text = line.toString().trim();
+        if (!text) {
+            continue;
+        }
+        try {
+            events.push(JSON.parse(text));
+        }
+        catch (err) {
+            console.error("Invalid JSON:", text);
+        }
+    }
+    return events;
+}
+export function loadFlow(filePath) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+}
+export function collectTraceFiles(resultDir) {
+    const traces = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir)) {
+            const fullPath = path.join(dir, entry);
+            const stat = fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (entry === "trace.zip") {
+                traces.push(fullPath);
+            }
+        }
+    };
+    walk(resultDir);
+    return traces;
+}

package/src/lib/parser.js

@@ -0,0 +1,283 @@
+import unzipper from 'unzipper';
+import archiver from 'archiver';
+import path from "path";
+import fs from "fs";
+import { LogLevel, ResultDir } from "../model/runnerConfig";
+export async function getJsonFileData(tracePath, fileName) {
+    const directory = await unzipper.Open.file(tracePath);
+    const file = directory.files.find(f => f.path.endsWith(fileName));
+    if (!file) {
+        return {};
+    }
+    const content = await file.buffer();
+    return JSON.parse(content.toString("utf-8"));
+}
+export async function getFileData(tracePath, fileName) {
+    const directory = await unzipper.Open.file(tracePath);
+    const traceFile = directory.files.find(f => f.path.endsWith(fileName));
+    if (!traceFile) {
+        return [];
+    }
+    const content = await traceFile.buffer();
+    return content.toString('utf-8').split('\n').filter(Boolean);
+}
+async function extractResources(zipPath, targetImages = []) {
+    const baseDir = path.dirname(zipPath);
+    const runName = path.basename(baseDir);
+    const resultDir = path.dirname(baseDir);
+    const parentDir = resultDir === "." ? runName : resultDir;
+    const appendRunName = resultDir === "." ? [] : [runName];
+    const screenshotsDir = path.join(parentDir, ResultDir.SCREENSHOT, ...appendRunName);
+    const sourceDir = path.join(parentDir, ResultDir.SOURCE, ...appendRunName);
+    // Create folders if not exists
+    [screenshotsDir, sourceDir].forEach(dir => {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    });
+    const directory = await unzipper.Open.file(zipPath);
+    // Copy target images
+    const imagePromises = targetImages.map(targetImage => {
+        const fileEntry = directory.files.find((file) => file.path === `resources/${targetImage}`);
+        if (!fileEntry) {
+            return Promise.resolve();
+        }
+        const outputPath = path.join(screenshotsDir, targetImage);
+        return new Promise((resolve, reject) => {
+            fileEntry
+                .stream()
+                .pipe(fs.createWriteStream(outputPath))
+                .on('finish', () => {
+                resolve(true);
+            })
+                .on('error', reject);
+        });
+    });
+    // Copy all src@*.txt files
+    const sourcePromises = directory.files
+        .filter(file => file.path.startsWith('resources/') &&
+        /^src@.*\.txt$/.test(path.basename(file.path)))
+        .map(fileEntry => {
+        const fileName = path.basename(fileEntry.path);
+        const outputPath = path.join(sourceDir, fileName);
+        return new Promise((resolve, reject) => {
+            fileEntry
+                .stream()
+                .pipe(fs.createWriteStream(outputPath))
+                .on('finish', () => {
+                resolve(true);
+            })
+                .on('error', reject);
+        });
+    });
+    const errorContext = path.join(baseDir, "error-context.md");
+    if (fs.existsSync(errorContext)) {
+        fs.copyFileSync(errorContext, path.join(sourceDir, "error-context.md"));
+    }
+    await Promise.all([...imagePromises, ...sourcePromises]);
+}
+export async function zipResources(outputZipPath, screenshotsDir, sourceDir) {
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(outputZipPath);
+        const archive = archiver("zip", { zlib: { level: 9 } });
+        output.on("close", resolve);
+        archive.on("error", reject);
+        archive.pipe(output);
+        if (fs.existsSync(screenshotsDir)) {
+            archive.directory(screenshotsDir, ResultDir.SCREENSHOT);
+        }
+        if (fs.existsSync(sourceDir)) {
+            archive.directory(sourceDir, ResultDir.SOURCE);
+        }
+        archive.finalize();
+    });
+}
+export async function setHookActions(traceRawResult) {
+    const hookModel = { actions: [], stdio: [], errors: [] };
+    const hookActions = {};
+    for (const [index, row] of traceRawResult.entries()) {
+        const entry = JSON.parse(row);
+        if (entry.type === "context-options") {
+            Object.assign(hookModel, {
+                origin: entry.origin,
+                browserName: entry.browserName,
+                playwrightVersion: entry.playwrightVersion,
+                options: entry.options,
+                platform: entry.platform,
+                wallTime: entry.wallTime,
+                startTime: entry.monotonicTime,
+                sdkLanguage: entry.sdkLanguage,
+                testIdAttributeName: entry.testIdAttributeName,
+                contextId: entry.contextId,
+                testTimeout: entry.testTimeout,
+            });
+            continue;
+        }
+        else if (entry.type === "stdout" || entry.type === "stderr") {
+            hookModel?.stdio?.push(entry);
+        }
+        else if (entry.type === "before") {
+            const action = {
+                type: "action",
+                callId: entry.callId,
+                stepId: entry.stepId,
+                parentId: entry.parentId,
+                startTime: entry.startTime,
+                class: entry.class,
+                method: entry.method,
+                title: entry.title,
+                params: entry.params,
+                stack: entry.stack,
+                log: [],
+            };
+            hookActions[entry.callId] = action;
+            hookModel.actions.push(action);
+        }
+        else if (entry.type === "after" && hookActions[entry.callId]) {
+            Object.assign(hookActions[entry.callId], {
+                endTime: entry.endTime,
+                annotations: entry.annotations,
+                error: entry.error,
+            });
+        }
+        else if (entry.type == "error") {
+            hookModel.errors?.push(entry);
+        }
+        if (index === (traceRawResult.length - 1) && entry.type === "after") {
+            hookModel.endTime = entry.endTime;
+            if (hookModel.endTime != null && hookModel.startTime) {
+                hookModel.duration = Number((hookModel.endTime - hookModel.startTime).toFixed(3));
+            }
+        }
+    }
+    return hookModel;
+}
+export async function setActions(traceRawResult, traceModel, tracePath, stackData) {
+    let beforeFlag = false;
+    let action = null;
+    let targetImages = [];
+    for (const row of traceRawResult) {
+        const entry = JSON.parse(row);
+        if (entry.type === 'context-options') {
+            traceModel.origin = entry.origin;
+            traceModel.browserName = entry.browserName;
+            traceModel.playwrightVersion = entry.playwrightVersion;
+            traceModel.options = entry.options;
+            traceModel.platform = entry.platform;
+            traceModel.wallTime = entry.wallTime;
+            traceModel.startTime = entry.monotonicTime;
+            traceModel.sdkLanguage = entry.sdkLanguage;
+            traceModel.testIdAttributeName = entry.testIdAttributeName;
+            traceModel.contextId = entry.contextId;
+        }
+        else if (entry.type == "event" || entry.type == "console") {
+            traceModel.events?.push(entry);
+        }
+        else if (entry.type === "stdout" || entry.type === "stderr") {
+            traceModel?.stdio?.push(entry);
+        }
+        else if (entry.type == "screencast-frame") {
+            let page = traceModel.pages?.find(p => p.pageId === entry.pageId);
+            if (!page) {
+                page = {
+                    pageId: entry.pageId,
+                    screencastFrames: [],
+                };
+                traceModel.pages?.push(page);
+            }
+            targetImages.push(entry.sha1);
+            page.screencastFrames.push(entry);
+        }
+        else {
+            if (entry.type == "before") {
+                action = {
+                    callId: entry.callId,
+                    class: entry.class,
+                    method: entry.method,
+                    startTime: entry.startTime,
+                    type: "action",
+                    params: entry.params,
+                    pageId: entry.pageId,
+                    log: [],
+                    stack: stackData[entry.callId]
+                };
+                if (entry.class == "Frame") {
+                    action.beforeSnapshot = entry.beforeSnapshot;
+                }
+                beforeFlag = true;
+            }
+            if (beforeFlag && action != null && action.callId == entry.callId) {
+                if (entry.type == "log") {
+                    action.log?.push({
+                        time: entry.time,
+                        message: entry.message
+                    });
+                }
+                if (entry.type == "after") {
+                    beforeFlag = false;
+                    action.endTime = entry.endTime;
+                    action.result = entry.result;
+                    action.error = entry.error;
+                    action.afterSnapshot = entry.afterSnapshot;
+                    traceModel.actions?.push(action);
+                }
+            }
+        }
+    }
+    traceModel.endTime = action?.endTime;
+    if (traceModel.endTime != null && traceModel.startTime) {
+        traceModel.duration = Number((traceModel.endTime - traceModel.startTime).toFixed(3));
+    }
+    await extractResources(tracePath, targetImages);
+}
+export async function setResources(resourceRawResult, traceModel) {
+    for (const row of resourceRawResult) {
+        const entry = JSON.parse(row);
+        traceModel.resources?.push(entry.snapshot);
+    }
+}
+export async function prepareStackData(stacksRawResult) {
+    const preparedData = {};
+    const files = stacksRawResult.files || [];
+    const stacks = stacksRawResult.stacks || [];
+    for (const stack of stacks) {
+        const [callId, frames] = stack;
+        preparedData[`call@${callId}`] = frames.map(([fileIndex, line, column, fn]) => ({
+            file: files[fileIndex] || `source-file-${fileIndex}`,
+            fileIndex: `source-file-${fileIndex}`,
+            line,
+            column,
+            functionName: fn || ""
+        }));
+    }
+    return preparedData;
+}
+export async function prepareTraceModel(tracePath, logLevel) {
+    const traceRawResult = await getFileData(tracePath, "trace.trace");
+    const resourceRawResult = await getFileData(tracePath, "trace.network");
+    const stacksRawResult = await getJsonFileData(tracePath, "trace.stacks");
+    const traceModel = {
+        actions: [],
+        events: [],
+        resources: [],
+        errors: [],
+        pages: [],
+        stdio: []
+    };
+    if (logLevel == LogLevel.DEBUG) {
+        fs.writeFileSync(path.join(path.dirname(tracePath), "trace-raw-data.json"), JSON.stringify(traceRawResult, null, 2), "utf-8");
+    }
+    const stackData = await prepareStackData(stacksRawResult);
+    await setActions(traceRawResult, traceModel, tracePath, stackData);
+    await setResources(resourceRawResult, traceModel);
+    const testHookResult = await getFileData(tracePath, "test.trace");
+    if (testHookResult && testHookResult.length > 0) {
+        if (logLevel == LogLevel.DEBUG) {
+            //raw data to validate data from trace
+            fs.writeFileSync(path.join(path.dirname(tracePath), "test-trace-raw-data.json"), JSON.stringify(testHookResult, null, 2), "utf-8");
+        }
+        const hookModel = await setHookActions(testHookResult);
+        return [hookModel, traceModel];
+    }
+    return [traceModel];
+}

package/src/model/runnerConfig.js

@@ -0,0 +1,24 @@
+export var BrowserType;
+(function (BrowserType) {
+    BrowserType["CHROMIUM"] = "chromium";
+    BrowserType["FIREFOX"] = "firefox";
+    BrowserType["WEBKIT"] = "webkit";
+})(BrowserType || (BrowserType = {}));
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["INFO"] = "info";
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["ERROR"] = "error";
+})(LogLevel || (LogLevel = {}));
+export var ScriptType;
+(function (ScriptType) {
+    ScriptType["JSON"] = "json";
+    ScriptType["PLAYWRIGHT"] = "playwright";
+    ScriptType["PLAYWRIGHT_TEST"] = "playwright/test";
+})(ScriptType || (ScriptType = {}));
+export var ResultDir;
+(function (ResultDir) {
+    ResultDir["BASE_DIR"] = "result";
+    ResultDir["SCREENSHOT"] = "screenshots";
+    ResultDir["SOURCE"] = "source";
+})(ResultDir || (ResultDir = {}));

package/src/model/traceModel.js

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

package/src/runner.js

@@ -0,0 +1,225 @@
+import fs from "fs";
+import path from "path";
+import { chromium, firefox, webkit } from "playwright";
+import { actionRegistry } from "./actions";
+import { BrowserType, ResultDir, ScriptType } from "./model/runnerConfig";
+import { prepareTraceModel, zipResources } from "./lib/parser";
+import { getLogger } from "log4js";
+import { spawn } from "node:child_process";
+import { collectTraceFiles, loadFlow } from "./lib/helper";
+const RESULT_FILE = "trace-model.json";
+export class PlaywrightRunner {
+    constructor() {
+        this.browser = null;
+        this.context = null;
+        this.page = null;
+        this.options = null;
+        this.logger = getLogger(PlaywrightRunner.name);
+    }
+    async init(collectionPath, options) {
+        this.logger.info("Initializing PlaywrightRunner...");
+        // Normalize resultDir
+        if (!options.resultDir || options.resultDir.trim() === "") {
+            options.resultDir = ResultDir.BASE_DIR;
+            this.logger.debug("No resultDir specified. Defaulting to 'results'.");
+        }
+        this.options = options;
+        // Detect script type
+        this.options.scriptType = await this.detectScriptType(collectionPath);
+        this.options.isValidScript = this.options.scriptType !== undefined;
+        if (!this.options.isValidScript) {
+            this.logger.warn("Script is not valid.");
+            process.exit(9);
+        }
+        // Skip browser setup for Playwright Test files
+        if (this.options.scriptType === ScriptType.PLAYWRIGHT_TEST) {
+            this.logger.info("Playwright Test detected. Skipping manual browser setup.");
+            return;
+        }
+        // Browser setup
+        const browserType = options.browser || BrowserType.CHROMIUM;
+        const headless = options.headless;
+        this.logger.debug(`Browser type: ${browserType}, headless: ${headless}`);
+        this.browser = await (browserType === BrowserType.FIREFOX ? firefox :
+            browserType === BrowserType.WEBKIT ? webkit :
+                chromium).launch({
+            headless,
+            ...(options.chromiumPath && { executablePath: options.chromiumPath })
+        });
+        this.logger.info("Browser launched successfully.");
+        let headers = {};
+        if (options.extraHTTPHeaders) {
+            try {
+                headers = JSON.parse(options.extraHTTPHeaders);
+            }
+            catch (err) {
+                this.logger.warn("Invalid JSON for extraHTTPHeaders, ignoring:", options.extraHTTPHeaders);
+                headers = {}; // fallback to empty headers
+            }
+        }
+        this.context = await this.browser.newContext({
+            ignoreHTTPSErrors: true,
+            ...(options.sslClientCert && {
+                clientCert: {
+                    cert: options.sslClientCert,
+                    key: options.sslClientKey,
+                    passphrase: options.sslClientPassphrase
+                }
+            }),
+            extraHTTPHeaders: headers,
+        });
+        this.logger.info("Browser context created.");
+        await this.context.tracing.start({ snapshots: true, screenshots: true, sources: true });
+        this.logger.info("Tracing started (snapshots, screenshots, sources enabled).");
+        this.page = await this.context.newPage();
+        // @ts-ignore
+        if (this.options?.scriptType != ScriptType.PLAYWRIGHT_TEST && this.options.timeout != null) {
+            this.page.setDefaultTimeout(Number(this.options.timeout));
+        }
+        this.logger.info("New page created.");
+    }
+    async run(collectionPath, options) {
+        this.logger.info(`Running collection: ${collectionPath}`);
+        // Default trace path(s)
+        let tracePaths = [
+            options.resultDir
+                ? path.join(options.resultDir, "trace.zip")
+                : "trace.zip"
+        ];
+        switch (this.options?.scriptType) {
+            case ScriptType.JSON: {
+                const flow = loadFlow(collectionPath);
+                this.logger.info(`Loaded flow: ${flow.name} with ${flow.steps.length} steps`);
+                for (const [index, step] of flow.steps.entries()) {
+                    const handler = actionRegistry[step.action];
+                    this.logger.debug(`Executing step ${index}: action=${step.action}`);
+                    try {
+                        if (!handler)
+                            this.logger.error(`Unknown action: ${step.action}`);
+                        if (!this.page) {
+                            this.logger.error("Page not initialized. Did you call init()?");
+                            process.exit(9);
+                        }
+                        await handler(this.page, step);
+                    }
+                    catch (err) {
+                        this.logger.error(`Step ${index} failed: ${err.message}`, err);
+                    }
+                }
+                break;
+            }
+            case ScriptType.PLAYWRIGHT: {
+                this.logger.info("Detected plain Playwright script with default export.");
+                const mod = await import(path.resolve(collectionPath));
+                const fn = mod.default;
+                if (typeof fn !== "function") {
+                    throw new Error("Script does not export a default function");
+                }
+                try {
+                    await fn(this.page);
+                    this.logger.info("Script execution finished.");
+                }
+                catch (err) {
+                    this.logger.error(`Script execution failed: ${err.message}`);
+                }
+                break;
+            }
+            case ScriptType.PLAYWRIGHT_TEST: {
+                this.logger.info("Detected Playwright Test file. Running via CLI...");
+                const args = [
+                    "playwright",
+                    "test",
+                    collectionPath,
+                    "--browser", options.browser || BrowserType.CHROMIUM,
+                    "--output", options.resultDir || "results",
+                    "--trace", "on"
+                ];
+                if (options.timeout != null)
+                    args.push("--timeout", options.timeout);
+                if (!options.headless)
+                    args.push("--headed");
+                // if (options.verbose) args.push("--verbose");
+                this.logger.debug(`Spawning Playwright CLI: npx ${args.join(" ")}`);
+                await new Promise((resolve) => {
+                    const proc = spawn("npx", args, { stdio: "inherit", shell: true });
+                    proc.on("close", (code) => {
+                        if (code === 0) {
+                            this.logger.info("Playwright Test finished successfully.");
+                        }
+                        else {
+                            this.logger.error(`Playwright Test exited with code ${code}`);
+                        }
+                        tracePaths = collectTraceFiles(options.resultDir || "results");
+                        resolve();
+                    });
+                });
+                break;
+            }
+            default:
+                this.logger.error("Unsupported or invalid script type.");
+                process.exit(9);
+        }
+        this.logger.info("Stopping tracing...");
+        await this.traceProcess(tracePaths);
+    }
+    async traceProcess(tracePaths) {
+        if (!tracePaths?.length) {
+            this.logger.warn("No trace paths provided.");
+            return;
+        }
+        // Only stop tracing if this.context is active and we’re handling a live run
+        if (this.context && this.options?.scriptType != ScriptType.PLAYWRIGHT_TEST) {
+            await this.context.tracing.stop({
+                path: tracePaths[0]
+            });
+            this.logger.info(`Trace saved to ${tracePaths}`);
+        }
+        const models = {};
+        for (const tracePath of tracePaths) {
+            try {
+                this.logger.info(`Parsing trace: ${tracePath}`);
+                const traceModel = await prepareTraceModel(tracePath, this.options?.logLevel);
+                const runName = path.basename(path.dirname(tracePath));
+                models[runName] = traceModel;
+                const individualPath = path.join(path.dirname(tracePath), RESULT_FILE);
+                fs.writeFileSync(individualPath, JSON.stringify({ "__self": traceModel }, null, 2), "utf-8");
+                this.logger.debug(`Individual trace model written to ${individualPath}`);
+            }
+            catch (err) {
+                this.logger.error(`Failed to process trace ${tracePath}: ${err.message}`, err);
+            }
+        }
+        // Write combined model if more than one trace
+        if (this.options?.scriptType == ScriptType.PLAYWRIGHT_TEST) {
+            const combinedPath = this.options?.resultDir
+                ? path.join(this.options.resultDir, RESULT_FILE)
+                : RESULT_FILE;
+            fs.writeFileSync(combinedPath, JSON.stringify(models, null, 2), "utf-8");
+            this.logger.info(`Combined trace model written to ${combinedPath}`);
+        }
+        const resourceDir = this.options?.resultDir ?? ResultDir.BASE_DIR;
+        const finalZipPath = path.join(resourceDir, `artifacts.zip`);
+        await zipResources(finalZipPath, path.join(resourceDir, ResultDir.SCREENSHOT), path.join(resourceDir, ResultDir.SOURCE));
+        if (this.options?.returnResult) {
+            console.log(JSON.stringify(models));
+        }
+    }
+    async detectScriptType(collectionPath) {
+        const fileContent = fs.readFileSync(collectionPath, "utf-8");
+        if (fileContent.includes("export default")) {
+            return ScriptType.PLAYWRIGHT;
+        }
+        if (fileContent.includes("test(")) {
+            return ScriptType.PLAYWRIGHT_TEST;
+        }
+        if (collectionPath.endsWith(".json")) {
+            return ScriptType.JSON;
+        }
+        return undefined;
+    }
+    async close() {
+        this.logger.info("Closing browser...");
+        await this.browser?.close();
+        this.logger.info("Browser closed.");
+    }
+}

package/tsconfig.json

@@ -1,14 +1,11 @@
 {
   "compilerOptions": {
-    "target": "ES2020",                // modern async/await + optional chaining
-    "module": "CommonJS",              // Node.js default
-    "moduleResolution": "node",        // resolves imports correctly
-    "esModuleInterop": true,           // allows default imports from CommonJS libs (like log4js)
-    "resolveJsonModule": true,         // lets you import JSON files
-    "outDir": "./dist",                // compiled output folder
-    "rootDir": "./src",                // source folder
-    "strict": true,                    // enables strict type checking
-    "skipLibCheck": true               // avoids type issues in node_modules
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
   },
   "include": ["src"],
   "exclude": ["node_modules", "dist", "results"]