@hubspot/local-dev-lib 0.0.7 → 0.0.9

package/errors/apiErrors.d.ts

@@ -4,7 +4,7 @@ export declare function isApiStatusCodeError(err: GenericError): boolean;
 export declare function isMissingScopeError(err: GenericError): boolean;
 export declare function isGatingError(err: GenericError): boolean;
 export declare function isApiUploadValidationError(err: GenericError): boolean;
-export declare function isSpecifiedHubSpotAuthError(err: GenericError, { statusCode, category, subCategory }: Partial<HubSpotAuthError>): boolean;
+export declare function isSpecifiedHubSpotAuthError(err: GenericError, { status, category, subCategory }: Partial<HubSpotAuthError>): boolean;
 /**
  * @throws
  */

package/errors/apiErrors.js

@@ -4,35 +4,36 @@ exports.throwApiUploadError = exports.throwApiError = exports.throwApiStatusCode
 const api_1 = require("../constants/api");
 const lang_1 = require("../utils/lang");
 const standardErrors_1 = require("./standardErrors");
+const i18nKey = 'errors.apiErrors';
 function isApiStatusCodeError(err) {
     return (err.name === 'StatusCodeError' ||
-        (!!err.statusCode && err.statusCode >= 100 && err.statusCode < 600));
+        (!!err.status && err.status >= 100 && err.status < 600));
 }
 exports.isApiStatusCodeError = isApiStatusCodeError;
 function isMissingScopeError(err) {
     return (isApiStatusCodeError(err) &&
-        err.statusCode === 403 &&
+        err.status === 403 &&
         !!err.error &&
         err.error.category === 'MISSING_SCOPES');
 }
 exports.isMissingScopeError = isMissingScopeError;
 function isGatingError(err) {
     return (isApiStatusCodeError(err) &&
-        err.statusCode === 403 &&
+        err.status === 403 &&
         !!err.error &&
         err.error.category === 'GATED');
 }
 exports.isGatingError = isGatingError;
 function isApiUploadValidationError(err) {
     return (isApiStatusCodeError(err) &&
-        err.statusCode === 400 &&
+        err.status === 400 &&
         !!err.response &&
         !!err.response.body &&
         !!(err.response.body.message || !!err.response.body.errors));
 }
 exports.isApiUploadValidationError = isApiUploadValidationError;
