@stuntman/server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Andrzej Pasterczyk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/config/default.json

@@ -0,0 +1,23 @@
+{
+    "stuntman": {
+        "mock": {
+            "domain": "stuntman",
+            "port": 2015,
+            "timeout": 60000,
+            "externalDns": ["8.8.8.8", "1.1.1.1"]
+        },
+        "api": {
+            "port": 1985,
+            "disabled": false
+        },
+        "webgui": {
+            "disabled": false
+        },
+        "storage": {
+            "traffic": {
+                "limitCount": 500,
+                "limitSize": 524288000
+            }
+        }
+    }
+}

package/config/test.json

@@ -0,0 +1,26 @@
+{
+    "stuntman": {
+        "mock": {
+            "domain": "stuntman",
+            "port": 80,
+            "httpsPort": 443,
+            "httpsCert": "-----BEGIN CERTIFICATE-----\nMIIC7jCCAdYCCQDHj59tQDx5iTANBgkqhkiG9w0BAQsFADA5MREwDwYDVQQKDAhz\ndHVudG1hbjERMA8GA1UECwwIc3R1bnRtYW4xETAPBgNVBAMMCHN0dW50bWFuMB4X\nDTIzMDIxNjE1MzQzNFoXDTI0MDIxNjE1MzQzNFowOTERMA8GA1UECgwIc3R1bnRt\nYW4xETAPBgNVBAsMCHN0dW50bWFuMREwDwYDVQQDDAhzdHVudG1hbjCCASIwDQYJ\nKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK23MCp+grcLiyFzxvSU9iOFReIKZRVN\n0+DTlxl/sN4pvYlt7Hji7n/Yh55m7ACF1j8LRjaU6MOYIGofF4lbgA3nEbZVNJoH\nAtlSjk/JZc4LnDFinAWWxna2FpwrpfEnknIJ2B7fjtk5dM/WzSMn1MdPiC9V9Ee0\nPFe0PlpFl/hQSd4/VXfLxNy3bzW5AXa5CuTVRaEmts21TbL4VYe6KNPMkbTe+NJh\nwBrwVqS5lB3Z5racxOn5Dw5g5NuHgSA6LvUxdKhdkPs7y7e87XADadakibd9u02j\nimJwQih31O4rPJINLDYhVj5muyPGw9lpxEQ7UthxRxuzodm4F+5ZM1ECAwEAATAN\nBgkqhkiG9w0BAQsFAAOCAQEAhqISsPYrM+G37vw8I6YCWNSW0dJrpvfNpiz6oXal\nicIxOJz06qg0HsEXoWhdneo9PSA66KAmdcTplwPJtZ486izwD3F46+TZLkesOuCS\nDW9ihEPY5XPyjZDSz2J4EwBD4pH0AFeXSVFDIyXCSoWypSKjSq5lm7hOQuCOLkkm\ntlsptc4R3MGuvNYKSDBvxCjTy76jlXpMWINdVV18M4bVmRnVj+vYlQbYP5tCYGUm\nnzlFVi0dCLdvS2LGiKhARLQILP9YzC86a9UDPyWs703Zvqm5cnknCLEpjaR8dhd8\njAcDPHUe1RkR8wGrGwkkrIQfe8r8ovEylJgLT8HtNLqEXg==\n-----END CERTIFICATE-----\n",
+            "httpsKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQEArbcwKn6CtwuLIXPG9JT2I4VF4gplFU3T4NOXGX+w3im9iW3s\neOLuf9iHnmbsAIXWPwtGNpTow5ggah8XiVuADecRtlU0mgcC2VKOT8llzgucMWKc\nBZbGdrYWnCul8SeScgnYHt+O2Tl0z9bNIyfUx0+IL1X0R7Q8V7Q+WkWX+FBJ3j9V\nd8vE3LdvNbkBdrkK5NVFoSa2zbVNsvhVh7oo08yRtN740mHAGvBWpLmUHdnmtpzE\n6fkPDmDk24eBIDou9TF0qF2Q+zvLt7ztcANp1qSJt327TaOKYnBCKHfU7is8kg0s\nNiFWPma7I8bD2WnERDtS2HFHG7Oh2bgX7lkzUQIDAQABAoIBAH+L7GKXBvTNFfeW\n4XK9WMgV14yzIyr0POhrkxrWxY8pSI/6VNEhlgnqexET8p4jpn4dkg0LYqgSL2Kb\nt5VTyH7stPWSNBAPq8jTM8hjUEtr/N/JzlLQNKH+6jT6W1noOz9d+QAaFvFpnVnp\nFi+E1FcPDyfqTXTEYjXnEo0HYiCf5RAIw64VYRR3OfmCWFHjwz3sDbhvTW1bYfZA\nddwViTIoELfebF3cCLg4zWVkyCeZRpmbRJaeyttrqgOLbjD6tn7SFkZVJ8v4BBoK\nZSdRaFrzPrRxBYcLRbXlIaNp0QeM/NkSBZIg63vhwZydR+Y3wDE4mCzZ8UqiOyLC\nGIdHky0CgYEA1yY1WJ1ubOB67w4dckWMw9SOw00AP/i5o0j4kFz8nkcWhx8W6rJW\nrZrPq6yAZ6ffzR4aIwrq0W22nHB20sOvamO7UH7TzG3BuM787ChMqB0bEy98hKHZ\nHTAOKyqG9A50N+QNicUS9gXDWk67/i3j19bw8rLWMrNsQDM9SZHYvaMCgYEAzrMB\nz+ofYQ04z7gIKmlOK+lG9pT3JyNVdnLnHFhil4Q4AKMDDIsoKkDqjE2jJeTNzE+G\nIGlZyiBK6sArTJdNthrvrJLmvJJfVEGWpSnShNxDf+gzIJeUoA/TCJvUac1CXd8g\nHwnhR3Dp1I3SZwm32Hig/vzxe8Dd+YONPoNm8nsCgYBJ1pcgXodzXmdSe+mnOi9h\nViXY6ShYzCgJ3hVQllksiQE2Rnk6+xG8axEyvfUjnf21C8u0kx6b2ad+cSqWkwo0\n3R2ANsbBtjlyD7fF5N7KI5MTNozpiBJXbhKuxd2jDQLd26q5yaUEQl4VNEhYp682\neFIhOTdCF0njjrJN+XwFOQKBgF6j2aWQBhQS0LtTAPIiSzeR1PscE9notL3KOIVi\n9ql3UYkBGmlI4fgOxxW8ioHUNGJi2v/GHOWOSZ8Yo/qqoFtMFAdJL7qRrnJOoaI3\n9vr8Oy+6aoZ2wQdUl4SujOBwqf1/Jx7vECX8ziOTWA3zhijoepalzA+krD4NfMNt\nuNo3AoGBAISjSwEUrpR3II4uj8UuPZaVFNvACujaJLWnKcGwFvQsn/2GTcfzdzm/\nTxwHwpRZLJhFFpboFGVW5pX7g9leqdZERGlqPpTkCSAiQ0eFRbHsIhX7TS9VyYMz\n7iLq9dccEn5DDnUVXWkZxz2h0yG8/nTlNGli0BL2O+DEWZ9b32xE\n-----END RSA PRIVATE KEY-----\n",
+            "timeout": 60000,
+            "externalDns": ["8.8.8.8", "1.1.1.1"]
+        },
+        "api": {
+            "port": 1985,
+            "disabled": false
+        },
+        "webgui": {
+            "disabled": false
+        },
+        "storage": {
+            "traffic": {
+                "limitCount": 500,
+                "limitSize": 524288000
+            }
+        }
+    }
+}

