@stuntman/server 0.1.5 → 0.1.7

package/README.md

@@ -31,7 +31,7 @@ pnpm stuntman
 
 Stuntman uses [config](https://github.com/node-config/node-config)
 
-You can create `config/default.json` with settings of your liking matching `ServerConfig` type
+You can create `config/default.json` with settings of your liking matching `Stuntman.Config` type
 
 ## Running as a package
 
@@ -55,9 +55,9 @@ node ./node_modules/.bin/stuntman
 
 ```ts
 import { Mock } from '../mock';
-import { serverConfig } from '@stuntman/shared';
+import { stuntmanConfig } from '@stuntman/shared';
 
-const mock = new Mock(serverConfig);
+const mock = new Mock(stuntmanConfig);
 
 mock.start();
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stuntman/server",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Stuntman - HTTP proxy / mock server with API",
   "main": "dist/index.js",
   "repository": {
@@ -41,17 +41,19 @@
     "pug": "3.0.2",
     "serialize-javascript": "6.0.1",
     "ts-import": "4.0.0-beta.10",
-    "typescript": "4.9.5",
     "undici": "5.20.0",
     "uuid": "9.0.0"
   },
   "devDependencies": {
+    "@jest/globals": "29.4.3",
     "@prettier/plugin-pug": "2.4.1",
     "@types/express": "4.17.17",
     "@types/glob": "8.1.0",
     "@types/serialize-javascript": "5.0.2",
     "@types/uuid": "9.0.0",
-    "prettier": "2.8.4"
+    "jest": "29.4.3",
+    "prettier": "2.8.4",
+    "typescript": "4.9.5"
   },
   "bin": {
     "stuntman": "./dist/bin/stuntman.js"
@@ -64,11 +66,11 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "SUPPRESS_NO_CONFIG_WARNING=1 jest",
     "clean": "rm -fr dist",
     "build": "tsc && cp -rv src/api/webgui dist/api",
-    "lint": "prettier --check . && eslint . --ext ts",
-    "lint:fix": "prettier --write ./{src,test} && eslint ./{src,test} --ext ts --fix",
+    "lint": "prettier --check \"./{src,test}/**/*\" && eslint \"./{src,test}/**/*\"",
+    "lint:fix": "prettier --write \"./{src,test}/**/*\" && eslint \"./{src,test}/**/*\" --fix",
     "start": "node ./dist/bin/stuntman.js",
     "start:dev": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' ./src/bin/stuntman.ts",
     "start:debug": "node --inspect-brk=0.0.0.0 ./node_modules/.bin/ts-node --transpile-only ./src/bin/stuntman.ts"

package/src/api/api.ts

@@ -19,67 +19,81 @@ const API_KEY_HEADER = 'x-api-key';
 
 export class API {
     protected options: Required<ApiOptions>;
-    protected apiApp: ExpressServer;
+    protected webGuiOptions: Stuntman.WebGuiConfig;
+    protected apiApp: ExpressServer | null = null;
     trafficStore: LRUCache<string, Stuntman.LogEntry>;
     server: http.Server | null = null;
-    auth: (req: Request, type: 'read' | 'write') => void;
-    authReadOnly: (req: Request, res: Response, next: NextFunction) => void;
-    authReadWrite: (req: Request, res: Response, next: NextFunction) => void;
 
-    constructor(options: ApiOptions, webGuiOptions?: Stuntman.WebGuiConfig) {
+    constructor(options: ApiOptions, webGuiOptions: Stuntman.WebGuiConfig = { disabled: false }) {
         if (!options.apiKeyReadOnly !== !options.apiKeyReadWrite) {
             throw new Error('apiKeyReadOnly and apiKeyReadWrite options need to be set either both or none');
         }
         this.options = options;
+        this.webGuiOptions = webGuiOptions;
 
         this.trafficStore = getTrafficStore(this.options.mockUuid);
-        this.apiApp = express();
-
-        this.apiApp.use(express.json());
-        this.apiApp.use(express.text());
+        this.auth = this.auth.bind(this);
+        this.authReadOnly = this.authReadOnly.bind(this);
+        this.authReadWrite = this.authReadWrite.bind(this);
+    }
 
-        this.auth = (req: Request, type: 'read' | 'write'): void => {
-            if (!this.options.apiKeyReadOnly && !this.options.apiKeyReadWrite) {
-                return;
-            }
-            const hasValidReadKey = req.header(API_KEY_HEADER) === this.options.apiKeyReadOnly;
-            const hasValidWriteKey = req.header(API_KEY_HEADER) === this.options.apiKeyReadWrite;
-            const hasValidKey = type === 'read' ? hasValidReadKey || hasValidWriteKey : hasValidWriteKey;
-            if (!hasValidKey) {
-                throw new AppError({ httpCode: HttpCode.UNAUTHORIZED, message: 'unauthorized' });
-            }
+    private auth(req: Request, type: 'read' | 'write'): void {
+        if (!this.options.apiKeyReadOnly && !this.options.apiKeyReadWrite) {
             return;
-        };
+        }
+        const hasValidReadKey = req.header(API_KEY_HEADER) === this.options.apiKeyReadOnly;
+        const hasValidWriteKey = req.header(API_KEY_HEADER) === this.options.apiKeyReadWrite;
+        const hasValidKey = type === 'read' ? hasValidReadKey || hasValidWriteKey : hasValidWriteKey;
+        if (!hasValidKey) {
+            throw new AppError({ httpCode: HttpCode.UNAUTHORIZED, message: 'unauthorized' });
+        }
+        return;
+    }
 
-        this.authReadOnly = (req: Request, res: Response, next: NextFunction): void => {
-            this.auth(req, 'read');
-            next();
-        };
+    protected authReadOnly(req: Request, _res: Response, next: NextFunction): void {
+        this.auth(req, 'read');
+        next();
+    }
 
-        this.authReadWrite = (req: Request, res: Response, next: NextFunction): void => {
-            this.auth(req, 'write');
-            next();
-        };
+    protected authReadWrite(req: Request, _res: Response, next: NextFunction): void {
+        this.auth(req, 'write');
+        next();
+    }
+
+    private initApi() {
+        this.apiApp = express();
+
+        this.apiApp.use(express.json());
+        this.apiApp.use(express.text());
 
-        this.apiApp.use((req: Request, res: Response, next: NextFunction) => {
+        this.apiApp.use((req: Request, _res: Response, next: NextFunction) => {
             RequestContext.bind(req, this.options.mockUuid);
             next();
         });
 
-        this.apiApp.get('/rule', this.authReadOnly, async (req, res) => {
+        this.apiApp.get('/rule', this.authReadOnly.bind, async (_req, res) => {
             res.send(stringify(await getRuleExecutor(this.options.mockUuid).getRules()));
         });
 
         this.apiApp.get('/rule/:ruleId', this.authReadOnly, async (req, res) => {
+            if (!req.params.ruleId) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleId' });
+            }
             res.send(stringify(await getRuleExecutor(this.options.mockUuid).getRule(req.params.ruleId)));
         });
 
         this.apiApp.get('/rule/:ruleId/disable', this.authReadWrite, (req, res) => {
+            if (!req.params.ruleId) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleId' });
+            }
             getRuleExecutor(this.options.mockUuid).disableRule(req.params.ruleId);
             res.send();
         });
 
         this.apiApp.get('/rule/:ruleId/enable', this.authReadWrite, (req, res) => {
+            if (!req.params.ruleId) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleId' });
+            }
             getRuleExecutor(this.options.mockUuid).enableRule(req.params.ruleId);
             res.send();
         });
@@ -98,35 +112,41 @@ export class API {
         );
 
         this.apiApp.get('/rule/:ruleId/remove', this.authReadWrite, async (req, res) => {
+            if (!req.params.ruleId) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleId' });
+            }
             await getRuleExecutor(this.options.mockUuid).removeRule(req.params.ruleId);
             res.send();
         });
 
-        this.apiApp.get('/traffic', this.authReadOnly, (req, res) => {
-            const serializedTraffic: Record<string, Stuntman.LogEntry> = {};
-            for (const [key, value] of this.trafficStore.entries()) {
-                serializedTraffic[key] = value;
+        this.apiApp.get('/traffic', this.authReadOnly, (_req, res) => {
+            const serializedTraffic: Stuntman.LogEntry[] = [];
+            for (const value of this.trafficStore.values()) {
+                serializedTraffic.push(value);
             }
             res.json(serializedTraffic);
         });
 
         this.apiApp.get('/traffic/:ruleIdOrLabel', this.authReadOnly, (req, res) => {
-            const serializedTraffic: Record<string, Stuntman.LogEntry> = {};
-            for (const [key, value] of this.trafficStore.entries()) {
+            if (!req.params.ruleIdOrLabel) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleIdOrLabel' });
+            }
+            const serializedTraffic: Stuntman.LogEntry[] = [];
+            for (const value of this.trafficStore.values()) {
                 if (value.mockRuleId === req.params.ruleIdOrLabel || (value.labels || []).includes(req.params.ruleIdOrLabel)) {
-                    serializedTraffic[key] = value;
+                    serializedTraffic.push(value);
                 }
             }
             res.json(serializedTraffic);
         });
 
-        if (!webGuiOptions?.disabled) {
+        if (!this.webGuiOptions.disabled) {
             this.apiApp.set('views', __dirname + '/webgui');
             this.apiApp.set('view engine', 'pug');
             this.initWebGui();
         }
 
-        this.apiApp.all(/.*/, (req: Request, res: Response) => res.status(404).send());
+        this.apiApp.all(/.*/, (_req: Request, res: Response) => res.status(404).send());
 
         this.apiApp.use((error: Error | AppError, req: Request, res: Response) => {
             const ctx: RequestContext | null = RequestContext.get(req);
@@ -152,7 +172,10 @@ export class API {
     }
 
     private initWebGui() {
-        this.apiApp.get('/webgui/rules', this.authReadOnly, async (req, res) => {
+        if (!this.apiApp) {
+            throw new Error('initialization error');
+        }
+        this.apiApp.get('/webgui/rules', this.authReadOnly, async (_req, res) => {
             const rules: Record<string, string> = {};
             for (const rule of await getRuleExecutor(this.options.mockUuid).getRules()) {
                 rules[rule.id] = serializeJavascript(liveRuleToRule(rule), { unsafe: true });
@@ -160,7 +183,7 @@ export class API {
             res.render('rules', { rules: escapedSerialize(rules), INDEX_DTS, ruleKeys: Object.keys(rules) });
         });
 
-        this.apiApp.get('/webgui/traffic', this.authReadOnly, async (req, res) => {
+        this.apiApp.get('/webgui/traffic', this.authReadOnly, async (_req, res) => {
             const serializedTraffic: Stuntman.LogEntry[] = [];
             for (const value of this.trafficStore.values()) {
                 serializedTraffic.push(value);
@@ -190,13 +213,7 @@ export class API {
                     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 }),
-                        },
-                    }),
+                    actions: rule.actions,
                     ...(rule.disableAfterUse !== undefined && { disableAfterUse: rule.disableAfterUse }),
                     ...(rule.isEnabled !== undefined && { isEnabled: rule.isEnabled }),
                     ...(rule.labels !== undefined && { labels: rule.labels }),
@@ -214,6 +231,10 @@ export class API {
         if (this.server) {
             throw new Error('mock server already started');
         }
+        this.initApi();
+        if (!this.apiApp) {
+            throw new Error('initialization error');
+        }
         this.server = this.apiApp.listen(this.options.port, () => {
             logger.info(`API listening on ${this.options.port}`);
         });

package/src/api/utils.ts

@@ -11,6 +11,7 @@ export const deserializeRule = (serializedRule: Stuntman.SerializedRule): Stuntm
         id: serializedRule.id,
         matches: (req: Stuntman.Request) => new Function('____arg0', serializedRule.matches.remoteFn)(req),
         ttlSeconds: serializedRule.ttlSeconds,
+        actions: { mockResponse: { status: 200 } },
         ...(serializedRule.disableAfterUse !== undefined && { disableAfterUse: serializedRule.disableAfterUse }),
         ...(serializedRule.removeAfterUse !== undefined && { removeAfterUse: serializedRule.removeAfterUse }),
         ...(serializedRule.labels !== undefined && { labels: serializedRule.labels }),
@@ -18,37 +19,36 @@ export const deserializeRule = (serializedRule: Stuntman.SerializedRule): Stuntm
         ...(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: Stuntman.Request) =>
-                              new Function(
-                                  '____arg0',
-                                  (serializedRule.actions?.mockResponse as Stuntman.SerializedRemotableFunction).remoteFn
-                              )(req)
-                        : serializedRule.actions.mockResponse,
-            };
-        } else {
-            rule.actions = {};
-            if (serializedRule.actions.modifyRequest) {
-                rule.actions.modifyRequest = (req: Stuntman.Request) =>
+    // 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: Stuntman.Request) =>
+                          new Function(
+                              '____arg0',
+                              (serializedRule.actions.mockResponse as Stuntman.SerializedRemotableFunction).remoteFn
+                          )(req)
+                    : serializedRule.actions.mockResponse,
+        };
+    } else {
+        rule.actions = {
+            ...(serializedRule.actions.modifyRequest && {
+                modifyRequest: ((req: Stuntman.Request) =>
                     new Function(
                         '____arg0',
-                        (serializedRule.actions?.modifyRequest as Stuntman.SerializedRemotableFunction).remoteFn
-                    )(req);
-            }
-            if (serializedRule.actions.modifyResponse) {
-                rule.actions.modifyResponse = (req: Stuntman.Request, res: Stuntman.Response) =>
+                        (serializedRule.actions.modifyRequest as Stuntman.SerializedRemotableFunction).remoteFn
+                    )(req)) as Stuntman.RequestManipulationFn,
+            }),
+            ...(serializedRule.actions.modifyResponse && {
+                modifyResponse: ((req: Stuntman.Request, res: Stuntman.Response) =>
                     new Function(
                         '____arg0',
                         '____arg1',
-                        (serializedRule.actions?.modifyResponse as Stuntman.SerializedRemotableFunction).remoteFn
-                    )(req, res);
-            }
-        }
+                        (serializedRule.actions.modifyResponse as Stuntman.SerializedRemotableFunction).remoteFn
+                    )(req, res)) as Stuntman.ResponseManipulationFn,
+            }),
+        } as Stuntman.Actions;
     }
     logger.debug(rule, 'deserialized rule');
     return rule;

package/src/api/validators.ts

@@ -14,44 +14,53 @@ export const validateSerializedRuleProperties = (rule: Stuntman.SerializedRule):
     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 !== 'object') {
+        throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.actions - not an object' });
+    }
+    if (
+        rule.actions.proxyPass !== true &&
+        typeof rule.actions.mockResponse !== 'object' &&
+        typeof rule.actions.modifyRequest !== 'object' &&
+        typeof rule.actions.modifyResponse !== 'object'
+    ) {
+        throw new AppError({
+            httpCode: HttpCode.BAD_REQUEST,
+            message: 'invalid rule.actions - missing one of: proxyPass, mockResponse, modifyRequest, modifyResponse',
+        });
+    }
+    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 (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 ('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.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.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' &&
@@ -73,7 +82,7 @@ export const validateSerializedRuleProperties = (rule: Stuntman.SerializedRule):
     ) {
         throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'invalid rule.labels' });
     }
-    if (rule.actions?.mockResponse && rule.actions.modifyResponse) {
+    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',

package/src/api/webgui/rules.pug

@@ -22,6 +22,7 @@ html
             div(style='margin-left: 240px')
                 #container(style='height: 400px')
                     script.
+                        /* eslint no-undef: 0 */
                         const uuidv4 = () => {
                             function getRandomSymbol(symbol) {
                                 var array;
@@ -72,7 +73,6 @@ html
                             }
                             const editor = monaco.editor.create(document.getElementById('container'), {
                                 theme: 'vs-dark',
-                                autoIndent: true,
                                 formatOnPaste: true,
                                 formatOnType: true,
                                 automaticLayout: true,
@@ -120,6 +120,8 @@ html
                                                 body: ruleFunctionText + '\n return STUNTMAN_RULE;',
                                             }).then((response) => {
                                                 if (response.ok) {
+                                                    const newUrl = `${window.location.protocol}//${window.location.host}${window.location.pathname}?ruleId=${encodeURIComponent(newId)}`;
+                                                    window.history.pushState({ path: newUrl }, '', newUrl);
                                                     window.location.reload();
                                                     return;
                                                 }
