@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

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

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

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

@@ -0,0 +1,39 @@
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import * as projectsConfig from '../../projects/config.js';
+import { performChecks } from '../yargsChecksMiddleware.js';
+import { uiLogger } from '../../ui/logger.js';
+import { commands } from '../../../lang/en.js';
+vi.mock('../../projects/config');
+const getIsInProjectSpy = vi.spyOn(projectsConfig, 'getIsInProject');
+const processExitSpy = vi.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(() => performChecks(argv)).toThrow();
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.generalErrors.srcIsProject(argv.src, argv._.toString()));
+        });
+        it('should return true when no checks fail', () => {
+            const argv = {
+                _: ['upload'],
+                src: './not-a-project',
+                $0: 'hs',
+            };
+            getIsInProjectSpy.mockReturnValue(false);
+            expect(performChecks(argv)).toBe(true);
+            expect(processExitSpy).not.toHaveBeenCalled();
+            expect(uiLogger.error).not.toHaveBeenCalled();
+        });
+    });
+});

package/lib/middleware/autoUpdateMiddleware.d.ts

@@ -0,0 +1,4 @@
+import { Arguments } from 'yargs';
+export declare function autoUpdateCLI(argv: Arguments<{
+    useEnv?: boolean;
+}>): Promise<void>;

package/lib/middleware/autoUpdateMiddleware.js

