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

package/lib/ui/uiMessages.d.ts

@@ -0,0 +1,73 @@
+export declare const uiMessages: {
+    betaTag: string;
+    deprecatedTag: string;
+    deprecatedDescription: (message: string, command: string, url?: string) => string;
+    disabledMessage: (command: string, url?: string) => string;
+    disabledUrlText: string;
+    commandRenamedMessage: (newCommand: string) => string;
+    featureHighlight: {
+        defaultTitle: string;
+        featureKeys: {
+            accountOption: {
+                command: string;
+                message: (command: string) => string;
+            };
+            accountsListCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            accountsUseCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            authCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            feedbackCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            getStartedCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            helpCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            projectCreateCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            projectDeployCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            projectHelpCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            projectUploadCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            projectDevCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            projectInstallDepsCommand: {
+                command: string;
+                message: (command: string) => string;
+            };
+            projectCommandTip: {
+                message: string;
+            };
+            sampleProjects: {
+                linkText: string;
+                url: string;
+                message: (link: string) => string;
+            };
+        };
+    };
+};

package/lib/ui/uiMessages.js

@@ -0,0 +1,76 @@
+// UI messages for the UI module - separate file to avoid circular imports with lang/en.ts
+// This contains the same strings that would be in lib.ui.* from lang/en.ts
+import { uiCommandReference, uiLink } from './index.js';
+export const uiMessages = {
+    betaTag: '[BETA]',
+    deprecatedTag: '[DEPRECATED]',
+    deprecatedDescription: (message, command, url) => `${message}. The ${uiCommandReference(command)} command is deprecated and will be disabled soon. ${url ? uiLink('Learn more', url) : ''}`,
+    disabledMessage: (command, url) => `The ${uiCommandReference(command)} command is disabled. Run ${uiCommandReference('npm i -g @hubspot/cli@latest')} to update to the latest HubSpot CLI version. ${url ? uiLink('Learn more', url) : ''}`,
+    disabledUrlText: 'See all HubSpot CLI commands here.',
+    commandRenamedMessage: (newCommand) => `This command has been deprecated. Please use ${uiCommandReference(newCommand)} instead.`,
+    featureHighlight: {
+        defaultTitle: "What's next?",
+        featureKeys: {
+            accountOption: {
+                command: '--account',
+                message: (command) => `Use the ${command} option with any command to override the default account`,
+            },
+            accountsListCommand: {
+                command: 'hs accounts list',
+                message: (command) => `${command} - See a list of configured HubSpot accounts`,
+            },
+            accountsUseCommand: {
+                command: 'hs accounts use',
+                message: (command) => `${command} - Set the Hubspot account that the CLI will target by default`,
+            },
+            authCommand: {
+                command: 'hs auth',
+                message: (command) => `${command} - Connect the CLI to additional HubSpot accounts`,
+            },
+            feedbackCommand: {
+                command: 'hs feedback',
+                message: (command) => `${command} - Report a bug or leave feedback`,
+            },
+            getStartedCommand: {
+                command: 'hs get-started',
+                message: (command) => `${command} - Get started with HubSpot development`,
+            },
+            helpCommand: {
+                command: 'hs help',
+                message: (command) => `${command} - See a list of available commands`,
+            },
+            projectCreateCommand: {
+                command: 'hs project create',
+                message: (command) => `${command} - Create a new project`,
+            },
+            projectDeployCommand: {
+                command: 'hs project deploy',
+                message: (command) => `Ready to take your project live? Run ${command}`,
+            },
+            projectHelpCommand: {
+                command: 'hs project --help',
+                message: (command) => `${command} - Learn more about available project commands`,
+            },
+            projectUploadCommand: {
+                command: 'hs project upload',
+                message: (command) => `${command} - Upload your project to HubSpot and trigger builds`,
+            },
+            projectDevCommand: {
+                command: 'hs project dev',
+                message: (command) => `${command} - Set up a test environment and start local development`,
+            },
+            projectInstallDepsCommand: {
+                command: 'hs project install-deps',
+                message: (command) => `${command} - Install all project dependencies`,
+            },
+            projectCommandTip: {
+                message: 'Tip: All project commands must be run from within a project directory',
+            },
+            sampleProjects: {
+                linkText: "HubSpot's sample projects",
+                url: 'https://developers.hubspot.com/docs/platform/sample-projects?utm_source=cli&utm_content=project_create_whats_next',
+                message: (link) => `See ${link}`,
+            },
+        },
+    },
+};

package/lib/upload.d.ts

@@ -0,0 +1 @@
+export declare function getUploadableFileList(src: string, convertFields?: boolean): Promise<string[]>;