@@ -133,7 +135,7 @@ html
 
                             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 };`;
+                                const emptyRule = `import type * as Stuntman from 'stuntman';\n\nvar STUNTMAN_RULE: Stuntman.Rule = { id: '${ruleId}', matches: (req: Stuntman.Request) => true, ttlSeconds: 600, actions: { mockResponse: { status: '200', body: '${ruleId}' }} };`;
                                 models[ruleId] = monaco.editor.createModel(emptyRule, 'typescript', `file:///${ruleId}.ts`);
                                 const ruleKeyNode = document.getElementById('ruleKeys').firstChild;
                                 const ruleKeyNodeClone = ruleKeyNode.cloneNode(true);

package/src/api/webgui/style.css

@@ -21,8 +21,8 @@ button.rule {
 }
 
 ul.no-bullets {
-    list-style-type: none; /* Remove bullets */
-    padding: 0; /* Remove padding */
-    margin: 0; /* Remove margins */
+    list-style-type: none;
+    padding: 0;
+    margin: 0;
     text-align: left;
 }

package/src/api/webgui/traffic.pug

@@ -12,6 +12,7 @@ html
             div(style='margin-left: 220px')
                 #container(style='height: 800px')
                     script.
+                        /* eslint no-undef: 0 */
                         require.config({
                             paths: {
                                 vs: 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.35.0/min/vs',

package/src/bin/stuntman.ts

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

package/src/ipUtils.ts

@@ -55,7 +55,7 @@ export class IPUtils {
                     return;
                 }
                 logger.debug({ ip: addresses, hostname }, 'resolved hostname');
-                resolve([addresses[0], ...addresses.slice(1)]);
+                resolve([addresses[0]!, ...addresses.slice(1)]);
             };
             if (options?.useExternalDns) {
                 if (!this.externalDns) {