@@ -0,0 +1,105 @@
+import { isConfigFlagEnabled } from '@hubspot/local-dev-lib/config';
+import { CONFIG_FLAGS } from '@hubspot/local-dev-lib/constants/config';
+import { pkg } from '../jsonLoader.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { lib } from '../../lang/en.js';
+import { debugError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { isTargetedCommand } from './commandTargetingUtils.js';
+import { renderInline } from '../../ui/render.js';
+import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
+import { getCliUpgradeInfo, installCliVersion, isCliGloballyInstalled, canCliBeAutoUpgraded, } from '../cliUpgradeUtils.js';
+const CMS_CLI_PACKAGE_NAME = '@hubspot/cms-cli';
+async function updateNotification(currentVersion, latestVersion, updateCommand) {
+    await renderInline(getWarningBox({
+        title: pkg.name === CMS_CLI_PACKAGE_NAME
+            ? ''
+            : lib.middleware.updateNotification.notifyTitle,
+        message: pkg.name === CMS_CLI_PACKAGE_NAME
+            ? lib.middleware.updateNotification.cmsUpdateNotification(CMS_CLI_PACKAGE_NAME)
+            : lib.middleware.updateNotification.cliUpdateNotification(currentVersion, updateCommand, latestVersion),
+        textCentered: true,
+    }));
+}
+const SKIP_AUTO_UPDATE_COMMANDS = {
+    upgrade: true,
+    update: true,
+    config: {
+        set: true,
+    },
+};
+const preventAutoUpdateForCommand = (commandParts) => {
+    return isTargetedCommand(commandParts, SKIP_AUTO_UPDATE_COMMANDS);
+};
+export async function autoUpdateCLI(argv) {
+    let showManualInstallHelp = true;
+    let isAllowAutoUpdatesEnabled = false;
+    try {
+        // Default to false if the flag is not set. Users must explicitly enable auto-updates.
+        isAllowAutoUpdatesEnabled = isConfigFlagEnabled(CONFIG_FLAGS.ALLOW_AUTO_UPDATES, false);
+    }
+    catch (e) {
+        debugError(e);
+    }
+    const cliUpgradeInfo = getCliUpgradeInfo();
+    if (isAllowAutoUpdatesEnabled &&
+        cliUpgradeInfo.current &&
+        cliUpgradeInfo.latest &&
+        cliUpgradeInfo.type &&
+        !argv.useEnv &&
+        !process.env.SKIP_HUBSPOT_CLI_AUTO_UPDATES &&
+        !preventAutoUpdateForCommand(argv._)) {
+        // Ignore all update notifications if the current version is a pre-release (contains a hyphen)
+        if (cliUpgradeInfo.current.includes('-')) {
+            showManualInstallHelp = false;
+        }
+        else if (!['major', 'latest'].includes(cliUpgradeInfo.type)) {
+            // type "latest" => current installed version is latest
+            // Auto-update if upgrade type is "minor" or "patch"
+            SpinniesManager.init({
+                succeedColor: 'white',
+            });
+            SpinniesManager.add('cliAutoUpdate', {
+                text: lib.middleware.autoUpdateCLI.updateAvailable(cliUpgradeInfo.latest),
+            });
+            try {
+                if (await canCliBeAutoUpgraded()) {
+                    await installCliVersion();
+                    showManualInstallHelp = false;
+                    SpinniesManager.succeed('cliAutoUpdate', {
+                        text: lib.middleware.autoUpdateCLI.updateSucceeded(cliUpgradeInfo.latest),
+                    });
+                    uiLogger.log('');
+                }
+                else {
+                    SpinniesManager.fail('cliAutoUpdate', {
+                        text: lib.middleware.autoUpdateCLI.notInstalledGlobally,
+                    });
+                }
+            }
+            catch (e) {
+                debugError(e);
+                SpinniesManager.fail('cliAutoUpdate', {
+                    text: lib.middleware.autoUpdateCLI.updateFailed(cliUpgradeInfo.latest),
+                });
+            }
+        }
+    }
+    // Fallback to showing the manual install message if we cannot auto-upgrade
+    if (showManualInstallHelp &&
+        cliUpgradeInfo.latest &&
+        cliUpgradeInfo.current &&
+        cliUpgradeInfo.type !== 'latest' &&
+        cliUpgradeInfo.current !== cliUpgradeInfo.latest &&
+        process.stdout.isTTY) {
+        await updateNotification(cliUpgradeInfo.current, cliUpgradeInfo.latest, `npm i ${(await isCliGloballyInstalled()) ? '-g' : ''} ${pkg.name}`);
+        // Let users know that auto-updates can be enabled by setting the allow-auto-updates config flag
+        if (!isAllowAutoUpdatesEnabled &&
+            (await canCliBeAutoUpgraded()) &&
+            cliUpgradeInfo.type !== 'major') {
+            uiLogger.log('');
+            uiLogger.log(lib.middleware.autoUpdateCLI.enableAutoUpdatesMessage);
+            uiLogger.log('');
+        }
+    }
+}

package/lib/middleware/commandTargetingUtils.d.ts

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

package/lib/middleware/commandTargetingUtils.js

@@ -0,0 +1,76 @@
+import { globalConfigFileExists } from '@hubspot/local-dev-lib/config';
+export function isTargetedCommand(commandParts, targetCommandMap) {
+    const currentCommandPart = commandParts[0];
+    if (!targetCommandMap[currentCommandPart]) {
+        return false;
+    }
+    if (typeof targetCommandMap[currentCommandPart] === 'boolean' &&
+        targetCommandMap[currentCommandPart]) {
+        return true;
+    }
+    if (commandParts.length > 1) {
+        const targetSubCommandMap = targetCommandMap[currentCommandPart];
+        if (!targetSubCommandMap) {
+            return false;
+        }
+        return isTargetedCommand(commandParts.slice(1), targetSubCommandMap);
+    }
+    return false;
+}
+const SKIP_CONFIG_LOADING_COMMANDS = {
+    init: true,
+    feedback: true,
+    mcp: { start: true },
+};
+// Returns true if the command requires a config file to be present
+export function shouldLoadConfigForCommand(commandParts) {
+    const globalConfigExists = globalConfigFileExists();
+    // the user is trying to migrate the global config
+    const isGlobalConfigMigration = !globalConfigExists &&
+        isTargetedCommand(commandParts, {
+            account: { auth: true },
+            config: { migrate: true },
+        });
+    return (!isGlobalConfigMigration &&
+        !isTargetedCommand(commandParts, SKIP_CONFIG_LOADING_COMMANDS));
+}
+const SKIP_CONFIG_VALIDATION_COMMANDS = {
+    auth: true,
+    account: { auth: true },
+    mcp: {
+        setup: true,
+        start: true,
+    },
+};
+// Returns true if the command requires a valid config file to be present
+// Should only run if config has been loaded
+export function shouldRunConfigValidationForCommand(commandParts) {
+    return (shouldLoadConfigForCommand(commandParts) &&
+        !isTargetedCommand(commandParts, SKIP_CONFIG_VALIDATION_COMMANDS));
+}
+const accountsSubCommands = {
+    auth: true,
+    clean: true,
+    list: true,
+    ls: true,
+    remove: true,
+    use: true,
+};
+const sandboxesSubCommands = {
+    delete: true,
+};
+const SKIP_ACCOUNT_VALIDATION_COMMANDS = {
+    account: accountsSubCommands,
+    accounts: accountsSubCommands,
+    sandbox: sandboxesSubCommands,
+    sandboxes: sandboxesSubCommands,
+    config: {
+        migrate: true,
+    },
+};
+// Returns true if the command requires a valid account to be set in the config
+// Should only run if config has been loaded and validated
+export function shouldRunAccountValidationForCommand(commandParts) {
+    return (shouldRunConfigValidationForCommand(commandParts) &&
+        !isTargetedCommand(commandParts, SKIP_ACCOUNT_VALIDATION_COMMANDS));
+}

package/lib/middleware/configMiddleware.d.ts

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

package/lib/middleware/configMiddleware.js

@@ -0,0 +1,93 @@
+import path from 'path';
+import { getConfigAccountIfExists, validateConfig, getConfigDefaultAccountIfExists, configFileExists, } from '@hubspot/local-dev-lib/config';
+import { ENVIRONMENT_VARIABLES } from '@hubspot/local-dev-lib/constants/config';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { validateAccount } from '../validation.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { commands } from '../../lang/en.js';
+import { shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from './commandTargetingUtils.js';
+import { parseStringToNumber } from '../parsing.js';
+import { uiLogger } from '../ui/logger.js';
+import { lib } from '../../lang/en.js';
+export function handleCustomConfigLocationMiddleware(argv) {
+    const { useEnv, config } = argv;
+    if (useEnv) {
+        process.env[ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG] = 'true';
+    }
+    else if (config && typeof config === 'string') {
+        const absoluteConfigPath = path.isAbsolute(config)
+            ? config
+            : path.join(getCwd(), config);
+        process.env.HUBSPOT_CONFIG_PATH = absoluteConfigPath;
+    }
+}
+/**
+ * Auto-injects the derivedAccountId flag into all commands
+ */
+export async function injectAccountIdMiddleware(argv) {
+    const { account } = argv;
+    // Preserves the original --account flag for certain commands.
+    argv.userProvidedAccount = account;
+    if (argv.useEnv && process.env.HUBSPOT_ACCOUNT_ID) {
+        try {
+            argv.derivedAccountId = parseStringToNumber(process.env.HUBSPOT_ACCOUNT_ID);
+        }
+        catch (err) {
+            uiLogger.error(lib.configMiddleWare.invalidAccountIdEnvironmentVariable);
+        }
+    }
+    else {
+        // Wrap in try-catch to handle cases where config file doesn't exist yet (e.g., during hs init)
+        try {
+            let accountInConfig = account
+                ? getConfigAccountIfExists(account)
+                : undefined;
+            if (!accountInConfig) {
+                accountInConfig = getConfigDefaultAccountIfExists();
+            }
+            argv.derivedAccountId = accountInConfig?.accountId;
+        }
+        catch (err) {
+            // Config file doesn't exist yet, which is fine for commands like hs init
+            argv.derivedAccountId = undefined;
+        }
+    }
+}
+export async function validateConfigMiddleware(argv) {
+    // Skip this when no command is provided
+    if (!argv._.length || argv.help) {
+        return;
+    }
+    // Do not load or validate the config for the commands that do not require it
+    if (!shouldLoadConfigForCommand(argv._)) {
+        return;
+    }
+    // We don't run validation 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 (!process.env[ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG] &&
+        !configFileExists()) {
+        console.error('Config file not found, run hs account auth to configure your account');
+        process.exit(EXIT_CODES.ERROR);
+    }
+    // Only validate the config if the command requires it
+    if (shouldRunConfigValidationForCommand(argv._)) {
+        const { isValid, errors } = validateConfig();
+        if (!isValid) {
+            uiLogger.error(commands.generalErrors.validateConfigMiddleware.configValidationFailed(errors));
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+}
+export async function validateAccountOptions(argv) {
+    // Skip this when no command is provided
+    if (argv._.length && !argv.help) {
+        let validAccount = true;
+        // Only validate the account if the command requires it
+        if (shouldRunAccountValidationForCommand(argv._)) {
+            validAccount = await validateAccount(argv);
+        }
+        if (!validAccount) {
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+}

package/lib/middleware/fireAlarmMiddleware.d.ts

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

package/lib/middleware/fireAlarmMiddleware.js

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+import { fetchFireAlarms } from '@hubspot/local-dev-lib/api/fireAlarm';
+import { debugError } from '../errorHandlers/index.js';
+import { pkg } from '../jsonLoader.js';
+import { renderInline } from '../../ui/render.js';
+import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
+/*
+ * 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 fetchFireAlarms(accountId);
+        relevantAlarms = fireAlarms.filter(fireAlarm => filterFireAlarm(fireAlarm, command, version));
+    }
+    catch (error) {
+        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.bold(alarm.title)}\n${alarm.message}`);
+            }
+            return acc;
+        }, '');
+        await renderInline(getWarningBox({
+            title: 'Notifications',
+            message: notifications,
+        }));
+    }
+}
+export async function checkFireAlarms(argv) {
+    const { derivedAccountId } = argv;
+    try {
+        if (derivedAccountId) {
+            await logFireAlarms(derivedAccountId, argv._.join(' '), pkg.version);
+        }
+    }
+    catch (error) {
+        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,21 @@
+import { getConfigFilePath, globalConfigFileExists, } from '@hubspot/local-dev-lib/config';
+import { ENVIRONMENT_VARIABLES } from '@hubspot/local-dev-lib/constants/config';
+import { checkAndWarnGitInclusion } from '../ui/git.js';
+import { debugError } from '../errorHandlers/index.js';
+export function checkAndWarnGitInclusionMiddleware(argv) {
+    // Skip this when no command is provided or if using environment config
+    if (argv._.length &&
+        !process.env[ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG]) {
+        // Skip if using global config
+        if (globalConfigFileExists()) {
+            return;
+        }
+        try {
+            const configPath = getConfigFilePath();
+            checkAndWarnGitInclusion(configPath);
+        }
+        catch (error) {
+            debugError(error);
+        }
+    }
+}

package/lib/middleware/requestMiddleware.d.ts

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

package/lib/middleware/requestMiddleware.js

@@ -0,0 +1,5 @@
+import { addUserAgentHeader } from '@hubspot/local-dev-lib/http';
+import { pkg } from '../jsonLoader.js';
+export function setRequestHeaders() {
+    addUserAgentHeader('HubSpot CLI', pkg.version);
+}

package/lib/middleware/spinniesMiddleware.d.ts

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

package/lib/middleware/spinniesMiddleware.js

@@ -0,0 +1,4 @@
+import SpinniesManager from '../ui/SpinniesManager.js';
+export function initializeSpinniesManager() {
+    SpinniesManager.init();
+}

package/lib/middleware/usageTrackingMiddleware.d.ts

@@ -0,0 +1,13 @@
+import { Arguments } from 'yargs';
+/**
+ * Middleware to handle the --disable-usage-tracking flag
+ * Sets an environment variable that can be checked by tracking functions
+ */
+export declare function handleDisableUsageTracking(argv: Arguments<{
+    disableUsageTracking?: boolean;
+}>): void;
+/**
+ * Helper function to check if usage tracking is disabled
+ * @returns true if usage tracking is disabled via environment variable
+ */
+export declare function isUsageTrackingDisableFlagSet(): boolean;

package/lib/middleware/usageTrackingMiddleware.js

@@ -0,0 +1,16 @@
+/**
+ * Middleware to handle the --disable-usage-tracking flag
+ * Sets an environment variable that can be checked by tracking functions
+ */
+export function handleDisableUsageTracking(argv) {
+    if (argv.disableUsageTracking) {
+        process.env.DISABLE_USAGE_TRACKING = 'true';
+    }
+}
+/**
+ * Helper function to check if usage tracking is disabled
+ * @returns true if usage tracking is disabled via environment variable
+ */
+export function isUsageTrackingDisableFlagSet() {
+    return process.env.DISABLE_USAGE_TRACKING === 'true';
+}

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,18 @@
+import { uiLogger } from '../ui/logger.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { commands } from '../../lang/en.js';
+import { getIsInProject } from '../projects/config.js';
+import { isTargetedCommand } from './commandTargetingUtils.js';
+const UPLOAD_AND_WATCH_COMMANDS = {
+    upload: true,
+    watch: true,
+};
+export function performChecks(argv) {
+    // Require "project" command when running upload/watch inside of a project
+    if (isTargetedCommand(argv._, UPLOAD_AND_WATCH_COMMANDS) &&
+        getIsInProject(argv.src)) {
+        uiLogger.error(commands.generalErrors.srcIsProject(argv.src || './', argv._.join(' ')));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    return true;
+}

package/lib/npm/npmCli.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_PACKAGE_MANAGER = "npm";
+export declare function isGloballyInstalled(packageName: string): Promise<boolean>;
+export declare function getLatestPackageVersion(packageName: string): Promise<{
+    latest: string | null;
+    next: string | null;
+}>;
+export declare function executeInstall(packages?: string[], flags?: string | null, options?: {
+    cwd?: string;
+}): Promise<void>;
+export declare function executeUpdate(packages?: string[], flags?: string | null, options?: {
+    cwd?: string;
+}): Promise<void>;
+/**
+ * Check if a package is installed globally via npm
+ * This verifies that npm can see the package in its global packages list
+ */
+export declare function isInstalledGloballyWithNPM(packageName: string): Promise<boolean>;

package/lib/npm/npmCli.js

@@ -0,0 +1,59 @@
+import { exec as execAsync } from 'node:child_process';
+import util from 'util';
+import { uiLogger } from '../ui/logger.js';
+export const DEFAULT_PACKAGE_MANAGER = 'npm';
+export async function isGloballyInstalled(packageName) {
+    const exec = util.promisify(execAsync);
+    try {
+        await exec(`${packageName} --version`);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export async function getLatestPackageVersion(packageName) {
+    try {
+        const exec = util.promisify(execAsync);
+        const { stdout } = await exec(`npm info ${packageName} dist-tags --json`);
+        const { latest, next } = JSON.parse(stdout);
+        return { latest, next };
+    }
+    catch (e) {
+        return { latest: null, next: null };
+    }
+}
+export async function executeInstall(packages = [], flags, options) {
+    const installCommand = `${DEFAULT_PACKAGE_MANAGER} install${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
+    uiLogger.debug('Running', installCommand);
+    const exec = util.promisify(execAsync);
+    await exec(installCommand, options);
+}
+export async function executeUpdate(packages = [], flags, options) {
+    const updateCommand = `${DEFAULT_PACKAGE_MANAGER} update${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
+    uiLogger.debug('Running', updateCommand);
+    const exec = util.promisify(execAsync);
+    await exec(updateCommand, options);
+}
+/**
+ * Check if a package is installed globally via npm
+ * This verifies that npm can see the package in its global packages list
+ */
+export async function isInstalledGloballyWithNPM(packageName) {
+    // First check if npm is available
+    const isNpmGloballyInstalled = await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER);
+    if (!isNpmGloballyInstalled) {
+        return false;
+    }
+    // Then verify that npm can see the package in its global installation
+    // This definitively proves it was installed via npm
+    const exec = util.promisify(execAsync);
+    try {
+        await exec(`npm list -g ${packageName} --depth=0`);
+        return true;
+    }
+    catch (e) {
+        // npm list fails if the package isn't installed globally via npm
+        return false;
+    }
+}