@hubspot/cli 7.3.0 → 7.4.0-beta.0

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

@@ -0,0 +1,194 @@
+"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 cliConfig = __importStar(require("@hubspot/local-dev-lib/config"));
+const validation = __importStar(require("../../validation"));
+const exitCodes_1 = require("../../enums/exitCodes");
+const configMiddleware_1 = require("../configMiddleware");
+jest.mock('@hubspot/local-dev-lib/logger', () => ({
+    logger: {
+        error: jest.fn(),
+        log: jest.fn(),
+    },
+}));
+jest.mock('@hubspot/local-dev-lib/config');
+jest.mock('../../validation');
+const validateAccountSpy = jest.spyOn(validation, 'validateAccount');
+const loadConfigSpy = jest.spyOn(cliConfig, 'loadConfig');
+const getAccountIdSpy = jest.spyOn(cliConfig, 'getAccountId');
+const configFileExistsSpy = jest.spyOn(cliConfig, 'configFileExists');
+const getConfigPathSpy = jest.spyOn(cliConfig, 'getConfigPath');
+const validateConfigSpy = jest.spyOn(cliConfig, 'validateConfig');
+const processExitSpy = jest.spyOn(process, 'exit');
+describe('lib/middleware/configMiddleware', () => {
+    beforeEach(() => {
+        processExitSpy.mockImplementation(code => {
+            throw new Error(`Process.exit called with code ${code}`);
+        });
+        getConfigPathSpy.mockReturnValue('/path/to/config');
+    });
+    describe('handleDeprecatedEnvVariables()', () => {
+        it('should handle deprecated HUBSPOT_PORTAL_ID environment variable', () => {
+            const originalEnv = process.env;
+            process.env = {
+                ...originalEnv,
+                HUBSPOT_PORTAL_ID: '123',
+                HUBSPOT_ACCOUNT_ID: undefined,
+            };
+            const argv = {
+                _: ['some-command'],
+                useEnv: true,
+                $0: 'hs',
+            };
+            (0, configMiddleware_1.handleDeprecatedEnvVariables)(argv);
+            expect(logger_1.logger.log).toHaveBeenCalledWith(expect.stringContaining('The HUBSPOT_PORTAL_ID environment variable is deprecated. Please use HUBSPOT_ACCOUNT_ID instead.'));
+            expect(process.env.HUBSPOT_ACCOUNT_ID).toBe('123');
+            process.env = originalEnv;
+        });
+        it('should not handle HUBSPOT_PORTAL_ID if HUBSPOT_ACCOUNT_ID is set', () => {
+            const originalEnv = process.env;
+            process.env = {
+                ...originalEnv,
+                HUBSPOT_PORTAL_ID: '123',
+                HUBSPOT_ACCOUNT_ID: '456',
+            };
+            const argv = {
+                _: ['some-command'],
+                useEnv: true,
+                $0: 'hs',
+            };
+            (0, configMiddleware_1.handleDeprecatedEnvVariables)(argv);
+            expect(logger_1.logger.log).not.toHaveBeenCalled();
+            expect(process.env.HUBSPOT_ACCOUNT_ID).toBe('456');
+            process.env = originalEnv;
+        });
+    });
+    describe('injectAccountIdMiddleware()', () => {
+        it('should use HUBSPOT_ACCOUNT_ID from environment when useEnv is true', async () => {
+            const originalEnv = process.env;
+            process.env = {
+                ...originalEnv,
+                HUBSPOT_ACCOUNT_ID: '123',
+            };
+            const argv = {
+                _: ['some-command'],
+                useEnv: true,
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.injectAccountIdMiddleware)(argv);
+            expect(argv.providedAccountId).toBeUndefined();
+            expect(argv.derivedAccountId).toBe(123);
+            expect(getAccountIdSpy).not.toHaveBeenCalled();
+            process.env = originalEnv;
+        });
+        it('should use getAccountId when useEnv is false', async () => {
+            getAccountIdSpy.mockReturnValue(456);
+            const argv = {
+                _: ['some-command'],
+                account: 'test-account',
+                useEnv: false,
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.injectAccountIdMiddleware)(argv);
+            expect(argv.providedAccountId).toBe('test-account');
+            expect(argv.derivedAccountId).toBe(456);
+            expect(getAccountIdSpy).toHaveBeenCalledWith('test-account');
+        });
+    });
+    describe('loadConfigMiddleware()', () => {
+        it('should exit with error when config file exists and --config flag is used', async () => {
+            configFileExistsSpy.mockReturnValue(true);
+            const argv = {
+                _: ['some-command'],
+                config: 'custom-config.json',
+                $0: 'hs',
+            };
+            await expect((0, configMiddleware_1.loadConfigMiddleware)(argv)).rejects.toThrow();
+            expect(processExitSpy).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.ERROR);
+            expect(logger_1.logger.error).toHaveBeenCalledWith('A configuration file already exists at /path/to/config. To specify a new configuration file, delete the existing one and try again.');
+        });
+        it('should load config and validate for non-init commands', async () => {
+            configFileExistsSpy.mockReturnValue(false);
+            loadConfigSpy.mockReturnValue({});
+            validateConfigSpy.mockReturnValue(true);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.loadConfigMiddleware)(argv);
+            expect(loadConfigSpy).toHaveBeenCalled();
+            expect(validateConfigSpy).toHaveBeenCalled();
+        });
+        it('should skip validation for init command', async () => {
+            configFileExistsSpy.mockReturnValue(false);
+            const argv = {
+                _: ['init'],
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.loadConfigMiddleware)(argv);
+            expect(loadConfigSpy).not.toHaveBeenCalled();
+            expect(validateConfigSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('validateAccountOptions()', () => {
+        it('should validate account for non-skipped commands', async () => {
+            validateAccountSpy.mockResolvedValue(true);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.validateAccountOptions)(argv);
+            expect(validateAccountSpy).toHaveBeenCalledWith(argv);
+        });
+        it('should skip validation for init command', async () => {
+            const argv = {
+                _: ['init'],
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.validateAccountOptions)(argv);
+            expect(validateAccountSpy).not.toHaveBeenCalled();
+        });
+        it('should exit with error when account validation fails', async () => {
+            validateAccountSpy.mockResolvedValue(false);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            await expect((0, configMiddleware_1.validateAccountOptions)(argv)).rejects.toThrow();
+            expect(processExitSpy).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.ERROR);
+        });
+    });
+});

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

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

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 projects = __importStar(require("../../projects"));
+const yargsChecksMiddleware_1 = require("../yargsChecksMiddleware");
+jest.mock('@hubspot/local-dev-lib/logger', () => ({
+    logger: {
+        error: jest.fn(),
+    },
+}));
+jest.mock('../../projects');
+jest.mock('../../lang', () => ({
+    i18n: jest.fn(key => key),
+}));
+const getIsInProjectSpy = jest.spyOn(projects, '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,109 @@
+"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) {
+        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) &&
+        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: {
+        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) {
+        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>;