@speedkit/cli 2.4.1

package/dist/services/onboarding/dashboard/request-diff-service.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestDiffService = void 0;
+const baqend_response_1 = require("../browser/baqend-response");
+const safe_1 = require("../../../helpers/safe");
+class RequestDiffService {
+    diffService;
+    constructor(diffService) {
+        this.diffService = diffService;
+    }
+    async postDiff(url, parametersString) {
+        const params = parametersString.replace('[', '').replace(']', '').split((',')).map(param => {
+            return param.trim();
+        });
+        const { urlWithParam, urlWithoutParam } = this.createUrlsForDiff(url, params);
+        const result = await (0, safe_1.safe)(this.diffLocal(urlWithParam, urlWithoutParam));
+        if (result.success === true) {
+            return new baqend_response_1.BaqendResponse(JSON.stringify({ status: 'success', isIdentical: result.data }), 'application/json; charset=UTF-8');
+        }
+        return new baqend_response_1.BaqendResponse(JSON.stringify({ status: 'error', error: result.error }), 'application/json; charset=UTF-8', null, 500);
+    }
+    async diffLocal(urlWithParam, urlWithoutParam) {
+        const htmlWithParam = await this.fetchHtml(urlWithParam);
+        const htmlWithoutParam = await this.fetchHtml(urlWithoutParam);
+        const paramsFilePath = await this.diffService.writeContentToTemporalFile('params', htmlWithParam);
+        const pureFilePath = await this.diffService.writeContentToTemporalFile('pure', htmlWithoutParam);
+        return await this.diffService.executeDiff(paramsFilePath, pureFilePath);
+    }
+    async doOriginVsContentDiff(url, content) {
+        const html = await this.fetchHtml(url);
+        const origin = await this.diffService.writeContentToTemporalFile('origin', html);
+        const local = await this.diffService.writeContentToTemporalFile('content', content);
+        return await this.diffService.executeDiff(local, origin);
+    }
+    async fetchHtml(url) {
+        const response = await fetch(url);
+        return await response.text();
+    }
+    createUrlsForDiff(urlWithParam, params) {
+        const url = new URL(urlWithParam);
+        const search_params = url.searchParams;
+        for (const param of params) {
+            search_params.delete(param);
+        }
+        url.search = search_params.toString();
+        const urlWithoutParam = url.toString();
+        console.log('With-----');
+        console.log(urlWithParam);
+        console.log('Without-----');
+        console.log(urlWithoutParam);
+        console.log('-----');
+        // TODO: Insert the content
+        return {
+            urlWithParam,
+            urlWithoutParam
+        };
+    }
+}
+exports.RequestDiffService = RequestDiffService;

package/dist/services/onboarding/error/vm-error.d.ts

@@ -0,0 +1,2 @@
+export declare class VmError extends Error {
+}

package/dist/services/onboarding/error/vm-error.js

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

package/dist/services/onboarding/fetch-event-handler.d.ts

@@ -0,0 +1,19 @@
+import { FetchRequestPausedEventHandler } from "./onboarding-model";
+import { Protocol } from "puppeteer-core";
+import { CDPSession, Target } from "puppeteer";
+import { CliService } from "../cli";
+import CustomerConfig from "../integration-api/struct/customer-config";
+import ConfigApiService from "../config-api/config-api-service";
+export declare class FetchEventHandler {
+    private browserFetchEvents;
+    private customerConfig;
+    private cli;
+    private client?;
+    constructor(browserFetchEvents: FetchRequestPausedEventHandler[], customerConfig: CustomerConfig, cli: CliService, client?: ConfigApiService);
+    handleRequestFetchEvents(target: Target): Promise<void>;
+    private canHandlePattern;
+    private onFetchRequestPaused;
+    getAuthPattern(): Protocol.Fetch.RequestPattern[];
+    private onFetchAuthRequired;
+    sendDefaultAuthBehaviour(browserClient: CDPSession, requestId: string): Promise<void>;
+}

