@stuntman/server 0.1.0

package/dist/api/webgui/traffic.pug

@@ -0,0 +1,37 @@
+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/dist/bin/stuntman.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/stuntman.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mock_1 = require("../mock");
+const shared_1 = require("@stuntman/shared");
+const mock = new mock_1.Mock(shared_1.serverConfig);
+mock.start();

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StuntmanMock = void 0;
+var mock_1 = require("./mock");
+Object.defineProperty(exports, "StuntmanMock", { enumerable: true, get: function () { return mock_1.Mock; } });

package/dist/ipUtils.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import dns from 'node:dns';
+export declare class IPUtils {
+    protected dnsResolutionCache: import("lru-cache")<string, string>;
+    protected mockUuid: string;
+    externalDns: dns.Resolver | null;
+    constructor(options: {
+        mockUuid: string;
+        externalDns?: string[];
+    });
+    isLocalhostIP(ip: string): boolean;
+    private resolveIPs;
+    resolveIP(hostname: string, options?: {
+        useExternalDns?: true;
+    }): Promise<string>;
+    isIP(hostname: string): boolean;
+}

package/dist/ipUtils.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPUtils = void 0;
+const os_1 = require("os");
+const node_dns_1 = __importStar(require("node:dns"));
+const storage_1 = require("./storage");
+const shared_1 = require("@stuntman/shared");
+const localhostIPs = ['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((0, os_1.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);
+        }
+    }
+}
+class IPUtils {
+    constructor(options) {
+        var _a;
+        this.externalDns = null;
+        this.mockUuid = options.mockUuid;
+        if ((_a = options.externalDns) === null || _a === void 0 ? void 0 : _a.length) {
+            this.externalDns = new node_dns_1.Resolver();
+            this.externalDns.setServers(options.externalDns);
+        }
+        this.dnsResolutionCache = (0, storage_1.getDnsResolutionCache)(this.mockUuid);
+    }
+    isLocalhostIP(ip) {
+        return localhostIPs.includes(ip);
+    }
+    async resolveIPs(hostname, options) {
+        return new Promise((resolve, reject) => {
+            const callback = (error, addresses) => {
+                if (error) {
+                    shared_1.logger.debug({ error, hostname }, 'error resolving hostname');
+                    reject(error);
+                    return;
+                }
+                if (typeof addresses === 'string') {
+                    shared_1.logger.debug({ ip: [addresses], hostname }, 'resolved hostname');
+                    resolve([addresses]);
+                    return;
+                }
+                if (!addresses || addresses.length === 0) {
+                    shared_1.logger.debug({ hostname }, 'missing IPs');
+                    reject(new Error('No addresses found'));
+                    return;
+                }
+                shared_1.logger.debug({ ip: addresses, hostname }, 'resolved hostname');
+                resolve([addresses[0], ...addresses.slice(1)]);
+            };
+            if (options === null || options === void 0 ? void 0 : options.useExternalDns) {
+                if (!this.externalDns) {
+                    reject(new Error('external dns servers not set'));
+                    return;
+                }
+                this.externalDns.resolve(hostname, callback);
+                return;
+            }
+            node_dns_1.default.lookup(hostname, callback);
+        });
+    }
+    async resolveIP(hostname, options) {
+        const cachedIP = this.dnsResolutionCache.get(hostname);
+        if (cachedIP) {
+            return cachedIP;
+        }
+        return (await this.resolveIPs(hostname, options))[0];
+    }
+    isIP(hostname) {
+        return IP_WITH_OPTIONAL_PORT_REGEX.test(hostname);
+    }
+}
+exports.IPUtils = IPUtils;

package/dist/mock.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
+import express from 'express';
+import type * as Stuntman from '@stuntman/shared';
+import { IPUtils } from './ipUtils';
+import LRUCache from 'lru-cache';
+import { API } from './api/api';
+export declare 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;
+    protected serverHttps: https.Server | null;
+    protected trafficStore: LRUCache<string, Stuntman.LogEntry>;
+    protected ipUtils: IPUtils | null;
+    private _api;
+    get apiServer(): API | null;
+    constructor(options: Stuntman.ServerConfig);
+    start(): void;
+    stop(): void;
+    protected unproxyRequest(req: express.Request): Stuntman.BaseRequest;
+    protected removeProxyPort(req: Stuntman.Request): void;
+}

package/dist/mock.js

