@stuntman/server 0.1.0 → 0.1.1

package/src/api/webgui/rules.pug

@@ -1,145 +0,0 @@
-doctype html
-html
-    head
-        title Stuntman - rule editor
-        script(src='https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.35.0/min/vs/loader.min.js')
-        style
-            include style.css
-    body(style='color: rgb(204, 204, 204); background-color: rgb(50, 50, 50)')
-        button#newRule(type='button', onclick='window.newRule()') New rule
-        button#saveRule(type='button', onclick='window.saveRule()', disabled) Save rule
-        div(style='width: 100%; overflow: hidden')
-            div(style='width: 230px; float: left')
-                h3 Rules
-                    ul#ruleKeys.no-bullets
-                        each ruleId in ruleKeys
-                            li
-                                button.rule(
-                                    type='button',
-                                    onclick='window.setRuleModel(this.getAttribute("data-rule-id"))',
-                                    data-rule-id=ruleId
-                                )= ruleId
-            div(style='margin-left: 240px')
-                #container(style='height: 400px')
-                    script.
-                        const uuidv4 = () => {
-                            function getRandomSymbol(symbol) {
-                                var array;
-
-                                if (symbol === 'y') {
-                                    array = ['8', '9', 'a', 'b'];
-                                    return array[Math.floor(Math.random() * array.length)];
-                                }
-
-                                array = new Uint8Array(1);
-                                window.crypto.getRandomValues(array);
-                                return (array[0] % 16).toString(16);
-                            }
-
-                            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, getRandomSymbol);
-                        };
-                        require.config({
-                            paths: {
-                                vs: 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.35.0/min/vs',
-                            },
-                        });
-                        require(['vs/editor/editor.main'], function () {
-                            monaco.languages.typescript.javascriptDefaults.setEagerModelSync(true);
-                            monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
-                                noSemanticValidation: false,
-                                noSyntaxValidation: false,
-                            });
-
-                            // compiler options
-                            monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
-                                target: monaco.languages.typescript.ScriptTarget.ES6,
-                                allowNonTsExtensions: true,
-                                noLib: true,
-                                moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
-                                module: monaco.languages.typescript.ModuleKind.CommonJS,
-                                noEmit: true,
-                                checkJs: true,
-                                allowJs: true,
-                                isolatedModules: true,
-                                typeRoots: ['node_modules/@types'],
-                            });
-
-                            monaco.languages.typescript.typescriptDefaults.addExtraLib(`!{INDEX_DTS}`, 'file:///node_modules/@types/stuntman/index.d.ts');
-                            const models = {};
-                            const rules = eval('(!{rules})');
-                            for (const ruleId of Object.keys(rules)) {
-                                models[ruleId] = monaco.editor.createModel("import type * as Stuntman from 'stuntman';\n\nvar STUNTMAN_RULE: Stuntman.Rule = " + rules[ruleId] + ';', 'typescript', `file:///${ruleId}.ts`);
-                            }
-                            const editor = monaco.editor.create(document.getElementById('container'), {
-                                theme: 'vs-dark',
-                                autoIndent: true,
-                                formatOnPaste: true,
-                                formatOnType: true,
-                                automaticLayout: true,
-                                autoIndent: true,
-                                tabSize: 2,
-                            });
-                            editor.onDidChangeModel((event) => {
-                                const isInternal = /^file:\/\/\/internal\/.+/.test(event.newModelUrl);
-                                if (isInternal) {
-                                    document.getElementById('saveRule').setAttribute('disabled', 'true');
-                                } else {
-                                    document.getElementById('saveRule').removeAttribute('disabled');
-                                }
-
-                                setTimeout(() => {
-                                    editor.getAction('editor.action.formatDocument').run();
-                                }, 100);
-                            });
-
-                            window.setRuleModel = (ruleId) => {
-                                if (history.pushState) {
-                                    const newUrl = `${window.location.protocol}//${window.location.host}${window.location.pathname}?ruleId=${encodeURIComponent(ruleId)}`;
-                                    window.history.pushState({ path: newUrl }, '', newUrl);
-                                }
-                                editor.setModel(models[ruleId]);
-                            };
-
-                            const urlSearchParams = new URLSearchParams(window.location.search);
-                            if (urlSearchParams.has('ruleId') && urlSearchParams.get('ruleId') in models) {
-                                editor.setModel(models[urlSearchParams.get('ruleId')]);
-                            }
-
-                            window.saveRule = () => {
-                                document.getElementById('saveRule').setAttribute('disabled', 'true');
-                                const modelUri = editor.getModel().uri;
-                                const result = monaco.languages.typescript.getTypeScriptWorker();
-                                result.then((worker) => {
-                                    worker(modelUri).then(function (client) {
-                                        client.getEmitOutput(modelUri.toString()).then((output) => {
-                                            const ruleFunctionText = output.outputFiles[0].text.replace(/^export .+$/im, '');
-                                            const newId = new Function(ruleFunctionText + '\n return STUNTMAN_RULE;')().id;
-                                            fetch('/webgui/rules/unsafesave', {
-                                                method: 'POST',
-                                                headers: { 'content-type': 'text/plain' },
-                                                body: ruleFunctionText + '\n return STUNTMAN_RULE;',
-                                            }).then((response) => {
-                                                if (response.ok) {
-                                                    window.location.reload();
-                                                    return;
-                                                }
-                                                alert('Error when saving rule');
-                                                document.getElementById('saveRule').removeAttribute('disabled');
-                                            });
-                                        });
-                                    });
-                                });
-                            };
-
-                            window.newRule = () => {
-                                const ruleId = uuidv4();
-                                const emptyRule = `import type * as Stuntman from \'stuntman\';\n\nvar STUNTMAN_RULE: Stuntman.Rule = { id: '${ruleId}', matches: (req: Stuntman.Request) => true, ttlSeconds: 600 };`;
-                                models[ruleId] = monaco.editor.createModel(emptyRule, 'typescript', `file:///${ruleId}.ts`);
-                                const ruleKeyNode = document.getElementById('ruleKeys').firstChild;
-                                const ruleKeyNodeClone = ruleKeyNode.cloneNode(true);
-                                ruleKeyNodeClone.getElementsByTagName('button')[0].setAttribute('data-rule-id', ruleId);
-                                ruleKeyNodeClone.getElementsByTagName('button')[0].innerText = ruleId;
-                                document.getElementById('ruleKeys').appendChild(ruleKeyNodeClone);
-                                window.setRuleModel(ruleId);
-                            };
-                        });