package/dist/services/onboarding/fetch-event-handler.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchEventHandler = void 0;
+const tslib_1 = require("tslib");
+const puppeteer_core_1 = require("puppeteer-core");
+const abort_response_1 = require("./browser/abort-response");
+const cli_1 = require("../cli");
+const login_error_1 = tslib_1.__importDefault(require("../config-api/error/login-error"));
+const safe_1 = require("../../helpers/safe");
+class FetchEventHandler {
+    browserFetchEvents;
+    customerConfig;
+    cli;
+    client;
+    constructor(browserFetchEvents, customerConfig, cli, client) {
+        this.browserFetchEvents = browserFetchEvents;
+        this.customerConfig = customerConfig;
+        this.cli = cli;
+        this.client = client;
+    }
+    async handleRequestFetchEvents(target) {
+        const browserClient = await target.createCDPSession();
+        await browserClient.send('Fetch.enable', {
+            handleAuthRequests: true,
+            //see: https://chromedevtools.github.io/devtools-protocol/tot/Fetch#type-RequestPattern
+            patterns: this.browserFetchEvents.flatMap(handler => {
+                return handler.patterns;
+            }).concat(this.getAuthPattern()),
+        });
+        browserClient.on('Fetch.authRequired', async (event) => {
+            const response = await (0, safe_1.safe)(this.onFetchAuthRequired(event, browserClient));
+            if (response.success === true) {
+                return response.data;
+            }
+            this.cli.writeError(response.error);
+        });
+        browserClient.on('Fetch.requestPaused', async (event) => {
+            const response = await (0, safe_1.safe)(this.onFetchRequestPaused(event, browserClient));
+            if (response.success === true) {
+                return;
+            }
+            if (response.errorObj) {
+                this.cli.writeError(`error on ${event.request.url}`);
+                this.cli.writeError(`${response.errorObj.message}`);
+                return;
+            }
+            this.cli.writeError(`error on ${target.url()}`);
+            this.cli.writeError(JSON.stringify(response.errorObj));
+        });
+    }
+    canHandlePattern(fetchEventHandler, url, resourceType, requestStage) {
+        return fetchEventHandler.patterns.some(pattern => {
+            if (!(new RegExp(pattern.urlPattern).test(url))) {
+                return false;
+            }
+            if (pattern.requestStage !== requestStage) {
+                return false;
+            }
+            return !pattern.resourceType || pattern.resourceType === resourceType;
+        });
+    }
+    async onFetchRequestPaused(event, browserClient) {
+        const requestId = event.requestId;
+        for (const fetchEvent of this.browserFetchEvents) {
+            // check if current request could be handled
+            if (!this.canHandlePattern(fetchEvent, event.request.url, event.resourceType, event.responseHeaders ? 'Response' : 'Request')) {
+                continue;
+            }
+            const response = await fetchEvent.handle(event, browserClient);
+            if (!response) {
+                continue;
+            }
+            if (response instanceof abort_response_1.AbortResponse) {
+                await browserClient.send('Fetch.failRequest', { requestId: requestId, errorReason: response.errorReason });
+                return;
+            }
+            await browserClient.send('Fetch.fulfillRequest', {
+                ...response,
+                requestId,
+            });
+            return;
+        }
+        //see: https://chromedevtools.github.io/devtools-protocol/tot/Fetch#method-continueRequest
+        await browserClient.send('Fetch.continueRequest', {
+            requestId: requestId,
+        });
+    }
+    getAuthPattern() {
+        let result = [];
+        for (const origin of this.customerConfig.origins) {
+            const pattern = [
+                {
+                    urlPattern: `${origin}*`,
+                    requestStage: "Request"
+                }
+            ];
+            result.push(...pattern);
+        }
+        return result;
+    }
+    async onFetchAuthRequired(event, browserClient) {
+        this.cli.writeWarning(`auth requested for ${event.request.url}`);
+        if (!this.customerConfig.origins.some((origin) => { return event.request.url.includes(origin); }) || !this.client) {
+            this.cli.writeWarning(`incorrect origin for auth request: -> ${this.customerConfig.origins.join("|")}`);
+            return { response: "Default" };
+        }
+        this.cli.startAction('wait for credentials from server-config');
+        const serverConfigResponse = await (0, safe_1.safe)(this.client.getServerConfig());
+        if (serverConfigResponse.success === true) {
+            const config = JSON.parse(serverConfigResponse.data);
+            const authUrlOrigin = new URL(event.request.url).origin;
+            for (const auth of config.speedKit.authentications) {
+                if (auth.uri.includes(authUrlOrigin) && auth.type === event.authChallenge.scheme) {
+                    await browserClient.send('Fetch.continueWithAuth', {
+                        requestId: event.requestId,
+                        authChallengeResponse: {
+                            response: "ProvideCredentials",
+                            username: auth.user,
+                            password: auth.password
+                        }
+                    });
+                    this.cli.endAction(cli_1.CliActionStatus.COMPLETED);
+                    this.cli.writeSuccess(`auth provided for ${event.request.url}`);
+                    await this.sendDefaultAuthBehaviour(browserClient, event.requestId);
+                    return;
+                }
+            }
+            this.cli.endAction(cli_1.CliActionStatus.FAILED);
+            this.cli.writeError(`error providing auth: no credentials found in runtimeConfig of app ${this.customerConfig.app}`);
+            await this.sendDefaultAuthBehaviour(browserClient, event.requestId);
+            return;
+        }
+        this.cli.endAction(cli_1.CliActionStatus.FAILED);
+        if (serverConfigResponse.errorObj instanceof puppeteer_core_1.ProtocolError) {
+            // unknown raceCondition where the authResponse is sent to fast
+            return;
+        }
+        if (serverConfigResponse.errorObj instanceof login_error_1.default) {
+            this.cli.writeError(`could not login to app ${serverConfigResponse.errorObj.app} to gather credentials. Try run sk login`);
+            await this.sendDefaultAuthBehaviour(browserClient, event.requestId);
+            return;
+        }
+        this.cli.writeError(`error providing auth: ${JSON.stringify(serverConfigResponse.errorObj)}`);
+        await this.sendDefaultAuthBehaviour(browserClient, event.requestId);
+    }
+    async sendDefaultAuthBehaviour(browserClient, requestId) {
+        await browserClient.send('Fetch.continueWithAuth', {
+            requestId,
+            authChallengeResponse: {
+                response: "Default"
+            }
+        });
+    }
+}
+exports.FetchEventHandler = FetchEventHandler;

