qase-javascript-commons 2.5.5 → 2.5.7

package/changelog.md

@@ -1,3 +1,17 @@
+# qase-javascript-commons@2.5.7
+
+## Bug fixes
+
+- Moved profiler modules to a separate sub-path export (`qase-javascript-commons/profilers`) to fix Webpack `UnhandledSchemeError` when using Cypress. The main entry point no longer pulls in `node:` URI imports (`async_hooks`, `http`, `https`, `diagnostics_channel`).
+
+# qase-javascript-commons@2.5.6
+
+## What's new
+
+- Added Network Profiler framework for automatic HTTP/HTTPS request interception during test execution.
+- Added `StepType.REQUEST` step type for network request data in test results.
+- Added configurable profiler options in `qase.config.json` (`profilers` and `networkProfiler` fields).
+
 # qase-javascript-commons@2.5.5
 
 ## What's new

package/dist/client/clientV2.d.ts

@@ -21,6 +21,7 @@ export declare class ClientV2 extends ClientV1 {
     private createBaseResultStep;
     private processTextStep;
     private processGherkinStep;
+    private processRequestStep;
     private getExecution;
     private getRelation;
     private getDefaultSuiteRelation;

package/dist/client/clientV2.js

@@ -173,9 +173,12 @@ class ClientV2 extends clientV1_1.ClientV1 {
         if (step.step_type === models_1.StepType.TEXT) {
             this.processTextStep(step, resultStep, testTitle);
         }
-        else {
+        else if (step.step_type === models_1.StepType.GHERKIN) {
             this.processGherkinStep(step, resultStep);
         }
+        else if (step.step_type === models_1.StepType.REQUEST) {
+            this.processRequestStep(step, resultStep);
+        }
         if (step.steps.length > 0) {
             resultStep.steps = await this.transformSteps(step.steps, testTitle);
         }
@@ -215,6 +218,13 @@ class ClientV2 extends clientV1_1.ClientV1 {
         const stepData = step.data;
         resultStep.data.action = stepData.keyword;
     }
+    processRequestStep(step, resultStep) {
+        if (!('request_method' in step.data) || !resultStep.data) {
+            return;
+        }
+        const stepData = step.data;
+        resultStep.data.action = `${stepData.request_method} ${stepData.request_url}`;
+    }
     getExecution(exec) {
         return {
             status: ClientV2.statusMap[exec.status],

package/dist/config/config-validation-schema.d.ts

@@ -298,5 +298,29 @@ export declare const configValidationSchema: {
                 };
             };
         };
+        profilers: {
+            type: string;
+            items: {
+                type: string;
+            };
+            nullable: boolean;
+        };
+        networkProfiler: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                skip_domains: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    nullable: boolean;
+                };
+                track_on_fail: {
+                    type: string;
+                    nullable: boolean;
+                };
+            };
+        };
     };
 };

package/dist/config/config-validation-schema.js

@@ -282,5 +282,27 @@ exports.configValidationSchema = {
                 },
             },
         },
+        profilers: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+            nullable: true,
+        },
+        networkProfiler: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                skip_domains: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    nullable: true,
+                },
+                track_on_fail: {
+                    type: 'boolean',
+                    nullable: true,
+                },
+            },
+        },
     },
 };

package/dist/models/index.d.ts

@@ -2,6 +2,7 @@ export { TestResultType } from './test-result';
 export type { Relation, Suite, SuiteData, TestopsProjectMapping } from './test-result';
 export { TestExecution, TestStatusEnum } from './test-execution';
 export { TestStepType, StepType } from './test-step';
+export type { StepRequestData, StepTextData, StepGherkinData } from './step-data';
 export { StepStatusEnum } from './step-execution';
 export type { Attachment } from './attachment';
 export type { Report } from './report';

package/dist/models/step-data.d.ts

@@ -8,3 +8,12 @@ export interface StepGherkinData {
     name: string;
     line: number;
 }
+export interface StepRequestData {
+    request_method: string;
+    request_url: string;
+    request_headers: Record<string, string> | null;
+    request_body: string | null;
+    status_code: number | null;
+    response_body: string | null;
+    response_headers: Record<string, string> | null;
+}

package/dist/models/test-step.d.ts

