@hubspot/cli 8.1.0 → 8.1.2-experimental.0

package/lib/link/index.js

@@ -0,0 +1,185 @@
+import { getAllConfigAccounts, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { confirmPrompt } from '../prompts/promptUtils.js';
+import { promptForAccountsToLink, promptForAccountsToUnlink, promptForAction, promptForDefaultAccount, } from './prompts.js';
+import { ACTION_RESULT_STATUS, } from '../../types/Link.js';
+import { getDefaultAccountOverrideFilePath, removeDefaultAccountOverrideFile, } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { authenticateNewAccount } from '../accountAuth.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+export class ActionHandlers {
+    static async link({ state, context, }) {
+        const { eligibleAccounts, inEligibleAccounts } = context.globalAccountsList.reduce((accumulator, account) => {
+            if (state.accounts.includes(account.accountId)) {
+                accumulator.inEligibleAccounts.push(account);
+            }
+            else {
+                accumulator.eligibleAccounts.push(account);
+            }
+            return accumulator;
+        }, { eligibleAccounts: [], inEligibleAccounts: [] });
+        const toAdd = await promptForAccountsToLink(context, eligibleAccounts, inEligibleAccounts, state.localDefaultAccount);
+        const accounts = [...state.accounts, ...toAdd];
+        uiLogger.info(commands.account.subcommands.link.events.accountsLinked(toAdd.length));
+        const overrideFilePath = getDefaultAccountOverrideFilePath();
+        if (overrideFilePath &&
+            context.accountOverrideId &&
+            accounts.includes(context.accountOverrideId)) {
+            uiLogger.log(commands.account.subcommands.link.events.overrideAccountDetected(context.accountOverrideId));
+            uiLogger.log('');
+            const useOverride = await confirmPrompt(commands.account.subcommands.link.prompts.keepAsDefault);
+            removeDefaultAccountOverrideFile();
+            uiLogger.success(commands.account.subcommands.link.events.overrideFileRemoved);
+            if (useOverride) {
+                uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(context.accountOverrideId));
+                return {
+                    status: ACTION_RESULT_STATUS.SUCCESS,
+                    settings: {
+                        accounts,
+                        localDefaultAccount: context.accountOverrideId,
+                    },
+                };
+            }
+        }
+        const localDefaultAccount = await resolveDefaultAccount({
+            accounts,
+            currentDefault: state.localDefaultAccount,
+        });
+        return {
+            status: ACTION_RESULT_STATUS.SUCCESS,
+            settings: { accounts, localDefaultAccount },
+        };
+    }
+    static async unlink({ state }) {
+        const toRemove = await promptForAccountsToUnlink(state.accounts, state.localDefaultAccount);
+        if (toRemove.length === 0) {
+            return { status: ACTION_RESULT_STATUS.NOOP };
+        }
+        const remainingAccounts = state.accounts.filter(account => !toRemove.includes(account));
+        const defaultWasRemoved = state.localDefaultAccount !== undefined &&
+            toRemove.includes(state.localDefaultAccount);
+        // All accounts removed
+        if (remainingAccounts.length === 0) {
+            uiLogger.success(commands.account.subcommands.link.events.noAccountsLinked);
+            return {
+                status: ACTION_RESULT_STATUS.SUCCESS,
+                settings: {
+                    accounts: remainingAccounts,
+                    localDefaultAccount: undefined,
+                },
+            };
+        }
+        //  Default was NOT removed — accounts remain, default unchanged
+        if (!defaultWasRemoved) {
+            uiLogger.success(commands.account.subcommands.link.events.accountsUnlinked(toRemove.length));
+            uiLogger.success(commands.account.subcommands.link.events.defaultAccountRemains(state.localDefaultAccount));
+            return {
+                status: ACTION_RESULT_STATUS.SUCCESS,
+                settings: {
+                    accounts: remainingAccounts,
+                    localDefaultAccount: state.localDefaultAccount,
+                },
+            };
+        }
+        //  Default WAS removed — need a new default
+        uiLogger.warn(commands.account.subcommands.link.events.defaultAccountRemoved(remainingAccounts.length !== 1));
+        const localDefaultAccount = await resolveDefaultAccount({
+            accounts: remainingAccounts,
+            currentDefault: undefined,
+        });
+        if (remainingAccounts.length === 1) {
+            uiLogger.success(commands.account.subcommands.link.events.updatedLinkedAccounts);
+        }
+        return {
+            status: ACTION_RESULT_STATUS.SUCCESS,
+            settings: { accounts: remainingAccounts, localDefaultAccount },
+        };
+    }
+    static async authenticate({ state, context, args, }) {
+        const updatedConfig = await authenticateNewAccount({
+            env: args.qa ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD,
+            setAsDefaultAccount: false,
+        });
+        if (!updatedConfig) {
+            return {
+                status: ACTION_RESULT_STATUS.ERROR,
+                reason: commands.account.subcommands.link.errors.authFailed,
+            };
+        }
+        const updatedContext = {
+            globalAccountsList: getAllConfigAccounts(),
+            globalDefaultAccount: getConfigDefaultAccountIfExists(),
+            accountOverrideId: context.accountOverrideId,
+            preselectedAccountId: updatedConfig.accountId,
+        };
+        return ActionHandlers.link({ state, context: updatedContext, args });
+    }
+    static async cancel() {
+        return {
+            status: ACTION_RESULT_STATUS.NOOP,
+        };
+    }
+}
+export async function handleLinkFlow({ settings, accountOverrideId, args, }) {
+    const context = {
+        globalAccountsList: getAllConfigAccounts(),
+        globalDefaultAccount: getConfigDefaultAccountIfExists(),
+        accountOverrideId,
+    };
+    const accounts = settings.accounts ?? [];
+    // The default account must be one of the linked accounts. This can get
+    // out of sync if the settings file is manually edited.
+    const hasInvalidDefault = settings.localDefaultAccount !== undefined &&
+        !accounts.includes(settings.localDefaultAccount);
+    if (hasInvalidDefault) {
+        uiLogger.warn(commands.account.subcommands.link.events.invalidDefaultAccount(settings.localDefaultAccount));
+    }
+    const initialState = {
+        localDefaultAccount: hasInvalidDefault
+            ? undefined
+            : settings.localDefaultAccount,
+        accounts,
+    };
+    return runAction(initialState, context, args);
+}
+async function runAction(state, context, args) {
+    const action = await promptForAction(state);
+    return ActionHandlers[action]({ state, context, args });
+}
+async function resolveDefaultAccount({ accounts, currentDefault, prompt = '', }) {
+    if (accounts.length === 1) {
+        uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(accounts[0]));
+        return accounts[0];
+    }
+    return promptForDefaultAccount(accounts, currentDefault, prompt);
+}
+export async function handleLinkedUseAction({ state, targetAccountId, }) {
+    if (targetAccountId !== undefined) {
+        if (state.accounts.includes(targetAccountId)) {
+            uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(targetAccountId));
+            return {
+                status: ACTION_RESULT_STATUS.SUCCESS,
+                settings: {
+                    accounts: state.accounts,
+                    localDefaultAccount: targetAccountId,
+                },
+            };
+        }
+        const accounts = [...state.accounts, targetAccountId];
+        uiLogger.info(commands.account.subcommands.link.events.accountsLinked(1));
+        uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(targetAccountId));
+        return {
+            status: ACTION_RESULT_STATUS.SUCCESS,
+            settings: { accounts, localDefaultAccount: targetAccountId },
+        };
+    }
+    const localDefaultAccount = await resolveDefaultAccount({
+        accounts: state.accounts,
+        currentDefault: state.localDefaultAccount,
+    });
+    uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(localDefaultAccount));
+    return {
+        status: ACTION_RESULT_STATUS.SUCCESS,
+        settings: { accounts: state.accounts, localDefaultAccount },
+    };
+}