package/dist/services/onboarding/fetch-events/customer-domain-document-response.d.ts

@@ -0,0 +1,24 @@
+import Protocol from 'devtools-protocol';
+import { FetchRequestPausedEventHandler } from "../onboarding-model";
+import CustomerConfig from "../../integration-api/struct/customer-config";
+import { CDPSession } from "puppeteer";
+import { ConfigFileInterface } from "../../integration-api/integration-api-model";
+/**
+ * Intercepts any request to the customersOrigin and equivalent requests to baqendAssetApi
+ * @implements {FetchRequestPausedEventHandler}
+ */
+export declare class CustomerDomainDocumentResponse implements FetchRequestPausedEventHandler {
+    private customerConfig;
+    private configDynamicBlock;
+    private configDynamicStyles;
+    get patterns(): Protocol.Fetch.RequestPattern[];
+    constructor(customerConfig: CustomerConfig, configDynamicBlock: ConfigFileInterface, configDynamicStyles: ConfigFileInterface);
+    handle(event: Protocol.Fetch.RequestPausedEvent, client: CDPSession): Promise<Partial<Protocol.Fetch.FulfillRequestRequest> | void>;
+    private isValidHtmlContent;
+    private isValidResponse;
+    private isHtmlContentHeader;
+    private getHtmlContent;
+    private isSpeedKitResponse;
+    private rewriteInstallResource;
+    private rewriteHtmlToLocalConfig;
+}