package/lib/upload.js

@@ -0,0 +1,49 @@
+import path from 'path';
+import { walk } from '@hubspot/local-dev-lib/fs';
+import { createIgnoreFilter } from '@hubspot/local-dev-lib/ignoreRules';
+import { isConvertableFieldJs } from '@hubspot/local-dev-lib/cms/handleFieldsJS';
+import { isAllowedExtension } from '@hubspot/local-dev-lib/path';
+import { fieldsJsPrompt } from './prompts/cmsFieldPrompt.js';
+import { logError } from './errorHandlers/index.js';
+/*
+ * Walks the src folder for files, filters them based on ignore filter.
+ * If convertFields is true then will check for any JS fields conflicts (i.e., JS fields file and fields.json file) and prompt to resolve
+ */
+export async function getUploadableFileList(src, convertFields) {
+    let filePaths = [];
+    try {
+        filePaths = await walk(src);
+    }
+    catch (e) {
+        logError(e);
+    }
+    const allowedFiles = filePaths
+        .filter(file => {
+        if (!isAllowedExtension(file)) {
+            return false;
+        }
+        return true;
+    })
+        .filter(createIgnoreFilter(false));
+    if (!convertFields) {
+        return allowedFiles;
+    }
+    const uploadableFiles = [];
+    let skipFiles = [];
+    for (const filePath of allowedFiles) {
+        const fileName = path.basename(filePath);
+        if (skipFiles.includes(filePath))
+            continue;
+        const isConvertable = isConvertableFieldJs(src, filePath, convertFields);
+        if (isConvertable || fileName == 'fields.json') {
+            // This prompt checks if there are multiple field files in the folder and gets user to choose.
+            const [choice, updatedSkipFiles] = await fieldsJsPrompt(filePath, src, skipFiles);
+            skipFiles = updatedSkipFiles;
+            // If they chose something other than the current file, move on.
+            if (choice !== filePath)
+                continue;
+        }
+        uploadableFiles.push(filePath);
+    }
+    return uploadableFiles;
+}

package/lib/usageTracking.d.ts

@@ -0,0 +1,32 @@
+type Meta = {
+    action?: string;
+    os?: string;
+    nodeVersion?: string;
+    nodeMajorVersion?: string;
+    version?: string;
+    command?: string;
+    authType?: string;
+    step?: string;
+    assetType?: string;
+    mode?: string;
+    type?: string | number;
+    file?: boolean;
+    successful?: boolean;
+};
+export declare const EventClass: {
+    USAGE: string;
+    INTERACTION: string;
+    VIEW: string;
+    ACTIVATION: string;
+};
+export declare function getNodeVersionData(): {
+    nodeVersion: string;
+    nodeMajorVersion: string;
+};
+export declare function getPlatform(): string;
+export declare function trackCommandUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
+export declare function trackHelpUsage(command: string): Promise<void>;
+export declare function trackConvertFieldsUsage(command: string): Promise<void>;
+export declare function trackAuthAction(command: string, authType: string, step: string, accountId?: number): Promise<void>;
+export declare function trackCommandMetadataUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
+export {};

package/lib/usageTracking.js

