@hubspot/local-dev-lib 0.0.8 → 0.0.9

package/lib/logging/logs.js

@@ -7,6 +7,8 @@ exports.outputLogs = void 0;
 const moment_1 = __importDefault(require("moment"));
 const chalk_1 = __importDefault(require("chalk"));
 const logger_1 = require("./logger");
+const lang_1 = require("../../utils/lang");
+const i18nKey = 'lib.logging.logs';
 const SEPARATOR = ' - ';
 const LOG_STATUS_COLORS = {
     SUCCESS: logger_1.Styles.success,
@@ -61,7 +63,9 @@ function processLog(log, options) {
         return logHandler[log.status](log, options);
     }
     catch (e) {
-        logger_1.logger.error(`Unable to process log ${JSON.stringify(log)}`);
+        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.unableToProcessLog`, {
+            log: JSON.stringify(log),
+        }));
     }
 }
 function processLogs(logsResp, options) {

package/lib/oauth.js

@@ -11,10 +11,11 @@ const logger_1 = require("../utils/logger");
 const logger_2 = require("../utils/logger");
 const getAccountIdentifier_1 = require("../utils/getAccountIdentifier");
 const config_1 = require("../config");
+const i18nKey = 'lib.oauth';
 const oauthManagers = new Map();
 function writeOauthTokenInfo(accountConfig) {
     const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig);
-    (0, logger_1.debug)('oauth.writeTokenInfo', { portalId: accountId || '' });
+    (0, logger_1.debug)(`${i18nKey}.writeTokenInfo`, { portalId: accountId || '' });
     (0, config_1.updateAccountConfig)(accountConfig);
     (0, config_1.writeConfig)();
 }
@@ -27,15 +28,15 @@ function getOauthManager(accountId, accountConfig) {
 exports.getOauthManager = getOauthManager;
 const addOauthToAccountConfigCallbackKeys = ['init', 'success'];
 function addOauthToAccountConfig(oauth, logCallbacks) {
-    const logger = (0, logger_2.makeTypedLogger)(logCallbacks, 'oauth.addOauthToAccountConfig');
-    logger('init');
+    const logger = (0, logger_2.makeTypedLogger)(logCallbacks);
+    logger('init', `${i18nKey}.addOauthToAccountConfig.init`);
     try {
         (0, config_1.updateAccountConfig)({
             ...oauth.toObj(),
             authType: auth_1.AUTH_METHODS.oauth.value,
         });
         (0, config_1.writeConfig)();
-        logger('success');
+        logger('success', `${i18nKey}.addOauthToAccountConfig.success`);
     }
     catch (err) {
         (0, standardErrors_1.throwError)(err);

package/lib/personalAccessKey.js

@@ -11,6 +11,7 @@ const standardErrors_1 = require("../errors/standardErrors");
 const localDevAuth_1 = require("../api/localDevAuth");
 const sandboxHubs_1 = require("../api/sandboxHubs");
 const config_1 = require("../config");
+const i18nKey = 'lib.personalAccessKey';
 const refreshRequests = new Map();
 function getRefreshKey(personalAccessKey, expiration) {
     return `${personalAccessKey}-${expiration || 'fresh'}`;
@@ -23,7 +24,7 @@ async function getAccessToken(personalAccessKey, env = environments_1.ENVIRONMEN
     catch (e) {
         const error = e;
         if (error.response && error.response.body) {
-            (0, standardErrors_1.throwAuthErrorWithMessage)('personalAccessKey.invalidPersonalAccessKey', { errorMessage: error.response.body.message || '' }, error);
+            (0, standardErrors_1.throwAuthErrorWithMessage)(`${i18nKey}.errors.invalidPersonalAccessKey`, { errorMessage: error.response.body.message || '' }, error);
         }
         else {
             (0, standardErrors_1.throwError)(e);
@@ -77,7 +78,7 @@ async function getNewAccessToken(accountId, personalAccessKey, expiresAt, env) {
 async function accessTokenForPersonalAccessKey(accountId) {
     const account = (0, config_1.getAccountConfig)(accountId);
     if (!account) {
-        (0, standardErrors_1.throwErrorWithMessage)('personalAccessKey.accountNotFound', { accountId });
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.accountNotFound`, { accountId });
     }
     const { auth, personalAccessKey, env } = account;
     const authTokenInfo = auth && auth.tokenInfo;