package/dist/services/onboarding/fetch-events/customer-domain-document-response.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerDomainDocumentResponse = void 0;
+const origin_response_1 = require("../browser/origin-response");
+/**
+ * Intercepts any request to the customersOrigin and equivalent requests to baqendAssetApi
+ * @implements {FetchRequestPausedEventHandler}
+ */
+class CustomerDomainDocumentResponse {
+    customerConfig;
+    configDynamicBlock;
+    configDynamicStyles;
+    get patterns() {
+        let result = [];
+        for (const origin of this.customerConfig.origins) {
+            const pattern = [
+                {
+                    urlPattern: `${origin}*`,
+                    resourceType: 'Document',
+                    requestStage: "Response"
+                },
+                {
+                    urlPattern: `${origin}*`,
+                    resourceType: 'Fetch',
+                    requestStage: "Response"
+                },
+                {
+                    urlPattern: `${origin}*`,
+                    resourceType: 'XHR',
+                    requestStage: "Response"
+                },
+                {
+                    urlPattern: `https://${this.customerConfig.appDomain}/v1/asset/${origin}*`,
+                    resourceType: 'Fetch',
+                    requestStage: "Response"
+                },
+                {
+                    urlPattern: `https://${this.customerConfig.appDomain}/v1/asset/${origin}*`,
+                    resourceType: "XHR",
+                    requestStage: "Response"
+                }
+            ];
+            result.push(...pattern);
+        }
+        return result;
+    }
+    constructor(customerConfig, configDynamicBlock, configDynamicStyles) {
+        this.customerConfig = customerConfig;
+        this.configDynamicBlock = configDynamicBlock;
+        this.configDynamicStyles = configDynamicStyles;
+    }
+    async handle(event, client) {
+        if (!this.isValidResponse(event)) {
+            return;
+        }
+        if (!this.isHtmlContentHeader(event.responseHeaders)) {
+            return;
+        }
+        let text = await this.getHtmlContent(client, event);
+        if (!this.isValidHtmlContent(text)) {
+            return;
+        }
+        if (this.customerConfig.forceInstall) {
+            text = this.rewriteInstallResource(text);
+        }
+        if (this.isSpeedKitResponse(text)) {
+            text = this.rewriteHtmlToLocalConfig(text);
+        }
+        return new origin_response_1.OriginResponse(text, event.responseHeaders, event.responseStatusCode);
+    }
+    isValidHtmlContent(text) {
+        return text.includes('<html');
+    }
+    isValidResponse(event) {
+        return event.responseHeaders &&
+            event.responseStatusCode &&
+            event.responseStatusCode > 199 &&
+            event.responseStatusCode < 300;
+    }
+    isHtmlContentHeader(responseHeaders) {
+        const contentType = responseHeaders.filter(headerRecord => {
+            return headerRecord.name.toLowerCase() === 'content-type';
+        })?.[0]?.['value'];
+        return contentType && contentType.includes('text/html');
+    }
+    async getHtmlContent(client, event) {
+        const contentType = event.responseHeaders.filter(headerRecord => {
+            return headerRecord.name.toLowerCase() === 'content-type';
+        })?.[0]?.['value'] || '';
+        const charset = contentType.split('charset=')?.[1];
+        const { body, base64Encoded } = await client.send('Fetch.getResponseBody', { requestId: event.requestId });
+        if (base64Encoded) {
+            // todo get encodingHeader for target encoding
+            return Buffer.from(body, 'base64').toString(charset || 'utf-8');
+        }
+        return body;
+    }
+    isSpeedKitResponse(text) {
+        return text.includes('speed-kit-dynamic');
+    }
+    rewriteInstallResource(text) {
+        text = text.replace(/<script(?:.(?!<\/script>))*app\.baqend\.com\/v1\/speedkit\/install.js(?:.|(?!<\/script>))*<\/script>/, '');
+        return text.replace(/<\s*head\b[^>]*>/, (head) => {
+            return `${head}\n<script src="${this.customerConfig.installPath}" ${this.customerConfig.installParams}></script>`;
+        });
+    }
+    rewriteHtmlToLocalConfig(html) {
+        const DF_CONFIG_PATTERN = /(<script[^>]* id="speed-kit-df-config"[^>]*>)([\s\S]*?)(<\/script>)/g;
+        const DF_STYLES_PATTERN = /(<style[^>]* id="speed-kit-df-styles"[^>]*>)(?:(?!<\/style>)[\s\S])*(<\/style>)/g;
+        html = html.replace(DF_CONFIG_PATTERN, (_, tag, body, end) => {
+            const injectedConfig = body.match(/window\.dynamicBlockConfig\.appName\s=.*$/s) ?? [''];
+            return `${tag}${this.configDynamicBlock.getContent()}${injectedConfig[0]}${end}`;
+        });
+        html = html.replace(DF_STYLES_PATTERN, (_, tag, end) => `${tag}${this.configDynamicStyles.getContent()}${end}`);
+        return html;
+    }
+}
+exports.CustomerDomainDocumentResponse = CustomerDomainDocumentResponse;

package/dist/services/onboarding/fetch-events/customer-service-worker-js.d.ts