@@ -1,14 +1,15 @@
-import { StepGherkinData, StepTextData } from './step-data';
+import { StepGherkinData, StepRequestData, StepTextData } from './step-data';
 import { StepExecution } from './step-execution';
 import { Attachment } from './attachment';
 export declare enum StepType {
     TEXT = "text",
-    GHERKIN = "gherkin"
+    GHERKIN = "gherkin",
+    REQUEST = "request"
 }
 export declare class TestStepType {
     id: string;
     step_type: StepType;
-    data: StepTextData | StepGherkinData;
+    data: StepTextData | StepGherkinData | StepRequestData;
     parent_id: string | null;
     execution: StepExecution;
     attachments: Attachment[];

package/dist/models/test-step.js

@@ -6,6 +6,7 @@ var StepType;
 (function (StepType) {
     StepType["TEXT"] = "text";
     StepType["GHERKIN"] = "gherkin";
+    StepType["REQUEST"] = "request";
 })(StepType || (exports.StepType = StepType = {}));
 class TestStepType {
     id;
@@ -29,13 +30,24 @@ class TestStepType {
                 data: null,
             };
         }
-        else {
+        else if (type === StepType.GHERKIN) {
             this.data = {
                 keyword: '',
                 name: '',
                 line: 0,
             };
         }
+        else {
+            this.data = {
+                request_method: '',
+                request_url: '',
+                request_headers: null,
+                request_body: null,
+                status_code: null,
+                response_body: null,
+                response_headers: null,
+            };
+        }
     }
 }
 exports.TestStepType = TestStepType;

package/dist/options/options-type.d.ts