@@ -0,0 +1,174 @@
+import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
+import { getConfigAccountById, getConfig } from '@hubspot/local-dev-lib/config';
+import { API_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
+import { uiLogger } from './ui/logger.js';
+import { pkg } from './jsonLoader.js';
+import { debugError } from './errorHandlers/index.js';
+import { isUsageTrackingDisableFlagSet } from './middleware/usageTrackingMiddleware.js';
+const version = pkg.version;
+const usageTrackingDiabled = 'Usage tracking is disabled via the --disable-usage-tracking flag, not sending usage events';
+export const EventClass = {
+    USAGE: 'USAGE',
+    INTERACTION: 'INTERACTION',
+    VIEW: 'VIEW',
+    ACTIVATION: 'ACTIVATION',
+};
+export function getNodeVersionData() {
+    return {
+        nodeVersion: process.version,
+        nodeMajorVersion: (process.version || '').split('.')[0],
+    };
+}
+export function getPlatform() {
+    switch (process.platform) {
+        case 'darwin':
+            return 'macos';
+        case 'win32':
+            return 'windows';
+        default:
+            return process.platform;
+    }
+}
+export async function trackCommandUsage(command, meta = {}, accountId) {
+    if (isUsageTrackingDisableFlagSet()) {
+        uiLogger.debug(usageTrackingDiabled);
+        return;
+    }
+    try {
+        const config = getConfig();
+        if (config?.allowUsageTracking === false) {
+            return;
+        }
+    }
+    catch (e) { }
+    uiLogger.debug(`Attempting to track usage of "${command}" command`);
+    let authType = 'unknown';
+    if (accountId) {
+        try {
+            const accountConfig = getConfigAccountById(accountId);
+            authType =
+                accountConfig && accountConfig.authType
+                    ? accountConfig.authType
+                    : API_KEY_AUTH_METHOD.value;
+        }
+        catch (e) { }
+    }
+    return trackCliInteraction({
+        action: 'cli-command',
+        command,
+        authType,
+        meta,
+        accountId,
+    });
+}
+export async function trackHelpUsage(command) {
+    if (isUsageTrackingDisableFlagSet()) {
+        uiLogger.debug(usageTrackingDiabled);
+        return;
+    }
+    const config = getConfig();
+    if (config?.allowUsageTracking === false) {
+        return;
+    }
+    if (command) {
+        uiLogger.debug(`Tracking help usage of "${command}" sub-command`);
+    }
+    else {
+        uiLogger.debug('Tracking help usage of main command');
+    }
+    return trackCliInteraction({
+        action: 'cli-help',
+        command,
+    });
+}
+export async function trackConvertFieldsUsage(command) {
+    return trackCliInteraction({
+        action: 'cli-process-fields',
+        command,
+    });
+}
+export async function trackAuthAction(command, authType, step, accountId) {
+    return trackCliInteraction({
+        action: 'cli-auth',
+        command,
+        authType,
+        accountId,
+        meta: {
+            step,
+        },
+    });
+}
+export async function trackCommandMetadataUsage(command, meta = {}, accountId) {
+    if (isUsageTrackingDisableFlagSet()) {
+        uiLogger.debug(usageTrackingDiabled);
+        return;
+    }
+    const config = getConfig();
+    if (config?.allowUsageTracking === false) {
+        return;
+    }
+    uiLogger.debug(`Attempting to track metadata usage of "${command}" command`);
+    let authType = 'unknown';
+    if (accountId) {
+        const accountConfig = getConfigAccountById(accountId);
+        authType =
+            accountConfig && accountConfig.authType
+                ? accountConfig.authType
+                : API_KEY_AUTH_METHOD.value;
+    }
+    return trackCliInteraction({
+        action: 'cli-command-metadata',
+        command,
+        authType,
+        accountId,
+        meta,
+    });
+}
+async function trackCliInteraction({ action, accountId, command, authType, meta = {}, }) {
+    try {
+        const config = getConfig();
+        if (config?.allowUsageTracking === false) {
+            return;
+        }
+        const usageTrackingEvent = {
+            action,
+            os: getPlatform(),
+            ...getNodeVersionData(),
+            version,
+            command,
+            authType,
+            ...meta,
+        };
+        if (process.env.HUBSPOT_MCP_AI_AGENT) {
+            try {
+                await trackUsage('cli-interaction', EventClass.INTERACTION, {
+                    ...usageTrackingEvent,
+                    action: 'cli-mcp-server',
+                    type: process.env.HUBSPOT_MCP_AI_AGENT,
+                }, accountId);
+                uiLogger.debug('Sent AI usage tracking command event:', {
+                    ...usageTrackingEvent,
+                    action: 'cli-mcp-server',
+                    type: process.env.HUBSPOT_MCP_AI_AGENT,
+                });
+            }
+            catch (error) {
+                debugError(error);
+            }
+        }
+        if (isUsageTrackingDisableFlagSet()) {
+            uiLogger.debug(usageTrackingDiabled);
+            return;
+        }
+        try {
+            uiLogger.debug('Sent usage tracking command event:', usageTrackingEvent);
+            return trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+        }
+        catch (error) {
+            debugError(error);
+        }
+    }
+    catch (e) {
+        debugError(e);
+    }
+}

package/lib/utils/hasFlag.d.ts

@@ -0,0 +1 @@
+export declare function hasFlag(flag: string, argv?: string[]): boolean;

package/lib/utils/hasFlag.js

@@ -0,0 +1,9 @@
+import process from 'process';
+// See https://github.com/sindresorhus/has-flag/blob/main/index.js (License: https://github.com/sindresorhus/has-flag/blob/main/license)
+export function hasFlag(flag, argv = process.argv) {
+    const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf('--');
+    return (position !== -1 &&
+        (terminatorPosition === -1 || position < terminatorPosition));
+}

package/lib/validation.d.ts

@@ -0,0 +1,13 @@
+import { Arguments } from 'yargs';
+import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
+export declare function validateAccount(options: Arguments<{
+    account?: string;
+    accountId?: string;
+    derivedAccountId?: number;
+    userProvidedAccount?: string;
+}>): Promise<boolean>;
+export declare function validateCmsPublishMode(options: Arguments<{
+    cmsPublishMode?: CmsPublishMode;
+}>): boolean;
+export declare function fileExists(_path: string): boolean;
+export declare function checkAndConvertToJson(_path: string): unknown | null;

package/lib/validation.js

@@ -0,0 +1,142 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { uiLogger } from '../lib/ui/logger.js';
+import { CMS_PUBLISH_MODE } from '@hubspot/local-dev-lib/constants/files';
+import { API_KEY_AUTH_METHOD, OAUTH_AUTH_METHOD, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
+import { commaSeparatedValues } from '@hubspot/local-dev-lib/text';
+import { getConfigFilePath, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
+import { getOauthManager } from '@hubspot/local-dev-lib/oauth';
+import { accessTokenForPersonalAccessKey } from '@hubspot/local-dev-lib/personalAccessKey';
+import { getAbsoluteFilePath, getCwd, getExt, } from '@hubspot/local-dev-lib/path';
+import { ENVIRONMENT_VARIABLES } from '@hubspot/local-dev-lib/constants/config';
+import { getCmsPublishMode } from './commonOpts.js';
+import { logError } from './errorHandlers/index.js';
+import { lib } from '../lang/en.js';
+export async function validateAccount(options) {
+    const { derivedAccountId, userProvidedAccount } = options;
+    const accountId = derivedAccountId;
+    if (!accountId) {
+        if (userProvidedAccount) {
+            uiLogger.error(lib.validation.accountNotFoundInConfig(userProvidedAccount));
+        }
+        else {
+            uiLogger.error(lib.validation.accountRequired);
+        }
+        return false;
+    }
+    if (userProvidedAccount &&
+        process.env[ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG]) {
+        throw new Error(lib.validation.userProvidedAccount);
+    }
+    const accountConfig = getConfigAccountById(accountId);
+    if (!accountConfig) {
+        uiLogger.error(lib.validation.accountNotConfigured(accountId));
+        return false;
+    }
+    const { authType } = accountConfig;
+    if (typeof authType === 'string' && authType !== authType.toLowerCase()) {
+        uiLogger.error(lib.validation.invalidAuthType(authType, accountId, getConfigFilePath(), commaSeparatedValues([
+            PERSONAL_ACCESS_KEY_AUTH_METHOD,
+            OAUTH_AUTH_METHOD,
+            API_KEY_AUTH_METHOD,
+        ].map(method => method.value))));
+    }
+    if (authType === 'oauth2') {
+        if (typeof accountConfig.auth !== 'object') {
+            uiLogger.error(lib.validation.oauth2ConfigMissing(accountId));
+            return false;
+        }
+        const { clientId, clientSecret, tokenInfo } = accountConfig.auth;
+        if (!clientId || !clientSecret || !tokenInfo || !tokenInfo.refreshToken) {
+            uiLogger.error(lib.validation.oauth2ConfigIncorrect(accountId));
+            return false;
+        }
+        const oauth = getOauthManager(accountConfig);
+        try {
+            let accessToken;
+            if (oauth) {
+                accessToken = await oauth.accessToken();
+            }
+            if (!accessToken) {
+                uiLogger.error(lib.validation.oauth2AccessTokenNotFound(accountId));
+                return false;
+            }
+        }
+        catch (e) {
+            logError(e);
+            return false;
+        }
+    }
+    else if (authType === 'personalaccesskey') {
+        if (!accountConfig.personalAccessKey) {
+            uiLogger.error(lib.validation.personalAccessKeyMissing(accountId));
+            return false;
+        }
+        try {
+            const accessToken = await accessTokenForPersonalAccessKey(accountId);
+            if (!accessToken) {
+                uiLogger.error(lib.validation.personalAccessKeyTokenRetrievalFailed(accountId));
+                return false;
+            }
+        }
+        catch (e) {
+            logError(e);
+            return false;
+        }
+    }
+    else if (!accountConfig.apiKey) {
+        uiLogger.error(lib.validation.authConfigurationMissing(accountId));
+        return false;
+    }
+    return true;
+}
+export function validateCmsPublishMode(options) {
+    const cmsPublishMode = getCmsPublishMode(options);
+    if (CMS_PUBLISH_MODE[cmsPublishMode]) {
+        return true;
+    }
+    const modesMessage = lib.validation.availableCMSModes(Object.values(CMS_PUBLISH_MODE).join(', '));
+    if (cmsPublishMode != null) {
+        uiLogger.error(lib.validation.invalidCmsPublishMode(cmsPublishMode, modesMessage));
+    }
+    else {
+        uiLogger.error(lib.validation.missingCmsPublishMode(modesMessage));
+    }
+    return false;
+}
+export function fileExists(_path) {
+    try {
+        const absoluteSrcPath = path.resolve(getCwd(), _path);
+        if (!absoluteSrcPath)
+            return false;
+        const stats = fs.statSync(absoluteSrcPath);
+        const isFile = stats.isFile();
+        if (!isFile) {
+            return false;
+        }
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+export function checkAndConvertToJson(_path) {
+    const filePath = getAbsoluteFilePath(_path);
+    if (!fileExists(filePath)) {
+        uiLogger.error(lib.validation.pathNotFile(_path));
+        return null;
+    }
+    if (getExt(_path) !== 'json') {
+        uiLogger.error(lib.validation.fileNotJson(_path));
+        return null;
+    }
+    let result;
+    try {
+        result = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch (e) {
+        uiLogger.error(lib.validation.fileInvalidJson(_path));
+        result = null;
+    }
+    return result;
+}

package/lib/yargsUtils.d.ts

@@ -0,0 +1,16 @@
+import { Argv } from 'yargs';
+import { hasFlag } from './utils/hasFlag.js';
+export { hasFlag };
+export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>, command: string | string[], describe?: string, options?: {
+    useGlobalOptions?: boolean;
+    useAccountOptions?: boolean;
+    useConfigOptions?: boolean;
+    useEnvironmentOptions?: boolean;
+    useTestingOptions?: boolean;
+    useCmsPublishModeOptions?: boolean | {
+        read?: boolean;
+        write?: boolean;
+    };
+    useJSONOutputOptions?: boolean;
+}): (yargs: Argv) => Promise<Argv<T>>;
+export declare function strictEnforceBoolean(rawArgs: string[], booleanOptions: string[]): boolean;

package/lib/yargsUtils.js

@@ -0,0 +1,49 @@
+import { addCustomHelpOutput, addTestingOptions, addAccountOptions, addConfigOptions, addGlobalOptions, addUseEnvironmentOptions, addCmsPublishModeOptions, addJSONOutputOptions, } from './commonOpts.js';
+import { hasFlag } from './utils/hasFlag.js';
+import { commands } from '../lang/en.js';
+// Re-export for backwards compatibility
+export { hasFlag };
+export function makeYargsBuilder(callback, command, describe, options = {}) {
+    return async function (yargs) {
+        if (options.useGlobalOptions) {
+            addGlobalOptions(yargs);
+        }
+        if (options.useAccountOptions) {
+            addAccountOptions(yargs);
+        }
+        if (options.useConfigOptions) {
+            addConfigOptions(yargs);
+        }
+        if (options.useEnvironmentOptions) {
+            addUseEnvironmentOptions(yargs);
+        }
+        if (options.useTestingOptions) {
+            addTestingOptions(yargs);
+        }
+        if (options.useJSONOutputOptions) {
+            addJSONOutputOptions(yargs);
+        }
+        if (options.useCmsPublishModeOptions) {
+            const opts = typeof options.useCmsPublishModeOptions === 'object'
+                ? options.useCmsPublishModeOptions
+                : { write: true };
+            addCmsPublishModeOptions(yargs, opts);
+        }
+        const result = callback(yargs);
+        // Must go last to pick up available options
+        await addCustomHelpOutput(result, command, describe);
+        return result;
+    };
+}
+export function strictEnforceBoolean(rawArgs, booleanOptions) {
+    for (const option of booleanOptions) {
+        const argIndex = rawArgs.findIndex(arg => arg.startsWith(`--${option}=`));
+        if (argIndex !== -1) {
+            const value = rawArgs[argIndex].split('=')[1];
+            if (value && !['true', 'false'].includes(value.toLowerCase())) {
+                throw new Error(commands.config.subcommands.set.errors.invalidBoolean(option, value));
+            }
+        }
+    }
+    return true;
+}

package/mcp-server/server.d.ts

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

package/mcp-server/server.js

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerProjectTools, registerCmsTools } from './tools/index.js';
+const server = new McpServer({
+    name: 'HubSpot CLI MCP Server',
+    version: '0.0.1',
+    description: 'Helps perform tasks for local development of HubSpot projects.',
+});
+registerProjectTools(server);
+registerCmsTools(server);
+// Start receiving messages on stdin and sending messages on stdout
+const transport = new StdioServerTransport();
+server.connect(transport);