@@ -0,0 +1,14 @@
+import Protocol from 'devtools-protocol';
+import { FetchRequestPausedEventHandler } from "../onboarding-model";
+import CustomerConfig from "../../integration-api/struct/customer-config";
+/**
+ * Intercepts request to /wrapper-sw.js
+ *
+ * @implements {FetchRequestPausedEventHandler}
+ */
+export declare class CustomerServiceWorkerJs implements FetchRequestPausedEventHandler {
+    private customerConfig;
+    get patterns(): Protocol.Fetch.RequestPattern[];
+    constructor(customerConfig: CustomerConfig);
+    handle(): Promise<Partial<Protocol.Fetch.FulfillRequestRequest>>;
+}

package/dist/services/onboarding/fetch-events/customer-service-worker-js.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerServiceWorkerJs = void 0;
+const baqend_response_1 = require("../browser/baqend-response");
+/**
+ * Intercepts request to /wrapper-sw.js
+ *
+ * @implements {FetchRequestPausedEventHandler}
+ */
+class CustomerServiceWorkerJs {
+    customerConfig;
+    get patterns() {
+        let result = [];
+        for (const origin of this.customerConfig.origins) {
+            result.push({
+                urlPattern: `${origin}${this.customerConfig.swPath}*`,
+                requestStage: "Request"
+            });
+        }
+        return result;
+    }
+    constructor(customerConfig) {
+        this.customerConfig = customerConfig;
+    }
+    async handle() {
+        const wrapperSwCode = `importScripts(\`https://${this.customerConfig.appDomain}/v1/speedkit/sw.js\${location.search}\`); // skonboarding`;
+        return new baqend_response_1.BaqendResponse(wrapperSwCode, 'text/javascript; charset=utf-8');
+    }
+}
+exports.CustomerServiceWorkerJs = CustomerServiceWorkerJs;

package/dist/services/onboarding/fetch-events/dashboard-request.d.ts

@@ -0,0 +1,15 @@
+import Protocol from 'devtools-protocol';
+import { FetchRequestPausedEventHandler } from "../onboarding-model";
+import { Dashboard } from "../dashboard";
+/**
+ * The DashboardRequest class represents a request handler for the dashboard.
+ * Handle all the requests on the secondTab(http://skonboarding.local)
+ *
+ * @implements {FetchRequestPausedEventHandler}
+ */
+export declare class DashboardRequest implements FetchRequestPausedEventHandler {
+    private dashboard;
+    readonly patterns: Protocol.Fetch.RequestPattern[];
+    constructor(dashboard: Dashboard);
+    handle(event: Protocol.Fetch.RequestPausedEvent): Promise<Partial<Protocol.Fetch.FulfillRequestRequest>>;
+}

package/dist/services/onboarding/fetch-events/dashboard-request.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardRequest = void 0;
+/**
+ * The DashboardRequest class represents a request handler for the dashboard.
+ * Handle all the requests on the secondTab(http://skonboarding.local)
+ *
+ * @implements {FetchRequestPausedEventHandler}
+ */
+class DashboardRequest {
+    dashboard;
+    patterns = [
+        {
+            urlPattern: `http://skonboarding.local*`,
+            requestStage: "Request"
+        },
+        {
+            urlPattern: `https://skonboarding.local*`,
+            requestStage: "Request"
+        },
+    ];
+    constructor(dashboard) {
+        this.dashboard = dashboard;
+    }
+    async handle(event) {
+        return await this.dashboard.getResponse(event.request);
+    }
+}
+exports.DashboardRequest = DashboardRequest;

package/dist/services/onboarding/fetch-events/speed-kit-asset-request.d.ts

