@hubspot/cli 8.0.10-experimental.4 → 8.0.10-experimental.6

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

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

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

@@ -1,39 +0,0 @@
-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

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

package/lib/middleware/autoUpdateMiddleware.js

@@ -1,105 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

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

package/lib/middleware/fireAlarmMiddleware.js

@@ -1,118 +0,0 @@
-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

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

package/lib/middleware/gitMiddleware.js

@@ -1,21 +0,0 @@
-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

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

package/lib/middleware/requestMiddleware.js

@@ -1,5 +0,0 @@
-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

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

package/lib/middleware/spinniesMiddleware.js

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

package/lib/middleware/usageTrackingMiddleware.d.ts

@@ -1,13 +0,0 @@
-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

@@ -1,16 +0,0 @@
-/**
- * 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

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

package/lib/middleware/yargsChecksMiddleware.js

@@ -1,18 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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;
-    }
-}