package/dist/api/api.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import http from 'http';
+import { Express as ExpressServer } from 'express';
+import type * as Stuntman from '@stuntman/shared';
+import LRUCache from 'lru-cache';
+type ApiOptions = Stuntman.ApiConfig & {
+    mockUuid: string;
+};
+export declare class API {
+    protected options: Required<ApiOptions>;
+    protected apiApp: ExpressServer;
+    trafficStore: LRUCache<string, Stuntman.LogEntry>;
+    server: http.Server | null;
+    constructor(options: ApiOptions, webGuiOptions?: Stuntman.WebGuiConfig);
+    private initWebGui;
+    start(): void;
+    stop(): void;
+}
+export {};

package/dist/api/api.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API = void 0;
+const express_1 = __importDefault(require("express"));
+const uuid_1 = require("uuid");
+const storage_1 = require("../storage");
+const ruleExecutor_1 = require("../ruleExecutor");
+const shared_1 = require("@stuntman/shared");
+const requestContext_1 = __importDefault(require("../requestContext"));
+const serialize_javascript_1 = __importDefault(require("serialize-javascript"));
+const validatiors_1 = require("./validatiors");
+const utils_1 = require("./utils");
+class API {
+    constructor(options, webGuiOptions) {
+        this.server = null;
+        this.options = options;
+        this.trafficStore = (0, storage_1.getTrafficStore)(this.options.mockUuid);
+        this.apiApp = (0, express_1.default)();
+        this.apiApp.use(express_1.default.json());
+        this.apiApp.use(express_1.default.text());
+        this.apiApp.use((req, res, next) => {
+            requestContext_1.default.bind(req, this.options.mockUuid);
+            next();
+        });
+        this.apiApp.get('/rule', async (req, res) => {
+            res.send((0, shared_1.stringify)(await ruleExecutor_1.ruleExecutor.getRules()));
+        });
+        this.apiApp.get('/rule/:ruleId', async (req, res) => {
+            res.send((0, shared_1.stringify)(await ruleExecutor_1.ruleExecutor.getRule(req.params.ruleId)));
+        });
+        this.apiApp.get('/rule/:ruleId/disable', (req, res) => {
+            ruleExecutor_1.ruleExecutor.disableRule(req.params.ruleId);
+            res.send();
+        });
+        this.apiApp.get('/rule/:ruleId/enable', (req, res) => {
+            ruleExecutor_1.ruleExecutor.enableRule(req.params.ruleId);
+            res.send();
+        });
+        this.apiApp.post('/rule', async (req, res) => {
+            const deserializedRule = (0, utils_1.deserializeRule)(req.body);
+            (0, validatiors_1.validateDeserializedRule)(deserializedRule);
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            const rule = await ruleExecutor_1.ruleExecutor.addRule(deserializedRule);
+            res.send((0, shared_1.stringify)(rule));
+        });
+        this.apiApp.get('/rule/:ruleId/remove', async (req, res) => {
+            await ruleExecutor_1.ruleExecutor.removeRule(req.params.ruleId);
+            res.send();
+        });
+        this.apiApp.get('/traffic', (req, res) => {
+            const serializedTraffic = {};
+            for (const [key, value] of this.trafficStore.entries()) {
+                serializedTraffic[key] = value;
+            }
+            res.json(serializedTraffic);
+        });
+        this.apiApp.get('/traffic/:ruleIdOrLabel', (req, res) => {
+            const serializedTraffic = {};
+            for (const [key, value] of this.trafficStore.entries()) {
+                if (value.mockRuleId === req.params.ruleIdOrLabel || (value.labels || []).includes(req.params.ruleIdOrLabel)) {
+                    serializedTraffic[key] = value;
+                }
+            }
+            res.json(serializedTraffic);
+        });
+        this.apiApp.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)();
+            if (error instanceof shared_1.AppError && error.isOperational && res) {
+                shared_1.logger.error(error);
+                res.status(error.httpCode).json({
+                    error: { message: error.message, httpCode: error.httpCode, stack: error.stack },
+                });
+                return;
+            }
+            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('Application encountered a critical error. Exiting');
+            process.exit(1);
+        });
+        this.apiApp.set('views', __dirname + '/webgui');
+        this.apiApp.set('view engine', 'pug');
+        if (!(webGuiOptions === null || webGuiOptions === void 0 ? void 0 : webGuiOptions.disabled)) {
+            this.initWebGui();
+        }
+    }
+    initWebGui() {
+        this.apiApp.get('/webgui/rules', async (req, res) => {
+            const rules = {};
+            for (const rule of await ruleExecutor_1.ruleExecutor.getRules()) {
+                rules[rule.id] = (0, serialize_javascript_1.default)((0, utils_1.liveRuleToRule)(rule), { unsafe: true });
+            }
+            res.render('rules', { rules: (0, utils_1.escapedSerialize)(rules), INDEX_DTS: shared_1.INDEX_DTS, ruleKeys: Object.keys(rules) });
+        });
+        this.apiApp.get('/webgui/traffic', async (req, res) => {
+            const serializedTraffic = [];
+            for (const value of this.trafficStore.values()) {
+                serializedTraffic.push(value);
+            }
+            res.render('traffic', {
+                traffic: JSON.stringify(serializedTraffic.sort((a, b) => b.originalRequest.timestamp - a.originalRequest.timestamp)),
+            });
+        });
+        // TODO make webui way better and safer, nicer formatting, eslint/prettier, blackjack and hookers
+        this.apiApp.post('/webgui/rules/unsafesave', async (req, res) => {
+            const rule = new Function(req.body)();
+            if (!rule ||
+                !rule.id ||
+                typeof rule.matches !== 'function' ||
+                typeof rule.ttlSeconds !== 'number' ||
+                rule.ttlSeconds > shared_1.MAX_RULE_TTL_SECONDS) {
+                throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'Invalid rule' });
+            }
+            await ruleExecutor_1.ruleExecutor.addRule({
+                id: rule.id,
+                matches: rule.matches,
+                ttlSeconds: rule.ttlSeconds,
+                ...(rule.actions && {
+                    actions: {
+                        ...(rule.actions.mockResponse
+                            ? { mockResponse: rule.actions.mockResponse }
+                            : { modifyRequest: rule.actions.modifyRequest, modifyResponse: rule.actions.modifyResponse }),
+                    },
+                }),
+                ...(rule.disableAfterUse !== undefined && { disableAfterUse: rule.disableAfterUse }),
+                ...(rule.isEnabled !== undefined && { isEnabled: rule.isEnabled }),
+                ...(rule.labels !== undefined && { labels: rule.labels }),
+                ...(rule.priority !== undefined && { priority: rule.priority }),
+                ...(rule.removeAfterUse !== undefined && { removeAfterUse: rule.removeAfterUse }),
+                ...(rule.storeTraffic !== undefined && { storeTraffic: rule.storeTraffic }),
+            }, true);
+            res.send();
+        });
+    }
+    start() {
+        if (this.server) {
+            throw new Error('mock server already started');
+        }
+        this.server = this.apiApp.listen(this.options.port, () => {
+            shared_1.logger.info(`API listening on ${this.options.port}`);
+        });
+    }
+    stop() {
+        if (!this.server) {
+            throw new Error('mock server not started');
+        }
+        this.server.close((error) => {
+            shared_1.logger.warn(error, 'problem closing server');
+            this.server = null;
+        });
+    }
+}
+exports.API = API;