@@ -0,0 +1,26 @@
+import Protocol from "devtools-protocol";
+import { FetchRequestPausedEventHandler } from "../onboarding-model";
+import CustomerConfig from "../../integration-api/struct/customer-config";
+import { DocumentHandlerServer } from "../../document-handler-runtime/document-handler-server";
+import { AbortResponse } from "../browser/abort-response";
+import { Cache } from "../request-cache/cache";
+import { CliService } from "../../cli";
+/**
+ * Handles fetch requests for Speed Kit assets and returns customized responses.
+ */
+export declare class SpeedKitAssetRequest implements FetchRequestPausedEventHandler {
+    private customerConfig;
+    private documentHandler;
+    private cache;
+    private cli;
+    get patterns(): Protocol.Fetch.RequestPattern[];
+    constructor(customerConfig: CustomerConfig, documentHandler: DocumentHandlerServer, cache: Cache, cli: CliService);
+    handle(event: Protocol.Fetch.RequestPausedEvent): Promise<Partial<Protocol.Fetch.FulfillRequestRequest> | AbortResponse>;
+    private getCachedResponse;
+    private buildCustomHeaders;
+    private createResponseFromLocalDocumentHandler;
+    private getAssetUrl;
+    private isHtmlContentHeader;
+    private isValidHtmlContent;
+    private rewriteInstallResource;
+}

