@hubspot/local-dev-lib 0.2.2 → 0.2.3-experimental.0

package/lib/hubdb.js

@@ -9,11 +9,11 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const prettier_1 = __importDefault(require("prettier"));
 const hubdb_1 = require("../api/hubdb");
 const path_2 = require("./path");
-const standardErrors_1 = require("../errors/standardErrors");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'lib.hubdb';
 function validateJsonPath(src) {
     if (path_1.default.extname(src) !== '.json') {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidJsonPath`);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonPath`));
     }
 }
 function validateJsonFile(src) {
@@ -22,10 +22,12 @@ function validateJsonFile(src) {
         stats = fs_extra_1.default.statSync(src);
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidJsonFile`, { src }, err);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonFile`, { src }), {
+            cause: err,
+        });
     }
     if (!stats.isFile()) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidJsonFile`, { src });
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidJsonFile`, { src }));
     }
     validateJsonPath(src);
 }
@@ -42,7 +44,7 @@ async function addRowsToHubDbTable(accountId, tableId, rows = []) {
     if (rowsToUpdate.length > 0) {
         await (0, hubdb_1.createRows)(accountId, tableId, rowsToUpdate);
     }
-    const { rowCount } = await (0, hubdb_1.publishTable)(accountId, tableId);
+    const { data: { rowCount }, } = await (0, hubdb_1.publishTable)(accountId, tableId);
     return {
         tableId,
         rowCount,
@@ -53,7 +55,7 @@ async function createHubDbTable(accountId, src) {
     validateJsonFile(src);
     const table = fs_extra_1.default.readJsonSync(src);
     const { rows, ...schema } = table;
-    const { id } = await (0, hubdb_1.createTable)(accountId, schema);
+    const { data: { id }, } = await (0, hubdb_1.createTable)(accountId, schema);
     return addRowsToHubDbTable(accountId, id, rows);
 }
 exports.createHubDbTable = createHubDbTable;
@@ -96,15 +98,15 @@ async function fetchAllRows(accountId, tableId) {
     let rows = [];
     let after = null;
     do {
-        const response = await (0, hubdb_1.fetchRows)(accountId, tableId, after ? { after } : undefined);
-        const { paging, results } = response;
+        const axiosResponse = await (0, hubdb_1.fetchRows)(accountId, tableId, after ? { after } : undefined);
+        const { paging, results } = axiosResponse.data;
         rows = rows.concat(results);
         after = paging && paging.next ? paging.next.after : null;
     } while (after !== null);
     return rows;
 }
 async function downloadHubDbTable(accountId, tableId, dest) {
-    const table = await (0, hubdb_1.fetchTable)(accountId, tableId);
+    const { data: table } = await (0, hubdb_1.fetchTable)(accountId, tableId);
     dest = path_1.default.resolve((0, path_2.getCwd)(), dest || `${table.name}.hubdb.json`);
     if (fs_extra_1.default.pathExistsSync(dest)) {
         validateJsonFile(dest);

package/{utils → lib}/notify.js

@@ -7,7 +7,7 @@ exports.triggerNotify = void 0;
 const fs_1 = __importDefault(require("fs"));
 const moment_1 = __importDefault(require("moment"));
 const debounce_1 = __importDefault(require("debounce"));
-const standardErrors_1 = require("../errors/standardErrors");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'utils.notify';
 const notifyQueue = [];
 const notifyPromises = [];
@@ -37,7 +37,7 @@ function notifyFilePath(filePathToNotify, outputToWrite) {
             fs_1.default.appendFileSync(filePathToNotify, outputToWrite);
         }
         catch (e) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.filePath`, { filePath: filePathToNotify }, e);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.filePath`, { filePath: filePathToNotify }), { cause: e });
         }
     }
 }

package/lib/oauth.d.ts

@@ -1,7 +1,4 @@
-import OAuth2Manager from '../models/OAuth2Manager';
+import { OAuth2Manager } from '../models/OAuth2Manager';
 import { FlatAccountFields } from '../types/Accounts';