package/lib/link/linkUtils.d.ts

@@ -0,0 +1,5 @@
+import { HsSettingsFile } from '@hubspot/local-dev-lib/types/HsSettings';
+export declare function isDirectoryLinked(settings: HsSettingsFile | null): settings is HsSettingsFile;
+export declare function hasDeprecatedConfigConflict(commandArgs: (string | number)[]): boolean;
+export declare function addAccountToLinkedSettings(accountId: number): void;
+export declare function writeLinkedSettings(settings: HsSettingsFile, settingsPath: string): boolean;

package/lib/link/linkUtils.js

@@ -0,0 +1,49 @@
+import { localConfigFileExists } from '@hubspot/local-dev-lib/config';
+import { getHsSettingsFileIfExists, writeHsSettingsFile, } from '@hubspot/local-dev-lib/config/hsSettings';
+import { uiLogger } from '../ui/logger.js';
+import { debugError } from '../errorHandlers/index.js';
+import { commands } from '../../lang/en.js';
+export function isDirectoryLinked(settings) {
+    return settings !== null && settings.accounts.length > 0;
+}
+export function hasDeprecatedConfigConflict(commandArgs) {
+    if (localConfigFileExists()) {
+        uiLogger.error(commands.account.subcommands.link.shared.deprecatedConfigNotSupported(`hs ${commandArgs.join(' ')}`));
+        return true;
+    }
+    return false;
+}
+export function addAccountToLinkedSettings(accountId) {
+    if (localConfigFileExists()) {
+        return;
+    }
+    const settings = getHsSettingsFileIfExists();
+    if (!settings || settings.accounts.length === 0) {
+        return;
+    }
+    if (settings.accounts.includes(accountId)) {
+        return;
+    }
+    const updated = {
+        ...settings,
+        accounts: [...settings.accounts, accountId],
+    };
+    try {
+        writeHsSettingsFile(updated);
+        uiLogger.info(commands.account.subcommands.link.shared.accountAutoLinked(accountId));
+    }
+    catch (err) {
+        uiLogger.warn(commands.account.subcommands.link.shared.accountAutoLinkFailed(accountId));
+        debugError(err);
+    }
+}
+export function writeLinkedSettings(settings, settingsPath) {
+    try {
+        writeHsSettingsFile(settings);
+        return true;
+    }
+    catch (err) {
+        uiLogger.error(commands.account.subcommands.link.shared.writeSettingsFailed(settingsPath, err));
+        return false;
+    }
+}