package/dist/services/onboarding/fetch-events/speed-kit-asset-request.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeedKitAssetRequest = void 0;
+const baqend_response_1 = require("../browser/baqend-response");
+/**
+ * Handles fetch requests for Speed Kit assets and returns customized responses.
+ */
+class SpeedKitAssetRequest {
+    customerConfig;
+    documentHandler;
+    cache;
+    cli;
+    get patterns() {
+        let result = [];
+        for (const origin of this.customerConfig.origins) {
+            const pattern = [
+                {
+                    urlPattern: `https://${this.customerConfig.appDomain}/v1/asset/${origin}*`,
+                    resourceType: 'Fetch',
+                    requestStage: "Request"
+                },
+                {
+                    urlPattern: `https://${this.customerConfig.appDomain}/v1/asset/${origin}*`,
+                    resourceType: "XHR",
+                    requestStage: "Request"
+                }
+            ];
+            result.push(...pattern);
+        }
+        return result;
+    }
+    constructor(customerConfig, documentHandler, cache, cli) {
+        this.customerConfig = customerConfig;
+        this.documentHandler = documentHandler;
+        this.cache = cache;
+        this.cli = cli;
+    }
+    async handle(event) {
+        const originUrl = this.getAssetUrl(event.request.url);
+        const UrlObject = new URL(event.request.url);
+        const variation = UrlObject.searchParams.has('bqvariation') ? UrlObject.searchParams.get('bqvariation') : 'DEFAULT';
+        const cachedResponse = this.getCachedResponse(event.request.url);
+        if (cachedResponse instanceof baqend_response_1.BaqendResponse) {
+            return cachedResponse;
+        }
+        const response = await fetch(originUrl, { headers: (event.request.headers) });
+        const customHeaders = this.buildCustomHeaders(originUrl);
+        if (response.headers.get('Content-Type').includes('image') || response.headers.get('Content-Type').includes('font')) {
+            return;
+        }
+        const responseContent = await response.text();
+        if (!this.isHtmlContentHeader(response.headers) || !this.isValidHtmlContent(responseContent)) {
+            const customResponse = new baqend_response_1.BaqendResponse(responseContent, response.headers.get('Content-Type') || null, customHeaders);
+            this.cache.addEntry(event.request.url, customResponse);
+            return customResponse;
+        }
+        try {
+            let customResponse = await this.createResponseFromLocalDocumentHandler(responseContent, variation, originUrl, event.request.headers);
+            customResponse = customResponse.replace('speed-kit-dynamic-load', 'skonboarding speed-kit-dynamic-load');
+            if (this.customerConfig.forceInstall) {
+                customResponse = this.rewriteInstallResource(customResponse);
+            }
+            const response = new baqend_response_1.BaqendResponse(customResponse, null, customHeaders);
+            this.cache.addEntry(event.request.url, response);
+            return response;
+        }
+        catch (error) {
+            let message = 'could not transform html';
+            if (error instanceof Error) {
+                message = error.message;
+            }
+            this.cli.writeError(message);
+            customHeaders.push({ name: 'x-error', value: message });
+            return new baqend_response_1.BaqendResponse(message, null, customHeaders, 500);
+        }
+    }
+    getCachedResponse(requestUrl) {
+        const response = this.cache.getEntry(requestUrl);
+        if (!(response instanceof baqend_response_1.BaqendResponse)) {
+            return;
+        }
+        response.setHeader('x-cache', 'POP, HIT');
+        response.setHeader('x-served-by', 'cache-local');
+        response.setHeader('server-timing', 'pop;desc=LOCAL;dur=1,cache;desc=CACHE,hotness;desc=1,proto;desc=h3');
+        return response;
+    }
+    buildCustomHeaders(originUrl) {
+        const time = new Date().toUTCString();
+        const originDomain = new URL(originUrl).origin;
+        return [
+            { name: 'origin', value: originDomain },
+            { name: 'Access-Control-Allow-Credentials', value: 'true' },
+            {
+                name: 'Access-Control-Expose-Headers',
+                value: 'Location, ETag, Baqend-Authorization-Token, Baqend-Acl, Baqend-Size, Baqend-SW-Control, Baqend-Created-At, Date, Age, Baqend-Speed-Kit, Baqend-Custom-Headers, X-Served-By, X-Cache, X-Timer, Access-Control-Allow-Origin, Fastly-Io-Info, Server-Timing'
+            },
+            { name: 'strict-transport-security', value: 'max-age=31536000; includeSubDomains' },
+            { name: 'timing-allow-origin', value: originDomain },
+            { name: 'Cache-Control', value: 'public,browser-ttl=0,sw-max-age=31536000,max-age=31469674' },
+            { name: 'server-timing', value: 'pop;desc=LOCAL;dur=1,cache;desc=STREAM,hotness;desc=1,proto;desc=h3' },
+            { name: 'Alt-Svc', value: 'h3=":443";ma=86400,h3-29=":443";ma=86400,h3-27=":443";ma=86400' },
+            { name: 'x-frame-options', value: 'SAMEORIGIN' },
+            { name: 'x-cache', value: 'STREAM, HIT' },
+            { name: 'x-cache-hits', value: '1' },
+            { name: 'x-served-by', value: 'stream-local' },
+            { name: 'Date', value: time },
+            { name: 'last-modified', value: time },
+            { name: 'Baqend-Created-At', value: time },
+            { name: 'Age', value: '0' },
+        ];
+    }
+    async createResponseFromLocalDocumentHandler(html, variation, url, headers) {
+        return this.documentHandler.transform(html, variation, url, headers);
+    }
+    getAssetUrl(requestUrl) {
+        const url = new URL(requestUrl);
+        url.searchParams.forEach((value, name, searchParams) => {
+            if (name.startsWith("bq") || name === "bqsk") {
+                searchParams.delete(name);
+            }
+        });
+        const cleanedUrl = url.toString();
+        return cleanedUrl.split("app.baqend.com/v1/asset/")[1];
+    }
+    isHtmlContentHeader(responseHeaders) {
+        return responseHeaders.has('content-type') && responseHeaders.get('content-type').includes('text/html');
+    }
+    isValidHtmlContent(text) {
+        return text.includes('<html');
+    }
+    rewriteInstallResource(text) {
+        text = text.replace(/<script(?:.(?!<\/script>))*app\.baqend\.com\/v1\/speedkit\/install.js(?:.|(?!<\/script>))*<\/script>/, '');
+        return text.replace(/<\s*head\b[^>]*>/, (head) => {
+            return `${head}\n<script src="${this.customerConfig.installPath}" ${this.customerConfig.installParams}></script>`;
+        });
+    }
+}
+exports.SpeedKitAssetRequest = SpeedKitAssetRequest;

package/dist/services/onboarding/fetch-events/speed-kit-install-html.d.ts

@@ -0,0 +1,15 @@
+import Protocol from 'devtools-protocol';
+import { BrowserContext, FetchRequestPausedEventHandler } from "../onboarding-model";
+import CustomerConfig from "../../integration-api/struct/customer-config";
+import { InstallSpeedKitHtmlTemplate } from "../templates/install-speed-kit-html-template";
+/**
+ * Represents a class that handles the installation of Speed Kit HTML.
+ */
+export declare class SpeedKitInstallHtml implements FetchRequestPausedEventHandler {
+    private customerConfig;
+    private browserContext;
+    private speedKitInstallHtmlTemplate;
+    get patterns(): Protocol.Fetch.RequestPattern[];
+    constructor(customerConfig: CustomerConfig, browserContext: BrowserContext, speedKitInstallHtmlTemplate: InstallSpeedKitHtmlTemplate);
+    handle(): Promise<Partial<Protocol.Fetch.FulfillRequestRequest>>;
+}