@hubspot/cli 7.4.7-experimental.0 → 7.4.7

package/lib/middleware/__test__/gitMiddleware.test.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = __importStar(require("@hubspot/local-dev-lib/config"));
+const gitUI = __importStar(require("../../ui/git"));
+const gitMiddleware_1 = require("../gitMiddleware");
+jest.mock('@hubspot/local-dev-lib/config');
+jest.mock('../../ui/git');
+const getConfigPathSpy = jest.spyOn(config, 'getConfigPath');
+const checkAndWarnGitInclusionSpy = jest.spyOn(gitUI, 'checkAndWarnGitInclusion');
+describe('lib/middleware/gitMiddleware', () => {
+    describe('checkAndWarnGitInclusionMiddleware()', () => {
+        it('should call checkAndWarnGitInclusion when command is provided and config path exists', () => {
+            const mockConfigPath = '/path/to/config';
+            getConfigPathSpy.mockReturnValue(mockConfigPath);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            (0, gitMiddleware_1.checkAndWarnGitInclusionMiddleware)(argv);
+            expect(getConfigPathSpy).toHaveBeenCalledTimes(1);
+            expect(checkAndWarnGitInclusionSpy).toHaveBeenCalledWith(mockConfigPath);
+        });
+        it('should not call checkAndWarnGitInclusion when no command is provided', () => {
+            const argv = {
+                _: [],
+                $0: 'hs',
+            };
+            (0, gitMiddleware_1.checkAndWarnGitInclusionMiddleware)(argv);
+            expect(getConfigPathSpy).not.toHaveBeenCalled();
+            expect(checkAndWarnGitInclusionSpy).not.toHaveBeenCalled();
+        });
+        it('should not call checkAndWarnGitInclusion when config path is null', () => {
+            getConfigPathSpy.mockReturnValue(null);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            (0, gitMiddleware_1.checkAndWarnGitInclusionMiddleware)(argv);
+            expect(getConfigPathSpy).toHaveBeenCalledTimes(1);
+            expect(checkAndWarnGitInclusionSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/lib/middleware/__test__/notificationsMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__test__/notificationsMiddleware.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { notifyAboutUpdates } = require('../notificationsMiddleware');
+describe('lib/middleware/notificationsMiddleware', () => {
+    describe('notifyAboutUpdates()', () => {
+        it('should safely execute without throwing an error', () => {
+            expect(() => notifyAboutUpdates()).not.toThrow();
+        });
+    });
+});

package/lib/middleware/__test__/requestMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__test__/requestMiddleware.test.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("@hubspot/local-dev-lib/http");
+const requestMiddleware_1 = require("../requestMiddleware");
+const package_json_1 = __importDefault(require("../../../package.json"));
+jest.mock('@hubspot/local-dev-lib/http', () => ({
+    addUserAgentHeader: jest.fn(),
+}));
+describe('lib/middleware/requestMiddleware', () => {
+    describe('setRequestHeaders()', () => {
+        it('should call addUserAgentHeader with correct parameters', () => {
+            (0, requestMiddleware_1.setRequestHeaders)();
+            expect(http_1.addUserAgentHeader).toHaveBeenCalledTimes(1);
+            expect(http_1.addUserAgentHeader).toHaveBeenCalledWith('HubSpot CLI', package_json_1.default.version);
+        });
+    });
+});

package/lib/middleware/__test__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__test__/utils.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const targetCommandMap = {
+    init: { target: true },
+    account: {
+        target: true,
+        subCommands: {
+            use: { target: true },
+        },
+    },
+    project: {
+        subCommands: {
+            deploy: { target: true },
+        },
+    },
+};
+describe('lib/middleware/utils', () => {
+    describe('isTargetedCommand()', () => {
+        it('should return true for a direct target command', () => {
+            const result = (0, utils_1.isTargetedCommand)(['init'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return true for a command with a subcommand', () => {
+            const result = (0, utils_1.isTargetedCommand)(['account'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return true for a nested target command', () => {
+            const result = (0, utils_1.isTargetedCommand)(['project', 'deploy'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return false for a non-existent command', () => {
+            const result = (0, utils_1.isTargetedCommand)(['nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-targeted command', () => {
+            const result = (0, utils_1.isTargetedCommand)(['auth'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a command with a targeted subcommand', () => {
+            const result = (0, utils_1.isTargetedCommand)(['project'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-existent subcommand', () => {
+            const result = (0, utils_1.isTargetedCommand)(['auth', 'nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for an empty command array', () => {
+            const result = (0, utils_1.isTargetedCommand)([], targetCommandMap);
+            expect(result).toBe(false);
+        });
+    });
+});

package/lib/middleware/__test__/yargsChecksMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__test__/yargsChecksMiddleware.test.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const exitCodes_1 = require("../../enums/exitCodes");
+const projectsConfig = __importStar(require("../../projects/config"));
+const yargsChecksMiddleware_1 = require("../yargsChecksMiddleware");
+jest.mock('@hubspot/local-dev-lib/logger', () => ({
+    logger: {
+        error: jest.fn(),
+    },
+}));
+jest.mock('../../projects/config');
+jest.mock('../../lang', () => ({
+    i18n: jest.fn(key => key),
+}));
+const getIsInProjectSpy = jest.spyOn(projectsConfig, 'getIsInProject');
+const processExitSpy = jest.spyOn(process, 'exit');
+describe('lib/middleware/yargsChecksMiddleware', () => {
+    beforeEach(() => {
+        processExitSpy.mockImplementation(code => {
+            throw new Error(`Process.exit called with code ${code}`);
+        });
+    });
+    describe('performChecks()', () => {
+        it('should exit with error when running upload/watch inside a project', () => {
+            const argv = {
+                _: ['upload'],
+                src: './project',
+                $0: 'hs',
+            };
+            getIsInProjectSpy.mockReturnValue(true);
+            expect(() => (0, yargsChecksMiddleware_1.performChecks)(argv)).toThrow();
+            expect(processExitSpy).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.ERROR);
+            expect(logger_1.logger.error).toHaveBeenCalledWith('commands.generalErrors.srcIsProject');
+        });
+        it('should return true when no checks fail', () => {
+            const argv = {
+                _: ['upload'],
+                src: './not-a-project',
+                $0: 'hs',
+            };
+            getIsInProjectSpy.mockReturnValue(false);
+            expect((0, yargsChecksMiddleware_1.performChecks)(argv)).toBe(true);
+            expect(processExitSpy).not.toHaveBeenCalled();
+            expect(logger_1.logger.error).not.toHaveBeenCalled();
+        });
+    });
+});

package/lib/middleware/configMiddleware.d.ts

@@ -0,0 +1,13 @@
+import { Arguments } from 'yargs';
+import { CLIOptions } from '@hubspot/local-dev-lib/types/CLIOptions';
+export declare function handleDeprecatedEnvVariables(argv: Arguments<{
+    useEnv?: boolean;
+}>): void;
+/**
+ * Auto-injects the derivedAccountId flag into all commands
+ */
+export declare function injectAccountIdMiddleware(argv: Arguments<{
+    account?: string;
+}>): Promise<void>;
+export declare function loadConfigMiddleware(argv: Arguments<CLIOptions>): Promise<void>;
+export declare function validateAccountOptions(argv: Arguments): Promise<void>;

package/lib/middleware/configMiddleware.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDeprecatedEnvVariables = handleDeprecatedEnvVariables;
+exports.injectAccountIdMiddleware = injectAccountIdMiddleware;
+exports.loadConfigMiddleware = loadConfigMiddleware;
+exports.validateAccountOptions = validateAccountOptions;
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const validation_1 = require("../validation");
+const exitCodes_1 = require("../enums/exitCodes");
+const lang_1 = require("../lang");
+const ui_1 = require("../ui");
+const utils_1 = require("./utils");
+function handleDeprecatedEnvVariables(argv) {
+    // HUBSPOT_PORTAL_ID is deprecated, but we'll still support it for now
+    // The HubSpot GH Deploy Action still uses HUBSPOT_PORTAL_ID
+    if (argv.useEnv &&
+        process.env.HUBSPOT_PORTAL_ID &&
+        !process.env.HUBSPOT_ACCOUNT_ID) {
+        (0, ui_1.uiDeprecatedTag)((0, lang_1.i18n)(`commands.generalErrors.handleDeprecatedEnvVariables.portalEnvVarDeprecated`, {
+            configPath: (0, config_1.getConfigPath)(),
+        }));
+        process.env.HUBSPOT_ACCOUNT_ID = process.env.HUBSPOT_PORTAL_ID;
+    }
+}
+/**
+ * Auto-injects the derivedAccountId flag into all commands
+ */
+async function injectAccountIdMiddleware(argv) {
+    const { account } = argv;
+    // Preserves the original --account flag for certain commands.
+    argv.providedAccountId = account;
+    if (argv.useEnv && process.env.HUBSPOT_ACCOUNT_ID) {
+        argv.derivedAccountId = parseInt(process.env.HUBSPOT_ACCOUNT_ID, 10);
+    }
+    else {
+        argv.derivedAccountId = (0, config_1.getAccountId)(account);
+    }
+}
+const SKIP_CONFIG_VALIDATION = {
+    init: { target: true },
+    auth: { target: true },
+};
+async function loadConfigMiddleware(argv) {
+    // Skip this when no command is provided
+    if (!argv._.length || argv.help) {
+        return;
+    }
+    const maybeValidateConfig = () => {
+        if (!(0, utils_1.isTargetedCommand)(argv._, SKIP_CONFIG_VALIDATION) &&
+            !(0, config_1.validateConfig)()) {
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+    };
+    if (!(0, config_1.configFileExists)(true) &&
+        (0, utils_1.isTargetedCommand)(argv._, {
+            account: { target: false, subCommands: { auth: { target: true } } },
+        })) {
+        return;
+    }
+    if ((0, config_1.configFileExists)(true) &&
+        argv.config &&
+        !(0, utils_1.isTargetedCommand)(argv._, {
+            config: { target: false, subCommands: { migrate: { target: true } } },
+        })) {
+        logger_1.logger.error((0, lang_1.i18n)(`commands.generalErrors.loadConfigMiddleware.configFileExists`, {
+            configPath: (0, config_1.getConfigPath)(),
+        }));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    else if (!(0, utils_1.isTargetedCommand)(argv._, { init: { target: true } })) {
+        const config = (0, config_1.loadConfig)(argv.config, argv);
+        // We don't run validateConfig() for auth because users should be able to run it when
+        // no accounts are configured, but we still want to exit if the config file is not found
+        if ((0, utils_1.isTargetedCommand)(argv._, { auth: { target: true } }) && !config) {
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+    }
+    maybeValidateConfig();
+}
+const accountsSubCommands = {
+    target: false,
+    subCommands: {
+        auth: { target: true },
+        clean: { target: true },
+        list: { target: true },
+        ls: { target: true },
+        remove: { target: true },
+    },
+};
+const sandboxesSubCommands = {
+    target: false,
+    subCommands: {
+        delete: { target: true },
+    },
+};
+const SKIP_ACCOUNT_VALIDATION = {
+    init: { target: true },
+    auth: { target: true },
+    account: accountsSubCommands,
+    accounts: accountsSubCommands,
+    sandbox: sandboxesSubCommands,
+    sandboxes: sandboxesSubCommands,
+};
+async function validateAccountOptions(argv) {
+    // Skip this when no command is provided
+    if (argv._.length && !argv.help) {
+        let validAccount = true;
+        if (!(0, utils_1.isTargetedCommand)(argv._, SKIP_ACCOUNT_VALIDATION)) {
+            validAccount = await (0, validation_1.validateAccount)(argv);
+        }
+        if (!validAccount) {
+            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        }
+    }
+}

package/lib/middleware/fireAlarmMiddleware.d.ts

@@ -0,0 +1,4 @@
+import { Arguments } from 'yargs';
+export declare function checkFireAlarms(args: Arguments<{
+    derivedAccountId: number;
+}>): Promise<void>;

package/lib/middleware/fireAlarmMiddleware.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFireAlarms = checkFireAlarms;
+const chalk_1 = __importDefault(require("chalk"));
+const fireAlarm_1 = require("@hubspot/local-dev-lib/api/fireAlarm");
+const errorHandlers_1 = require("../errorHandlers");
+const package_json_1 = __importDefault(require("../../package.json"));
+const boxen_1 = require("../ui/boxen");
+/*
+ * Versions can be formatted like this:
+ * =7.2.2 -> targets the exact version 7.2.2
+ * =7.2.* -> targets all versions with a major of 7 and a minor of 2
+ * =7.* -> targets all versions with a major of 7
+ * =* -> targets all versions
+ * <=7.2.2 -> targets all versions equal to or less than 7.2.2
+ * <=7.2.* -> targets all versions equal to or less than 7.2
+ */
+const WILDCARD = '*';
+function isVersionTargeted(version, targetVersionString) {
+    // Assume we're targeting no versions if no version string is found
+    // Target all versions using the * wildcard
+    if (!targetVersionString) {
+        return false;
+    }
+    // Only support version targeting for the <= or = operator
+    if (!targetVersionString.startsWith('<=') &&
+        !targetVersionString.startsWith('=')) {
+        return false;
+    }
+    const targetVersion = targetVersionString.substring(targetVersionString.indexOf('=') + 1);
+    // Only allow exact version matching for tagged CLI releases (like -beta)
+    if (version.includes('-') || targetVersionString.includes('-')) {
+        if (!targetVersionString.startsWith('=')) {
+            return false;
+        }
+        return version === targetVersion;
+    }
+    const targetVersionParts = targetVersion.split('.');
+    const versionParts = version.split('.');
+    // Require the wildcard to be explicitly set to target all versions
+    if (versionParts.length < 3 &&
+        versionParts[versionParts.length - 1] !== WILDCARD) {
+        return false;
+    }
+    // Don't allow the less than or equal to operator to be used with the wildcard
+    // in the major version part (e.g. <=*)
+    if (targetVersionString.startsWith('<=') && versionParts[0] === WILDCARD) {
+        return false;
+    }
+    let targetAnyVersion = false;
+    return targetVersionParts.every((targetPart, i) => {
+        const versionPart = versionParts[i];
+        // Support generic version targeting (like 1.2.*)
+        if (targetPart === WILDCARD || targetAnyVersion) {
+            targetAnyVersion = true;
+            return true;
+        }
+        // Double check that the target part is a number
+        if (isNaN(Number(targetPart))) {
+            return false;
+        }
+        return targetVersionString.startsWith('<=')
+            ? Number(versionPart) <= Number(targetPart)
+            : Number(versionPart) === Number(targetPart);
+    });
+}
+function isCommandTargeted(command, targetCommandsString) {
+    // Require the wildcard to be explicitly set to target all commands
+    if (!targetCommandsString) {
+        return false;
+    }
+    if (targetCommandsString === WILDCARD) {
+        return true;
+    }
+    const targetCommands = targetCommandsString.split(',');
+    return targetCommands.some(cmd => command.startsWith(cmd));
+}
+function filterFireAlarm(fireAlarm, command, version) {
+    const commandIsTargeted = isCommandTargeted(command, fireAlarm.querySelector);
+    const versionIsTargeted = isVersionTargeted(version, fireAlarm.urlRegexPattern);
+    return commandIsTargeted && versionIsTargeted;
+}
+async function getFireAlarms(accountId, command, version) {
+    let relevantAlarms = [];
+    try {
+        const { data: fireAlarms } = await (0, fireAlarm_1.fetchFireAlarms)(accountId);
+        relevantAlarms = fireAlarms.filter(fireAlarm => filterFireAlarm(fireAlarm, command, version));
+    }
+    catch (error) {
+        (0, errorHandlers_1.debugError)(error);
+    }
+    return relevantAlarms;
+}
+async function logFireAlarms(accountId, command, version) {
+    const alarms = await getFireAlarms(accountId, command, version);
+    if (alarms.length > 0) {
+        const notifications = alarms.reduce((acc, alarm) => {
+            if (alarm.title && alarm.message) {
+                return (acc +
+                    `${acc.length > 0 ? '\n\n' : ''}${chalk_1.default.bold(alarm.title)}\n${alarm.message}`);
+            }
+            return acc;
+        }, '');
+        await (0, boxen_1.logInBox)({
+            contents: notifications,
+            options: {
+                title: 'Notifications',
+            },
+        });
+    }
+}
+async function checkFireAlarms(args) {
+    const { derivedAccountId } = args;
+    try {
+        await logFireAlarms(derivedAccountId, args._.join(' '), package_json_1.default.version);
+    }
+    catch (error) {
+        (0, errorHandlers_1.debugError)(error);
+    }
+}

package/lib/middleware/gitMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { Arguments } from 'yargs';
+export declare function checkAndWarnGitInclusionMiddleware(argv: Arguments): void;

package/lib/middleware/gitMiddleware.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAndWarnGitInclusionMiddleware = checkAndWarnGitInclusionMiddleware;
+const config_1 = require("@hubspot/local-dev-lib/config");
+const git_1 = require("../ui/git");
+function checkAndWarnGitInclusionMiddleware(argv) {
+    // Skip this when no command is provided
+    if (argv._.length) {
+        const configPath = (0, config_1.getConfigPath)();
+        if (configPath) {
+            (0, git_1.checkAndWarnGitInclusion)(configPath);
+        }
+    }
+}

package/lib/middleware/notificationsMiddleware.d.ts

@@ -0,0 +1 @@
+export declare function notifyAboutUpdates(): void;

package/lib/middleware/notificationsMiddleware.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyAboutUpdates = notifyAboutUpdates;
+// Update-notifier is CommonJS, so we need to use require
+const updateNotifier = require('update-notifier');
+const chalk = require('chalk');
+const pkg = require('../../package.json');
+const { UI_COLORS, uiCommandReference } = require('../ui');
+const { i18n } = require('../lang');
+const notifier = updateNotifier({
+    pkg: { ...pkg, name: '@hubspot/cli' },
+    distTag: 'latest',
+    shouldNotifyInNpmScript: true,
+});
+const CMS_CLI_PACKAGE_NAME = '@hubspot/cms-cli';
+function notifyAboutUpdates() {
+    notifier.notify({
+        message: pkg.name === CMS_CLI_PACKAGE_NAME
+            ? i18n(`commands.generalErrors.updateNotify.cmsUpdateNotification`, {
+                packageName: CMS_CLI_PACKAGE_NAME,
+                updateCommand: uiCommandReference('{updateCommand}'),
+            })
+            : i18n(`commands.generalErrors.updateNotify.cliUpdateNotification`, {
+                updateCommand: uiCommandReference('{updateCommand}'),
+            }),
+        defer: false,
+        boxenOptions: {
+            borderColor: UI_COLORS.MARIGOLD_DARK,
+            margin: 1,
+            padding: 1,
+            textAlignment: 'center',
+            borderStyle: 'round',
+            title: pkg.name === CMS_CLI_PACKAGE_NAME
+                ? null
+                : chalk.bold(i18n(`commands.generalErrors.updateNotify.notifyTitle`)),
+        },
+    });
+}

package/lib/middleware/requestMiddleware.d.ts

@@ -0,0 +1 @@
+export declare function setRequestHeaders(): void;

package/lib/middleware/requestMiddleware.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRequestHeaders = setRequestHeaders;
+const http_1 = require("@hubspot/local-dev-lib/http");
+const package_json_1 = __importDefault(require("../../package.json"));
+function setRequestHeaders() {
+    (0, http_1.addUserAgentHeader)('HubSpot CLI', package_json_1.default.version);
+}

package/lib/middleware/utils.d.ts

@@ -0,0 +1,8 @@
+type TargetCommandMap = {
+    [key: string]: {
+        target?: boolean;
+        subCommands?: TargetCommandMap;
+    };
+};
+export declare function isTargetedCommand(commandParts: (string | number)[], targetCommandMap: TargetCommandMap): boolean;
+export {};

package/lib/middleware/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTargetedCommand = isTargetedCommand;
+function isTargetedCommand(commandParts, targetCommandMap) {
+    const currentCommand = commandParts[0];
+    if (!targetCommandMap[currentCommand]) {
+        return false;
+    }
+    if (targetCommandMap[currentCommand].target) {
+        return true;
+    }
+    const subCommands = targetCommandMap[currentCommand].subCommands || {};
+    if (commandParts.length > 1) {
+        return isTargetedCommand(commandParts.slice(1), subCommands);
+    }
+    return false;
+}

package/lib/middleware/yargsChecksMiddleware.d.ts

@@ -0,0 +1,4 @@
+import { Arguments } from 'yargs';
+export declare function performChecks(argv: Arguments<{
+    src?: string;
+}>): boolean;

package/lib/middleware/yargsChecksMiddleware.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performChecks = performChecks;
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const exitCodes_1 = require("../enums/exitCodes");
+const lang_1 = require("../lang");
+const config_1 = require("../projects/config");
+const utils_1 = require("./utils");
+const UPLOAD_AND_WATCH_COMMANDS = {
+    upload: { target: true },
+    watch: { target: true },
+};
+function performChecks(argv) {
+    // Require "project" command when running upload/watch inside of a project
+    if ((0, utils_1.isTargetedCommand)(argv._, UPLOAD_AND_WATCH_COMMANDS) &&
+        (0, config_1.getIsInProject)(argv.src)) {
+        logger_1.logger.error((0, lang_1.i18n)(`commands.generalErrors.srcIsProject`, {
+            src: argv.src || './',
+            command: argv._.join(' '),
+        }));
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    return true;
+}