@@ -31,6 +31,11 @@ export type OptionsType = {
     /** Multi-project configuration (used when mode is testops_multi). */
     testops_multi?: TestOpsMultiConfigType | undefined;
     report?: RecursivePartial<AdditionalReportOptionsType> | undefined;
+    profilers?: string[] | undefined;
+    networkProfiler?: {
+        skip_domains?: string[] | undefined;
+        track_on_fail?: boolean | undefined;
+    } | undefined;
 };
 export type FrameworkOptionsType<F extends string, O> = {
     framework?: Partial<Record<F, O>>;

package/dist/profilers/abstract-profiler.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class AbstractProfiler {
+    abstract enable(): void;
+    abstract disable(): void;
+    abstract restore(): void;
+}

package/dist/profilers/abstract-profiler.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractProfiler = void 0;
+class AbstractProfiler {
+}
+exports.AbstractProfiler = AbstractProfiler;

package/dist/profilers/fetch-interceptor.d.ts

@@ -0,0 +1,60 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { TestStepType } from '../models/test-step';
+interface ProfilerRef {
+    shouldSkip(url: string): boolean;
+    trackOnFail: boolean;
+    fallbackSteps: TestStepType[];
+}
+/**
+ * FetchInterceptor subscribes to undici diagnostics_channel events to capture
+ * outgoing fetch() calls as REQUEST-type steps in the AsyncLocalStorage store.
+ *
+ * Works with Node.js 18+ global fetch (which uses undici internally).
+ * Gracefully skips subscription on Node < 18 (no global fetch).
+ *
+ * Key design decisions:
+ *  - WeakMap keyed on undici request objects (same reference across all events)
+ *  - ALS context captured at undici:request:create time, NOT at headers time.
+ *    This is critical because undici connection pooling can break AsyncLocalStorage
+ *    propagation between the create and headers events when connections are reused.
+ *  - globalThis.fetch wrapping intercepts error response bodies (undici:request:bodyChunkReceived
+ *    is not available in Node 22's built-in undici)
+ *  - All handlers wrapped in try/catch (INTC-06: silent failure)
+ *
+ * Event flow:
+ *  undici:request:create   → capture method, URL, start time, ALS context → WeakMap
+ *  undici:request:headers  → build step using WeakMap data, push to ALS accumulator
+ *  undici:request:trailers → cleanup WeakMap entry
+ *  fetch wrapper           → update response_body for error responses (>= 400)
+ */
+export declare class FetchInterceptor {
+    private readonly store;
+    private readonly profiler;
+    private readonly pendingRequests;
+    private readonly bodyHandlers;
+    private readonly createHandler;
+    private readonly headersHandler;
+    private readonly trailersHandler;
+    private origFetch;
+    constructor(store: AsyncLocalStorage<TestStepType[]>, profiler: ProfilerRef);
+    /**
+     * Subscribe to undici diagnostics_channel events and wrap global fetch for
+     * error response body capture.
+     *
+     * No-op on Node < 18 (no global fetch) or if diagnostics_channel unavailable.
+     */
+    subscribe(): void;
+    /**
+     * Unsubscribe from diagnostics_channel events and restore original global fetch.
+     */
+    unsubscribe(): void;
+    private handleCreate;
+    private handleHeaders;
+    private handleTrailers;
+    /**
+     * Called by the fetch wrapper when an error response body is available.
+     * Finds the most recently added step for this URL/status and updates its response_body.
+     */
+    private applyResponseBody;
+}
+export {};

package/dist/profilers/fetch-interceptor.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchInterceptor = void 0;
+const http_interceptor_1 = require("./http-interceptor");
+// ─── FetchInterceptor ─────────────────────────────────────────────────────────
+/**
+ * FetchInterceptor subscribes to undici diagnostics_channel events to capture
+ * outgoing fetch() calls as REQUEST-type steps in the AsyncLocalStorage store.
+ *
+ * Works with Node.js 18+ global fetch (which uses undici internally).
+ * Gracefully skips subscription on Node < 18 (no global fetch).
+ *
+ * Key design decisions:
+ *  - WeakMap keyed on undici request objects (same reference across all events)
+ *  - ALS context captured at undici:request:create time, NOT at headers time.
+ *    This is critical because undici connection pooling can break AsyncLocalStorage
+ *    propagation between the create and headers events when connections are reused.
+ *  - globalThis.fetch wrapping intercepts error response bodies (undici:request:bodyChunkReceived
+ *    is not available in Node 22's built-in undici)
+ *  - All handlers wrapped in try/catch (INTC-06: silent failure)
+ *
+ * Event flow:
+ *  undici:request:create   → capture method, URL, start time, ALS context → WeakMap
+ *  undici:request:headers  → build step using WeakMap data, push to ALS accumulator
+ *  undici:request:trailers → cleanup WeakMap entry
+ *  fetch wrapper           → update response_body for error responses (>= 400)
+ */
+class FetchInterceptor {
+    store;
+    profiler;
+    // WeakMap keyed on undici request objects (same reference across create/headers/trailers events)
+    pendingRequests = new WeakMap();
+    // Map from step to body-update callback (for error response body capture)
+    bodyHandlers = new WeakMap();
+    // Bound handler references (needed for subscribe/unsubscribe identity)
+    createHandler;
+    headersHandler;
+    trailersHandler;
+    // Saved original fetch for wrapping/unwrapping
+    origFetch = null;
+    constructor(store, profiler) {
+        this.store = store;
+        this.profiler = profiler;
+        // Bind handlers as arrow functions for subscribe/unsubscribe reference identity
+        this.createHandler = (msg) => {
+            try {
+                this.handleCreate(msg);
+            }
+            catch {
+                // INTC-06: silent failure
+            }
+        };
+        this.headersHandler = (msg) => {
+            try {
+                this.handleHeaders(msg);
+            }
+            catch {
+                // INTC-06: silent failure
+            }
+        };
+        this.trailersHandler = (msg) => {
+            try {
+                this.handleTrailers(msg);
+            }
+            catch {
+                // INTC-06: silent failure
+            }
+        };
+    }
+    /**
+     * Subscribe to undici diagnostics_channel events and wrap global fetch for
+     * error response body capture.
+     *
+     * No-op on Node < 18 (no global fetch) or if diagnostics_channel unavailable.
+     */
+    subscribe() {
+        // Guard: require global fetch (Node 18+)
+        if (typeof globalThis.fetch !== 'function') {
+            return;
+        }
+        let dc;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+            dc = require('node:diagnostics_channel');
+        }
+        catch {
+            return; // diagnostics_channel unavailable — skip entirely
+        }
+        if (typeof dc.subscribe !== 'function') {
+            return;
+        }
+        dc.subscribe('undici:request:create', this.createHandler);
+        dc.subscribe('undici:request:headers', this.headersHandler);
+        dc.subscribe('undici:request:trailers', this.trailersHandler);
+        // Wrap global fetch to intercept error response bodies
+        // (undici:request:bodyChunkReceived not available in Node 22 built-in undici)
+        this.origFetch = globalThis.fetch;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        globalThis.fetch = async function wrappedFetch(input, init) {
+            const origFetch = self.origFetch;
+            if (!origFetch) {
+                throw new Error('fetch not available');
+            }
+            const response = await origFetch.call(globalThis, input, init);
+            // Intercept error responses to capture body
+            if (response.status >= 400 && self.profiler.trackOnFail) {
+                try {
+                    // Clone to read body without consuming the original response
+                    const cloned = response.clone();
+                    void cloned.text().then((bodyText) => {
+                        try {
+                            self.applyResponseBody(input, response.status, bodyText);
+                        }
+                        catch {
+                            // INTC-06: silent failure
+                        }
+                    });
+                }
+                catch {
+                    // INTC-06: silent failure
+                }
+            }
+            return response;
+        };
+    }
+    /**
+     * Unsubscribe from diagnostics_channel events and restore original global fetch.
+     */
+    unsubscribe() {
+        // Restore original fetch
+        if (this.origFetch !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            globalThis.fetch = this.origFetch;
+            this.origFetch = null;
+        }
+        let dc;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+            dc = require('node:diagnostics_channel');
+        }
+        catch {
+            return;
+        }
+        // Feature-detect unsubscribe (Pitfall 5: not available in all Node versions)
+        if (typeof dc.unsubscribe !== 'function') {
+            return;
+        }
+        try {
+            dc.unsubscribe('undici:request:create', this.createHandler);
+        }
+        catch {
+            // silent
+        }
+        try {
+            dc.unsubscribe('undici:request:headers', this.headersHandler);
+        }
+        catch {
+            // silent
+        }
+        try {
+            dc.unsubscribe('undici:request:trailers', this.trailersHandler);
+        }
+        catch {
+            // silent
+        }
+    }
+    // ─── Private event handlers ─────────────────────────────────────────────────
+    handleCreate(msg) {
+        const message = msg;
+        const req = message.request;
+        if (!req)
+            return;
+        // CRITICAL: Capture ALS context HERE (at create time), not in headersHandler.
+        // Due to undici connection pooling, store.getStore() may return undefined in
+        // the headers event when connections are reused across test runs.
+        const acc = this.store.getStore();
+        // acc may be null/undefined when outside a run() context — use fallback accumulator in that case
+        const method = typeof req['method'] === 'string' ? req['method'] : 'GET';
+        const origin = typeof req['origin'] === 'string' ? req['origin'] : '';
+        const path = typeof req['path'] === 'string' ? req['path'] : '/';
+        const url = `${origin}${path}`;
+        // Check shouldSkip
+        if (this.profiler.shouldSkip(url)) {
+            return;
+        }
+        this.pendingRequests.set(req, {
+            method,
+            url,
+            startTime: Date.now(),
+            alsContext: acc ?? null,
+        });
+    }
+    handleHeaders(msg) {
+        const message = msg;
+        const req = message.request;
+        if (!req)
+            return;
+        const pending = this.pendingRequests.get(req);
+        if (!pending)
+            return;
+        // Use the ALS context captured at create time — do NOT call store.getStore() here.
+        // Connection pooling in undici can break ALS propagation between events.
+        const acc = pending.alsContext;
+        const endTime = Date.now();
+        const statusCode = message.response?.statusCode ?? 0;
+        const step = (0, http_interceptor_1.buildRequestStep)({
+            method: pending.method,
+            url: pending.url,
+            statusCode,
+            responseBody: null, // filled in later for errors via fetch wrapper
+            responseHeaders: null,
+            startTime: pending.startTime,
+            endTime,
+        });
+        if (acc !== null) {
+            acc.push(step);
+        }
+        else {
+            // No ALS context — push to fallback accumulator (for Jest/Vitest/WDIO workers)
+            this.profiler.fallbackSteps.push(step);
+        }
+        // Register body handler for error responses
+        if (statusCode >= 400 && this.profiler.trackOnFail) {
+            this.bodyHandlers.set(step, (bodyText) => {
+                step.data.response_body = bodyText;
+            });
+        }
+    }
+    handleTrailers(msg) {
+        const message = msg;
+        const req = message.request;
+        if (!req)
+            return;
+        // Clean up pending state
+        this.pendingRequests.delete(req);
+    }
+    /**
+     * Called by the fetch wrapper when an error response body is available.
+     * Finds the most recently added step for this URL/status and updates its response_body.
+     */
+    applyResponseBody(input, statusCode, bodyText) {
+        const url = typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.toString()
+                : input.url;
+        // Get all accumulated steps — use ALS context if available, fallback accumulator otherwise
+        const searchArray = this.store.getStore() ?? this.profiler.fallbackSteps;
+        if (searchArray.length === 0)
+            return;
+        // Find the last step that matches this response and has null body
+        for (let i = searchArray.length - 1; i >= 0; i--) {
+            const step = searchArray[i];
+            if (!step)
+                continue;
+            const data = step.data;
+            if (data.status_code !== statusCode)
+                continue;
+            if (data.response_body !== null)
+                continue;
+            // Check if URL matches (handle query strings, trailing slashes)
+            const stepUrl = data.request_url ?? '';
+            const inputUrlBase = url.split('?')[0] ?? url;
+            if (url.includes(stepUrl) || stepUrl.includes(inputUrlBase) || stepUrl === inputUrlBase) {
+                const handler = this.bodyHandlers.get(step);
+                if (handler) {
+                    handler(bodyText);
+                    this.bodyHandlers.delete(step);
+                    return;
+                }
+            }
+        }
+    }
+}
+exports.FetchInterceptor = FetchInterceptor;