package/dist/api/utils.d.ts

@@ -0,0 +1,4 @@
+import type * as Stuntman from '@stuntman/shared';
+export declare const deserializeRule: (serializedRule: Stuntman.SerializedRule) => Stuntman.Rule;
+export declare const escapedSerialize: (obj: any) => string;
+export declare const liveRuleToRule: (liveRule: Stuntman.LiveRule) => Stuntman.Rule;

package/dist/api/utils.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.liveRuleToRule = exports.escapedSerialize = exports.deserializeRule = void 0;
+const serialize_javascript_1 = __importDefault(require("serialize-javascript"));
+const shared_1 = require("@stuntman/shared");
+const validatiors_1 = require("./validatiors");
+// TODO
+const deserializeRule = (serializedRule) => {
+    shared_1.logger.debug(serializedRule, 'attempt to deserialize rule');
+    (0, validatiors_1.validateSerializedRuleProperties)(serializedRule);
+    const rule = {
+        id: serializedRule.id,
+        matches: (req) => new Function('____arg0', serializedRule.matches.remoteFn)(req),
+        ttlSeconds: serializedRule.ttlSeconds,
+        ...(serializedRule.disableAfterUse !== undefined && { disableAfterUse: serializedRule.disableAfterUse }),
+        ...(serializedRule.removeAfterUse !== undefined && { removeAfterUse: serializedRule.removeAfterUse }),
+        ...(serializedRule.labels !== undefined && { labels: serializedRule.labels }),
+        ...(serializedRule.priority !== undefined && { priority: serializedRule.priority }),
+        ...(serializedRule.isEnabled !== undefined && { isEnabled: serializedRule.isEnabled }),
+        ...(serializedRule.storeTraffic !== undefined && { storeTraffic: serializedRule.storeTraffic }),
+    };
+    if (serializedRule.actions) {
+        // TODO store the original localFn and variables sent from client for web UI editing maybe
+        if (serializedRule.actions.mockResponse) {
+            rule.actions = {
+                mockResponse: 'remoteFn' in serializedRule.actions.mockResponse
+                    ? (req) => {
+                        var _a;
+                        return new Function('____arg0', ((_a = serializedRule.actions) === null || _a === void 0 ? void 0 : _a.mockResponse).remoteFn)(req);
+                    }
+                    : serializedRule.actions.mockResponse,
+            };
+        }
+        else {
+            rule.actions = {};
+            if (serializedRule.actions.modifyRequest) {
+                rule.actions.modifyRequest = (req) => {
+                    var _a;
+                    return new Function('____arg0', ((_a = serializedRule.actions) === null || _a === void 0 ? void 0 : _a.modifyRequest).remoteFn)(req);
+                };
+            }
+            if (serializedRule.actions.modifyResponse) {
+                rule.actions.modifyResponse = (req, res) => {
+                    var _a;
+                    return new Function('____arg0', '____arg1', ((_a = serializedRule.actions) === null || _a === void 0 ? void 0 : _a.modifyResponse).remoteFn)(req, res);
+                };
+            }
+        }
+    }
+    shared_1.logger.debug(rule, 'deserialized rule');
+    return rule;
+};
+exports.deserializeRule = deserializeRule;
+const escapedSerialize = (obj) => (0, serialize_javascript_1.default)(obj).replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, "\\n'\n+ '");
+exports.escapedSerialize = escapedSerialize;
+const liveRuleToRule = (liveRule) => {
+    const ruleClone = { ...liveRule };
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    delete ruleClone.counter;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    delete ruleClone.createdTimestamp;
+    return ruleClone;
+};
+exports.liveRuleToRule = liveRuleToRule;