package/src/api/webgui/style.css

@@ -1,28 +0,0 @@
-div#container {
-    resize: vertical;
-    overflow: auto;
-}
-
-body {
-    font-family: Menlo, Monaco, 'Courier New', monospace;
-}
-
-button.rule {
-    font-family: Menlo, Monaco, 'Courier New', monospace;
-    background: none !important;
-    border: none;
-    padding: 0 !important;
-    color: #aaa;
-    text-decoration: underline;
-    cursor: pointer;
-    margin-top: 10px;
-    font-size: x-small;
-    text-align: left;
-}
-
-ul.no-bullets {
-    list-style-type: none; /* Remove bullets */
-    padding: 0; /* Remove padding */
-    margin: 0; /* Remove margins */
-    text-align: left;
-}

package/src/api/webgui/traffic.pug

@@ -1,37 +0,0 @@
-doctype html
-html
-    head
-        title Stuntman - rule editor
-        script(src='https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.35.0/min/vs/loader.min.js')
-        style
-            include style.css
-    body(style='color: rgb(204, 204, 204); background-color: rgb(50, 50, 50)')
-        div(style='width: 100%; overflow: hidden')
-            div(style='width: 200px; float: left')
-                h3 Traffic log
-            div(style='margin-left: 220px')
-                #container(style='height: 800px')
-                    script.
-                        require.config({
-                            paths: {
-                                vs: 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.35.0/min/vs',
-                            },
-                        });
-                        require(['vs/editor/editor.main'], function () {
-                            const traffic = !{ traffic };
-                            const model = monaco.editor.createModel(JSON.stringify(traffic, null, 2), 'json');
-                            const editor = monaco.editor.create(document.getElementById('container'), {
-                                theme: 'vs-dark',
-                                autoIndent: true,
-                                formatOnPaste: true,
-                                formatOnType: true,
-                                automaticLayout: true,
-                                readOnly: true,
-                            });
-                            editor.onDidChangeModel((event) => {
-                                setTimeout(() => {
-                                    editor.getAction('editor.action.formatDocument').run();
-                                }, 100);
-                            });
-                            editor.setModel(model);
-                        });