package/dist/profilers/http-interceptor.d.ts

@@ -0,0 +1,69 @@
+import http from 'node:http';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { TestStepType } from '../models/test-step';
+interface ProfilerRef {
+    shouldSkip(url: string): boolean;
+    trackOnFail: boolean;
+    fallbackSteps: TestStepType[];
+}
+export interface RequestInfo {
+    method: string;
+    url: string;
+}
+/**
+ * Handles the 3 `http.request()` call signatures:
+ *  - (url: string, options?, callback?)
+ *  - (url: URL, options?, callback?)
+ *  - (options: RequestOptions, callback?)
+ *
+ * Returns `{ method, url }`. Default method is 'GET'.
+ */
+export declare function extractRequestInfo(args: [
+    string | URL | http.RequestOptions,
+    (http.RequestOptions | ((res: http.IncomingMessage) => void))?,
+    ((res: http.IncomingMessage) => void)?
+]): RequestInfo;
+/**
+ * Converts `http.IncomingHttpHeaders` (which has `string | string[] | undefined` values)
+ * to `Record<string, string>`. Multi-value headers joined with `', '`. Undefined values skipped.
+ */
+export declare function headersToRecord(headers: http.IncomingHttpHeaders): Record<string, string>;
+export declare function buildRequestStep(params: {
+    method: string;
+    url: string;
+    statusCode: number;
+    responseBody: string | null;
+    responseHeaders: Record<string, string> | null;
+    startTime: number;
+    endTime: number;
+}): TestStepType;
+/**
+ * HttpInterceptor monkey-patches Node.js http/https module functions to capture
+ * outgoing requests as REQUEST-type steps in the AsyncLocalStorage store.
+ *
+ * Pattern:
+ *  1. `install()` — saves originals, replaces with wrappers
+ *  2. `uninstall()` — restores originals
+ */
+export declare class HttpInterceptor {
+    private readonly store;
+    private readonly profiler;
+    private origHttpRequest;
+    private origHttpGet;
+    private origHttpsRequest;
+    private origHttpsGet;
+    constructor(store: AsyncLocalStorage<TestStepType[]>, profiler: ProfilerRef);
+    install(): void;
+    uninstall(): void;
+    /**
+     * Creates a wrapper around a http.request-like function.
+     * The wrapper:
+     *  1. Calls the original function to get the ClientRequest
+     *  2. Checks if there's an active ALS context — if not, returns unchanged
+     *  3. Checks shouldSkip — if true, returns unchanged
+     *  4. Intercepts the 'response' event via req.emit override
+     *  5. Builds a TestStepType on response end and pushes to accumulator
+     */
+    private wrapRequestFn;
+}
+export {};

