pagespeed-quest 0.3.2 → 0.3.3

package/build/inventory.js

@@ -0,0 +1,175 @@
+import Fs from 'fs';
+import Fsp from 'fs/promises';
+import Path from 'path';
+import { compress, decompress } from './encoding.js';
+import { convertEditableText, isText } from './formatting.js';
+import { parseContentTypeHeader, requestContentFilePath, stringifyContentTypeHeader } from './http.js';
+const InventoryDir = 'inventory';
+const IndexFile = 'index.json';
+export class InventoryRepository {
+    dirPath;
+    dependency;
+    constructor(dirPath, dependency) {
+        this.dirPath = dirPath || Path.join(process.cwd(), InventoryDir);
+        this.dependency = dependency || {};
+    }
+    async saveInventory(inventory) {
+        const inventoryJson = JSON.stringify(inventory, null, 2);
+        await Fsp.mkdir(this.dirPath, { recursive: true });
+        await Fsp.writeFile(Path.join(this.dirPath, IndexFile), inventoryJson);
+    }
+    async loadInventory() {
+        const inventoryJson = await Fsp.readFile(Path.join(this.dirPath, IndexFile), 'utf8');
+        const inventory = JSON.parse(inventoryJson);
+        return inventory;
+    }
+    async saveTransactions(transactions) {
+        // To keep transactions order in Promise.all,
+        // store transactions and resources in a map.
+        const map = new Map();
+        await Fsp.mkdir(this.dirPath, { recursive: true });
+        const saveTransaction = async (transaction) => {
+            const resource = {
+                method: transaction.method,
+                url: transaction.url,
+                ttfbMs: transaction.ttfbMs,
+                statusCode: transaction.statusCode,
+                errorMessage: transaction.errorMessage,
+                rawHeaders: transaction.rawHeaders,
+            };
+            // Headers
+            if (transaction.rawHeaders) {
+                if (transaction.rawHeaders['content-type']) {
+                    const { mime, charset } = parseContentTypeHeader(transaction.rawHeaders['content-type']);
+                    if (mime)
+                        resource.contentTypeMime = mime;
+                    if (charset)
+                        resource.contentTypeCharset = charset;
+                }
+                if (transaction.rawHeaders['content-encoding']) {
+                    const contentEncoding = transaction.rawHeaders['content-encoding'];
+                    if (contentEncoding)
+                        resource.contentEncoding = contentEncoding;
+                }
+            }
+            // Mbps
+            if (transaction.durationMs && transaction.content) {
+                const contentBits = transaction.content.length * 8;
+                const seconds = transaction.durationMs / 1000;
+                const mega = 1024 * 1024;
+                resource.mbps = contentBits / seconds / mega;
+            }
+            // Content
+            if (transaction.content) {
+                const steps = {};
+                const contentFilePath = requestContentFilePath(resource.method, resource.url);
+                const fullPath = Path.join(this.dirPath, contentFilePath);
+                // Content-Encoding
+                steps.decoded = resource.contentEncoding
+                    ? await decompress(resource.contentEncoding, transaction.content)
+                    : transaction.content;
+                // Try to make editable (utf8, beautify)
+                steps.editable = steps.decoded;
+                if (isText(resource.contentTypeMime)) {
+                    try {
+                        steps.editable = await convertEditableText(steps.decoded, resource.contentTypeMime, resource.contentTypeCharset);
+                        resource.contentTypeCharset = 'utf-8';
+                    }
+                    catch (err) {
+                        this.dependency.logger?.error({ err, resource }, `Formatting failed ${transaction.url}: ${err.message}`);
+                    }
+                }
+                await Fsp.mkdir(Path.dirname(fullPath), { recursive: true });
+                await Fsp.writeFile(fullPath, steps.editable);
+                resource.contentFilePath = contentFilePath;
+            }
+            map.set(transaction, resource);
+        };
+        const tryToSaveTransaction = async (transaction) => {
+            try {
+                await saveTransaction(transaction);
+            }
+            catch (err) {
+                this.dependency.logger?.error({ err, method: transaction.method, url: transaction.url }, `Failed to save transaction ${transaction.url}: ${err.message}`);
+            }
+        };
+        await Promise.all(transactions.map(tryToSaveTransaction));
+        // Restore transactions order after Promise.all
+        const resources = transactions.reduce((resources, transaction) => {
+            const resource = map.get(transaction);
+            if (resource)
+                resources.push(resource);
+            return resources;
+        }, []);
+        return resources;
+    }
+    async loadTransactions(resources) {
+        const map = new Map();
+        const loadTransaction = async (resource) => {
+            const transaction = {
+                method: resource.method,
+                url: resource.url,
+                ttfbMs: resource.ttfbMs,
+                statusCode: resource.statusCode,
+                errorMessage: resource.errorMessage,
+                rawHeaders: { ...(resource.rawHeaders || {}) },
+            };
+            // content
+            let content;
+            if (resource.contentUtf8) {
+                content = Buffer.from(resource.contentUtf8);
+            }
+            else if (resource.contentBase64) {
+                content = Buffer.from(resource.contentBase64, 'base64');
+            }
+            else if (resource.contentFilePath) {
+                const fullPath = Path.join(this.dirPath, resource.contentFilePath);
+                if (Fs.existsSync(fullPath)) {
+                    content = await Fsp.readFile(fullPath);
+                }
+            }
+            if (content) {
+                // encoding
+                if (resource.contentEncoding) {
+                    transaction.content = await compress(resource.contentEncoding, content);
+                    transaction.rawHeaders['content-encoding'] = resource.contentEncoding;
+                }
+                else {
+                    transaction.content = content;
+                    delete transaction.rawHeaders['content-encoding'];
+                }
+                // length
+                transaction.rawHeaders['content-length'] = `${transaction.content.length}`;
+                // duration
+                const bytesPerMs = resource.mbps ? (resource.mbps * 1024 * 1024) / 8 / 1000 : 0;
+                transaction.durationMs = bytesPerMs ? content.length / bytesPerMs : 0;
+            }
+            else {
+                transaction.rawHeaders['content-length'] = '0';
+                transaction.durationMs = 0;
+            }
+            // Content-Type
+            if (resource.contentTypeMime) {
+                transaction.rawHeaders['content-type'] = stringifyContentTypeHeader(resource.contentTypeMime, resource.contentTypeCharset);
+            }
+            map.set(resource, transaction);
+        };
+        const tryToLoadTransaction = async (resource) => {
+            try {
+                await loadTransaction(resource);
+            }
+            catch (err) {
+                this.dependency.logger?.error({ err, resource }, `Loading transaction failed ${resource.url}: ${err.message}`);
+            }
+        };
+        await Promise.all(resources.map(tryToLoadTransaction));
+        const transactions = resources.reduce((transactions, resource) => {
+            const transaction = map.get(resource);
+            if (transaction)
+                transactions.push(transaction);
+            return transactions;
+        }, []);
+        return transactions;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inventory.js","sourceRoot":"","sources":["../src/inventory.ts"],"names":[],"mappings":"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"}

package/build/lighthouse.d.ts

@@ -0,0 +1,12 @@
+import { DependencyInterface, DeviceType } from './types.js';
+export interface ExecLighthouseInput {
+    url: string;
+    proxyPort: number;
+    deviceType?: DeviceType;
+    cpuMultiplier?: string;
+    noThrottling?: boolean;
+    view?: boolean;
+    artifactsDir?: string;
+    headless: boolean;
+}
+export declare function execLighthouse(opts: ExecLighthouseInput, dependency: Pick<DependencyInterface, 'mkdirp' | 'executeLighthouse'>): Promise<void>;

package/build/lighthouse.js

@@ -0,0 +1,28 @@
+import Path from 'path';
+export async function execLighthouse(opts, dependency) {
+    const artifactsDir = opts.artifactsDir || './artifacts';
+    await dependency.mkdirp(artifactsDir);
+    const deviceType = opts.deviceType || 'mobile';
+    const outputPath = Path.join(artifactsDir, 'lighthouse');
+    const args = [
+        opts.url,
+        '--save-assets',
+        '--output=html,json',
+        `--output-path=${outputPath}`,
+        '--only-categories=performance',
+        `--form-factor=${deviceType}`,
+    ];
+    if (opts.noThrottling) {
+        args.push('--throttling.rttMs=0', '--throttling.throughputKbps=0', '--throttling.downloadThroughputKbps=0', '--throttling.uploadThroughputKbps=0', '--throttling.cpuSlowdownMultiplier=1');
+    }
+    else if (opts.cpuMultiplier)
+        args.push(`--throttling.cpuSlowdownMultiplier=${opts.cpuMultiplier}`);
+    const chromeFlags = ['--ignore-certificate-errors', `--proxy-server=http://localhost:${opts.proxyPort}`];
+    if (opts.headless)
+        chromeFlags.push('--headless');
+    args.push(`--chrome-flags="${chromeFlags.join(' ')}"`);
+    if (opts.view)
+        args.push('--view');
+    await dependency.executeLighthouse(args);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlnaHRob3VzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9saWdodGhvdXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sSUFBSSxNQUFNLE1BQU0sQ0FBQTtBQWV2QixNQUFNLENBQUMsS0FBSyxVQUFVLGNBQWMsQ0FDbEMsSUFBeUIsRUFDekIsVUFBcUU7SUFFckUsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLFlBQVksSUFBSSxhQUFhLENBQUE7SUFDdkQsTUFBTSxVQUFVLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFBO0lBRXJDLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLElBQUksUUFBUSxDQUFBO0lBQzlDLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLFlBQVksQ0FBQyxDQUFBO0lBQ3hELE1BQU0sSUFBSSxHQUFhO1FBQ3JCLElBQUksQ0FBQyxHQUFHO1FBQ1IsZUFBZTtRQUNmLG9CQUFvQjtRQUNwQixpQkFBaUIsVUFBVSxFQUFFO1FBQzdCLCtCQUErQjtRQUMvQixpQkFBaUIsVUFBVSxFQUFFO0tBQzlCLENBQUE7SUFFRCxJQUFJLElBQUksQ0FBQyxZQUFZLEVBQUU7UUFDckIsSUFBSSxDQUFDLElBQUksQ0FDUCxzQkFBc0IsRUFDdEIsK0JBQStCLEVBQy9CLHVDQUF1QyxFQUN2QyxxQ0FBcUMsRUFDckMsc0NBQXNDLENBQ3ZDLENBQUE7S0FDRjtTQUFNLElBQUksSUFBSSxDQUFDLGFBQWE7UUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLHNDQUFzQyxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUMsQ0FBQTtJQUVwRyxNQUFNLFdBQVcsR0FBYSxDQUFDLDZCQUE2QixFQUFFLG1DQUFtQyxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FBQTtJQUNsSCxJQUFJLElBQUksQ0FBQyxRQUFRO1FBQUUsV0FBVyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQTtJQUNqRCxJQUFJLENBQUMsSUFBSSxDQUFDLG1CQUFtQixXQUFXLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQTtJQUV0RCxJQUFJLElBQUksQ0FBQyxJQUFJO1FBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUVsQyxNQUFNLFVBQVUsQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsQ0FBQTtBQUMxQyxDQUFDIn0=

package/build/loadshow.d.ts

@@ -0,0 +1,19 @@
+import { DependencyInterface, DeviceType } from './types.js';
+export interface ExecLoadshowInput {
+    url: string;
+    proxyPort: number;
+    deviceType?: DeviceType;
+    noThrottling?: boolean;
+    syncLighthouseSpec?: boolean;
+    artifactsDir?: string;
+}
+export interface ExecLoadshowSpec {
+    viewportWidth?: number;
+    columns?: number;
+    cpuThrottling?: number;
+    networkLatencyMs?: number;
+    networkThroughputMbps?: number;
+    userAgent?: string;
+    proxyPort?: number;
+}
+export declare function execLoadshow(input: ExecLoadshowInput, dependency: Pick<DependencyInterface, 'mkdirp' | 'executeLoadshow'>): Promise<void>;

package/build/loadshow.js

@@ -0,0 +1,65 @@
+import Path from 'path';
+import { defaultConfig, desktopConfig } from 'lighthouse';
+function execSpecToCommandArgs(spec) {
+    const args = [];
+    // layout
+    if (spec.columns !== undefined)
+        args.push('-u', `layout.columns=${spec.columns}`);
+    // recording
+    if (spec.viewportWidth !== undefined)
+        args.push('-u', `recording.viewportWidth=${spec.viewportWidth}`);
+    if (spec.cpuThrottling !== undefined)
+        args.push('-u', `recording.cpuThrottling=${spec.cpuThrottling}`);
+    if (spec.networkLatencyMs !== undefined)
+        args.push('-u', `recording.network.latencyMs=${spec.networkLatencyMs}`);
+    if (spec.networkThroughputMbps !== undefined) {
+        args.push('-u', `recording.network.uploadThroughputMbps=${spec.networkThroughputMbps}`);
+        args.push('-u', `recording.network.downloadThroughputMbps=${spec.networkThroughputMbps}`);
+    }
+    if (spec.userAgent !== undefined)
+        args.push('-u', `recording.headers.User-Agent=${spec.userAgent}`);
+    // recording.puppeteer
+    const chromeArgs = ['--ignore-certificate-errors'];
+    if (spec.proxyPort !== undefined) {
+        chromeArgs.push(`--proxy-server=http://localhost:${spec.proxyPort}`);
+    }
+    args.push('-u', 'recording.puppeteer.args=' + chromeArgs.join(','));
+    return args;
+}
+export async function execLoadshow(input, dependency) {
+    const artifactsDir = input.artifactsDir || './artifacts';
+    const loadshowDir = Path.join(artifactsDir, 'loadshow');
+    const outputPath = Path.join(artifactsDir, 'loadshow.mp4');
+    await dependency.mkdirp(loadshowDir);
+    // By form factor
+    const lighthouseByDevice = input.deviceType === 'desktop' ? desktopConfig : defaultConfig;
+    const customByDevice = input.deviceType === 'desktop' ? { columns: 2 } : { columns: 3 };
+    // Basic spec
+    const userAgent = lighthouseByDevice.settings?.emulatedUserAgent;
+    const spec = {
+        proxyPort: input.proxyPort,
+        columns: customByDevice.columns,
+        viewportWidth: lighthouseByDevice.settings?.screenEmulation?.width,
+        cpuThrottling: lighthouseByDevice.settings?.throttling?.cpuSlowdownMultiplier,
+        userAgent: typeof userAgent === 'string' ? userAgent : undefined,
+    };
+    // Sync network conditions with Lighthouse
+    if (input.syncLighthouseSpec) {
+        if (lighthouseByDevice.settings?.throttling?.rttMs)
+            spec.networkLatencyMs = lighthouseByDevice.settings?.throttling?.rttMs;
+        if (lighthouseByDevice.settings?.throttling?.throughputKbps)
+            spec.networkThroughputMbps = lighthouseByDevice.settings?.throttling?.throughputKbps / 1024;
+    }
+    // No throttling
+    if (input.noThrottling) {
+        spec.networkLatencyMs = 0;
+        spec.networkThroughputMbps = 999999;
+    }
+    const args = [];
+    args.push('record');
+    args.push('-a', loadshowDir);
+    args.push(...execSpecToCommandArgs(spec));
+    args.push(input.url, outputPath);
+    await dependency.executeLoadshow(args);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/playback.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { HttpHeaders } from './http.js';
+import { Inventory } from './inventory.js';
+import { Proxy, ProxyDependency, ProxyOptions } from './proxy.js';
+export interface PlaybackTransaction {
+    method: string;
+    url: string;
+    ttfbMs: number;
+    statusCode?: number;
+    err?: Error;
+    rawHeaders?: HttpHeaders;
+    contentChunks: Buffer[];
+    contentLength: number;
+    durationMs: number;
+}
+export declare class PlaybackProxy extends Proxy {
+    transactionsMap: Map<string, Map<string, PlaybackTransaction>>;
+    loadTransactions(inventory: Inventory): Promise<void>;
+    setup(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export declare function withPlaybackProxy(options: ProxyOptions, dependency: ProxyDependency, cb: (proxy: PlaybackProxy) => Promise<void>): Promise<void>;

package/build/playback.js

@@ -0,0 +1,104 @@
+import { Proxy } from './proxy.js';
+const ChunkSize = 1024 * 16;
+export class PlaybackProxy extends Proxy {
+    transactionsMap = new Map();
+    async loadTransactions(inventory) {
+        const transactions = await this.inventoryRepository.loadTransactions(inventory.resources);
+        for (const transaction of transactions) {
+            const playbackTransaction = {
+                method: transaction.method,
+                url: transaction.url,
+                ttfbMs: transaction.ttfbMs,
+                statusCode: transaction.statusCode,
+                err: transaction.errorMessage ? new Error(transaction.errorMessage) : undefined,
+                rawHeaders: transaction.rawHeaders || {},
+                contentChunks: [],
+                contentLength: 0,
+                durationMs: transaction.durationMs || 0,
+            };
+            if (transaction.content) {
+                const maxChunks = 10;
+                const minInterval = 10;
+                const chunks = Math.min(maxChunks, Math.floor(playbackTransaction.durationMs / minInterval));
+                playbackTransaction.contentChunks = [];
+                const chunkSize = Math.max(ChunkSize, Math.ceil(transaction.content.length / chunks));
+                for (let i = 0; i <= transaction.content.length; i += chunkSize) {
+                    playbackTransaction.contentChunks.push(transaction.content.subarray(i, i + chunkSize));
+                }
+            }
+            if (!this.transactionsMap.has(transaction.method)) {
+                this.transactionsMap.set(transaction.method, new Map());
+            }
+            this.transactionsMap.get(transaction.method).set(transaction.url, playbackTransaction);
+        }
+    }
+    async setup() {
+        const inventory = await this.inventoryRepository.loadInventory();
+        await this.loadTransactions(inventory);
+        if (inventory.entryUrl)
+            this.entryUrl = inventory.entryUrl;
+        let requestNumber = 1;
+        this.proxy.onRequest((ctx, onRequestComplete) => {
+            const number = requestNumber++;
+            const identifier = Proxy.contextRequest(ctx);
+            const transaction = this.transactionsMap.get(identifier.method)?.get(identifier.url);
+            if (!transaction) {
+                this.dependency.logger?.warn({ number, identifier }, `Request #${number} ${identifier.url} (${identifier.method}) not found in inventory`);
+                return;
+            }
+            const contentStream = this.createThrottlingTransform() || ctx.proxyToClientResponse;
+            if (contentStream !== ctx.proxyToClientResponse) {
+                contentStream.pipe(ctx.proxyToClientResponse);
+            }
+            this.dependency.logger?.debug({ number, identifier }, `Request #${number} ${transaction.url} started`);
+            ctx.onError((_, err) => {
+                this.dependency.logger?.warn({ number, identifier, err }, `Request #${number} ${transaction.url} failed: ${err.message}`);
+            });
+            setTimeout(() => {
+                // Error
+                if (transaction.err) {
+                    return onRequestComplete(transaction.err);
+                }
+                // Status code
+                ctx.proxyToClientResponse.statusCode = transaction.statusCode || 500;
+                // Headers
+                if (transaction.rawHeaders) {
+                    for (const [key, value] of Object.entries(transaction.rawHeaders)) {
+                        if (ctx.proxyToClientResponse.headersSent)
+                            break;
+                        ctx.proxyToClientResponse.setHeader(key, value);
+                    }
+                }
+                // Empty content body
+                if (!transaction.contentChunks || transaction.contentChunks.length === 0) {
+                    contentStream.end();
+                    return;
+                }
+                // Content body
+                const chunks = [...transaction.contentChunks];
+                const intervalMs = transaction.durationMs / transaction.contentChunks.length;
+                const interval = setInterval(() => {
+                    const chunk = chunks.shift();
+                    if (chunk) {
+                        contentStream.write(chunk);
+                    }
+                    if (chunks.length === 0) {
+                        clearInterval(interval);
+                        contentStream.end();
+                        this.dependency.logger?.debug({ number, identifier }, `Request #${number} ${transaction.url} completed`);
+                    }
+                }, intervalMs);
+            }, transaction.ttfbMs);
+        });
+    }
+    async shutdown() {
+        // nothing to do
+    }
+}
+export async function withPlaybackProxy(options, dependency, cb) {
+    const proxy = new PlaybackProxy(options, dependency);
+    await proxy.start();
+    await cb(proxy);
+    await proxy.stop();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/proxy.d.ts

@@ -0,0 +1,35 @@
+import HttpMitmProxy from 'http-mitm-proxy';
+import { InventoryRepository } from './inventory.js';
+import { Throttle, ThrottlingTransform } from './throttling.js';
+import { DependencyInterface, DeviceType } from './types.js';
+export interface ProxyOptions extends HttpMitmProxy.IProxyOptions {
+    inventoryRepository?: InventoryRepository;
+    throttle?: Throttle;
+    throttlingRetryIntervalMs?: number;
+    entryUrl?: string;
+    deviceType?: DeviceType;
+}
+export type ProxyDependency = Pick<DependencyInterface, 'logger'>;
+export declare abstract class Proxy {
+    proxyOptions: HttpMitmProxy.IProxyOptions;
+    proxy: HttpMitmProxy.IProxy;
+    inventoryRepository: InventoryRepository;
+    throttle?: Throttle;
+    throttlingRetryIntervalMs: number;
+    entryUrl?: string;
+    deviceType?: DeviceType;
+    dependency: ProxyDependency;
+    constructor(options?: ProxyOptions, dependency?: ProxyDependency);
+    static contextRequest(ctx: HttpMitmProxy.IContext): {
+        method: string;
+        url: string;
+    };
+    createThrottlingTransform(): ThrottlingTransform | void;
+    abstract setup(): Promise<void>;
+    abstract shutdown(): Promise<void>;
+    start(): Promise<void>;
+    get port(): number;
+    get inventoryDirPath(): string;
+    stop(): Promise<void>;
+}
+export declare function withProxy<ProxyType extends Proxy>(proxy: ProxyType, fn: (proxy: ProxyType) => Promise<void>): Promise<void>;

package/build/proxy.js

@@ -0,0 +1,96 @@
+import Crypto from 'crypto';
+import Fsp from 'fs/promises';
+import Http from 'http';
+import Https from 'https';
+import Os from 'os';
+import Path from 'path';
+import GetPort from 'get-port';
+import HttpMitmProxy from 'http-mitm-proxy';
+import { InventoryRepository } from './inventory.js';
+import { ThrottlingTransform } from './throttling.js';
+export class Proxy {
+    proxyOptions;
+    proxy;
+    inventoryRepository;
+    throttle;
+    throttlingRetryIntervalMs;
+    entryUrl;
+    deviceType;
+    dependency;
+    constructor(options, dependency) {
+        options ||= {};
+        this.dependency = dependency || {};
+        // Proxy
+        this.proxyOptions = options;
+        this.proxy = HttpMitmProxy();
+        // Inventory repository
+        this.inventoryRepository = options.inventoryRepository ?? new InventoryRepository(undefined, this.dependency);
+        // Throttle
+        if (options.throttle)
+            this.throttle = options.throttle;
+        this.throttlingRetryIntervalMs = options.throttlingRetryIntervalMs || 10;
+        // Entry URL
+        this.entryUrl = options.entryUrl;
+        // Device type
+        this.deviceType = options.deviceType;
+    }
+    static contextRequest(ctx) {
+        if (!ctx.clientToProxyRequest.headers.host)
+            throw new Error('ctx.clientToProxyRequest.headers.host is empty');
+        const url = [
+            ctx.isSSL ? 'https://' : 'http://',
+            ctx.clientToProxyRequest.headers.host,
+            ctx.clientToProxyRequest.url,
+        ].join('');
+        const method = (ctx.clientToProxyRequest.method || 'get').toLowerCase();
+        return {
+            method,
+            url,
+        };
+    }
+    createThrottlingTransform() {
+        if (this.throttle) {
+            return new ThrottlingTransform(this.throttle, this.throttlingRetryIntervalMs);
+        }
+    }
+    async start() {
+        if (this.throttle)
+            this.throttle.start();
+        const sslCaDir = this.proxyOptions.sslCaDir || process.env.SSL_CA_DIR || Path.join(Os.homedir(), '.pagespeed-quest/ca');
+        const port = Number(this.proxyOptions.port || process.env.PORT || (await GetPort()));
+        const options = {
+            port,
+            sslCaDir,
+            httpAgent: new Http.Agent({
+                keepAlive: true,
+            }),
+            httpsAgent: new Https.Agent({
+                keepAlive: true,
+                secureOptions: Crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT,
+            }),
+        };
+        await this.setup();
+        await Fsp.mkdir(options.sslCaDir, { recursive: true });
+        await new Promise((resolve, reject) => this.proxy.listen(options, (error) => (error ? reject(error) : resolve())));
+        this.dependency.logger?.info(`Proxy started to listening on port ${this.port}`);
+    }
+    get port() {
+        return this.proxy.httpPort;
+    }
+    get inventoryDirPath() {
+        return this.inventoryRepository.dirPath;
+    }
+    async stop() {
+        this.proxy.close();
+        await this.shutdown();
+        if (this.throttle)
+            this.throttle.stop();
+        this.dependency.logger?.info(`Proxy stopped`);
+    }
+}
+export async function withProxy(proxy, fn) {
+    await proxy.start();
+    await fn(proxy);
+    await proxy.stop();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/recording.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'http';
+import { Proxy, ProxyDependency, ProxyOptions } from './proxy.js';
+export interface RecordingTransaction {
+    startedAt?: Date;
+    responseStartedAt?: Date;
+    responseEndedAt?: Date;
+    method: string;
+    url: string;
+    statusCode?: number;
+    incomingHttpHeaders?: IncomingHttpHeaders;
+    contentChunks: Buffer[];
+    err?: Error;
+    errKind?: string;
+}
+export interface RecordingSession {
+    startedAt?: Date;
+    transactions: RecordingTransaction[];
+}
+export declare class RecordingProxy extends Proxy {
+    startedAt?: Date;
+    transactions: RecordingTransaction[];
+    setup(): Promise<void>;
+    saveInventory(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export declare function withRecordingProxy(options: ProxyOptions, dependency: ProxyDependency, cb: (proxy: RecordingProxy) => Promise<void>): Promise<void>;