package/lib/portManager.d.ts

@@ -0,0 +1,13 @@
+export declare const BASE_URL: string;
+export declare function startPortManagerServer(): Promise<void>;
+export declare function stopPortManagerServer(): Promise<void>;
+type RequestPortsData = {
+    instanceId: string;
+    port?: number;
+};
+export declare function requestPorts(portData: Array<RequestPortsData>): Promise<{
+    [instanceId: string]: number;
+}>;
+export declare function deleteServerInstance(serverInstanceId: string): Promise<void>;
+export declare function portManagerHasActiveServers(): Promise<boolean>;
+export {};

package/lib/portManager.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portManagerHasActiveServers = exports.deleteServerInstance = exports.requestPorts = exports.stopPortManagerServer = exports.startPortManagerServer = exports.BASE_URL = void 0;
+const axios_1 = __importDefault(require("axios"));
+const PortManagerServer_1 = __importDefault(require("../utils/PortManagerServer"));
+const detectPort_1 = require("../utils/detectPort");
+const ports_1 = require("../constants/ports");
+exports.BASE_URL = `http://localhost:${ports_1.PORT_MANAGER_SERVER_PORT}`;
+async function isPortManagerServerRunning() {
+    const port = await (0, detectPort_1.detectPort)(ports_1.PORT_MANAGER_SERVER_PORT);
+    return port !== ports_1.PORT_MANAGER_SERVER_PORT;
+}
+async function startPortManagerServer() {
+    const isRunning = await isPortManagerServerRunning();
+    if (!isRunning) {
+        await PortManagerServer_1.default.init();
+    }
+}
+exports.startPortManagerServer = startPortManagerServer;
+async function stopPortManagerServer() {
+    const isRunning = await isPortManagerServerRunning();
+    if (isRunning) {
+        await axios_1.default.post(`${exports.BASE_URL}/close`);
+    }
+}
+exports.stopPortManagerServer = stopPortManagerServer;
+async function requestPorts(portData) {
+    const { data } = await axios_1.default.post(`${exports.BASE_URL}/servers`, {
+        portData: portData,
+    });
+    return data.ports;
+}
+exports.requestPorts = requestPorts;
+async function deleteServerInstance(serverInstanceId) {
+    await axios_1.default.delete(`${exports.BASE_URL}/servers/${serverInstanceId}`);
+}
+exports.deleteServerInstance = deleteServerInstance;
+async function portManagerHasActiveServers() {
+    const { data } = await axios_1.default.get(`${exports.BASE_URL}/servers`);
+    return data.count > 0;
+}
+exports.portManagerHasActiveServers = portManagerHasActiveServers;

package/lib/sandboxes.js

@@ -4,7 +4,7 @@ exports.fetchTypes = exports.fetchTaskStatus = exports.initiateSync = exports.ge
 const sandboxHubs_1 = require("../api/sandboxHubs");
 const sandboxSync_1 = require("../api/sandboxSync");
 const standardErrors_1 = require("../errors/standardErrors");
-const i18nKey = 'sandboxes';
+const i18nKey = 'lib.sandboxes';
 async function createSandbox(accountId, name, type) {
     try {
         const resp = await (0, sandboxHubs_1.createSandbox)(accountId, name, type);
@@ -14,7 +14,7 @@ async function createSandbox(accountId, name, type) {
         };
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createSandbox`, {}, err);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.createSandbox`, {}, err);
     }
 }
 exports.createSandbox = createSandbox;
@@ -23,7 +23,7 @@ async function deleteSandbox(parentAccountId, sandboxAccountId) {
         await (0, sandboxHubs_1.deleteSandbox)(parentAccountId, sandboxAccountId);
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.deleteSandbox`, {}, err);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.deleteSandbox`, {}, err);
     }
     return {
         parentAccountId,
@@ -37,7 +37,7 @@ async function getSandboxUsageLimits(parentAccountId) {
         return resp && resp.usage;
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.getSandboxUsageLimits`, {}, err);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.getSandboxUsageLimits`, {}, err);
     }
 }
 exports.getSandboxUsageLimits = getSandboxUsageLimits;