package/src/bin/stuntman.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-import { Mock } from '../mock';
-import { serverConfig } from '@stuntman/shared';
-
-const mock = new Mock(serverConfig);
-
-mock.start();

package/src/index.ts

@@ -1 +0,0 @@
-export { Mock as StuntmanMock } from './mock';

package/src/ipUtils.ts

@@ -1,83 +0,0 @@
-import { networkInterfaces } from 'os';
-import dns, { Resolver as DNSResolver } from 'node:dns';
-import { getDnsResolutionCache } from './storage';
-import { logger } from '@stuntman/shared';
-
-const localhostIPs: string[] = ['127.0.0.1'];
-const IP_WITH_OPTIONAL_PORT_REGEX = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}(:[0-9]+)?$/i;
-
-for (const nets of Object.values(networkInterfaces())) {
-    if (!nets) {
-        continue;
-    }
-    for (const net of nets) {
-        const familyV4Value = typeof net.family === 'string' ? 'IPv4' : 4;
-        if (net.family === familyV4Value && !localhostIPs.includes(net.address)) {
-            localhostIPs.push(net.address);
-        }
-    }
-}
-
-export class IPUtils {
-    protected dnsResolutionCache;
-    protected mockUuid: string;
-    externalDns: dns.Resolver | null = null;
-
-    constructor(options: { mockUuid: string; externalDns?: string[] }) {
-        this.mockUuid = options.mockUuid;
-        if (options.externalDns?.length) {
-            this.externalDns = new DNSResolver();
-            this.externalDns.setServers(options.externalDns);
-        }
-        this.dnsResolutionCache = getDnsResolutionCache(this.mockUuid);
-    }
-
-    isLocalhostIP(ip: string): boolean {
-        return localhostIPs.includes(ip);
-    }
-
-    private async resolveIPs(hostname: string, options?: { useExternalDns?: true }): Promise<[string, ...string[]]> {
-        return new Promise<[string, ...string[]]>((resolve, reject) => {
-            const callback = (error: NodeJS.ErrnoException | null, addresses: string | string[]) => {
-                if (error) {
-                    logger.debug({ error, hostname }, 'error resolving hostname');
-                    reject(error);
-                    return;
-                }
-                if (typeof addresses === 'string') {
-                    logger.debug({ ip: [addresses], hostname }, 'resolved hostname');
-                    resolve([addresses]);
-                    return;
-                }
-                if (!addresses || addresses.length === 0) {
-                    logger.debug({ hostname }, 'missing IPs');
-                    reject(new Error('No addresses found'));
-                    return;
-                }
-                logger.debug({ ip: addresses, hostname }, 'resolved hostname');
-                resolve([addresses[0], ...addresses.slice(1)]);
-            };
-            if (options?.useExternalDns) {
-                if (!this.externalDns) {
-                    reject(new Error('external dns servers not set'));
-                    return;
-                }
-                this.externalDns.resolve(hostname, callback);
-                return;
-            }
-            dns.lookup(hostname, callback);
-        });
-    }
-
-    async resolveIP(hostname: string, options?: { useExternalDns?: true }): Promise<string> {
-        const cachedIP = this.dnsResolutionCache.get(hostname);
-        if (cachedIP) {
-            return cachedIP;
-        }
-        return (await this.resolveIPs(hostname, options))[0];
-    }
-
-    isIP(hostname: string): boolean {
-        return IP_WITH_OPTIONAL_PORT_REGEX.test(hostname);
-    }
-}