-function isSpecifiedHubSpotAuthError(err, { statusCode, category, subCategory }) {
-    const statusCodeErr = !statusCode || err.statusCode === statusCode;
+function isSpecifiedHubSpotAuthError(err, { status, category, subCategory }) {
+    const statusCodeErr = !status || err.status === status;
     const categoryErr = !category || err.category === category;
     const subCategoryErr = !subCategory || err.subCategory === subCategory;
     return Boolean(err.name === 'HubSpotAuthError' &&
@@ -70,9 +71,9 @@ function logValidationErrors(error) {
  * @throws
  */
 function throwStatusCodeError(error, context = {}) {
-    const { statusCode, message, response } = error;
+    const { status, message, response } = error;
     const errorData = JSON.stringify({
-        statusCode,
+        status,
         message,
         url: response ? response.request.href : null,
         method: response ? response.request.method : null,
@@ -87,8 +88,7 @@ exports.throwStatusCodeError = throwStatusCodeError;
  * @throws
  */
 function throwApiStatusCodeError(error, context = {}) {
-    const i18nKey = 'errors.errorTypes.api';
-    const { statusCode } = error;
+    const { status } = error;
     const { method } = error.options || {};
     const { projectName } = context;
     const isPutOrPost = method === 'PUT' || method === 'POST';
@@ -110,7 +110,7 @@ function throwApiStatusCodeError(error, context = {}) {
     }
     const isProjectMissingScopeError = isMissingScopeError(error) && projectName;
     const isProjectGatingError = isGatingError(error) && projectName;
-    switch (statusCode) {
+    switch (status) {
         case 400:
             errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.400`, { messageDetail }));
             break;
@@ -151,10 +151,10 @@ function throwApiStatusCodeError(error, context = {}) {
             errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.503`, { messageDetail }));
             break;
         default:
-            if (statusCode && statusCode >= 500 && statusCode < 600) {
+            if (status && status >= 500 && status < 600) {
                 errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.500Generic`, { messageDetail }));
             }
-            else if (statusCode && statusCode >= 400 && statusCode < 500) {
+            else if (status && status >= 400 && status < 500) {
                 errorMessage.push((0, lang_1.i18n)(`${i18nKey}.codes.400Generic`, { messageDetail }));
             }
             else {

package/errors/errors_DEPRECATED.js

@@ -6,9 +6,9 @@ function isSystemError(err) {
 }
 function debugErrorAndContext(error, context) {
     if (error.name === 'StatusCodeError') {
-        const { statusCode, message, response } = error;
+        const { status, message, response } = error;
         console.debug('Error: %o', {
-            statusCode,
+            status,
             message,
             url: response.request.href,
             method: response.request.method,

package/errors/fileSystemErrors.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.throwFileSystemError = void 0;
 const lang_1 = require("../utils/lang");
 const standardErrors_1 = require("./standardErrors");
-const i18nKey = 'errors.errorTypes.fileSystem';
+const i18nKey = 'errors.fileSystemErrors';
 function throwFileSystemError(error, context) {
     let fileAction = '';
     if (context.read) {

package/errors/standardErrors.d.ts

@@ -1,22 +1,23 @@
 import { BaseError, StatusCodeError } from '../types/Error';
+import { LangKey } from '../types/Lang';
 export declare function isSystemError(err: BaseError): boolean;
 export declare function isFatalError(err: BaseError): boolean;
 /**
  * @throws
  */
-export declare function throwErrorWithMessage(identifier: string, interpolation?: {
+export declare function throwErrorWithMessage(identifier: LangKey, interpolation?: {
     [key: string]: string | number;
 }, cause?: BaseError): never;
 /**
  * @throws
  */
-export declare function throwTypeErrorWithMessage(identifier: string, interpolation?: {
+export declare function throwTypeErrorWithMessage(identifier: LangKey, interpolation?: {
     [key: string]: string | number;
 }, cause?: BaseError): never;
 /**
  * @throws
  */
-export declare function throwAuthErrorWithMessage(identifier: string, interpolation?: {
+export declare function throwAuthErrorWithMessage(identifier: LangKey, interpolation?: {
     [key: string]: string | number;
 }, cause?: StatusCodeError): never;
 /**

package/errors/standardErrors.js

@@ -13,7 +13,7 @@ function isFatalError(err) {
 }
 exports.isFatalError = isFatalError;
 function genericThrowErrorWithMessage(ErrorType, identifier, interpolation, cause) {
-    const message = (0, lang_1.i18n)(`errors.${identifier}`, interpolation);
+    const message = (0, lang_1.i18n)(identifier, interpolation);
     if (cause) {
         throw new ErrorType(message, { cause });
     }
@@ -52,7 +52,7 @@ function throwError(error) {
     else {
         // Error or Error subclass
         const name = error.name || 'Error';
-        const message = [(0, lang_1.i18n)('errors.errorTypes.generic', { name })];
+        const message = [(0, lang_1.i18n)('errors.generic', { name })];
         [error.message, error.reason].forEach(msg => {
             if (msg) {
                 message.push(msg);

package/http/index.js

@@ -13,11 +13,12 @@ const oauth_1 = require("../lib/oauth");
 const standardErrors_1 = require("../errors/standardErrors");
 const logger_1 = require("../utils/logger");
 const axios_1 = __importDefault(require("axios"));
+const i18nKey = 'http.index';
 async function withOauth(accountId, accountConfig, axiosConfig) {
     const { headers } = axiosConfig;
     const oauth = (0, oauth_1.getOauthManager)(accountId, accountConfig);
     if (!oauth) {
-        (0, standardErrors_1.throwErrorWithMessage)('http.index.withOauth', { accountId });
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.withOauth`, { accountId });
     }
     const accessToken = await oauth.accessToken();
     return {
@@ -52,7 +53,7 @@ function withPortalId(portalId, axiosConfig) {
 async function withAuth(accountId, options) {
     const accountConfig = (0, config_1.getAccountConfig)(accountId);
     if (!accountConfig) {
-        (0, standardErrors_1.throwErrorWithMessage)('http.index.withAuth', { accountId });
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.withAuth`, { accountId });
     }
     const { env, authType, apiKey } = accountConfig;
     const axiosConfig = withPortalId(accountId, (0, getAxiosConfig_1.getAxiosConfig)({ env, ...options }));
@@ -113,12 +114,13 @@ function createGetRequestStream(contentType) {
     return async (accountId, options, destPath, logCallbacks) => {
         const { query, ...rest } = options;
         const axiosConfig = addQueryParams(rest, query);
-        const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'http.index.createGetRequestStream');
+        const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
         // eslint-disable-next-line no-async-promise-executor
         return new Promise(async (resolve, reject) => {
             try {
                 const { headers, ...opts } = await withAuth(accountId, axiosConfig);
                 const res = await (0, axios_1.default)({
+                    method: 'get',
                     ...opts,
                     headers: {
                         ...headers,
@@ -149,7 +151,9 @@ function createGetRequestStream(contentType) {
                         reject(err);
                     });
                     writeStream.on('close', async () => {
-                        logger('onWrite', { filepath });
+                        logger('onWrite', `${i18nKey}.createGetRequestStream.onWrite`, {
+                            filepath,
+                        });
                         resolve(res);
                     });
                 }

package/lang/en.json

@@ -0,0 +1,383 @@
+{
+    "lib": {
+        "trackUsage": {
+            "invalidEvent": "Usage tracking event {{ eventName }} is not a valid event type.",
+            "sendingEventAuthenticated": "Sending usage event to authenticated endpoint",
+            "sendingEventUnauthenticated": "Sending usage event to unauthenticated endpoint"
+        },
+        "archive": {
+            "extractZip": {
+                "init": "Extracting project source...",
+                "success": "Completed project source extraction.",
+                "errors": {
+                    "write": "An error occured writing temp project source.",
+                    "extract": "An error occured extracting project source."
+                }
+            },
+            "copySourceToDest": {
+                "init": "Copying project source...",
+                "sourceEmpty": "Project source is empty",
+                "success": "Completed copying project source.",
+                "error": "An error occured copying project source to {{ dest }}."
+            },
+            "cleanupTempDir": {
+                "error": "Failed to clean up temp dir: {{ tmpDir }}"
+            }
+        },
+        "gitignore": {
+            "errors": {
+                "configIgnore": "Unable to determine if config file is properly ignored by git."
+            }
+        },
+        "github": {
+            "fetchJsonFromRepository": {
+                "fetching": "Fetching {{ url }}...",
+                "errors": {
+                    "fetchFail": "An error occured fetching JSON file."
+                }
+            },
+            "fetchReleaseData": {
+                "errors": {
+                    "fetchFail": "Failed fetching release data for {{ tag }} project."
+                }
+            },
+            "downloadGithubRepoZip": {
+                "fetching": "Fetching {{ releaseType }} with name {{ repoName }}...",
+                "fetchingName": "Fetching {{ name }}...",
+                "completed": "Completed project fetch.",
+                "errors": {
+                    "fetchFail": "An error occurred fetching the project source."
+                }
+            },
+            "cloneGithubRepo": {
+                "success": "Your new {{ type }} has been created in {{ dest }}"
+            },
+            "downloadGithubRepoContents": {
+                "downloading": "Downloading content piece: {{ contentPiecePath }} from {{ downloadUrl }} to {{ downloadPath }}",
+                "errors": {
+                    "fetchFail": "Failed to fetch contents: {{ errorMessage }}"
+                }
+            }
+        },
+        "hubdb": {
+            "errors": {
+                "invalidJsonPath": "The HubDB table file must be a '.json' file",
+                "invalidJsonFile": "The '{{{ src }}' path is not a path to a file"
+            }
+        },
+        "personalAccessKey": {
+            "errors": {
+                "accountNotFound": "Account with id {{ accountId }} does not exist.",
+                "invalidPersonalAccessKey": "Error while retrieving new access token: {{ errorMessage }}"
+            }
+        },
+        "sandboxes": {
+            "errors": {
+                "createSandbox": "There was an error creating your sandbox.",
+                "deleteSandbox": "There was an error deleting your sandbox.",
+                "getSandboxUsageLimits": "There was an error fetching sandbox usage limits.",
+                "initiateSync": "There was an error initiating the sandbox sync.",
+                "fetchTaskStatus": "There was an error fetching the task status while syncing sandboxes.",
+                "fetchTypes": "There was an error fetching sandbox types."
+            }
+        },
+        "cms": {
+            "modules": {
+                "createModule": {
+                    "creatingModule": "Creating module at {{ path }}",
+                    "creatingPath": "Creating {{ path }}",
+                    "errors": {
+                        "writeModuleMeta": "The {{ path }} path already exists"
+                    }
+                }
+            },
+            "functions": {
+                "updateExistingConfig": {
+                    "unableToReadFile": "The file {{ configFilePath }} could not be read",
+                    "invalidJSON": "The file {{ configFilePath }} is not valid JSON",
+                    "couldNotUpdateFile": "The file {{ configFilePath }} could not be updated",
+                    "errors": {
+                        "configIsNotObjectError": "The existing {{ configFilePath }} is not an object",
+                        "endpointAreadyExistsError": "The endpoint {{ endpointPath }} already exists in {{ configFilePath }}"
+                    }
+                },
+                "createFunction": {
+                    "destPathAlreadyExists": "The {{ path }} path already exists",
+                    "createdDest": "Created {{ path }}",
+                    "failedToCreateFile": "The file {{ configFilePath }} could not be created",
+                    "createdFunctionFile": "Created {{ path }}",
+                    "createdConfigFile": "Created {{ path }}",
+                    "success": "A function for the endpoint '/_hcms/api/{{ endpointPath }}' has been created. Upload {{ folderName }} to try it out",
+                    "errors": {
+                        "nestedConfigError": "Cannot create a functions directory inside '{{ ancestorConfigPath }}'",
+                        "jsFileConflictError": "The JavaScript file at '{{ functionFilePath }}'' already exists"
+                    }
+                }
+            },
+            "handleFieldsJs": {
+                "convertFieldsJs": {
+                    "creating": "Creating child process with pid {{ pid }}",
+                    "terminating": "Child process with pid {{ pid }} has been terminated",
+                    "errors": {
+                        "errorConverting": "There was an error converting '{{ filePath }}'"
+                    }
+                },
+                "saveOutput": {
+                    "errors": {
+                        "saveFailed": "There was an error saving the json output of {{ path }}"
+                    }
+                },
+                "createTmpDirSync": {
+                    "errors": {
+                        "writeFailed": "An error occured writing temporary project source."
+                    }
+                },
+                "cleanupTmpDirSync": {
+                    "errors": {
+                        "deleteFailed": "There was an error deleting the temporary project source"
+                    }
+                }
+            },
+            "uploadFolder": {
+                "uploadFolder": {
+                    "success": "Uploaded file \"{{ file}}\" to \"{{ destPath }}\"",
+                    "attempt": "Attempting to upload file \"{{ file }}\" to \"{{ destPath }}\"",
+                    "failed": "Uploading file \"{{ file }}\" to \"{{ destPath }}\" failed so scheduled retry",
+                    "retry": "Retrying to upload file \"{{ file }}\" to \"{{ destPath }}\"",
+                    "retryFailed": "Uploading file \"{{ file }}\" to \"{{ destPath }}\" failed"
+                }
+            },
+            "templates": {
+                "createTemplate": {
+                    "creatingFile": "Creating file at {{ path }}",
+                    "creatingPath": "Making {{ path }} if needed",
+                    "errors": {
+                        "pathExists": "The {{ path }} path already exists"
+                    }
+                }
+            },
+            "processFieldsJs": {
+                "converting": "Converting \"{{ src }}\" to \"{{ dest }}\".",
+                "converted": "Finished converting \"{{ src }}\" to \"{{ dest }}\".",
+                "errors": {
+                    "invalidMjsFile": ".mjs files are only supported when using Node 13.2.0+",
+                    "notFunction": "There was an error loading JS file \"{{ path }}\". Expected type \"Function\" but received type \"{{ returned }}\". Make sure that your default export is a function.",
+                    "notArray": "There was an error loading JS file \"{{ path }}\". Expected type \"Array\" but received type \"{{ returned }}\" . Make sure that your function returns an array"
+                }
+            },
+            "watch": {
+                "notifyOfThemePreview": "To preview this theme, visit: {{ previewUrl }}",
+                "skipUnsupportedExtension": "Skipping {{ file }} due to unsupported extension",
+                "skipIgnoreRule": "Skipping {{ file }} due to an ignore rule",
+                "uploadAttempt": "Attempting to upload file \"{{ file }}\" to \"{{ dest }}\"",
+                "uploadSuccess": "Uploaded file {{ file }} to {{ dest }}",
+                "uploadFailed": "Uploading file {{ file }} to {{ dest }} failed",
+                "uploadRetry": "Retrying to upload file \"{{ file }}\" to \"{{ dest }}\"",
+                "deleteAttempt": "Attempting to delete file {{ remoteFilePath }}",
+                "deleteAttemptWithType": "Attempting to delete {{ type }} {{ remoteFilePath }}",
+                "deleteSuccess": "Deleted file {{ remoteFilePath }}",
+                "deleteSuccessWithType": "Deleted {{ type }} {{ remoteFilePath }}",
+                "deleteFailed": "Deleting file {{ remoteFilePath }} failed",
+                "folderUploadSuccess": "Completed uploading files in {{ src }} to {{ dest }} in {{ accountId }}",
+                "ready": "Watcher is ready and watching {{ src }}. Any changes detected will be automatically uploaded and overwrite the current version in the developer file system."
+            }
+        },
+        "logging": {
+            "git": {
+                "securityIssue": "Security Issue Detected",
+                "configFileTracked": "The HubSpot config file can be tracked by git.",
+                "fileName": "File: \"{{ configPath }}\"",
+                "remediate": "To remediate:",
+                "moveConfig": "- Move the config file to your home directory: '{{ homeDir }}'",
+                "addGitignore": "- Add gitignore pattern '{{ configPath }}' to a .gitignore file in root of your repository.",
+                "noRemote": "- Ensure that the config file has not already been pushed to a remote repository.",
+                "checkFailed": "Unable to determine if config file is properly ignored by git."
+            },
+            "logs": {
+                "unableToProcessLog": "Unable to process log {{ log }}"
+            }
+        },
+        "oauth": {
+            "writeTokenInfo": "Updating Oauth2 token info for portalId: {{ portalId }}",
+            "addOauthToAccountConfig": {
+                "init": "Updating configuration",
+                "success": "Configuration updated"
+            }
+        },
+        "fileMapper": {
+            "skippedExisting": "Skipped existing {{ filepath }}",
+            "wroteFolder": "Wrote folder {{ filepath }}",
+            "completedFetch": "Completed fetch of file \"{{ src }}\"{{ version }} to \"{{ dest }}\" from the Design Manager",
+            "folderFetch": "Fetched \"{{ src }}\" from account {{ accountId }} from the Design Manager successfully",
+            "completedFolderFetch": "Completed fetch of folder \"{{ src }}\"{{ version }} to \"{{ dest }}\" from the Design Manager",
+            "errors": {
+                "invalidRequest": "Invalid request for file: {{ src }}",
+                "invalidNode": "Invalid FileMapperNode: {{ json }}",
+                "invalidFileType": "Invalid file type requested: {{ srcPath }}",
+                "assetTimeout": "HubSpot assets are unavailable at the moment. Please wait a few minutes and try again.",
+                "failedToFetchFile": "Failed fetch of file \"{{ src }}\" to \"{{ dest }}\" from the Design Manager",
+                "failedToFetchFolder": "Failed fetch of folder \"{{ src }}\" to \"{{ dest }}\" from the Design Manager",
+                "invalidFetchFolderRequest": "Invalid request for folder: \"{{ src }}\"",
+                "incompleteFetch": "Not all files in folder \"{{ src }}\" were successfully fetched.  Re-run the last command to try again"
+            }
+        }
+    },
+    "config": {
+        "cliConfiguration": {
+            "errors": {
+                "noConfigLoaded": "No config loaded."
+            },
+            "load": {
+                "configFromEnv": "Loaded config from environment variables for {{ accountId }}",
+                "configFromFile": "Loaded config from configuration file.",
+                "empty": "The config file was empty. Initializing an empty config."
+            },
+            "validate": {
+                "noConfig": "Valiation failed: No config was found.",
+                "noConfigAccounts": "Valiation failed: config.accounts[] is not defined.",
+                "emptyAccountConfig": "Valiation failed: config.accounts[] has an empty entry.",
+                "noAccountId": "Valiation failed: config.accounts[] has an entry missing accountId.",
+                "duplicateAccountIds": "Valiation failed: config.accounts[] has multiple entries with {{ accountId }}.",
+                "duplicateAccountNames": "Valiation failed: config.accounts[] has multiple entries with {{ accountName }}.",
+                "nameContainsSpaces": "Valiation failed: config.name {{ accountName }} cannot contain spaces."
+            },
+            "updateAccount": {
+                "noConfigToUpdate": "No config to update.",
+                "updating": "Updating account config for {{ accountId }}",
+                "addingConfigEntry": "Adding account config entry for {{ accountId }}",
+                "errors": {
+                    "accountIdRequired": "An accountId is required to update the config"
+                }
+            },
+            "updateDefaultAccount": {
+                "errors": {
+                    "invalidInput": "A 'defaultAccount' with value of number or string is required to update the config."
+                }
+            },
+            "renameAccount": {
+                "errors": {
+                    "invalidName": "Cannot find account with identifier {{ currentName }}"
+                }
+            },
+            "removeAccountFromConfig": {
+                "deleting": "Deleting config for {{ accountId }}",
+                "errors": {
+                    "invalidId": "Unable to find account for {{ nameOrId }}."
+                }
+            },
+            "updateDefaultMode": {
+                "errors": {
+                    "invalidMode": "The mode {{ defaultMode }} is invalid. Valid values are {{ validModes }}."
+                }
+            },
+            "updateHttpTimeout": {
+                "errors": {
+                    "invalidTimeout": "The value {{ timeout }} is invalid. The value must be a number greater than {{ minTimeout }}."
+                }
+            },
+            "updateAllowUsageTracking": {
+                "errors": {
+                    "invalidInput": "Unable to update allowUsageTracking. The value {{ isEnabled }} is invalid. The value must be a boolean."
+                }
+            }
+        },
+        "configFile": {
+            "errorReading": "Config file could not be read: {{ configPath }}",
+            "writeSuccess": "Successfully wrote updated config data to {{ configPath }}",
+            "errorLoading": "A configuration file could not be found at {{ configPath }}.",
+            "errors": {
+                "parsing": "Config file could not be parsed"
+            }
+        },
+        "configUtils": {
+            "unknownType": "Unknown auth type {{ type }}"
+        },
+        "environment": {
+            "loadConfig": {
+                "missingAccountId": "Unable to load config from environment variables: Missing accountId",
+                "missingEnv": "Unable to load config from environment variables: Missing env",
+                "unknownAuthType": "Unable to load config from environment variables: Unknown auth type"
+            }
+        }
+    },
+    "models": {
+        "OAuth2Manager": {
+            "fetchingAccessToken": "Fetching access token for accountId {{ accountId }} for clientId {{ clientId }}",
+            "updatingTokenInfo": "Persisting updated tokenInfo for accountId {{ accountId }} for clientId {{ clientId }}",
+            "refreshingAccessToken": "Waiting for access token for accountId {{ accountId }}  for clientId {{ clientId }} to be fetched",
+            "errors": {
+                "missingRefreshToken": "The account {{ accountId }} has not been authenticated with Oauth2",
+                "auth": "Error while retrieving new token: {{ token }}"
+            }
+        }
+    },
+    "utils": {
+        "notify": {
+            "errors": {
+                "filePath": "Unable to notify file '{{ filePath }}'"
+            }
+        },
+        "cms": {
+            "modules": {
+                "throwInvalidPathInput": "Expected Path Input"
+            }
+        },
+        "detectPort": {
+            "errors": {
+                "invalidPort": "Port must be between {{ minPort }} and {{ maxPort }}"
+            }
+        },
+        "PortManagerServer": {
+            "started": "PortManagerServer running on port {{ port }}",
+            "setPort": "Server with instanceId {{ instanceId }} assigned to port {{ port }}",
+            "deletedPort": "Server with instanceId {{ instanceId }} unassigned from port {{ port }}",
+            "close": "PortManagerServer shutting down.",
+            "errors": {
+                "portInUse": "Failed to start PortManagerServer. Port {{ port }} is already in use.",
+                "duplicateInstance": "Failed to start PortManagerServer. An instance of PortManagerServer is already running.",
+                "404": "Could not find a server with instanceId {{ instanceId }}",
+                "409": "Failed to assign port. Server with instanceId {{ instanceId }} is already running on port {{ port }}",
+                "400": "Invalid port requested. Port must be between {{ minPort }} and {{ maxPort }}."
+            }
+        }
+    },
+    "http": {
+        "index": {
+            "createGetRequestStream": {
+                "onWrite": "Wrote file {{ filepath }}"
+            },
+            "errors": {
+                "withOauth": "Oauth manager for account {{ accountId }} not found.",
+                "withAuth": "Account with id {{ accountId }} not found."
+            }
+        }
+    },
+    "errors": {
+        "fileSystemErrors": {
+            "readAction": "reading from",
+            "writeAction": "writing to",
+            "otherAction": "accessing",
+            "unknownFilepath": "a file or folder",
+            "baseMessage": "An error occurred while {{ fileAction }} {{ filepath }}."
+        },
+        "apiErrors": {
+            "messageDetail": "{{ request }} in account {{ accountId }}",
+            "unableToUpload": "Unable to upload \"{{ payload }}.",
+            "codes": {
+                "400": "The {{ messageDetail }} was bad.",
+                "401": "The {{ messageDetail }} was unauthorized.",
+                "403": "The {{ messageDetail }} was forbidden.",
+                "404": "The {{ messageDetail }} was not found.",
+                "429": "The {{ messageDetail }} surpassed the rate limit. Retry in one minute.",
+                "503": "The {{ messageDetail }} could not be handled at this time. Please try again or visit https://help.hubspot.com/ to submit a ticket or contact HubSpot Support if the issue persists.",
+                "403MissingScope": "Couldn't run the project command because there are scopes missing in your production account. To update scopes, deactivate your current personal access key for {{ accountId }}, and generate a new one. Then run `hs auth` to update the CLI with the new key.",
+                "403Gating": "The current target account {{ accountId }} does not have access to HubSpot projects. To opt in to the CRM Development Beta and use projects, visit https://app.hubspot.com/l/whats-new/betas?productUpdateId=13860216.",
+                "404Request": "The {{ action }} failed because \"{{ request }}\" was not found in account {{ accountId }}.",
+                "500Generic": "The {{ messageDetail }} failed due to a server error. Please try again or visit https://help.hubspot.com/ to submit a ticket or contact HubSpot Support if the issue persists.",
+                "400Generic": "The {{ messageDetail }} failed due to a client error.",
+                "generic": "The {{ messageDetail }} failed."
+            }
+        },
+        "generic": "A {{ name }} has occurred"
+    }
+}