-import { LogCallbacksArg } from '../types/LogCallbacks';
-declare const addOauthToAccountConfigCallbackKeys: readonly ["init", "success"];
 export declare function getOauthManager(accountId: number, accountConfig: FlatAccountFields): OAuth2Manager | undefined;
-export declare function addOauthToAccountConfig(oauth: OAuth2Manager, logCallbacks: LogCallbacksArg<typeof addOauthToAccountConfigCallbackKeys>): void;
-export {};
+export declare function addOauthToAccountConfig(oauth: OAuth2Manager): void;

package/lib/oauth.js

@@ -1,45 +1,34 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addOauthToAccountConfig = exports.getOauthManager = void 0;
-const OAuth2Manager_1 = __importDefault(require("../models/OAuth2Manager"));
+const OAuth2Manager_1 = require("../models/OAuth2Manager");
 const auth_1 = require("../constants/auth");
-const standardErrors_1 = require("../errors/standardErrors");
-const logger_1 = require("../utils/logger");
-const logger_2 = require("../utils/logger");
-const getAccountIdentifier_1 = require("../utils/getAccountIdentifier");
+const logger_1 = require("./logger");
+const getAccountIdentifier_1 = require("../config/getAccountIdentifier");
 const config_1 = require("../config");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'lib.oauth';
-const addOauthToAccountConfigCallbackKeys = ['init', 'success'];
 const oauthManagers = new Map();
 function writeOauthTokenInfo(accountConfig) {
     const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig);