package/dist/api/validatiors.d.ts

@@ -0,0 +1,3 @@
+import type * as Stuntman from '@stuntman/shared';
+export declare const validateSerializedRuleProperties: (rule: Stuntman.SerializedRule) => void;
+export declare const validateDeserializedRule: (deserializedRule: Stuntman.Rule) => void;

package/dist/api/validatiors.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDeserializedRule = exports.validateSerializedRuleProperties = void 0;
+const shared_1 = require("@stuntman/shared");
+const validateSerializedRuleProperties = (rule) => {
+    var _a;
+    if (!rule) {
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid serialized rule' });
+    }
+    if (typeof rule.id !== 'string') {
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.id' });
+    }
+    if (typeof rule.matches !== 'object' || !('remoteFn' in rule.matches) || typeof rule.matches.remoteFn !== 'string') {
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.matches' });
+    }
+    if (rule.priority && typeof rule.priority !== 'number') {
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.priority' });
+    }
+    if (typeof rule.actions !== 'undefined') {
+        if (typeof rule.actions !== 'object') {
+            throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.actions' });
+        }
+        if (typeof rule.actions.mockResponse !== 'undefined') {
+            if (typeof rule.actions.mockResponse !== 'object') {
+                throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.actions.mockResponse' });
+            }
+            if ('remoteFn' in rule.actions.mockResponse && typeof rule.actions.mockResponse.remoteFn !== 'string') {
+                throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.actions.mockResponse' });
+            }
+            else if ('status' in rule.actions.mockResponse) {
+                if (typeof rule.actions.mockResponse.status !== 'number') {
+                    throw new shared_1.AppError({
+                        httpCode: shared_1.HttpCode.BAD_REQUEST,
+                        message: 'invalid rule.actions.mockResponse.status',
+                    });
+                }
+                if (typeof rule.actions.mockResponse.rawHeaders !== 'undefined' &&
+                    (!Array.isArray(rule.actions.mockResponse.rawHeaders) ||
+                        rule.actions.mockResponse.rawHeaders.some((header) => typeof header !== 'string'))) {
+                    throw new shared_1.AppError({
+                        httpCode: shared_1.HttpCode.BAD_REQUEST,
+                        message: 'invalid rule.actions.mockResponse.rawHeaders',
+                    });
+                }
+                if (typeof rule.actions.mockResponse.body !== 'undefined' && typeof rule.actions.mockResponse.body !== 'string') {
+                    throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.actions.mockResponse.body' });
+                }
+            }
+        }
+        if (typeof rule.actions.modifyRequest !== 'undefined' && typeof rule.actions.modifyRequest.remoteFn !== 'string') {
+            throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.actions.modifyRequest' });
+        }
+        if (typeof rule.actions.modifyResponse !== 'undefined' && typeof rule.actions.modifyResponse.remoteFn !== 'string') {
+            throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.actions.modifyResponse' });
+        }
+    }
+    if (typeof rule.disableAfterUse !== 'undefined' &&
+        typeof rule.disableAfterUse !== 'boolean' &&
+        (typeof rule.disableAfterUse !== 'number' || rule.disableAfterUse < 0)) {
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.disableAfterUse' });
+    }
+    if (typeof rule.removeAfterUse !== 'undefined' &&
+        typeof rule.removeAfterUse !== 'boolean' &&
+        (typeof rule.removeAfterUse !== 'number' || rule.removeAfterUse < 0)) {
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.removeAfterUse' });
+    }
+    if (typeof rule.labels !== 'undefined' &&
+        (!Array.isArray(rule.labels) || rule.labels.some((label) => typeof label !== 'string'))) {
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.labels' });
+    }
+    if (((_a = rule.actions) === null || _a === void 0 ? void 0 : _a.mockResponse) && rule.actions.modifyResponse) {
+        throw new shared_1.AppError({
+            httpCode: shared_1.HttpCode.BAD_REQUEST,
+            message: 'rule.actions.mockResponse and rule.actions.modifyResponse are mutually exclusive',
+        });
+    }
+    if (!rule.ttlSeconds || rule.ttlSeconds < shared_1.MIN_RULE_TTL_SECONDS || rule.ttlSeconds > shared_1.MAX_RULE_TTL_SECONDS) {
+        throw new shared_1.AppError({
+            httpCode: shared_1.HttpCode.BAD_REQUEST,
+            message: `rule.ttlSeconds should be within ${shared_1.MIN_RULE_TTL_SECONDS} and ${shared_1.MAX_RULE_TTL_SECONDS}`,
+        });
+    }
+    if (typeof rule.isEnabled !== 'undefined' && typeof rule.isEnabled !== 'boolean') {
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.isEnabled' });
+    }
+    if (typeof rule.storeTraffic !== 'undefined' && typeof rule.storeTraffic !== 'boolean') {
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'invalid rule.storeTraffic' });
+    }
+};
+exports.validateSerializedRuleProperties = validateSerializedRuleProperties;
+const validateDeserializedRule = (deserializedRule) => {
+    // TODO validate other functions ?
+    let matchValidationResult;
+    try {
+        matchValidationResult = deserializedRule.matches({
+            id: 'validation',
+            method: 'GET',
+            rawHeaders: new shared_1.RawHeaders(),
+            timestamp: Date.now(),
+            url: 'http://dummy.invalid/',
+        });
+    }
+    catch (error) {
+        shared_1.logger.error({ ruleId: deserializedRule.id }, error);
+        throw new shared_1.AppError({
+            httpCode: shared_1.HttpCode.UNPROCESSABLE_ENTITY,
+            message: 'match function returned invalid value',
+        });
+    }
+    if (matchValidationResult !== true &&
+        matchValidationResult !== false &&
+        matchValidationResult.result !== true &&
+        matchValidationResult.result !== false) {
+        shared_1.logger.error({ ruleId: deserializedRule.id, matchValidationResult }, 'match function retruned invalid value');
+        throw new shared_1.AppError({ httpCode: shared_1.HttpCode.UNPROCESSABLE_ENTITY, message: 'match function returned invalid value' });
+    }
+};
+exports.validateDeserializedRule = validateDeserializedRule;

package/dist/api/webgui/rules.pug

@@ -0,0 +1,145 @@
+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/dist/api/webgui/style.css

@@ -0,0 +1,28 @@
+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;
+}