package/dist/profilers/http-interceptor.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpInterceptor = void 0;
+exports.extractRequestInfo = extractRequestInfo;
+exports.headersToRecord = headersToRecord;
+exports.buildRequestStep = buildRequestStep;
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const uuid_1 = require("uuid");
+const test_step_1 = require("../models/test-step");
+const step_execution_1 = require("../models/step-execution");
+/**
+ * Handles the 3 `http.request()` call signatures:
+ *  - (url: string, options?, callback?)
+ *  - (url: URL, options?, callback?)
+ *  - (options: RequestOptions, callback?)
+ *
+ * Returns `{ method, url }`. Default method is 'GET'.
+ */
+function extractRequestInfo(args) {
+    const first = args[0];
+    if (typeof first === 'string') {
+        // Signature: (url: string, options?, callback?)
+        const options = args[1];
+        const method = options && typeof options === 'object' && !('emit' in options) && 'method' in options && typeof options.method === 'string'
+            ? options.method
+            : 'GET';
+        return { method, url: first };
+    }
+    if (first instanceof URL) {
+        // Signature: (url: URL, options?, callback?)
+        const options = args[1];
+        const method = options && typeof options === 'object' && !('emit' in options) && 'method' in options && typeof options.method === 'string'
+            ? options.method
+            : 'GET';
+        return { method, url: first.toString() };
+    }
+    // Signature: (options: RequestOptions, callback?)
+    const opts = first;
+    const method = opts.method ?? 'GET';
+    const protocol = opts.protocol ?? 'http:';
+    const hostname = opts.hostname ?? opts.host ?? 'localhost';
+    const port = opts.port !== undefined ? `:${String(opts.port)}` : '';
+    const path = opts.path ?? '/';
+    const url = `${protocol}//${hostname}${port}${path}`;
+    return { method, url };
+}
+// ─── Utility: headersToRecord ─────────────────────────────────────────────────
+/**
+ * Converts `http.IncomingHttpHeaders` (which has `string | string[] | undefined` values)
+ * to `Record<string, string>`. Multi-value headers joined with `', '`. Undefined values skipped.
+ */
+function headersToRecord(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            result[key] = value.join(', ');
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+// ─── Utility: buildRequestStep ───────────────────────────────────────────────
+function buildRequestStep(params) {
+    const step = new test_step_1.TestStepType(test_step_1.StepType.REQUEST);
+    step.id = (0, uuid_1.v4)();
+    const data = step.data;
+    data.request_method = params.method;
+    data.request_url = params.url;
+    data.request_headers = null;
+    data.request_body = null;
+    data.status_code = params.statusCode;
+    data.response_body = params.responseBody;
+    data.response_headers = params.responseHeaders;
+    step.execution.start_time = params.startTime;
+    step.execution.end_time = params.endTime;
+    step.execution.duration = params.endTime - params.startTime;
+    step.execution.status = params.statusCode >= 400 ? step_execution_1.StepStatusEnum.failed : step_execution_1.StepStatusEnum.passed;
+    return step;
+}
+// ─── HttpInterceptor ─────────────────────────────────────────────────────────
+/**
+ * HttpInterceptor monkey-patches Node.js http/https module functions to capture
+ * outgoing requests as REQUEST-type steps in the AsyncLocalStorage store.
+ *
+ * Pattern:
+ *  1. `install()` — saves originals, replaces with wrappers
+ *  2. `uninstall()` — restores originals
+ */
+class HttpInterceptor {
+    store;
+    profiler;
+    origHttpRequest = null;
+    origHttpGet = null;
+    origHttpsRequest = null;
+    origHttpsGet = null;
+    constructor(store, profiler) {
+        this.store = store;
+        this.profiler = profiler;
+    }
+    install() {
+        this.origHttpRequest = node_http_1.default.request;
+        this.origHttpGet = node_http_1.default.get;
+        this.origHttpsRequest = node_https_1.default.request;
+        this.origHttpsGet = node_https_1.default.get;
+        const wrappedHttpRequest = this.wrapRequestFn(this.origHttpRequest);
+        const wrappedHttpGet = this.wrapRequestFn(this.origHttpGet);
+        const wrappedHttpsRequest = this.wrapRequestFn(this.origHttpsRequest);
+        const wrappedHttpsGet = this.wrapRequestFn(this.origHttpsGet);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        node_http_1.default.request = wrappedHttpRequest;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        node_http_1.default.get = wrappedHttpGet;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        node_https_1.default.request = wrappedHttpsRequest;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        node_https_1.default.get = wrappedHttpsGet;
+    }
+    uninstall() {
+        if (this.origHttpRequest !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            node_http_1.default.request = this.origHttpRequest;
+            this.origHttpRequest = null;
+        }
+        if (this.origHttpGet !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            node_http_1.default.get = this.origHttpGet;
+            this.origHttpGet = null;
+        }
+        if (this.origHttpsRequest !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            node_https_1.default.request = this.origHttpsRequest;
+            this.origHttpsRequest = null;
+        }
+        if (this.origHttpsGet !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+            node_https_1.default.get = this.origHttpsGet;
+            this.origHttpsGet = null;
+        }
+    }
+    /**
+     * Creates a wrapper around a http.request-like function.
+     * The wrapper:
+     *  1. Calls the original function to get the ClientRequest
+     *  2. Checks if there's an active ALS context — if not, returns unchanged
+     *  3. Checks shouldSkip — if true, returns unchanged
+     *  4. Intercepts the 'response' event via req.emit override
+     *  5. Builds a TestStepType on response end and pushes to accumulator
+     */
+    wrapRequestFn(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    origFn) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return function (...args) {
+            // Call original first to get the ClientRequest
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            const req = origFn.apply(this, args);
+            // Extract request info
+            let reqInfo;
+            try {
+                reqInfo = extractRequestInfo(args);
+            }
+            catch {
+                return req;
+            }
+            // Check if this domain should be skipped
+            if (self.profiler.shouldSkip(reqInfo.url)) {
+                return req;
+            }
+            const startTime = Date.now();
+            const origEmit = req.emit.bind(req);
+            // Override req.emit to intercept the 'response' event
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            req.emit = function (event, ...emitArgs) {
+                if (event === 'response') {
+                    const res = emitArgs[0];
+                    try {
+                        const chunks = [];
+                        const isError = (res.statusCode ?? 0) >= 400;
+                        // Register data listener BEFORE calling original emit (Pitfall 2: stream consumption race)
+                        if (isError && self.profiler.trackOnFail) {
+                            res.on('data', (chunk) => {
+                                try {
+                                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                                }
+                                catch {
+                                    // silent failure
+                                }
+                            });
+                        }
+                        res.on('end', () => {
+                            try {
+                                const endTime = Date.now();
+                                const statusCode = res.statusCode ?? 0;
+                                const captureBody = statusCode >= 400 && self.profiler.trackOnFail;
+                                const responseBody = captureBody ? Buffer.concat(chunks).toString('utf8') : null;
+                                const responseHeaders = statusCode >= 400 ? headersToRecord(res.headers) : null;
+                                const step = buildRequestStep({
+                                    method: reqInfo.method,
+                                    url: reqInfo.url,
+                                    statusCode,
+                                    responseBody,
+                                    responseHeaders,
+                                    startTime,
+                                    endTime,
+                                });
+                                // Push to accumulator — re-fetch in case context is still active
+                                const acc = self.store.getStore();
+                                if (acc !== undefined && acc !== null) {
+                                    acc.push(step);
+                                }
+                                else {
+                                    // No ALS context — push to fallback accumulator (for Jest/Vitest/WDIO workers)
+                                    self.profiler.fallbackSteps.push(step);
+                                }
+                            }
+                            catch {
+                                // INTC-06: silent failure — do not propagate to test
+                            }
+                        });
+                    }
+                    catch {
+                        // INTC-06: silent failure in setup — do not propagate
+                    }
+                    // CRITICAL: Call original emit LAST (after registering data listeners)
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    return origEmit(event, ...emitArgs);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                return origEmit(event, ...emitArgs);
+            };
+            return req;
+        };
+    }
+}
+exports.HttpInterceptor = HttpInterceptor;

package/dist/profilers/index.d.ts

@@ -0,0 +1,5 @@
+export { AbstractProfiler } from './abstract-profiler';
+export { NetworkProfiler } from './network-profiler';
+export type { NetworkProfilerOptions } from './network-profiler';
+export { HttpInterceptor } from './http-interceptor';
+export { FetchInterceptor } from './fetch-interceptor';

package/dist/profilers/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchInterceptor = exports.HttpInterceptor = exports.NetworkProfiler = exports.AbstractProfiler = void 0;
+var abstract_profiler_1 = require("./abstract-profiler");
+Object.defineProperty(exports, "AbstractProfiler", { enumerable: true, get: function () { return abstract_profiler_1.AbstractProfiler; } });
+var network_profiler_1 = require("./network-profiler");
+Object.defineProperty(exports, "NetworkProfiler", { enumerable: true, get: function () { return network_profiler_1.NetworkProfiler; } });
+var http_interceptor_1 = require("./http-interceptor");
+Object.defineProperty(exports, "HttpInterceptor", { enumerable: true, get: function () { return http_interceptor_1.HttpInterceptor; } });
+var fetch_interceptor_1 = require("./fetch-interceptor");
+Object.defineProperty(exports, "FetchInterceptor", { enumerable: true, get: function () { return fetch_interceptor_1.FetchInterceptor; } });

package/dist/profilers/network-profiler.d.ts

@@ -0,0 +1,61 @@
+import { AbstractProfiler } from './abstract-profiler';
+import { TestStepType } from '../models';
+export interface NetworkProfilerOptions {
+    skipDomains?: string[] | undefined;
+    trackOnFail?: boolean | undefined;
+}
+export declare class NetworkProfiler extends AbstractProfiler {
+    private readonly skipDomains;
+    private readonly _trackOnFail;
+    /**
+     * Fallback accumulator for steps captured outside any run() context.
+     * Used by frameworks where test bodies cannot be wrapped in run() (Jest, Vitest, WDIO).
+     * Public so interceptors can push to it via ProfilerRef.
+     */
+    readonly fallbackSteps: TestStepType[];
+    private httpInterceptor;
+    private fetchInterceptor;
+    constructor(options?: NetworkProfilerOptions);
+    get trackOnFail(): boolean;
+    shouldSkip(url: string): boolean;
+    /**
+     * Install HTTP/HTTPS monkey-patches and subscribe to undici diagnostics_channel
+     * so that outgoing requests inside a `run()` context are captured as REQUEST steps.
+     */
+    enable(): void;
+    /**
+     * No-op per v1.3 design decision (flag-based activation model).
+     * Satisfies the AbstractProfiler contract.
+     */
+    disable(): void;
+    /**
+     * Uninstall HTTP/HTTPS monkey-patches and unsubscribe from undici diagnostics_channel —
+     * permanently removes interception.
+     */
+    restore(): void;
+    /**
+     * Wraps `fn` in an AsyncLocalStorage context so that any HTTP requests
+     * made inside `fn` are attributed to the step accumulator for this call.
+     *
+     * Returns `{ result, steps }` where `result` is the return value of `fn`
+     * and `steps` is the array of REQUEST steps captured during execution.
+     */
+    run<T>(fn: () => Promise<T>): Promise<{
+        result: T;
+        steps: TestStepType[];
+    }>;
+    /**
+     * Returns the current ALS store when called inside a `run()` context.
+     * Returns an empty array when called outside (no active context).
+     */
+    getSteps(): TestStepType[];
+    /**
+     * Returns a copy of steps accumulated outside any run() context (fallback accumulator).
+     * Used by frameworks where test bodies cannot be wrapped in run() (Jest, Vitest, WDIO).
+     */
+    getAllSteps(): TestStepType[];
+    /**
+     * Clears the fallback step accumulator. Call after collecting steps per test.
+     */
+    clearSteps(): void;
+}

package/dist/profilers/network-profiler.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkProfiler = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const abstract_profiler_1 = require("./abstract-profiler");
+const http_interceptor_1 = require("./http-interceptor");
+const fetch_interceptor_1 = require("./fetch-interceptor");
+const QASE_API_HOST = 'qase.io';
+// Module-level ALS store — shared across all NetworkProfiler instances to
+// allow nested run() calls to see the same context.
+const store = new node_async_hooks_1.AsyncLocalStorage();
+class NetworkProfiler extends abstract_profiler_1.AbstractProfiler {
+    skipDomains;
+    // Stored for Phase 13 use (controls whether to capture network steps on test failure)
+    _trackOnFail;
+    /**
+     * Fallback accumulator for steps captured outside any run() context.
+     * Used by frameworks where test bodies cannot be wrapped in run() (Jest, Vitest, WDIO).
+     * Public so interceptors can push to it via ProfilerRef.
+     */
+    fallbackSteps = [];
+    httpInterceptor = null;
+    fetchInterceptor = null;
+    constructor(options = {}) {
+        super();
+        this.skipDomains = options.skipDomains ?? [];
+        this._trackOnFail = options.trackOnFail ?? true;
+    }
+    get trackOnFail() {
+        return this._trackOnFail;
+    }
+    shouldSkip(url) {
+        if (url.includes(QASE_API_HOST)) {
+            return true;
+        }
+        return this.skipDomains.some((domain) => url.includes(domain));
+    }
+    /**
+     * Install HTTP/HTTPS monkey-patches and subscribe to undici diagnostics_channel
+     * so that outgoing requests inside a `run()` context are captured as REQUEST steps.
+     */
+    enable() {
+        this.httpInterceptor = new http_interceptor_1.HttpInterceptor(store, this);
+        this.httpInterceptor.install();
+        this.fetchInterceptor = new fetch_interceptor_1.FetchInterceptor(store, this);
+        this.fetchInterceptor.subscribe();
+    }
+    /**
+     * No-op per v1.3 design decision (flag-based activation model).
+     * Satisfies the AbstractProfiler contract.
+     */
+    disable() {
+        // Intentional no-op
+    }
+    /**
+     * Uninstall HTTP/HTTPS monkey-patches and unsubscribe from undici diagnostics_channel —
+     * permanently removes interception.
+     */
+    restore() {
+        this.fetchInterceptor?.unsubscribe();
+        this.fetchInterceptor = null;
+        this.httpInterceptor?.uninstall();
+        this.httpInterceptor = null;
+    }
+    /**
+     * Wraps `fn` in an AsyncLocalStorage context so that any HTTP requests
+     * made inside `fn` are attributed to the step accumulator for this call.
+     *
+     * Returns `{ result, steps }` where `result` is the return value of `fn`
+     * and `steps` is the array of REQUEST steps captured during execution.
+     */
+    async run(fn) {
+        const accumulator = [];
+        const result = await store.run(accumulator, fn);
+        return { result, steps: accumulator };
+    }
+    /**
+     * Returns the current ALS store when called inside a `run()` context.
+     * Returns an empty array when called outside (no active context).
+     */
+    getSteps() {
+        return store.getStore() ?? [];
+    }
+    /**
+     * Returns a copy of steps accumulated outside any run() context (fallback accumulator).
+     * Used by frameworks where test bodies cannot be wrapped in run() (Jest, Vitest, WDIO).
+     */
+    getAllSteps() {
+        return [...this.fallbackSteps];
+    }
+    /**
+     * Clears the fallback step accumulator. Call after collecting steps per test.
+     */
+    clearSteps() {
+        this.fallbackSteps.length = 0;
+    }
+}
+exports.NetworkProfiler = NetworkProfiler;

package/dist/reporters/report-reporter.js

@@ -279,6 +279,10 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
                 input_data: null, // JS GherkinData has no data field
             };
         }
+        // For request steps, pass raw fields through (all 7 StepRequestData fields are preserved)
+        if (step.step_type === models_1.StepType.REQUEST && 'request_method' in data) {
+            return data;
+        }
         return data;
     }
 }

package/package.json

@@ -1,9 +1,25 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.5.5",
+  "version": "2.5.7",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./profilers": {
+      "types": "./dist/profilers/index.d.ts",
+      "default": "./dist/profilers/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "profilers": ["./dist/profilers/index.d.ts"]
+    }
+  },
   "homepage": "https://github.com/qase-tms/qase-javascript",
   "bugs": {
     "url": "https://github.com/qase-tms/qase-javascript/issues"
@@ -46,7 +62,6 @@
     "@types/lodash.mergewith": "^4.6.9",
     "@types/mime-types": "^2.1.4",
     "@types/minimatch": "^6.0.0",
-    "@types/node": "^20.19.25",
     "@types/uuid": "^9.0.8",
     "axios": "^1.13.5",
     "jest": "^29.7.0",