-    (0, logger_1.debug)(`${i18nKey}.writeTokenInfo`, { portalId: accountId || '' });
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.writeTokenInfo`, { portalId: accountId || '' }));
     (0, config_1.updateAccountConfig)(accountConfig);
     (0, config_1.writeConfig)();
 }
 function getOauthManager(accountId, accountConfig) {
     if (!oauthManagers.has(accountId)) {
-        oauthManagers.set(accountId, OAuth2Manager_1.default.fromConfig(accountConfig, () => writeOauthTokenInfo(accountConfig)));
+        oauthManagers.set(accountId, OAuth2Manager_1.OAuth2Manager.fromConfig(accountConfig, () => writeOauthTokenInfo(accountConfig)));
     }
     return oauthManagers.get(accountId);
 }
 exports.getOauthManager = getOauthManager;
-function addOauthToAccountConfig(oauth, logCallbacks) {
-    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', `${i18nKey}.addOauthToAccountConfig.success`);
-    }
-    catch (err) {
-        (0, standardErrors_1.throwError)(err);
-    }
+function addOauthToAccountConfig(oauth) {
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.addOauthToAccountConfig.init`));
+    (0, config_1.updateAccountConfig)({
+        ...oauth.account,
+        authType: auth_1.AUTH_METHODS.oauth.value,
+    });
+    (0, config_1.writeConfig)();
+    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.addOauthToAccountConfig.success`));
 }
 exports.addOauthToAccountConfig = addOauthToAccountConfig;

package/lib/path.d.ts

@@ -9,3 +9,6 @@ export declare function getExt(filepath: string): string;
 export declare function getAllowedExtensions(allowList?: Array<string>): Set<string>;
 export declare function isAllowedExtension(filepath: string, allowList?: Array<string>): boolean;
 export declare function getAbsoluteFilePath(_path: string): string;
+export declare function sanitizeFileName(fileName: string): string;
+export declare function isValidPath(_path: string): boolean;
+export declare function untildify(pathWithTilde: string): string;

package/lib/path.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAbsoluteFilePath = exports.isAllowedExtension = exports.getAllowedExtensions = exports.getExt = exports.getCwd = exports.splitHubSpotPath = exports.splitLocalPath = exports.convertToLocalFileSystemPath = exports.convertToUnixPath = void 0;
+exports.untildify = exports.isValidPath = exports.sanitizeFileName = exports.getAbsoluteFilePath = exports.isAllowedExtension = exports.getAllowedExtensions = exports.getExt = exports.getCwd = exports.splitHubSpotPath = exports.splitLocalPath = exports.convertToLocalFileSystemPath = exports.convertToUnixPath = void 0;
 const path_1 = __importDefault(require("path"));
 const unixify_1 = __importDefault(require("unixify"));
 const extensions_1 = require("../constants/extensions");
+const os_1 = __importDefault(require("os"));
 function convertToUnixPath(_path) {
     return (0, unixify_1.default)(path_1.default.normalize(_path));
 }
@@ -87,3 +88,47 @@ function getAbsoluteFilePath(_path) {
     return path_1.default.resolve(getCwd(), _path);
 }
 exports.getAbsoluteFilePath = getAbsoluteFilePath;
+// Reserved names (Windows specific)
+const reservedNames = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
+// Based on the node-sanitize-filename package: https://github.com/parshap/node-sanitize-filename/blob/master/index.js
+function sanitizeFileName(fileName) {
+    // Windows invalid/control characters
+    // eslint-disable-next-line no-control-regex
+    const invalidChars = /[<>:"/|?*\x00-\x1F]/g;
+    //Replace invalid characters with dash
+    let sanitizedFileName = fileName.replace(invalidChars, '-');
+    // Removes trailing periods and spaces for Windows
+    sanitizedFileName = sanitizedFileName.replace(/[. ]+$/, '');
+    //Reserved names check for Windows
+    if (reservedNames.test(sanitizedFileName)) {
+        sanitizedFileName = `-${sanitizedFileName}`;
+    }
+    return sanitizedFileName;
+}
+exports.sanitizeFileName = sanitizeFileName;
+// Based on the node-sanitize-filename package: https://github.com/parshap/node-sanitize-filename/blob/master/index.js
+function isValidPath(_path) {
+    // Invalid characters excluding forward slash
+    // eslint-disable-next-line no-control-regex
+    const invalidChars = /[<>:"|?*\x00-\x1F]/;
+    const baseName = path_1.default.basename(_path);
+    if (invalidChars.test(baseName)) {
+        return false;
+    }
+    if (reservedNames.test(baseName)) {
+        return false;
+    }
+    return true;
+}
+exports.isValidPath = isValidPath;
+// Based on the untildify package: https://github.com/sindresorhus/untildify/blob/main/index.js
+function untildify(pathWithTilde) {
+    const homeDirectory = os_1.default.homedir();
+    if (typeof pathWithTilde !== 'string') {
+        throw new TypeError(`Expected a string, got ${typeof pathWithTilde}`);
+    }
+    return homeDirectory
+        ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory)
+        : pathWithTilde;
+}
+exports.untildify = untildify;

package/lib/personalAccessKey.d.ts

@@ -1,14 +1,11 @@
-import { CLIAccount } from '../types/Accounts';
+import { CLIAccount, ScopeGroupAuthorization } from '../types/Accounts';
 import { Environment } from '../types/Config';
-type AccessToken = {
-    portalId: number;
-    accessToken: string;
-    expiresAt: string;
-    scopeGroups: Array<string>;
-    encodedOAuthRefreshToken: string;
-    hubName: string;
-};
+import { AccessToken } from '../types/Accounts';
 export declare function getAccessToken(personalAccessKey: string, env?: Environment, accountId?: number): Promise<AccessToken>;
-export declare function accessTokenForPersonalAccessKey(accountId: number): Promise<string | undefined>;
+export declare function accessTokenForPersonalAccessKey(accountId: number, forceRefresh?: boolean): Promise<string | undefined>;
+export declare function enabledFeaturesForPersonalAccessKey(accountId: number): Promise<{
+    [key: string]: number;
+} | undefined>;
+export declare function scopesOnAccessToken(accountId: number): Promise<Array<string>>;
+export declare function authorizedScopesForPortalAndUser(accountId: number): Promise<Array<ScopeGroupAuthorization>>;
 export declare function updateConfigWithAccessToken(token: AccessToken, personalAccessKey: string, env?: Environment, name?: string, makeDefault?: boolean): Promise<CLIAccount | null>;
-export {};

package/lib/personalAccessKey.js

@@ -3,45 +3,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateConfigWithAccessToken = exports.accessTokenForPersonalAccessKey = exports.getAccessToken = void 0;
+exports.updateConfigWithAccessToken = exports.authorizedScopesForPortalAndUser = exports.scopesOnAccessToken = exports.enabledFeaturesForPersonalAccessKey = exports.accessTokenForPersonalAccessKey = exports.getAccessToken = void 0;
 const moment_1 = __importDefault(require("moment"));
 const environments_1 = require("../constants/environments");
 const auth_1 = require("../constants/auth");
-const standardErrors_1 = require("../errors/standardErrors");
 const localDevAuth_1 = require("../api/localDevAuth");
 const sandboxHubs_1 = require("../api/sandboxHubs");
 const config_1 = require("../config");
+const config_2 = require("../constants/config");
+const developerTestAccounts_1 = require("../api/developerTestAccounts");
+const logger_1 = require("./logger");
+const CLIConfiguration_1 = require("../config/CLIConfiguration");
+const lang_1 = require("../utils/lang");
+const errors_1 = require("../errors");
 const i18nKey = 'lib.personalAccessKey';
 const refreshRequests = new Map();
 function getRefreshKey(personalAccessKey, expiration) {
     return `${personalAccessKey}-${expiration || 'fresh'}`;
 }
 async function getAccessToken(personalAccessKey, env = environments_1.ENVIRONMENTS.PROD, accountId) {
-    let response;
-    try {
-        response = await (0, localDevAuth_1.fetchAccessToken)(personalAccessKey, env, accountId);
-    }
-    catch (e) {
-        const error = e;
-        if (error.response) {
-            (0, standardErrors_1.throwAuthErrorWithMessage)(`${i18nKey}.errors.invalidPersonalAccessKey`, { errorMessage: error.response.data.message || '' }, error);
-        }
-        else {
-            (0, standardErrors_1.throwError)(e);
-        }
-    }
+    const axiosResponse = await (0, localDevAuth_1.fetchAccessToken)(personalAccessKey, env, accountId);
+    const response = axiosResponse.data;
     return {
         portalId: response.hubId,
         accessToken: response.oauthAccessToken,
         expiresAt: (0, moment_1.default)(response.expiresAtMillis).toISOString(),
         scopeGroups: response.scopeGroups,
+        enabledFeatures: response.enabledFeatures,
         encodedOAuthRefreshToken: response.encodedOAuthRefreshToken,
         hubName: response.hubName,
+        accountType: response.accountType,
     };
 }
 exports.getAccessToken = getAccessToken;
 async function refreshAccessToken(personalAccessKey, env = environments_1.ENVIRONMENTS.PROD, accountId) {
-    const { accessToken, expiresAt } = await getAccessToken(personalAccessKey, env, accountId);
+    const accessTokenResponse = await getAccessToken(personalAccessKey, env, accountId);
+    const { accessToken, expiresAt } = accessTokenResponse;
     const config = (0, config_1.getAccountConfig)(accountId);
     (0, config_1.updateAccountConfig)({
         env,
@@ -53,20 +50,20 @@ async function refreshAccessToken(personalAccessKey, env = environments_1.ENVIRO
         },
     });
     (0, config_1.writeConfig)();
-    return accessToken;
+    return accessTokenResponse;
 }
 async function getNewAccessToken(accountId, personalAccessKey, expiresAt, env) {
     const key = getRefreshKey(personalAccessKey, expiresAt);
     if (refreshRequests.has(key)) {
         return refreshRequests.get(key);
     }
-    let accessToken;
+    let accessTokenResponse;
     try {
         const refreshAccessPromise = refreshAccessToken(personalAccessKey, env, accountId);
         if (key) {
             refreshRequests.set(key, refreshAccessPromise);
         }
-        accessToken = await refreshAccessPromise;
+        accessTokenResponse = await refreshAccessPromise;
     }
     catch (e) {
         if (key) {
@@ -74,57 +71,97 @@ async function getNewAccessToken(accountId, personalAccessKey, expiresAt, env) {
         }
         throw e;
     }
-    return accessToken;
+    return accessTokenResponse;
+}
+async function getNewAccessTokenByAccountId(accountId) {
+    const account = (0, config_1.getAccountConfig)(accountId);
+    if (!account) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.accountNotFound`, { accountId }));
+    }
+    const { auth, personalAccessKey, env } = account;
+    const accessTokenResponse = await getNewAccessToken(accountId, personalAccessKey, auth?.tokenInfo?.expiresAt, env);
+    return accessTokenResponse;
 }
