@stuntman/server 0.1.0

package/src/api/validatiors.ts

@@ -0,0 +1,123 @@
+import { AppError, HttpCode, MAX_RULE_TTL_SECONDS, MIN_RULE_TTL_SECONDS, logger, RawHeaders } from '@stuntman/shared';
+import type * as Stuntman from '@stuntman/shared';
+
+export const validateSerializedRuleProperties = (rule: Stuntman.SerializedRule): void => {
+    if (!rule) {
+        throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid serialized rule' });
+    }
+    if (typeof rule.id !== 'string') {
+        throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.id' });
+    }
+    if (typeof rule.matches !== 'object' || !('remoteFn' in rule.matches) || typeof rule.matches.remoteFn !== 'string') {
+        throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.matches' });
+    }
+    if (rule.priority && typeof rule.priority !== 'number') {
+        throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.priority' });
+    }
+    if (typeof rule.actions !== 'undefined') {
+        if (typeof rule.actions !== 'object') {
+            throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.actions' });
+        }
+        if (typeof rule.actions.mockResponse !== 'undefined') {
+            if (typeof rule.actions.mockResponse !== 'object') {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.actions.mockResponse' });
+            }
+            if ('remoteFn' in rule.actions.mockResponse && typeof rule.actions.mockResponse.remoteFn !== 'string') {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.actions.mockResponse' });
+            } else if ('status' in rule.actions.mockResponse) {
+                if (typeof rule.actions.mockResponse.status !== 'number') {
+                    throw new AppError({
+                        httpCode: 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 AppError({
+                        httpCode: HttpCode.BAD_REQUEST,
+                        message: 'invalid rule.actions.mockResponse.rawHeaders',
+                    });
+                }
+                if (typeof rule.actions.mockResponse.body !== 'undefined' && typeof rule.actions.mockResponse.body !== 'string') {
+                    throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.actions.mockResponse.body' });
+                }
+            }
+        }
+        if (typeof rule.actions.modifyRequest !== 'undefined' && typeof rule.actions.modifyRequest.remoteFn !== 'string') {
+            throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.actions.modifyRequest' });
+        }
+        if (typeof rule.actions.modifyResponse !== 'undefined' && typeof rule.actions.modifyResponse.remoteFn !== 'string') {
+            throw new AppError({ httpCode: 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 AppError({ httpCode: 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 AppError({ httpCode: 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 AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.labels' });
+    }
+    if (rule.actions?.mockResponse && rule.actions.modifyResponse) {
+        throw new AppError({
+            httpCode: HttpCode.BAD_REQUEST,
+            message: 'rule.actions.mockResponse and rule.actions.modifyResponse are mutually exclusive',
+        });
+    }
+    if (!rule.ttlSeconds || rule.ttlSeconds < MIN_RULE_TTL_SECONDS || rule.ttlSeconds > MAX_RULE_TTL_SECONDS) {
+        throw new AppError({
+            httpCode: HttpCode.BAD_REQUEST,
+            message: `rule.ttlSeconds should be within ${MIN_RULE_TTL_SECONDS} and ${MAX_RULE_TTL_SECONDS}`,
+        });
+    }
+    if (typeof rule.isEnabled !== 'undefined' && typeof rule.isEnabled !== 'boolean') {
+        throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.isEnabled' });
+    }
+    if (typeof rule.storeTraffic !== 'undefined' && typeof rule.storeTraffic !== 'boolean') {
+        throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.storeTraffic' });
+    }
+};
+
+export const validateDeserializedRule = (deserializedRule: Stuntman.Rule) => {
+    // TODO validate other functions ?
+    let matchValidationResult: Stuntman.RuleMatchResult;
+    try {
+        matchValidationResult = deserializedRule.matches({
+            id: 'validation',
+            method: 'GET',
+            rawHeaders: new RawHeaders(),
+            timestamp: Date.now(),
+            url: 'http://dummy.invalid/',
+        });
+    } catch (error: any) {
+        logger.error({ ruleId: deserializedRule.id }, error);
+        throw new AppError({
+            httpCode: HttpCode.UNPROCESSABLE_ENTITY,
+            message: 'match function returned invalid value',
+        });
+    }
+    if (
+        matchValidationResult !== true &&
+        matchValidationResult !== false &&
+        matchValidationResult.result !== true &&
+        matchValidationResult.result !== false
+    ) {
+        logger.error({ ruleId: deserializedRule.id, matchValidationResult }, 'match function retruned invalid value');
+        throw new AppError({ httpCode: HttpCode.UNPROCESSABLE_ENTITY, message: 'match function returned invalid value' });
+    }
+};

package/src/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/src/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;
+}

package/src/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/src/bin/stuntman.ts

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

package/src/index.ts

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

package/src/ipUtils.ts

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