@@ -0,0 +1,308 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mock = void 0;
+const https_1 = __importDefault(require("https"));
+const express_1 = __importDefault(require("express"));
+const uuid_1 = require("uuid");
+const ruleExecutor_1 = require("./ruleExecutor");
+const storage_1 = require("./storage");
+const shared_1 = require("@stuntman/shared");
+const requestContext_1 = __importDefault(require("./requestContext"));
+const ipUtils_1 = require("./ipUtils");
+const api_1 = require("./api/api");
+const naiveGQLParser = (body) => {
+    try {
+        let json = undefined;
+        try {
+            json = JSON.parse(Buffer.isBuffer(body) ? body.toString('utf-8') : body);
+        }
+        catch (kiss) {
+            // and swallow
+        }
+        if (!(json === null || json === void 0 ? void 0 : json.query) && !(json === null || json === void 0 ? void 0 : 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) {
+        shared_1.logger.debug(error, 'unable to parse GQL');
+    }
+    return undefined;
+};
+// TODO add proper web proxy mode
+class Mock {
+    get apiServer() {
+        if (this.options.api.disabled) {
+            return null;
+        }
+        if (!this._api) {
+            this._api = new api_1.API({ ...this.options.api, mockUuid: this.mockUuid }, this.options.webgui);
+        }
+        return this._api;
+    }
+    constructor(options) {
+        this.server = null;
+        this.serverHttps = null;
+        this.ipUtils = null;
+        this._api = null;
+        this.mockUuid = (0, uuid_1.v4)();
+        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 = (0, storage_1.getTrafficStore)(this.mockUuid, this.options.storage.traffic);
+        this.ipUtils =
+            !this.options.mock.externalDns || this.options.mock.externalDns.length === 0
+                ? null
+                : new ipUtils_1.IPUtils({ mockUuid: this.mockUuid, externalDns: this.options.mock.externalDns });
+        this.mockApp = (0, express_1.default)();
+        // TODO for now request body is just a buffer passed further, not inflated
+        this.mockApp.use(express_1.default.raw({ type: '*/*' }));
+        this.mockApp.use((req, res, next) => {
+            requestContext_1.default.bind(req, this.mockUuid);
+            next();
+        });
+        this.mockApp.all(/.*/, async (req, res) => {
+            var _a, _b, _c, _d, _e;
+            const ctx = requestContext_1.default.get(req);
+            const requestUuid = (ctx === null || ctx === void 0 ? void 0 : ctx.uuid) || (0, uuid_1.v4)();
+            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 shared_1.RawHeaders(...req.rawHeaders),
+                ...(Buffer.isBuffer(req.body) && { body: req.body.toString('utf-8') }),
+            };
+            shared_1.logger.debug(originalRequest, 'processing request');
+            const logContext = {
+                requestId: originalRequest.id,
+            };
+            const mockEntry = {
+                originalRequest,
+                modifiedRequest: {
+                    ...this.unproxyRequest(req),
+                    id: requestUuid,
+                    timestamp,
+                    ...(originalRequest.body && { gqlBody: naiveGQLParser(originalRequest.body) }),
+                },
+            };
+            if (!isProxiedHostname) {
+                this.removeProxyPort(mockEntry.modifiedRequest);
+            }
+            const matchingRule = await ruleExecutor_1.ruleExecutor.findMatchingRule(mockEntry.modifiedRequest);
+            if (matchingRule) {
+                mockEntry.mockRuleId = matchingRule.id;
+                mockEntry.labels = matchingRule.labels;
+                if ((_a = matchingRule.actions) === null || _a === void 0 ? void 0 : _a.mockResponse) {
+                    const staticResponse = typeof matchingRule.actions.mockResponse === 'function'
+                        ? matchingRule.actions.mockResponse(mockEntry.modifiedRequest)
+                        : matchingRule.actions.mockResponse;
+                    mockEntry.modifiedResponse = staticResponse;
+                    shared_1.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 ((_b = matchingRule.actions) === null || _b === void 0 ? void 0 : _b.modifyRequest) {
+                    mockEntry.modifiedRequest = (_c = matchingRule.actions) === null || _c === void 0 ? void 0 : _c.modifyRequest(mockEntry.modifiedRequest);
+                    shared_1.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 });
+                        shared_1.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
+                    shared_1.logger.warn({ ...logContext, error }, `error trying to resolve IP for "${hostname}"`);
+                }
+            }
+            let controller = new AbortController();
+            const fetchTimeout = setTimeout(() => {
+                if (controller) {
+                    controller.abort(`timeout after ${this.options.mock.timeout}`);
+                }
+            }, this.options.mock.timeout);
+            req.on('close', () => {
+                shared_1.logger.debug(logContext, 'remote client canceled the request');
+                clearTimeout(fetchTimeout);
+                if (controller) {
+                    controller.abort('remote client canceled the request');
+                }
+            });
+            let targetResponse;
+            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 shared_1.RawHeaders(...Array.from(targetResponse.headers.entries()).flatMap(([key, value]) => [key, value])),
+            };
+            shared_1.logger.debug({ ...logContext, originalResponse }, 'received response');
+            mockEntry.originalResponse = originalResponse;
+            let modifedResponse = {
+                ...originalResponse,
+                rawHeaders: new shared_1.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 ((_d = matchingRule === null || matchingRule === void 0 ? void 0 : matchingRule.actions) === null || _d === void 0 ? void 0 : _d.modifyResponse) {
+                modifedResponse = (_e = matchingRule === null || matchingRule === void 0 ? void 0 : matchingRule.actions) === null || _e === void 0 ? void 0 : _e.modifyResponse(mockEntry.modifiedRequest, originalResponse);
+                shared_1.logger.debug({ ...logContext, modifedResponse }, 'modified response');
+            }
+            mockEntry.modifiedResponse = modifedResponse;
+            if (matchingRule === null || matchingRule === void 0 ? void 0 : 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, req, res, _next) => {
+            const ctx = requestContext_1.default.get(req);
+            const uuid = (ctx === null || ctx === void 0 ? void 0 : ctx.uuid) || (0, uuid_1.v4)();
+            shared_1.logger.error({ ...error, uuid }, 'Unexpected error');
+            if (res) {
+                res.status(shared_1.HttpCode.INTERNAL_SERVER_ERROR).json({
+                    error: { message: error.message, httpCode: shared_1.HttpCode.INTERNAL_SERVER_ERROR, uuid },
+                });
+                return;
+            }
+            console.log('mock encountered a critical error. exiting');
+            process.exit(1);
+        });
+    }
+    start() {
+        if (this.server) {
+            throw new Error('mock server already started');
+        }
+        if (this.options.mock.httpsPort) {
+            this.serverHttps = https_1.default
+                .createServer({
+                key: this.options.mock.httpsKey,
+                cert: this.options.mock.httpsCert,
+            }, this.mockApp)
+                .listen(this.options.mock.httpsPort, () => {
+                shared_1.logger.info(`Mock listening on ${this.options.mock.domain}:${this.options.mock.httpsPort}`);
+            });
+        }
+        this.server = this.mockApp.listen(this.options.mock.port, () => {
+            var _a;
+            shared_1.logger.info(`Mock listening on ${this.options.mock.domain}:${this.options.mock.port}`);
+            if (!this.options.api.disabled) {
+                (_a = this.apiServer) === null || _a === void 0 ? void 0 : _a.start();
+            }
+        });
+    }
+    stop() {
+        var _a;
+        if (!this.server) {
+            throw new Error('mock server not started');
+        }
+        if (!this.options.api.disabled) {
+            (_a = this.apiServer) === null || _a === void 0 ? void 0 : _a.stop();
+        }
+        this.server.close((error) => {
+            shared_1.logger.warn(error, 'problem closing server');
+            this.server = null;
+        });
+    }
+    unproxyRequest(req) {
+        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 shared_1.RawHeaders(...req.rawHeaders.map((h) => h.replace(this.MOCK_DOMAIN_REGEX, ''))),
+            method: req.method,
+            ...(Buffer.isBuffer(req.body) && { body: req.body.toString('utf-8') }),
+        };
+    }
+    removeProxyPort(req) {
+        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]);
+        }
+    }
+}
+exports.Mock = Mock;