-async function accessTokenForPersonalAccessKey(accountId) {
+async function accessTokenForPersonalAccessKey(accountId, forceRefresh = false) {
     const account = (0, config_1.getAccountConfig)(accountId);
     if (!account) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.accountNotFound`, { accountId });
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.accountNotFound`, { accountId }));
     }
     const { auth, personalAccessKey, env } = account;
     const authTokenInfo = auth && auth.tokenInfo;
     const authDataExists = authTokenInfo && auth?.tokenInfo?.accessToken;
     if (!authDataExists ||
+        forceRefresh ||
         (0, moment_1.default)().add(5, 'minutes').isAfter((0, moment_1.default)(authTokenInfo.expiresAt))) {
-        return getNewAccessToken(accountId, personalAccessKey, authTokenInfo && authTokenInfo.expiresAt, env);
+        return getNewAccessToken(accountId, personalAccessKey, authTokenInfo && authTokenInfo.expiresAt, env).then(tokenInfo => tokenInfo.accessToken);
     }
     return auth?.tokenInfo?.accessToken;
 }
 exports.accessTokenForPersonalAccessKey = accessTokenForPersonalAccessKey;
+async function enabledFeaturesForPersonalAccessKey(accountId) {
+    const accessTokenResponse = await getNewAccessTokenByAccountId(accountId);
+    return accessTokenResponse?.enabledFeatures;
+}
+exports.enabledFeaturesForPersonalAccessKey = enabledFeaturesForPersonalAccessKey;
+async function scopesOnAccessToken(accountId) {
+    return (await getNewAccessTokenByAccountId(accountId)).scopeGroups;
+}
+exports.scopesOnAccessToken = scopesOnAccessToken;
+async function authorizedScopesForPortalAndUser(accountId) {
+    return (await (0, localDevAuth_1.fetchScopeAuthorizationData)(accountId)).data.results;
+}
+exports.authorizedScopesForPortalAndUser = authorizedScopesForPortalAndUser;
 async function updateConfigWithAccessToken(token, personalAccessKey, env, name, makeDefault = false) {
-    const { portalId, accessToken, expiresAt } = token;
+    const { portalId, accessToken, expiresAt, accountType } = token;
     const accountEnv = env || (0, config_1.getEnv)(name);
-    let hubInfo;
+    let parentAccountId;
     try {
-        hubInfo = await (0, sandboxHubs_1.fetchSandboxHubData)(accessToken, portalId, accountEnv);
+        if (accountType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX ||
+            accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+            const { data: sandboxDataResponse } = await (0, sandboxHubs_1.fetchSandboxHubData)(accessToken, portalId, accountEnv);
+            if (sandboxDataResponse.parentHubId) {
+                parentAccountId = sandboxDataResponse.parentHubId;
+            }
+        }
     }
     catch (err) {
-        // Ignore error, returns 404 if account is not a sandbox
+        // Log error but do not throw
+        if ((0, errors_1.isHubSpotHttpError)(err)) {
+            logger_1.logger.debug(err.message);
+        }
+        logger_1.logger.debug(err);
     }
-    let sandboxAccountType = null;
-    let parentAccountId = null;
-    if (hubInfo) {
-        if (hubInfo.type !== undefined) {
-            sandboxAccountType = hubInfo.type === null ? 'STANDARD' : hubInfo.type;
+    try {
+        if (accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST) {
+            const { data: developerTestAccountResponse } = await (0, developerTestAccounts_1.fetchDeveloperTestAccountData)(accessToken, portalId, accountEnv);
+            if (developerTestAccountResponse) {
+                parentAccountId = developerTestAccountResponse.parentPortalId;
+            }
         }
-        if (hubInfo.parentHubId) {
-            parentAccountId = hubInfo.parentHubId;
+    }
+    catch (err) {
+        // Log error but do not throw
+        if ((0, errors_1.isHubSpotHttpError)(err)) {
+            logger_1.logger.debug(err.message);
         }
+        logger_1.logger.debug(err);
     }
-    const updatedConfig = (0, config_1.updateAccountConfig)({
+    const updatedAccount = (0, config_1.updateAccountConfig)({
         accountId: portalId,
+        accountType,
         personalAccessKey,
         name,
         authType: auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
         tokenInfo: { accessToken, expiresAt },
-        sandboxAccountType,
         parentAccountId,
         env: accountEnv,
     });
-    (0, config_1.writeConfig)();
+    if (!CLIConfiguration_1.CLIConfiguration.isActive()) {
+        (0, config_1.writeConfig)();
+    }
     if (makeDefault && name) {
         (0, config_1.updateDefaultAccount)(name);
     }
-    return updatedConfig;
+    return updatedAccount;
 }
 exports.updateConfigWithAccessToken = updateConfigWithAccessToken;

package/lib/portManager.d.ts

@@ -1,13 +1,11 @@
+import { RequestPortsData } from '../types/PortManager';
 export declare const BASE_URL: string;
+export declare function isPortManagerPortAvailable(): Promise<boolean>;
+export declare function isPortManagerServerRunning(): Promise<boolean>;
 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

@@ -3,20 +3,32 @@ 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;
+exports.portManagerHasActiveServers = exports.deleteServerInstance = exports.requestPorts = exports.stopPortManagerServer = exports.startPortManagerServer = exports.isPortManagerServerRunning = exports.isPortManagerPortAvailable = 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 PortManagerServer_1 = require("../utils/PortManagerServer");
 const ports_1 = require("../constants/ports");
+const detectPort_1 = require("../utils/detectPort");
+const logger_1 = require("./logger");
 exports.BASE_URL = `http://localhost:${ports_1.PORT_MANAGER_SERVER_PORT}`;
+async function isPortManagerPortAvailable() {
+    return ((await (0, detectPort_1.detectPort)(ports_1.PORT_MANAGER_SERVER_PORT)) === ports_1.PORT_MANAGER_SERVER_PORT);
+}
+exports.isPortManagerPortAvailable = isPortManagerPortAvailable;
 async function isPortManagerServerRunning() {
-    const port = await (0, detectPort_1.detectPort)(ports_1.PORT_MANAGER_SERVER_PORT);
-    return port !== ports_1.PORT_MANAGER_SERVER_PORT;
+    try {
+        const { data } = await axios_1.default.get(`${exports.BASE_URL}${PortManagerServer_1.HEALTH_CHECK_PATH}`);
+        return data.status === PortManagerServer_1.SERVICE_HEALTHY;
+    }
+    catch (e) {
+        logger_1.logger.debug(e);
+        return false;
+    }
 }
+exports.isPortManagerServerRunning = isPortManagerServerRunning;
 async function startPortManagerServer() {
     const isRunning = await isPortManagerServerRunning();
     if (!isRunning) {
-        await PortManagerServer_1.default.init();
+        await PortManagerServer_1.PortManagerServer.init();
     }
 }
 exports.startPortManagerServer = startPortManagerServer;

package/lib/trackUsage.js

@@ -6,10 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.trackUsage = void 0;
 const axios_1 = __importDefault(require("axios"));
 const getAxiosConfig_1 = require("../http/getAxiosConfig");
-const logger_1 = require("../utils/logger");
-const http_1 = __importDefault(require("../http"));
+const logger_1 = require("./logger");
+const http_1 = require("../http");
 const config_1 = require("../config");
 const fileMapper_1 = require("../api/fileMapper");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'lib.trackUsage';
 async function trackUsage(eventName, eventClass, meta = {}, accountId) {
     const usageEvent = {
@@ -31,17 +32,23 @@ async function trackUsage(eventName, eventClass, meta = {}, accountId) {
             analyticsEndpoint = 'vscode-extension-usage';
             break;
         default:
-            (0, logger_1.debug)(`${i18nKey}.invalidEvent`, { eventName });
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.invalidEvent`, { eventName }));
     }
     const path = `${fileMapper_1.FILE_MAPPER_API_PATH}/${analyticsEndpoint}`;
     const accountConfig = accountId && (0, config_1.getAccountConfig)(accountId);
     if (accountConfig && accountConfig.authType === 'personalaccesskey') {
-        (0, logger_1.debug)(`${i18nKey}.sendingEventAuthenticated`);
-        return http_1.default.post(accountId, {
-            url: `${path}/authenticated`,
-            data: usageEvent,
-            resolveWithFullResponse: true,
-        });
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.sendingEventAuthenticated`));
+        try {
+            await http_1.http.post(accountId, {
+                url: `${path}/authenticated`,
+                data: usageEvent,
+                resolveWithFullResponse: true,
+            });
+            return;
+        }
+        catch (e) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.retryingEventUnauthenticated`));
+        }
     }
     const env = (0, config_1.getEnv)(accountId);
     const axiosConfig = (0, getAxiosConfig_1.getAxiosConfig)({
@@ -50,7 +57,7 @@ async function trackUsage(eventName, eventClass, meta = {}, accountId) {
         data: usageEvent,
         resolveWithFullResponse: true,
     });
-    (0, logger_1.debug)(`${i18nKey}.sendingEventUnauthenticated`);
-    (0, axios_1.default)({ ...axiosConfig, method: 'post' });
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.sendingEventUnauthenticated`));
+    return (0, axios_1.default)({ ...axiosConfig, method: 'post' });
 }
 exports.trackUsage = trackUsage;

package/lib/urls.js

@@ -11,7 +11,11 @@ function getEnvUrlString(env) {
 const getHubSpotWebsiteOrigin = (env) => `https://app.hubspot${getEnvUrlString(env)}.com`;
 exports.getHubSpotWebsiteOrigin = getHubSpotWebsiteOrigin;
 function getHubSpotApiOrigin(env, useLocalHost) {
-    let domain = process.env.HUBAPI_DOMAIN_OVERRIDE;
+    let domain;
+    const domainOverride = process.env.HUBAPI_DOMAIN_OVERRIDE;
+    if (domainOverride && typeof domainOverride === 'string') {
+        domain = `${domainOverride}${getEnvUrlString(env)}`;
+    }
     if (!domain || typeof domain !== 'string') {
         domain = `${useLocalHost ? 'local' : 'api'}.hubapi${getEnvUrlString(env)}`;
     }

package/models/FileSystemError.d.ts

@@ -0,0 +1,6 @@
+import { FileSystemErrorContext } from '../types/Error';
+export declare class FileSystemError extends Error {
+    private context;
+    constructor(options?: ErrorOptions, context?: FileSystemErrorContext);
+    toString(): string;
+}

package/models/FileSystemError.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemError = void 0;
+const lang_1 = require("../utils/lang");
+const errors_1 = require("../errors");
+const i18nKey = 'errors.fileSystemErrors';
+class FileSystemError extends Error {
+    context;
+    constructor(options, context) {
+        super('', options);
+        this.name = 'FileSystemError';
+        this.context = context;
+        if (context) {
+            let fileAction = '';
+            if (context.operation === 'read') {
+                fileAction = (0, lang_1.i18n)(`${i18nKey}.readAction`);
+            }
+            else if (context.operation === 'write') {
+                fileAction = (0, lang_1.i18n)(`${i18nKey}.writeAction`);
+            }
+            else {
+                fileAction = (0, lang_1.i18n)(`${i18nKey}.otherAction`);
+            }
+            const filepath = context.filepath
+                ? `"${context.filepath}"`
+                : (0, lang_1.i18n)(`${i18nKey}.unknownFilepath`);
+            const messages = [
+                (0, lang_1.i18n)(`${i18nKey}.baseMessage`, { fileAction, filepath }),
+            ];
+            // Many `fs` errors will be `SystemError`s
+            if ((0, errors_1.isSystemError)(options?.cause)) {
+                messages.push((0, lang_1.i18n)(`${i18nKey}.baseMessage`, {
+                    errorMessage: options?.cause?.message || '',
+                }));
+            }
+            this.message = messages.join(' ');
+        }
+    }
+    toString() {
+        let baseString = `${this.name}: ${this.message}`;
+        if (this.context) {
+            baseString = `${baseString} context: ${this.context}`;
+        }
+        return baseString;
+    }
+}
+exports.FileSystemError = FileSystemError;