@hubspot/cli 8.9.1-beta.0 → 8.10.0-beta.0

package/lang/en.js

@@ -4,7 +4,7 @@ import { PLATFORM_VERSIONS } from '@hubspot/project-parsing-lib/constants';
 import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, LEGACY_PUBLIC_APP_FILE, LOCAL_DEV_DEFAULT_PORT, PROJECT_CONFIG_FILE, PROJECT_WITH_APP, } from '../lib/constants.js';
 import { ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME, DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME, GLOBAL_CONFIG_PATH, } from '@hubspot/local-dev-lib/constants/config';
-import { indent, UI_COLORS, uiAccountDescription, uiAuthCommandReference, uiBetaTag, uiCommandReference, uiLink, } from '../lib/ui/index.js';
+import { indent, UI_COLORS, uiAccountDescription, uiAuthCommandReference, uiBetaTag, uiCommandReference, uiDeprecatedTag, uiLink, } from '../lib/ui/index.js';
 import { getLocalDevUiUrl, getProjectDetailUrl, getProjectSettingsUrl, } from '../lib/projects/urls.js';
 import { getProductUpdatesUrl } from '../lib/links.js';
 export const commands = {
@@ -1325,8 +1325,11 @@ export const commands = {
     },
     mcp: {
         describe: 'Commands for managing HubSpot MCP servers.',
+        promotion: {
+            activeNudge: `${chalk.bold('Tip:')} Work faster with AI coding tools. Run ${uiCommandReference('hs mcp setup')} to connect HubSpot developer context to supported clients.`,
+        },
         setup: {
-            describe: 'Setup the HubSpot development MCP servers.',
+            describe: `Run ${uiCommandReference('hs mcp setup')} to connect the HubSpot Dev MCP and work faster with your AI coding tools.`,
             installingDocSearch: 'Adding the docs-search mcp server',
             codex: 'Codex CLI',
             claudeCode: 'Claude Code',
@@ -1900,8 +1903,11 @@ export const commands = {
                 targetRequiresPreview: `${uiCommandReference('--target')} can only be used with ${uiCommandReference('--preview')}.`,
             },
             options: {
+                force: {
+                    describe: 'Skip confirmation prompts and force the upload.',
+                },
                 forceCreate: {
-                    describe: 'Automatically create project if it does not exist',
+                    describe: uiDeprecatedTag(`Automatically create project if it does not exist. Use ${uiCommandReference('--force')} instead.`, false),
                 },
                 message: {
                     describe: 'Add a message when you upload your project and create a build',
@@ -1912,6 +1918,9 @@ export const commands = {
                 skipNpmAudit: {
                     describe: 'Skip the npm audit security check before uploading',
                 },
+                skipAutoDeploy: {
+                    describe: 'Skip automatic deployment after a successful build',
+                },
                 preview: {
                     describe: 'Preview the build on a target portal after a successful upload',
                 },
@@ -2192,6 +2201,47 @@ export const commands = {
                 force: 'skip confirmation prompt',
             },
         },
+        installApp: {
+            describe: 'Install a static auth app from the current project into the target account',
+            verboseDescribe: `Install a static auth app from the current project into the target account.\n\nRun this command from within the project directory. The project must contain a privately distributed static auth app and must already be uploaded to the target account.`,
+            examples: {
+                default: 'Install the static auth app from the current project',
+                withAccount: 'Install the app into a specific account',
+                withProfile: 'Install the app into the account targeted by a profile',
+                json: 'Output install result as JSON',
+            },
+            options: {
+                force: 'Skip confirmation prompts',
+                profile: 'The profile to target with this install',
+            },
+            errors: {
+                noProjectConfig: `No project config found. Run this command from within a HubSpot project directory, or use ${uiCommandReference('hs project create')} to create a new one.`,
+                unsupportedPlatformVersion: (platformVersion) => `This command is only supported for projects on platform version 2025.2 or later (detected: ${platformVersion}).`,
+                failedToParseProject: 'Failed to parse the project. Check your project configuration is valid and try again.',
+                noAppInProject: 'No app was found in the local project. This command requires a project that contains an app.',
+                unsupportedAuthType: (authType) => `This command only supports static auth apps. Detected auth type: ${authType}.`,
+                unsupportedDistribution: (distribution) => `This command only supports privately distributed apps. Detected distribution: ${distribution}.`,
+                invalidAppDeveloperAccount: (accountId) => `Static auth apps can't be installed into the app developer account ${uiAccountDescription(accountId)}. Switch to a standard, sandbox, or developer test account with ${uiCommandReference('hs account use')}, or pass ${uiCommandReference('--account')}.`,
+                projectNotFound: (accountId, projectName) => `The project ${chalk.bold(projectName)} does not exist in ${uiAccountDescription(accountId)}. Run ${uiCommandReference('hs project upload')} to upload your project files to HubSpot.`,
+                appNotDeployed: (appName, accountId) => `The app ${chalk.bold(appName)} has not been deployed to ${uiAccountDescription(accountId)}. Upload the project with ${uiCommandReference('hs project upload')} and ensure the build succeeds, then try again.`,
+                automaticInstallUnavailable: (appName, accountId) => `${chalk.bold(appName)} could not be installed automatically in ${uiAccountDescription(accountId)}.`,
+                installFailed: (appName, accountId) => `Failed to install ${chalk.bold(appName)} in ${uiAccountDescription(accountId)}.`,
+            },
+            jsonErrors: {
+                automaticInstallUnavailable: 'Automatic install is unavailable for this account.',
+                installFailed: (appName, accountId) => `Failed to install ${appName} in account ${accountId}.`,
+            },
+            profileMessage: (profileName, accountId) => `Installing with ${chalk.bold(profileName)} profile: ${uiAccountDescription(accountId)}`,
+            appDeveloperAccountNotice: (accountId) => `${uiAccountDescription(accountId)} is an app developer account, which can't have apps installed into it.`,
+            selectInstallAccountPrompt: 'Select an account to install the app into',
+            uploadAndDeployPrompt: (accountId) => `The app isn't deployed to ${uiAccountDescription(accountId)} yet. Upload and deploy the project now?`,
+            alreadyInstalled: (appName, accountId) => `${chalk.bold(appName)} is already installed in ${uiAccountDescription(accountId)}.`,
+            outdatedScopes: (appName, accountId) => `${chalk.bold(appName)} is installed in ${uiAccountDescription(accountId)} with outdated scopes.`,
+            reinstallPrompt: 'Reinstall the app to grant the latest scopes?',
+            installPrompt: (appName, accountId) => `Install ${chalk.bold(appName)} in ${uiAccountDescription(accountId)}?`,
+            installFromBrowser: (installUrl) => `Install the app in HubSpot: ${uiLink('Open install page', installUrl)}`,
+            success: (appName, accountId) => `${chalk.bold(appName)} installed in ${uiAccountDescription(accountId)}.`,
+        },
         installStatus: {
             describe: 'Check whether a static auth app in the current project is installed in the target account. This command must be run from within a HubSpot project directory.',
             examples: {
@@ -2632,7 +2682,7 @@ export const commands = {
                 serviceLevel: 'Service Hub tier. Options: FREE, STARTER, PROFESSIONAL, ENTERPRISE',
                 salesLevel: 'Sales Hub tier. Options: FREE, STARTER, PROFESSIONAL, ENTERPRISE',
                 contentLevel: 'Content Hub tier. Options: FREE, STARTER, PROFESSIONAL, ENTERPRISE',
-                commerceLevel: 'Commerce Hub tier. Options: FREE, PROFESSIONAL, ENTERPRISE',
+                commerceLevel: 'Revenue Hub tier. Options: FREE, PROFESSIONAL, ENTERPRISE',
             },
             example: (configPath) => `Create a test account from the config file at ${configPath}`,
             examples: {
@@ -3293,6 +3343,11 @@ export const lib = {
     configMiddleWare: {
         invalidAccountIdEnvironmentVariable: 'Unable to parse `HUBSPOT_ACCOUNT_ID` environment variable into a number',
     },
+    accountTargetDiscovery: {
+        errors: {
+            explicitAccountNotFound: (account) => `Account ${chalk.bold(String(account))} was not found in your config. Run ${uiCommandReference('hs account list')} to see available accounts.`,
+        },
+    },
     process: {
         exitDebug: (signal) => `Attempting to gracefully exit. Triggered by ${signal}`,
     },
@@ -3569,6 +3624,11 @@ export const lib = {
             feedbackHeader: "We'd love to hear your feedback!",
             feedbackMessage: `How are you liking the new projects and developer tools? \n > Run ${uiCommandReference('hs feedback')} to let us know what you think!\n`,
         },
+        skippedHsMetaFiles: {
+            warning: (files) => `The following *-hsmeta.json files will be skipped.\nThis CLI version doesn't support the features they require:\n${files.map(f => `  ${chalk.bold(f)}`).join('\n')}\nRun ${uiCommandReference('hs upgrade')} to update the CLI, which may add support for these features.`,
+            uploadWarning: (files) => `The following *-hsmeta.json files will be skipped during upload.\nThis CLI version doesn't support the features they require:\n${files.map(f => `  ${chalk.bold(f)}`).join('\n')}\nRun ${uiCommandReference('hs upgrade')} to update the CLI, which may add support for these features.`,
+            prompt: '[--force] Continue anyway?',
+        },
         components: {
             unableToGetUidFromHsmeta: 'Unable to get UID from hsmeta',
             buildSuccessMessage: {
@@ -3576,9 +3636,9 @@ export const lib = {
                 docsUrl: 'https://developers.hubspot.com/docs/apps/developer-platform/build-apps/overview',
                 headerCreated: (projectName, projectDest) => `${chalk.bold(projectName)} was successfully created in ${projectDest}`,
                 headerAdded: (featureText, uid, plural) => `${featureText} ${plural ? 'were' : 'was'} successfully added to ${uid}:`,
-                docsDetails: (docsLink) => `📖 ${docsLink} for more details about building and testing these features.`,
-                uploadPrompt: `🚀 Run ${uiCommandReference('hs project upload')} when you're ready to deploy.`,
-                devPrompt: `🧪 Run ${uiCommandReference('hs project dev')} to start local development.`,
+                docsDetails: (docsLink) => `${docsLink} for more details about building and testing these features.`,
+                uploadPrompt: `Run ${uiCommandReference('hs project upload')} when you're ready to deploy.`,
+                devPrompt: `Run ${uiCommandReference('hs project dev')} to start local development.`,
             },
         },
     },
@@ -3873,6 +3933,7 @@ export const lib = {
             confirmUseExistingDeveloperTestAccount: (accountName) => `Continue with ${accountName}? This account isn't currently connected to the HubSpot CLI. By continuing, you'll be prompted to generate a personal access key and connect it.`,
             confirmLinkExistingDeveloperTestAccount: (accountName) => `${accountName} is not linked to this directory. Would you like to link it?`,
             noAccountId: 'No account ID found for the selected account. Please try again.',
+            fetchDeveloperTestAccountsError: 'Unable to fetch developer test accounts. Please try again.',
         },
         projectLogsPrompt: {
             functionName: (projectName) => `[--function] Select function in ${chalk.bold(projectName)} project`,
@@ -4277,6 +4338,11 @@ export const lib = {
             installed: (npmVersion) => `npm v${npmVersion} is installed`,
             unableToDetermine: 'Unable to determine if npm is installed',
         },
+        mcpChecks: {
+            configured: (clients) => `HubSpot MCP server configured in ${clients.join(', ')}`,
+            notConfigured: (clients) => `HubSpot MCP server not configured in ${clients.join(', ')}`,
+            notConfiguredSecondary: `Run ${uiCommandReference('hs mcp setup')} to connect AI coding tools to HubSpot developer context`,
+        },
         hsChecks: {
             notLatest: (hsVersion) => `Version ${hsVersion} outdated`,
             notLatestSecondary: (command, hsVersion) => `Run ${uiCommandReference(command)} to upgrade to the latest version ${hsVersion}`,

package/lib/accountTargetDiscovery.d.ts

@@ -0,0 +1,15 @@
+import { DiscoverAccountTargetsOptions, DiscoverAccountTargetsResult } from '../types/AccountTargets.js';
+/**
+ * Discovers the candidate target accounts for a command, plus the recommended
+ * one to use when a single account is the obvious choice.
+ *
+ * Profiles take precedence: when the project defines profiles, the candidates
+ * are the profile accounts only. Otherwise they are ranked explicit account,
+ * then env config, then linked directory, then global default.
+ *
+ * Takes plain options (not yargs argv) and never prompts or exits, so both the
+ * CLI and MCP can call it. `recommended` is omitted when no account is the
+ * obvious choice (for example, several profiles). Throws when an explicit
+ * account is provided but not found in the config.
+ */
+export declare function discoverAccountTargets(options?: DiscoverAccountTargetsOptions): Promise<DiscoverAccountTargetsResult>;

package/lib/accountTargetDiscovery.js

@@ -0,0 +1,175 @@
+import path from 'path';
+import { getConfigAccountIfExists, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { getHsSettingsFileIfExists } from '@hubspot/local-dev-lib/config/hsSettings';
+import { ENVIRONMENT_VARIABLES } from '@hubspot/local-dev-lib/constants/config';
+import { getAllHsProfiles, loadHsProfileFile, } from '@hubspot/project-parsing-lib/profiles';
+import { isTestAccountOrSandbox } from './accountTypes.js';
+import { isDirectoryLinked } from './link/linkUtils.js';
+import { lib } from '../lang/en.js';
+import { ACCOUNT_TARGET_CATEGORIES, ACCOUNT_TARGET_SELECTION_SOURCES, } from '../types/AccountTargets.js';
+function categorizeAccount(account) {
+    if (isTestAccountOrSandbox(account)) {
+        return ACCOUNT_TARGET_CATEGORIES.RECOMMENDED_TESTING;
+    }
+    if (!account.accountType) {
+        return ACCOUNT_TARGET_CATEGORIES.UNKNOWN;
+    }
+    return ACCOUNT_TARGET_CATEGORIES.PRODUCTION_WITH_CARE;
+}
+function candidateFromAccount(account, source, profileName) {
+    return {
+        accountId: account.accountId,
+        accountName: account.name,
+        accountType: account.accountType,
+        environment: account.env || undefined,
+        source,
+        category: categorizeAccount(account),
+        ...(profileName ? { profileName } : {}),
+    };
+}
+function candidateFromAccountId(accountId, source, profileName) {
+    const account = getConfigAccountIfExists(accountId);
+    if (account) {
+        return candidateFromAccount(account, source, profileName);
+    }
+    return {
+        accountId,
+        source,
+        category: ACCOUNT_TARGET_CATEGORIES.UNKNOWN,
+        ...(profileName ? { profileName } : {}),
+    };
+}
+function dedupeByAccountId(candidates) {
+    const seen = new Set();
+    return candidates.filter(candidate => {
+        if (seen.has(candidate.accountId)) {
+            return false;
+        }
+        seen.add(candidate.accountId);
+        return true;
+    });
+}
+async function gatherProfileCandidates(projectDir, projectConfig) {
+    const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
+    const profileNames = await getAllHsProfiles(projectSourceDir);
+    const candidates = [];
+    for (const name of profileNames) {
+        let profile;
+        try {
+            profile = loadHsProfileFile(projectSourceDir, name);
+        }
+        catch {
+            continue;
+        }
+        if (profile && profile.accountId) {
+            candidates.push(candidateFromAccountId(profile.accountId, ACCOUNT_TARGET_SELECTION_SOURCES.PROFILE, name));
+        }
+    }
+    return candidates;
+}
+function resolveProfileRecommendation(profileCandidates, explicitProfileName) {
+    if (explicitProfileName) {
+        return profileCandidates.find(candidate => candidate.profileName === explicitProfileName);
+    }
+    if (profileCandidates.length === 1) {
+        return profileCandidates[0];
+    }
+    return undefined;
+}
+function resolveNonProfileRecommendation({ explicitCandidate, envCandidate, linkedCandidates, linkedDefaultAccountId, defaultCandidate, }) {
+    if (explicitCandidate) {
+        return explicitCandidate;
+    }
+    if (envCandidate) {
+        return envCandidate;
+    }
+    if (linkedCandidates.length > 0) {
+        if (linkedDefaultAccountId !== undefined) {
+            const linkedDefault = linkedCandidates.find(candidate => candidate.accountId === linkedDefaultAccountId);
+            if (linkedDefault) {
+                return linkedDefault;
+            }
+        }
+        if (linkedCandidates.length === 1) {
+            return linkedCandidates[0];
+        }
+        return undefined;
+    }
+    return defaultCandidate;
+}
+/**
+ * Discovers the candidate target accounts for a command, plus the recommended
+ * one to use when a single account is the obvious choice.
+ *
+ * Profiles take precedence: when the project defines profiles, the candidates
+ * are the profile accounts only. Otherwise they are ranked explicit account,
+ * then env config, then linked directory, then global default.
+ *
+ * Takes plain options (not yargs argv) and never prompts or exits, so both the
+ * CLI and MCP can call it. `recommended` is omitted when no account is the
+ * obvious choice (for example, several profiles). Throws when an explicit
+ * account is provided but not found in the config.
+ */
+export async function discoverAccountTargets(options = {}) {
+    const { explicitAccount, useEnv, profileName, projectDir, projectConfig } = options;
+    if (projectDir && projectConfig) {
+        const profileCandidates = await gatherProfileCandidates(projectDir, projectConfig);
+        if (profileCandidates.length > 0) {
+            return {
+                candidates: dedupeByAccountId(profileCandidates),
+                recommended: resolveProfileRecommendation(profileCandidates, profileName),
+            };
+        }
+    }
+    const envConfigActive = Boolean(useEnv) ||
+        process.env[ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG] ===
+            'true';
+    const ordered = [];
+    let explicitCandidate;
+    if (explicitAccount !== undefined && explicitAccount !== '') {
+        const account = getConfigAccountIfExists(explicitAccount);
+        if (!account) {
+            throw new Error(lib.accountTargetDiscovery.errors.explicitAccountNotFound(explicitAccount));
+        }
+        explicitCandidate = candidateFromAccount(account, ACCOUNT_TARGET_SELECTION_SOURCES.EXPLICIT_ACCOUNT);
+        ordered.push(explicitCandidate);
+    }
+    let envCandidate;
+    if (envConfigActive) {
+        const envAccount = getConfigDefaultAccountIfExists();
+        if (envAccount) {
+            envCandidate = candidateFromAccount(envAccount, ACCOUNT_TARGET_SELECTION_SOURCES.ENV_CONFIG);
+            ordered.push(envCandidate);
+        }
+    }
+    const settings = getHsSettingsFileIfExists();
+    const directoryIsLinked = isDirectoryLinked(settings);
+    const linkedCandidates = [];
+    if (directoryIsLinked) {
+        for (const accountId of settings.accounts) {
+            const candidate = candidateFromAccountId(accountId, ACCOUNT_TARGET_SELECTION_SOURCES.LINKED_DIRECTORY);
+            linkedCandidates.push(candidate);
+            ordered.push(candidate);
+        }
+    }
+    let defaultCandidate;
+    if (!envConfigActive) {
+        const defaultAccount = getConfigDefaultAccountIfExists();
+        if (defaultAccount) {
+            defaultCandidate = candidateFromAccount(defaultAccount, ACCOUNT_TARGET_SELECTION_SOURCES.GLOBAL_DEFAULT);
+            ordered.push(defaultCandidate);
+        }
+    }
+    return {
+        candidates: dedupeByAccountId(ordered),
+        recommended: resolveNonProfileRecommendation({
+            explicitCandidate,
+            envCandidate,
+            linkedCandidates,
+            linkedDefaultAccountId: directoryIsLinked
+                ? settings.localDefaultAccount
+                : undefined,
+            defaultCandidate,
+        }),
+    };
+}

package/lib/app/install.d.ts

@@ -0,0 +1,22 @@
+import type { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import type { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
+import type { AppInstallationState, AppIRNode } from '../../types/ProjectComponents.js';
+export type ScopeGroup = {
+    id: number;
+    name: string;
+};
+type CanUseStaticAuthTestAccountInstallOptions = {
+    accountConfig?: HubSpotConfigAccount;
+    appNode?: AppIRNode | null;
+    parentAccountId?: number;
+};
+export declare function getAppNodeFromProjectNodes(projectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}): AppIRNode | null;
+export declare function isStaticAuthApp(appNode?: AppIRNode | null): boolean;
+export declare function isOAuthApp(appNode?: AppIRNode | null): boolean;
+export declare function isPrivateApp(appNode?: AppIRNode | null): boolean;
+export declare function isMarketplaceApp(appNode?: AppIRNode | null): boolean;
+export declare function getAppInstallationState(isInstalledWithScopeGroups: boolean, previouslyAuthorizedScopeGroups: ScopeGroup[]): AppInstallationState;
+export declare function canUseStaticAuthTestAccountInstall({ accountConfig, appNode, parentAccountId, }: CanUseStaticAuthTestAccountInstallOptions): boolean;
+export {};

package/lib/app/install.js

@@ -0,0 +1,42 @@
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, APP_INSTALLATION_STATES, } from '../constants.js';
+import { isDeveloperTestAccount, isSandbox } from '../accountTypes.js';
+import { isAppIRNode } from '../projects/structure.js';
+export function getAppNodeFromProjectNodes(projectNodes) {
+    return Object.values(projectNodes).find(isAppIRNode) || null;
+}
+export function isStaticAuthApp(appNode) {
+    return appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.STATIC;
+}
+export function isOAuthApp(appNode) {
+    return appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH;
+}
+export function isPrivateApp(appNode) {
+    return (appNode?.config.distribution?.toLowerCase() ===
+        APP_DISTRIBUTION_TYPES.PRIVATE);
+}
+export function isMarketplaceApp(appNode) {
+    return (appNode?.config.distribution?.toLowerCase() ===
+        APP_DISTRIBUTION_TYPES.MARKETPLACE);
+}
+export function getAppInstallationState(isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups) {
+    if (isInstalledWithScopeGroups) {
+        return APP_INSTALLATION_STATES.INSTALLED;
+    }
+    if (previouslyAuthorizedScopeGroups.length > 0) {
+        return APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES;
+    }
+    return APP_INSTALLATION_STATES.NOT_INSTALLED;
+}
+export function canUseStaticAuthTestAccountInstall({ accountConfig, appNode, parentAccountId, }) {
+    if (!accountConfig || !isStaticAuthApp(appNode)) {
+        return false;
+    }
+    const accountCanUseTestInstall = isDeveloperTestAccount(accountConfig) || isSandbox(accountConfig);
+    if (!accountCanUseTestInstall) {
+        return false;
+    }
+    if (parentAccountId === undefined) {
+        return true;
+    }
+    return accountConfig.parentAccountId === parentAccountId;
+}

package/lib/app/logs.js

@@ -46,7 +46,7 @@ export function parseSinceTime(sinceInput) {
             endTime: now.valueOf(),
         };
     }
-    const isoTime = moment(sinceInput);
+    const isoTime = moment(sinceInput, moment.ISO_8601, true);
     if (isoTime.isValid()) {
         return {
             startTime: isoTime.valueOf(),

package/lib/auth/awaitPersonalAccessKeyOverWebsocket.js

@@ -3,7 +3,7 @@ import { randomUUID } from 'crypto';
 import open from 'open';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import CLIWebSocketServer from '../CLIWebSocketServer.js';
-import { ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES, ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES, ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION, } from '../constants.js';
+import { ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES, ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES, ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION, } from '../constants.js';
 import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { uiLogger } from '../ui/logger.js';
@@ -55,7 +55,8 @@ function createMessageHandler(server, cliCallbackToken, resolveWebsocketPak) {
 }
 async function awaitKeypressOrWebsocketPak(websocketPakPromise) {
     if (!process.stdin.isTTY) {
-        return { type: 'keypress' };
+        const pak = await websocketPakPromise;
+        return { type: 'pak', pak };
     }
     SpinniesManager.init();
     SpinniesManager.add(SPINNER_ID, {

package/lib/doctor/Doctor.d.ts

@@ -17,6 +17,7 @@ export declare class Doctor {
     private checkIfNodeIsInstalled;
     private checkIfNpmIsInstalled;
     private checkCLIVersion;
+    private checkMcpReadiness;
     private checkIfNpmInstallRequired;
     private isValidJsonFile;
     private checkProjectConfigJsonFiles;

package/lib/doctor/Doctor.js

@@ -23,6 +23,8 @@ import { pkg } from '../jsonLoader.js';
 import { lib } from '../../lang/en.js';
 import { uiLink } from '../ui/index.js';
 import { isServerRunningAtUrl } from '../http.js';
+import { detectConfiguredMcpClients } from '../mcp/promotion.js';
+import { MCP_CLIENTS } from '../mcp/clients.js';
 import { WEBHOOKS_KEY, APP_KEY } from '@hubspot/project-parsing-lib/constants';
 import { validateProjectConfig } from '../projects/config.js';
 import { validateSourceDirectory, handleTranslate, } from '../projects/upload.js';
@@ -73,6 +75,7 @@ export class Doctor {
             this.checkIfNodeIsInstalled(),
             this.checkIfNpmIsInstalled(),
             this.checkCLIVersion(),
+            this.checkMcpReadiness(),
         ];
     }
     performNetworkingChecks() {
@@ -252,6 +255,29 @@ export class Doctor {
             });
         }
     }
+    async checkMcpReadiness() {
+        try {
+            const configuredClients = detectConfiguredMcpClients();
+            const allClientIds = MCP_CLIENTS.map(c => c.id);
+            const unconfiguredClients = allClientIds.filter(id => !configuredClients.includes(id));
+            if (configuredClients.length > 0) {
+                this.diagnosis?.addCliSection({
+                    type: 'success',
+                    message: lib.doctor.mcpChecks.configured(configuredClients),
+                });
+            }
+            if (unconfiguredClients.length > 0) {
+                this.diagnosis?.addCliSection({
+                    type: 'warning',
+                    message: lib.doctor.mcpChecks.notConfigured(unconfiguredClients),
+                    secondaryMessaging: lib.doctor.mcpChecks.notConfiguredSecondary,
+                });
+            }
+        }
+        catch (e) {
+            uiLogger.debug(getErrorMessage(e));
+        }
+    }
     async checkIfNpmInstallRequired() {
         let foundError = false;
         for (const packageFile of this.diagnosticInfo?.packageFiles || []) {

package/lib/getStartedV2Actions.js

@@ -73,7 +73,7 @@ async function fetchAppAfterDeploy(accountId, env) {
 async function buildProjectMetadata(projectDir, projectConfig, accountId) {
     const srcDir = path.join(projectDir, projectConfig.srcDir);
     const projectMetadata = await getProjectMetadata(srcDir);
-    const intermediateRepresentation = await translate({
+    const { intermediateRepresentation } = await translate({
         projectSourceDir: srcDir,
         platformVersion: projectConfig.platformVersion,
         accountId,
@@ -111,6 +111,7 @@ export async function uploadAndDeployAction({ accountId, projectDest, }) {
             isUploadCommand: false,
             sendIR: !isLegacyProject(projectConfig.platformVersion),
             skipValidation: false,
+            force: true,
         });
         if (uploadError) {
             throw new ProjectUploadError(commands.getStarted.errors.uploadActionFailed, uploadError);

package/lib/mcp/clients.d.ts

@@ -0,0 +1,13 @@
+export declare const MCP_SERVER_NAME = "HubSpotDev";
+export type McpClientId = 'codex' | 'claude' | 'cursor' | 'gemini' | 'vscode' | 'windsurf';
+type McpClientDetection = {
+    type: 'json' | 'text';
+    pathSegments: string[];
+};
+export type McpClient = {
+    id: McpClientId;
+    detection: McpClientDetection;
+};
+export declare const MCP_CLIENTS: McpClient[];
+export declare function getMcpClientPathSegments(id: McpClientId): string[];
+export {};

package/lib/mcp/clients.js

@@ -0,0 +1,55 @@
+export const MCP_SERVER_NAME = 'HubSpotDev';
+function getVsCodeMcpConfigPathSegments() {
+    if (process.platform === 'darwin') {
+        return ['Library', 'Application Support', 'Code', 'User', 'mcp.json'];
+    }
+    if (process.platform === 'win32') {
+        return ['AppData', 'Roaming', 'Code', 'User', 'mcp.json'];
+    }
+    return ['.config', 'Code', 'User', 'mcp.json'];
+}
+export const MCP_CLIENTS = [
+    {
+        id: 'codex',
+        detection: {
+            type: 'text',
+            pathSegments: ['.codex', 'config.toml'],
+        },
+    },
+    {
+        id: 'claude',
+        detection: { type: 'json', pathSegments: ['.claude.json'] },
+    },
+    {
+        id: 'cursor',
+        detection: { type: 'json', pathSegments: ['.cursor', 'mcp.json'] },
+    },
+    {
+        id: 'gemini',
+        detection: {
+            type: 'json',
+            pathSegments: ['.gemini', 'settings.json'],
+        },
+    },
+    {
+        id: 'vscode',
+        detection: {
+            type: 'json',
+            pathSegments: getVsCodeMcpConfigPathSegments(),
+        },
+    },
+    {
+        id: 'windsurf',
+        detection: {
+            type: 'json',
+            pathSegments: ['.codeium', 'windsurf', 'mcp_config.json'],
+        },
+    },
+];
+export function getMcpClientPathSegments(id) {
+    const client = MCP_CLIENTS.find(c => c.id === id);
+    if (!client) {
+        return [];
+    }
+    return client.detection.pathSegments;
+}

package/lib/mcp/promotion.d.ts

@@ -0,0 +1,3 @@
+export declare function detectConfiguredMcpClients(): string[];
+export declare function shouldShowMcpPromotion(): Promise<boolean>;
+export declare function showMcpPromotionNudge(commandName: string): Promise<void>;