@@ -46,7 +46,7 @@ async function initiateSync(fromHubId, toHubId, tasks, sandboxHubId) {
         return await (0, sandboxSync_1.initiateSync)(fromHubId, toHubId, tasks, sandboxHubId);
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.initiateSync`, {}, err);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.initiateSync`, {}, err);
     }
 }
 exports.initiateSync = initiateSync;
@@ -55,7 +55,7 @@ async function fetchTaskStatus(accountId, taskId) {
         return await (0, sandboxSync_1.fetchTaskStatus)(accountId, taskId);
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.fetchTaskStatus`, {}, err);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.fetchTaskStatus`, {}, err);
     }
 }
 exports.fetchTaskStatus = fetchTaskStatus;
@@ -65,7 +65,7 @@ async function fetchTypes(accountId, toHubId) {
         return resp && resp.results;
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.fetchTypes`, {}, err);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.fetchTypes`, {}, err);
     }
 }
 exports.fetchTypes = fetchTypes;

package/lib/trackUsage.js

@@ -8,8 +8,8 @@ const logger_1 = require("../utils/logger");
 const http_1 = __importDefault(require("../http"));
 const config_1 = require("../config");
 const fileMapper_1 = require("../api/fileMapper");
+const i18nKey = 'lib.trackUsage';
 async function trackUsage(eventName, eventClass, meta = {}, accountId) {
-    const i18nKey = 'api.filemapper.trackUsage';
     const usageEvent = {
         accountId,
         eventName,

package/models/OAuth2Manager.js

@@ -24,7 +24,7 @@ class OAuth2Manager {
     }
     async accessToken() {
         if (!this.account.auth.tokenInfo?.refreshToken) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.missingRefreshToken`, {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.missingRefreshToken`, {
                 accountId: (0, getAccountIdentifier_1.getAccountIdentifier)(this.account),
             });
         }
@@ -86,7 +86,7 @@ class OAuth2Manager {
         catch (e) {
             const error = e;
             if (error.response) {
-                (0, standardErrors_1.throwAuthErrorWithMessage)(`${i18nKey}.auth`, {
+                (0, standardErrors_1.throwAuthErrorWithMessage)(`${i18nKey}.errors.auth`, {
                     token: error.response.body.message || '',
                 }, error);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/local-dev-lib",
-    "version": "0.0.8",
+    "version": "0.0.9",
     "description": "Provides library functionality for HubSpot local development tooling, including the HubSpot CLI",
     "main": "lib/index.js",
     "repository": {
@@ -29,7 +29,9 @@
     "license": "Apache-2.0",
     "devDependencies": {
         "@types/content-disposition": "^0.5.5",
+        "@types/cors": "^2.8.15",
         "@types/debounce": "^1.2.1",
+        "@types/express": "^4.17.18",
         "@types/findup-sync": "^4.0.2",
         "@types/fs-extra": "^11.0.1",
         "@types/jest": "^29.5.0",
@@ -55,9 +57,12 @@
         "./logger": "./lib/logging/logger.js"
     },
     "dependencies": {
+        "address": "^2.0.1",
         "axios": "^1.3.5",
         "chokidar": "^3.5.3",
         "content-disposition": "^0.5.4",
+        "cors": "^2.8.5",
+        "express": "^4.18.2",
         "extract-zip": "^2.0.1",
         "findup-sync": "^5.0.0",
         "fs-extra": "^11.1.0",

package/types/Lang.d.ts

@@ -0,0 +1,7 @@
+import lang from '../lang/en.json';
+import { Leaves } from './Utils';
+export type GenericLanguageObject = {
+    [key: string]: string | GenericLanguageObject;
+};
+export type LanguageObject = typeof lang;
+export type LangKey = Leaves<LanguageObject>;

package/types/Lang.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/PortManager.d.ts

@@ -0,0 +1,4 @@
+export type RequestPortsData = {
+    instanceId: string;
+    port?: number;
+};

package/types/PortManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Schemas.d.ts

@@ -1,41 +1,26 @@
 export type Schema = {
     id: string;
-    createdAt: string;
-    updatedAt: string | null;
-    properties?: [
-        {
-            updatedAt: string | null;
-            createdAt: string;
-            name: string;
-            label: string;
-            type: string;
-            fieldType: string;
-            groupName: string;
-            displayOrder: number;
-            calculated: boolean;
-            externalOptions: boolean;
-            archived: boolean;
-            hasUniqueValue: boolean;
-        }
-    ];
-    associations?: [
-        {
-            id: string;
-            fromObjectTypeId: string;
-            toObjectTypeId: string;
-            name: string;
-        }
-    ];
+    name: string;
+    createdAt?: string;
+    updatedAt?: string;
+    properties: Array<any>;
+    associations: Array<{
+        id: string;
+        fromObjectTypeId: string;
+        toObjectTypeId: string;
+        name?: string;
+        createdAt?: string | null;
+        updatedAt?: string | null;
+    }>;
     labels: {
-        singular: string;
-        plural: string;
+        singular?: string;
+        plural?: string;
     };
     requiredProperties: Array<string>;
-    searchableProperties: Array<string>;
-    primaryDisplayProperty: Array<string>;
-    metaType: string;
-    fullyQualifiedName: string;
-    name: string;
+    searchableProperties?: Array<string>;
+    primaryDisplayProperty?: string;
+    fullyQualifiedName?: string;
+    [key: string]: any;
 };
 export type FetchSchemasResponse = {
     results: Array<Schema>;

package/types/Utils.d.ts

@@ -1 +1,6 @@
 export type ValueOf<T> = T[keyof T];
+type Join<K, P> = K extends string | number ? P extends string | number ? `${K}${'' extends P ? '' : '.'}${P}` : never : never;
+export type Leaves<T> = [10] extends [never] ? never : T extends object ? {
+    [K in keyof T]-?: Join<K, Leaves<T[K]>>;
+}[keyof T] : '';
+export {};

package/utils/PortManagerServer.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { Express, Request, Response } from 'express';
+import { Server } from 'http';
+import { RequestPortsData } from '../types/PortManager';
+type ServerPortMap = {
+    [instanceId: string]: number;
+};
+declare class PortManagerServer {
+    app?: Express;
+    server?: Server;
+    serverPortMap: ServerPortMap;
+    constructor();
+    init(): Promise<void>;
+    reset(): void;
+    listen(): Promise<Server>;
+    setupRoutes(): void;
+    setPort(instanceId: string, port: number): void;
+    deletePort(instanceId: string): void;
+    send404(res: Response, instanceId: string): void;
+    getServers: (req: Request, res: Response) => Promise<void>;
+    getServerPortByInstanceId: (req: Request, res: Response) => void;
+    assignPortsToServers: (req: Request<never, never, {
+        portData: Array<RequestPortsData>;
+    }>, res: Response) => Promise<void>;
+    deleteServerInstance: (req: Request, res: Response) => void;
+    closeServer: (req: Request, res: Response) => void;
+}
+declare const _default: PortManagerServer;
+export default _default;

package/utils/PortManagerServer.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const detectPort_1 = require("./detectPort");
+const ports_1 = require("../constants/ports");
+const standardErrors_1 = require("../errors/standardErrors");
+const logger_1 = require("./logger");
+const lang_1 = require("./lang");
+const i18nKey = 'utils.PortManagerServer';
+class PortManagerServer {
+    app;
+    server;
+    serverPortMap;
+    constructor() {
+        this.serverPortMap = {};
+    }
+    async init() {
+        if (this.app) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.duplicateInstance`);
+        }
+        this.app = (0, express_1.default)();
+        this.app.use(express_1.default.json());
+        this.app.use((0, cors_1.default)());
+        this.setupRoutes();
+        try {
+            this.server = await this.listen();
+        }
+        catch (e) {
+            const error = e;
+            if (error.code === 'EADDRINUSE') {
+                (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.portInUse`, {
+                    port: ports_1.PORT_MANAGER_SERVER_PORT,
+                }, error);
+            }
+            throw error;
+        }
+    }
+    reset() {
+        this.app = undefined;
+        this.server = undefined;
+        this.serverPortMap = {};
+    }
+    listen() {
+        return new Promise((resolve, reject) => {
+            const server = this.app.listen(ports_1.PORT_MANAGER_SERVER_PORT, () => {
+                (0, logger_1.debug)(`${i18nKey}.started`, {
+                    port: ports_1.PORT_MANAGER_SERVER_PORT,
+                });
+                resolve(server);
+            }).on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    setupRoutes() {
+        if (!this.app) {
+            return;
+        }
+        this.app.get('/servers', this.getServers);
+        this.app.get('/servers/:instanceId', this.getServerPortByInstanceId);
+        this.app.post('/servers', this.assignPortsToServers);
+        this.app.delete('/servers/:instanceId', this.deleteServerInstance);
+        this.app.post('/close', this.closeServer);
+    }
+    setPort(instanceId, port) {
+        (0, logger_1.debug)(`${i18nKey}.setPort`, { instanceId, port });
+        this.serverPortMap[instanceId] = port;
+    }
+    deletePort(instanceId) {
+        (0, logger_1.debug)(`${i18nKey}.deletedPort`, {
+            instanceId,
+            port: this.serverPortMap[instanceId],
+        });
+        delete this.serverPortMap[instanceId];
+    }
+    send404(res, instanceId) {
+        res
+            .status(404)
+            .send((0, lang_1.i18n)(`${i18nKey}.errors.404`, { instanceId: instanceId }));
+    }
+    getServers = async (req, res) => {
+        res.send({
+            servers: this.serverPortMap,
+            count: Object.keys(this.serverPortMap).length,
+        });
+    };
+    getServerPortByInstanceId = (req, res) => {
+        const { instanceId } = req.params;
+        const port = this.serverPortMap[instanceId];
+        if (port) {
+            res.send({ port });
+        }
+        else {
+            this.send404(res, instanceId);
+        }
+    };
+    assignPortsToServers = async (req, res) => {
+        const { portData } = req.body;
+        const portPromises = [];
+        for (let i = 0; i < portData.length; i++) {
+            const { port, instanceId } = portData[i];
+            if (this.serverPortMap[instanceId]) {
+                res.status(409).send((0, lang_1.i18n)(`${i18nKey}.errors.409`, {
+                    instanceId,
+                    port: this.serverPortMap[instanceId],
+                }));
+                return;
+            }
+            else if (port && (port < ports_1.MIN_PORT_NUMBER || port > ports_1.MAX_PORT_NUMBER)) {
+                res.status(400).send((0, lang_1.i18n)(`${i18nKey}.errors.400`, {
+                    minPort: ports_1.MIN_PORT_NUMBER,
+                    maxPort: ports_1.MAX_PORT_NUMBER,
+                }));
+                return;
+            }
+            else {
+                const promise = new Promise(resolve => {
+                    (0, detectPort_1.detectPort)(port, Object.values(this.serverPortMap)).then(resolvedPort => {
+                        resolve({
+                            [instanceId]: resolvedPort,
+                        });
+                    });
+                });
+                portPromises.push(promise);
+            }
+        }
+        const portList = await Promise.all(portPromises);
+        const ports = portList.reduce((a, c) => Object.assign(a, c));
+        for (const instanceId in ports) {
+            this.setPort(instanceId, ports[instanceId]);
+        }
+        res.send({ ports });
+    };
+    deleteServerInstance = (req, res) => {
+        const { instanceId } = req.params;
+        const port = this.serverPortMap[instanceId];
+        if (port) {
+            this.deletePort(instanceId);
+            res.send(200);
+        }
+        else {
+            this.send404(res, instanceId);
+        }
+    };
+    closeServer = (req, res) => {
+        if (this.server) {
+            (0, logger_1.debug)(`${i18nKey}.close`);
+            res.send(200);
+            this.server.close();
+            this.reset();
+        }
+    };
+}
+exports.default = new PortManagerServer();

package/utils/cms/modules.js

@@ -8,6 +8,7 @@ const path_1 = __importDefault(require("path"));
 const path_2 = require("../../lib/path");
 const extensions_1 = require("../../constants/extensions");
 const standardErrors_1 = require("../../errors/standardErrors");
+const i18nKey = 'utils.cms.modules';
 const isBool = (x) => !!x === x;
 function isPathInput(pathInput) {
     return !!(pathInput &&
@@ -18,7 +19,7 @@ exports.isPathInput = isPathInput;
 function throwInvalidPathInput(pathInput) {
     if (isPathInput(pathInput))
         return;
-    (0, standardErrors_1.throwTypeErrorWithMessage)('modules.throwInvalidPathInput');
+    (0, standardErrors_1.throwTypeErrorWithMessage)(`${i18nKey}.throwInvalidPathInput`);
 }
 function isModuleFolder(pathInput) {
     throwInvalidPathInput(pathInput);

package/utils/detectPort.d.ts

@@ -0,0 +1 @@
+export declare function detectPort(port?: number | null, exclude?: Array<number>): Promise<number>;

package/utils/detectPort.js

@@ -0,0 +1,102 @@
+"use strict";
+/*
+From https://github.com/node-modules/detect-port/tree/master
+
+The MIT License (MIT)
+
+Copyright (c) 2014 - present node-modules and other contributors
+
+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.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPort = void 0;
+const net_1 = __importDefault(require("net"));
+const address_1 = require("address");
+const standardErrors_1 = require("../errors/standardErrors");
+const ports_1 = require("../constants/ports");
+const i18nKey = 'utils.detectPort';
+function detectPort(port, exclude = []) {
+    if (port && (port < ports_1.MIN_PORT_NUMBER || port > ports_1.MAX_PORT_NUMBER)) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidPort`, {
+            minPort: ports_1.MIN_PORT_NUMBER,
+            maxPort: ports_1.MAX_PORT_NUMBER,
+        });
+    }
+    const portToUse = port || 0;
+    const maxPort = Math.min(portToUse + 10, ports_1.MAX_PORT_NUMBER);
+    return new Promise(resolve => {
+        tryListen(portToUse, maxPort, exclude, (_, resolvedPort) => {
+            resolve(resolvedPort);
+        });
+    });
+}
+exports.detectPort = detectPort;
+function tryListen(port, maxPort, exclude, callback) {
+    const shouldGiveUp = port >= maxPort;
+    const nextPort = shouldGiveUp ? 0 : port + 1;
+    const nextMaxPort = shouldGiveUp ? 0 : maxPort;
+    listen(port, undefined, (err, realPort) => {
+        // ignore random listening
+        if (port === 0) {
+            return callback(err, realPort);
+        }
+        if (exclude.includes(port)) {
+            return tryListen(nextPort, nextMaxPort, exclude, callback);
+        }
+        if (err) {
+            return tryListen(nextPort, nextMaxPort, exclude, callback);
+        }
+        // 2. check 0.0.0.0
+        listen(port, '0.0.0.0', err => {
+            if (err) {
+                return tryListen(nextPort, nextMaxPort, exclude, callback);
+            }
+            // 3. check localhost
+            listen(port, 'localhost', err => {
+                if (err && err.code !== 'EADDRNOTAVAIL') {
+                    return tryListen(nextPort, nextMaxPort, exclude, callback);
+                }
+                // 4. check current ip
+                listen(port, (0, address_1.ip)(), (err, realPort) => {
+                    if (err) {
+                        return tryListen(nextPort, nextMaxPort, exclude, callback);
+                    }
+                    callback(null, realPort);
+                });
+            });
+        });
+    });
+}
+function listen(port, hostname, callback) {
+    const server = new net_1.default.Server();
+    server.on('error', (err) => {
+        server.close();
+        if (err.code === 'ENOTFOUND') {
+            return callback(null, port);
+        }
+        return callback(err, 0);
+    });
+    server.listen(port, hostname, () => {
+        const addressInfo = server.address();
+        server.close();
+        return callback(null, addressInfo.port);
+    });
+}