package/lib/link/prompts.d.ts

@@ -0,0 +1,7 @@
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { ActionName, LinkContext } from '../../types/Link.js';
+import { HsSettingsFile } from '@hubspot/local-dev-lib/types/HsSettings';
+export declare function promptForAction(state: HsSettingsFile): Promise<ActionName>;
+export declare function promptForDefaultAccount(accounts: number[], currentDefaultAccount: number | undefined, prompt?: string): Promise<number>;
+export declare function promptForAccountsToLink(context: LinkContext, eligibleAccounts: HubSpotConfigAccount[], inEligibleAccounts: HubSpotConfigAccount[], localDefaultAccount: number | undefined): Promise<number[]>;
+export declare function promptForAccountsToUnlink(accounts: number[], localDefaultAccount: number | undefined): Promise<number[]>;

package/lib/link/prompts.js

@@ -0,0 +1,126 @@
+import { promptUser } from '../prompts/promptUtils.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { buildAccountRow, getNameColumnWidth, buildAccountHeader, sortDefaultFirst, } from './accountTableUtils.js';
+import { Separator } from '@inquirer/prompts';
+function buildColumnarChoices(accounts, localDefaultAccount) {
+    const rows = accounts.map(a => ({
+        ...buildAccountRow(a.accountId, a.accountId === localDefaultAccount),
+        disabled: a.disabled,
+        checked: a.checked,
+        hint: a.hint,
+    }));
+    const nameWidth = getNameColumnWidth(rows);
+    const header = buildAccountHeader(nameWidth);
+    return [
+        new Separator(header),
+        ...rows.map(row => {
+            const label = `${row.name.padEnd(nameWidth)}  ${row.accountId}`;
+            return {
+                name: row.hint ? `${label}  ${row.hint}` : label,
+                short: uiAccountDescription(Number(row.accountId), false),
+                value: Number(row.accountId),
+                disabled: row.disabled,
+                checked: row.checked,
+            };
+        }),
+    ];
+}
+function mapLinkAccountChoices(eligibleAccounts, inEligibleAccounts, accountOverrideId, localDefaultAccount, preselectedAccountId) {
+    const sortedIneligible = sortDefaultFirst(inEligibleAccounts, localDefaultAccount);
+    const accounts = [
+        ...eligibleAccounts.map(a => ({
+            accountId: a.accountId,
+            disabled: false,
+            checked: a.accountId === accountOverrideId ||
+                a.accountId === preselectedAccountId,
+            hint: a.accountId === accountOverrideId
+                ? commands.account.subcommands.link.prompts.fromHsAccount
+                : a.accountId === preselectedAccountId
+                    ? commands.account.subcommands.link.prompts.newlyAuthenticated
+                    : undefined,
+        })),
+        ...sortedIneligible.map(a => ({
+            accountId: a.accountId,
+            disabled: commands.account.subcommands.link.prompts.alreadyLinked,
+            checked: false,
+        })),
+    ];
+    return buildColumnarChoices(accounts, localDefaultAccount);
+}
+export async function promptForAction(state) {
+    const isSettingsEmpty = state.accounts.length === 0 && state.localDefaultAccount === undefined;
+    const { accountEditOption } = await promptUser({
+        type: 'list',
+        name: 'accountEditOption',
+        message: isSettingsEmpty
+            ? commands.account.subcommands.link.prompts.howToProceed
+            : commands.account.subcommands.link.prompts.whatToDo,
+        choices: [
+            {
+                name: commands.account.subcommands.link.prompts.linkExisting,
+                value: 'link',
+            },
+            {
+                name: commands.account.subcommands.link.prompts.authenticateNew,
+                value: 'authenticate',
+            },
+            {
+                name: commands.account.subcommands.link.prompts.cancel,
+                value: 'cancel',
+            },
+        ],
+    });
+    uiLogger.log('');
+    return accountEditOption;
+}
+export async function promptForDefaultAccount(accounts, currentDefaultAccount, prompt = '') {
+    const choiceAccounts = accounts.map(accountId => ({
+        accountId,
+    }));
+    const choices = buildColumnarChoices(choiceAccounts, currentDefaultAccount);
+    const { defaultAccount } = await promptUser({
+        type: 'list',
+        name: 'defaultAccount',
+        pageSize: 20,
+        message: prompt || commands.account.subcommands.link.prompts.selectDefault,
+        choices,
+        default: currentDefaultAccount ?? undefined,
+    });
+    uiLogger.log('');
+    return defaultAccount;
+}
+export async function promptForAccountsToLink(context, eligibleAccounts, inEligibleAccounts, localDefaultAccount) {
+    const { accountsToAdd } = await promptUser({
+        type: 'checkbox',
+        name: 'accountsToAdd',
+        pageSize: 20,
+        message: commands.account.subcommands.link.prompts.selectToLink,
+        choices: mapLinkAccountChoices(eligibleAccounts, inEligibleAccounts, context.accountOverrideId, localDefaultAccount, context.preselectedAccountId),
+        validate: (answer) => {
+            if (answer.length === 0) {
+                return commands.account.subcommands.link.prompts.mustSelectOne;
+            }
+            return true;
+        },
+    });
+    uiLogger.log('');
+    return accountsToAdd;
+}
+export async function promptForAccountsToUnlink(accounts, localDefaultAccount) {
+    const sortedAccounts = sortDefaultFirst(accounts, localDefaultAccount);
+    const choiceAccounts = sortedAccounts.map(accountId => ({
+        accountId,
+    }));
+    const choices = buildColumnarChoices(choiceAccounts, localDefaultAccount);
+    const { accountsToRemove } = await promptUser({
+        type: 'checkbox',
+        name: 'accountsToRemove',
+        pageSize: 20,
+        message: commands.account.subcommands.link.prompts.selectToUnlink,
+        choices,
+    });
+    uiLogger.log('');
+    return accountsToRemove;
+}