package/dist/requestContext.d.ts

@@ -0,0 +1,9 @@
+import type { Request } from 'express';
+export default class RequestContext {
+    static _bindings: WeakMap<Request, RequestContext>;
+    readonly mockUuid: string;
+    readonly uuid: string;
+    constructor(mockUuid: string);
+    static bind(req: Request, mockUuid: string): void;
+    static get(req: Request): RequestContext | null;
+}

package/dist/requestContext.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("uuid");
+class RequestContext {
+    constructor(mockUuid) {
+        this.uuid = (0, uuid_1.v4)();
+        this.mockUuid = mockUuid;
+    }
+    static bind(req, mockUuid) {
+        const ctx = new RequestContext(mockUuid);
+        RequestContext._bindings.set(req, ctx);
+    }
+    static get(req) {
+        return RequestContext._bindings.get(req) || null;
+    }
+}
+exports.default = RequestContext;
+RequestContext._bindings = new WeakMap();

package/dist/ruleExecutor.d.ts

@@ -0,0 +1,21 @@
+import type * as Stuntman from '@stuntman/shared';
+declare class RuleExecutor {
+    private _rules;
+    private get enabledRules();
+    constructor(rules?: Stuntman.Rule[]);
+    private hasExpired;
+    private cleanUpExpired;
+    addRule(rule: Stuntman.Rule, overwrite?: boolean): Promise<Stuntman.LiveRule>;
+    private _removeRule;
+    removeRule(id: string): Promise<void>;
+    removeRule(rule: Stuntman.Rule): Promise<void>;
+    enableRule(id: string): void;
+    enableRule(rule: Stuntman.Rule): void;
+    disableRule(id: string): void;
+    disableRule(rule: Stuntman.Rule): void;
+    findMatchingRule(request: Stuntman.Request): Promise<Stuntman.LiveRule | null>;
+    getRules(): Promise<readonly Stuntman.LiveRule[]>;
+    getRule(id: string): Promise<Stuntman.LiveRule | undefined>;
+}
+export declare const ruleExecutor: RuleExecutor;
+export {};