package/src/mock.ts

@@ -1,349 +0,0 @@
-import http from 'http';
-import https from 'https';
-import express from 'express';
-import { v4 as uuidv4 } from 'uuid';
-import { ruleExecutor } from './ruleExecutor';
-import { getTrafficStore } from './storage';
-import { RawHeaders, logger, HttpCode } from '@stuntman/shared';
-import RequestContext from './requestContext';
-import type * as Stuntman from '@stuntman/shared';
-import { IPUtils } from './ipUtils';
-import LRUCache from 'lru-cache';
-import { API } from './api/api';
-
-type WithRequiredProperty<Type, Key extends keyof Type> = Type & {
-    [Property in Key]-?: Type[Property];
-};
-
-const naiveGQLParser = (body: Buffer | string): Stuntman.GQLRequestBody | undefined => {
-    try {
-        let json: Stuntman.GQLRequestBody | undefined = undefined;
-        try {
-            json = JSON.parse(Buffer.isBuffer(body) ? body.toString('utf-8') : body);
-        } catch (kiss) {
-            // and swallow
-        }
-        if (!json?.query && !json?.operationName) {
-            return;
-        }
-        const lines = json.query
-            .split('\n')
-            .map((l) => l.replace(/^\s+/g, '').trim())
-            .filter((l) => !!l);
-        if (/^query /.test(lines[0])) {
-            json.type = 'query';
-        } else if (/^mutation /.test(lines[0])) {
-            json.type = 'mutation';
-        } else {
-            throw new Error(`Unable to resolve query type of ${lines[0]}`);
-        }
-        json.methodName = lines[json.operationName ? 1 : 0].split('(')[0].split('{')[0];
-        return json;
-    } catch (error) {
-        logger.debug(error, 'unable to parse GQL');
-    }
-    return undefined;
-};
-
-// TODO add proper web proxy mode
-
-export class Mock {
-    protected mockUuid: string;
-    protected options: Stuntman.ServerConfig;
-    protected mockApp: express.Express;
-    protected MOCK_DOMAIN_REGEX: RegExp;
-    protected URL_PORT_REGEX: RegExp;
-    protected server: http.Server | null = null;
-    protected serverHttps: https.Server | null = null;
-    protected trafficStore: LRUCache<string, Stuntman.LogEntry>;
-    protected ipUtils: IPUtils | null = null;
-    private _api: API | null = null;
-
-    get apiServer() {
-        if (this.options.api.disabled) {
-            return null;
-        }
-        if (!this._api) {
-            this._api = new API({ ...this.options.api, mockUuid: this.mockUuid }, this.options.webgui);
-        }
-        return this._api;
-    }
-
-    constructor(options: Stuntman.ServerConfig) {
-        this.mockUuid = uuidv4();
-        this.options = options;
-        if (this.options.mock.httpsPort && (!this.options.mock.httpsKey || !this.options.mock.httpsCert)) {
-            throw new Error('missing https key/cert');
-        }
-
-        this.MOCK_DOMAIN_REGEX = new RegExp(
-            `(?:\\.([0-9]+))?\\.(?:(?:${this.options.mock.domain})|(?:localhost))(https?)?(:${this.options.mock.port}${
-                this.options.mock.httpsPort ? `|${this.options.mock.httpsPort}` : ''
-            })?(?:\\b|$)`,
-            'i'
-        );
-        this.URL_PORT_REGEX = new RegExp(
-            `^(https?:\\/\\/[^:/]+):(?:${this.options.mock.port}${
-                this.options.mock.httpsPort ? `|${this.options.mock.httpsPort}` : ''
-            })(\\/.*)`,
-            'i'
-        );
-        this.trafficStore = getTrafficStore(this.mockUuid, this.options.storage.traffic);
-        this.ipUtils =
-            !this.options.mock.externalDns || this.options.mock.externalDns.length === 0
-                ? null
-                : new IPUtils({ mockUuid: this.mockUuid, externalDns: this.options.mock.externalDns });
-
-        this.mockApp = express();
-        // TODO for now request body is just a buffer passed further, not inflated
-        this.mockApp.use(express.raw({ type: '*/*' }));
-
-        this.mockApp.use((req: express.Request, res: express.Response, next: express.NextFunction) => {
-            RequestContext.bind(req, this.mockUuid);
-            next();
-        });
-
-        this.mockApp.all(/.*/, async (req, res) => {
-            const ctx: RequestContext | null = RequestContext.get(req);
-            const requestUuid = ctx?.uuid || uuidv4();
-            const timestamp = Date.now();
-            const originalHostname = req.hostname;
-            const unproxiedHostname = req.hostname.replace(this.MOCK_DOMAIN_REGEX, '');
-            const isProxiedHostname = originalHostname !== unproxiedHostname;
-            const originalRequest = {
-                id: requestUuid,
-                timestamp,
-                url: `${req.protocol}://${req.hostname}${req.originalUrl}`,
-                method: req.method,
-                rawHeaders: new RawHeaders(...req.rawHeaders),
-                ...(Buffer.isBuffer(req.body) && { body: req.body.toString('utf-8') }),
-            };
-            logger.debug(originalRequest, 'processing request');
-            const logContext: Record<string, any> = {
-                requestId: originalRequest.id,
-            };
-            const mockEntry: WithRequiredProperty<Stuntman.LogEntry, 'modifiedRequest'> = {
-                originalRequest,
-                modifiedRequest: {
-                    ...this.unproxyRequest(req),
-                    id: requestUuid,
-                    timestamp,
-                    ...(originalRequest.body && { gqlBody: naiveGQLParser(originalRequest.body) }),
-                },
-            };
-            if (!isProxiedHostname) {
-                this.removeProxyPort(mockEntry.modifiedRequest);
-            }
-            const matchingRule = await ruleExecutor.findMatchingRule(mockEntry.modifiedRequest);
-            if (matchingRule) {
-                mockEntry.mockRuleId = matchingRule.id;
-                mockEntry.labels = matchingRule.labels;
-                if (matchingRule.actions?.mockResponse) {
-                    const staticResponse =
-                        typeof matchingRule.actions.mockResponse === 'function'
-                            ? matchingRule.actions.mockResponse(mockEntry.modifiedRequest)
-                            : matchingRule.actions.mockResponse;
-                    mockEntry.modifiedResponse = staticResponse;
-                    logger.debug({ ...logContext, staticResponse }, 'replying with mocked response');
-                    if (matchingRule.storeTraffic) {
-                        this.trafficStore.set(requestUuid, mockEntry);
-                    }
-                    if (staticResponse.rawHeaders) {
-                        for (const header of staticResponse.rawHeaders.toHeaderPairs()) {
-                            res.setHeader(header[0], header[1]);
-                        }
-                    }
-                    res.status(staticResponse.status || 200);
-                    res.send(staticResponse.body);
-                    // static response blocks any further processing
-                    return;
-                }
-                if (matchingRule.actions?.modifyRequest) {
-                    mockEntry.modifiedRequest = matchingRule.actions?.modifyRequest(mockEntry.modifiedRequest);
-                    logger.debug({ ...logContext, modifiedRequest: mockEntry.modifiedRequest }, 'modified original request');
-                }
-            }
-            if (this.ipUtils && !isProxiedHostname && !this.ipUtils.isIP(originalHostname)) {
-                const hostname = originalHostname.split(':')[0];
-                try {
-                    const internalIPs = await this.ipUtils.resolveIP(hostname);
-                    if (this.ipUtils.isLocalhostIP(internalIPs) && this.options.mock.externalDns.length) {
-                        const externalIPs = await this.ipUtils.resolveIP(hostname, { useExternalDns: true });
-                        logger.debug({ ...logContext, hostname, externalIPs, internalIPs }, 'switched to external IP');
-                        mockEntry.modifiedRequest.url = mockEntry.modifiedRequest.url.replace(
-                            /^(https?:\/\/)[^:/]+/i,
-                            `$1${externalIPs}`
-                        );
-                    }
-                } catch (error) {
-                    // swallow the exeception, don't think much can be done at this point
-                    logger.warn({ ...logContext, error }, `error trying to resolve IP for "${hostname}"`);
-                }
-            }
-
-            let controller: AbortController | null = new AbortController();
-            const fetchTimeout = setTimeout(() => {
-                if (controller) {
-                    controller.abort(`timeout after ${this.options.mock.timeout}`);
-                }
-            }, this.options.mock.timeout);
-            req.on('close', () => {
-                logger.debug(logContext, 'remote client canceled the request');
-                clearTimeout(fetchTimeout);
-                if (controller) {
-                    controller.abort('remote client canceled the request');
-                }
-            });
-            let targetResponse: Response;
-            const hasKeepAlive = !!mockEntry.modifiedRequest.rawHeaders
-                .toHeaderPairs()
-                .find((h) => /^connection$/.test(h[0]) && /^keep-alive$/.test(h[1]));
-            try {
-                targetResponse = await fetch(mockEntry.modifiedRequest.url, {
-                    redirect: 'manual',
-                    headers: mockEntry.modifiedRequest.rawHeaders
-                        .toHeaderPairs()
-                        .filter((h) => !/^connection$/.test(h[0]) && !/^keep-alive$/.test(h[1])),
-                    body: mockEntry.modifiedRequest.body,
-                    method: mockEntry.modifiedRequest.method,
-                    keepalive: !!hasKeepAlive,
-                });
-            } finally {
-                controller = null;
-                clearTimeout(fetchTimeout);
-            }
-            const targetResponseBuffer = Buffer.from(await targetResponse.arrayBuffer());
-            const originalResponse = {
-                timestamp: Date.now(),
-                body: targetResponseBuffer.toString('binary'),
-                status: targetResponse.status,
-                rawHeaders: new RawHeaders(
-                    ...Array.from(targetResponse.headers.entries()).flatMap(([key, value]) => [key, value])
-                ),
-            };
-            logger.debug({ ...logContext, originalResponse }, 'received response');
-            mockEntry.originalResponse = originalResponse;
-            let modifedResponse: Stuntman.Response = {
-                ...originalResponse,
-                rawHeaders: new RawHeaders(
-                    ...Array.from(targetResponse.headers.entries()).flatMap(([key, value]) => {
-                        // TODO this replace may be too aggressive and doesn't handle protocol (won't be necessary with a trusted cert and mock serving http+https)
-                        return [
-                            key,
-                            isProxiedHostname
-                                ? value
-                                : value.replace(
-                                      new RegExp(`(?:^|\\b)(${unproxiedHostname.replace('.', '\\.')})(?:\\b|$)`, 'igm'),
-                                      originalHostname
-                                  ),
-                        ];
-                    })
-                ),
-            };
-            if (matchingRule?.actions?.modifyResponse) {
-                modifedResponse = matchingRule?.actions?.modifyResponse(mockEntry.modifiedRequest, originalResponse);
-                logger.debug({ ...logContext, modifedResponse }, 'modified response');
-            }
-
-            mockEntry.modifiedResponse = modifedResponse;
-            if (matchingRule?.storeTraffic) {
-                this.trafficStore.set(requestUuid, mockEntry);
-            }
-
-            if (modifedResponse.status) {
-                res.status(modifedResponse.status);
-            }
-            if (modifedResponse.rawHeaders) {
-                for (const header of modifedResponse.rawHeaders.toHeaderPairs()) {
-                    // since fetch decompresses responses we need to get rid of some headers
-                    // TODO maybe could be handled better than just skipping, although express should add these back for new body
-                    if (/^content-(?:length|encoding)$/i.test(header[0])) {
-                        continue;
-                    }
-                    res.setHeader(header[0], header[1]);
-                }
-            }
-            res.end(Buffer.from(modifedResponse.body, 'binary'));
-        });
-
-        this.mockApp.use((error: Error, req: express.Request, res: express.Response, _next: express.NextFunction) => {
-            const ctx: RequestContext | null = RequestContext.get(req);
-            const uuid = ctx?.uuid || uuidv4();
-            logger.error({ ...error, uuid }, 'Unexpected error');
-            if (res) {
-                res.status(HttpCode.INTERNAL_SERVER_ERROR).json({
-                    error: { message: error.message, httpCode: HttpCode.INTERNAL_SERVER_ERROR, uuid },
-                });
-                return;
-            }
-            console.log('mock encountered a critical error. exiting');
-            process.exit(1);
-        });
-    }
-
-    public start() {
-        if (this.server) {
-            throw new Error('mock server already started');
-        }
-        if (this.options.mock.httpsPort) {
-            this.serverHttps = https
-                .createServer(
-                    {
-                        key: this.options.mock.httpsKey,
-                        cert: this.options.mock.httpsCert,
-                    },
-                    this.mockApp
-                )
-                .listen(this.options.mock.httpsPort, () => {
-                    logger.info(`Mock listening on ${this.options.mock.domain}:${this.options.mock.httpsPort}`);
-                });
-        }
-        this.server = this.mockApp.listen(this.options.mock.port, () => {
-            logger.info(`Mock listening on ${this.options.mock.domain}:${this.options.mock.port}`);
-            if (!this.options.api.disabled) {
-                this.apiServer?.start();
-            }
-        });
-    }
-
-    public stop() {
-        if (!this.server) {
-            throw new Error('mock server not started');
-        }
-        if (!this.options.api.disabled) {
-            this.apiServer?.stop();
-        }
-        this.server.close((error) => {
-            logger.warn(error, 'problem closing server');
-            this.server = null;
-        });
-    }
-
-    protected unproxyRequest(req: express.Request): Stuntman.BaseRequest {
-        const protocol = (this.MOCK_DOMAIN_REGEX.exec(req.hostname) || [])[2] || req.protocol;
-        const port = (this.MOCK_DOMAIN_REGEX.exec(req.hostname) || [])[1] || undefined;
-
-        // TODO unproxied req might fail if there's a signed url :shrug:
-        // but then we can probably switch DNS for some particular 3rd party server to point to mock
-        // and in mock have a mapping rule for that domain to point directly to some IP :thinking:
-        return {
-            url: `${protocol}://${req.hostname.replace(this.MOCK_DOMAIN_REGEX, '')}${port ? `:${port}` : ''}${req.originalUrl}`,
-            rawHeaders: new RawHeaders(...req.rawHeaders.map((h) => h.replace(this.MOCK_DOMAIN_REGEX, ''))),
-            method: req.method,
-            ...(Buffer.isBuffer(req.body) && { body: req.body.toString('utf-8') }),
-        };
-    }
-
-    protected removeProxyPort(req: Stuntman.Request): void {
-        if (this.URL_PORT_REGEX.test(req.url)) {
-            req.url = req.url.replace(this.URL_PORT_REGEX, '$1$2');
-        }
-        const host = req.rawHeaders.get('host') || '';
-        if (
-            host.endsWith(`:${this.options.mock.port}`) ||
-            (this.options.mock.httpsPort && host.endsWith(`:${this.options.mock.httpsPort}`))
-        ) {
-            req.rawHeaders.set('host', host.split(':')[0]);
-        }
-    }
-}