package/lib/link/renderLinkedAccountsTable.d.ts

@@ -0,0 +1,2 @@
+import { HsSettingsFile } from '@hubspot/local-dev-lib/types/HsSettings';
+export declare function renderLinkedAccountsTable(settings: HsSettingsFile): Promise<void>;

package/lib/link/renderLinkedAccountsTable.js

@@ -0,0 +1,14 @@
+import { commands } from '../../lang/en.js';
+import { renderTable } from '../../ui/render.js';
+import { buildAccountRow, sortDefaultFirst } from './accountTableUtils.js';
+export async function renderLinkedAccountsTable(settings) {
+    const labels = commands.account.subcommands.list.labels;
+    const tableHeader = [labels.name, labels.accountId];
+    const sortedAccounts = sortDefaultFirst(settings.accounts, settings.localDefaultAccount);
+    const tableData = sortedAccounts.map(accountId => {
+        const isDefault = accountId === settings.localDefaultAccount;
+        const row = buildAccountRow(accountId, isDefault);
+        return [row.name, row.accountId];
+    });
+    await renderTable(tableHeader, tableData, true);
+}

package/lib/link/warnIfLinkedDirectory.d.ts

@@ -0,0 +1 @@
+export declare function warnIfLinkedDirectory(args: (string | number)[]): void;

package/lib/link/warnIfLinkedDirectory.js

@@ -0,0 +1,9 @@
+import { getHsSettingsFilePath } from '@hubspot/local-dev-lib/config/hsSettings';
+import { uiLogger } from '../ui/logger.js';
+import { lib } from '../../lang/en.js';
+export function warnIfLinkedDirectory(args) {
+    if (getHsSettingsFilePath() === null) {
+        return;
+    }
+    uiLogger.warn(lib.linkedDirectory.warning(`hs ${args.join(' ')}`, getHsSettingsFilePath()));
+}

package/lib/mcp/setup.d.ts

@@ -5,6 +5,7 @@ export declare const supportedTools: {
 interface McpCommand {
     command: string;
     args: string[];
+    env?: Record<string, string>;
 }
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;

package/lib/mcp/setup.js

@@ -47,23 +47,56 @@ export async function addMcpServerToConfig(targets) {
         else {
             derivedTargets = targets;
         }
+        // Prompt for standalone mode
+        const { useStandaloneMode } = await promptUser({
+            name: 'useStandaloneMode',
+            type: 'confirm',
+            message: commands.mcp.setup.prompts.standaloneMode,
+            default: false,
+        });
+        const { cliVersion } = useStandaloneMode
+            ? await promptUser({
+                name: 'cliVersion',
+                type: 'input',
+                message: commands.mcp.setup.prompts.cliVersion,
+                validate: (v) => !v || /^[\d]+\.[\d]+\.[\d]+([-+][\w.]+)?$/.test(v.trim())
+                    ? true
+                    : 'Please enter a valid semver version (e.g. 8.0.1) or leave blank for latest.',
+            })
+            : { cliVersion: '' };
+        const cliPackage = cliVersion
+            ? `@hubspot/cli@${cliVersion}`
+            : '@hubspot/cli';
+        const standaloneEnv = {
+            HUBSPOT_MCP_STANDALONE: 'true',
+        };
+        if (cliVersion) {
+            standaloneEnv.HUBSPOT_CLI_VERSION = cliVersion;
+        }
+        const mcpCommand = useStandaloneMode
+            ? {
+                command: 'npx',
+                args: ['-y', '-p', cliPackage, 'hs', 'mcp', 'start'],
+                env: standaloneEnv,
+            }
+            : defaultMcpCommand;
         if (derivedTargets.includes(claudeCode)) {
-            await runSetupFunction(setupClaudeCode);
+            await runSetupFunction(() => setupClaudeCode(mcpCommand));
         }
         if (derivedTargets.includes(cursor)) {
-            await runSetupFunction(setupCursor);
+            await runSetupFunction(() => setupCursor(mcpCommand));
         }
         if (derivedTargets.includes(windsurf)) {
-            await runSetupFunction(setupWindsurf);
+            await runSetupFunction(() => setupWindsurf(mcpCommand));
         }
         if (derivedTargets.includes(vscode)) {
-            await runSetupFunction(setupVsCode);
+            await runSetupFunction(() => setupVsCode(mcpCommand));
         }
         if (derivedTargets.includes(codex)) {
-            await runSetupFunction(setupCodex);
+            await runSetupFunction(() => setupCodex(mcpCommand));
         }
         if (derivedTargets.includes(gemini)) {
-            await runSetupFunction(setupGemini);
+            await runSetupFunction(() => setupGemini(mcpCommand));
         }
         uiLogger.info(commands.mcp.setup.success(derivedTargets));
         return derivedTargets;
@@ -121,10 +154,7 @@ function setupMcpConfigFile(config) {
         if (!mcpConfig.mcpServers) {
             mcpConfig.mcpServers = {};
         }
-        // Add or update HubSpot CLI MCP server
-        mcpConfig.mcpServers[mcpServerName] = {
-            ...config.mcpCommand,
-        };
+        mcpConfig.mcpServers[mcpServerName] = config.mcpCommand;
         // Write the updated config
         fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
         SpinniesManager.succeed('spinner', {
@@ -145,10 +175,12 @@ export async function setupVsCode(mcpCommand = defaultMcpCommand) {
         SpinniesManager.add('vsCode', {
             text: commands.mcp.setup.spinners.configuringVsCode,
         });
-        const mcpConfig = JSON.stringify({
+        const commandWithAgent = buildCommandWithAgentString(mcpCommand, vscode);
+        const configObject = {
             name: mcpServerName,
-            ...buildCommandWithAgentString(mcpCommand, vscode),
-        });
+            ...commandWithAgent,
+        };
+        const mcpConfig = JSON.stringify(configObject);
         await execAsync(`code --add-mcp ${JSON.stringify(mcpConfig)}`);
         SpinniesManager.succeed('vsCode', {
             text: commands.mcp.setup.spinners.configuredVsCode,
@@ -172,25 +204,27 @@ export async function setupVsCode(mcpCommand = defaultMcpCommand) {
     }
 }
 export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
+    SpinniesManager.add('claudeCode', {
+        text: commands.mcp.setup.spinners.configuringClaudeCode,
+    });
     try {
-        SpinniesManager.add('claudeCode', {
-            text: commands.mcp.setup.spinners.configuringClaudeCode,
+        // Check if claude command is available
+        await execAsync('claude --version');
+    }
+    catch (e) {
+        SpinniesManager.fail('claudeCode', {
+            text: commands.mcp.setup.spinners.claudeCodeNotFound,
         });
-        try {
-            // Check if claude command is available
-            await execAsync('claude --version');
-        }
-        catch (e) {
-            SpinniesManager.fail('claudeCode', {
-                text: commands.mcp.setup.spinners.claudeCodeNotFound,
-            });
-            return false;
-        }
+        return false;
+    }
+    try {
         // Run claude mcp add command
-        const mcpConfig = JSON.stringify({
+        const commandWithAgent = buildCommandWithAgentString(mcpCommand, claudeCode);
+        const configObject = {
             type: 'stdio',
-            ...buildCommandWithAgentString(mcpCommand, claudeCode),
-        });
+            ...commandWithAgent,
+        };
+        const mcpConfig = JSON.stringify(configObject);
         const { stdout } = await execAsync('claude mcp list');
         if (stdout.includes(mcpServerName)) {
             SpinniesManager.update('claudeCode', {
@@ -248,7 +282,7 @@ export async function setupCodex(mcpCommand = defaultMcpCommand) {
             return false;
         }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, codex);
-        await execAsync(`codex mcp add "${mcpServerName}" -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
+        await execAsync(`codex mcp add "${mcpServerName}"${buildEnvFlagString(mcpCommand)} -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('codexSpinner', {
             text: commands.mcp.setup.spinners.configuredCodex,
         });
@@ -277,7 +311,7 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
             return false;
         }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, gemini);
-        await execAsync(`gemini mcp add -s user "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
+        await execAsync(`gemini mcp add -s user${buildEnvFlagString(mcpCommand)} "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('geminiSpinner', {
             text: commands.mcp.setup.spinners.configuredGemini,
         });
@@ -296,3 +330,16 @@ function buildCommandWithAgentString(mcpCommand, agent) {
     mcpCommandCopy.args.push('--ai-agent', agent);
     return mcpCommandCopy;
 }
+function buildEnvFlagString(mcpCommand) {
+    const envFlags = [];
+    if (mcpCommand.env) {
+        const env = Object.entries(mcpCommand.env);
+        env.forEach(([key, value]) => {
+            envFlags.push(`--env ${key}="${value}"`);
+        });
+    }
+    if (envFlags.length === 0) {
+        return '';
+    }
+    return ` ${envFlags.join(' ')}`;
+}

package/lib/middleware/autoUpdateMiddleware.js

@@ -42,6 +42,10 @@ export async function autoUpdateCLI(argv) {
         debugError(e);
     }
     const cliUpgradeInfo = getCliUpgradeInfo();
+    // Ignore all update notifications if the current version is a pre-release (contains a hyphen)
+    if (cliUpgradeInfo.current && cliUpgradeInfo.current.includes('-')) {
+        showManualInstallHelp = false;
+    }
     if (isAllowAutoUpdatesEnabled &&
         cliUpgradeInfo.current &&
         cliUpgradeInfo.latest &&
@@ -49,9 +53,8 @@ export async function autoUpdateCLI(argv) {
         !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;
+        if (!showManualInstallHelp) {
+            // Pre-release version detected, skip auto-update
         }
         else if (!['major', 'latest'].includes(cliUpgradeInfo.type)) {
             // type "latest" => current installed version is latest

package/lib/process.d.ts

@@ -8,6 +8,6 @@ interface KeyPress {
 export declare const TERMINATION_SIGNALS: string[];
 export declare function handleExit(callback: (onTerminate: {
     isSIGHUP: boolean;
-}) => void): void;
+}) => void): () => void;
 export declare function handleKeypress(callback: (onKeyPress: KeyPress) => void): void;
 export {};

package/lib/process.js

@@ -16,9 +16,9 @@ export const TERMINATION_SIGNALS = [
 ];
 export function handleExit(callback) {
     let exitInProgress = false;
+    const listeners = [];
     TERMINATION_SIGNALS.forEach(signal => {
-        process.removeAllListeners(signal);
-        process.on(signal, async (...args) => {
+        const handler = async (...args) => {
             // Prevent duplicate exit handling
             if (!exitInProgress) {
                 exitInProgress = true;
@@ -38,8 +38,15 @@ export function handleExit(callback) {
                 }
                 await callback({ isSIGHUP });
             }
-        });
+        };
+        listeners.push({ signal, handler });
+        process.on(signal, handler);
     });
+    return () => {
+        for (const { signal, handler } of listeners) {
+            process.removeListener(signal, handler);
+        }
+    };
 }
 export function handleKeypress(callback) {
     readline.createInterface(process.stdin, process.stdout);