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

package/lib/middleware/fireAlarmMiddleware.js

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+import { fetchFireAlarms } from '@hubspot/local-dev-lib/api/fireAlarm';
+import { debugError } from '../errorHandlers/index.js';
+import { pkg } from '../jsonLoader.js';
+import { renderInline } from '../../ui/render.js';
+import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
+/*
+ * Versions can be formatted like this:
+ * =7.2.2 -> targets the exact version 7.2.2
+ * =7.2.* -> targets all versions with a major of 7 and a minor of 2
+ * =7.* -> targets all versions with a major of 7
+ * =* -> targets all versions
+ * <=7.2.2 -> targets all versions equal to or less than 7.2.2
+ * <=7.2.* -> targets all versions equal to or less than 7.2
+ */
+const WILDCARD = '*';
+function isVersionTargeted(version, targetVersionString) {
+    // Assume we're targeting no versions if no version string is found
+    // Target all versions using the * wildcard
+    if (!targetVersionString) {
+        return false;
+    }
+    // Only support version targeting for the <= or = operator
+    if (!targetVersionString.startsWith('<=') &&
+        !targetVersionString.startsWith('=')) {
+        return false;
+    }
+    const targetVersion = targetVersionString.substring(targetVersionString.indexOf('=') + 1);
+    // Only allow exact version matching for tagged CLI releases (like -beta)
+    if (version.includes('-') || targetVersionString.includes('-')) {
+        if (!targetVersionString.startsWith('=')) {
+            return false;
+        }
+        return version === targetVersion;
+    }
+    const targetVersionParts = targetVersion.split('.');
+    const versionParts = version.split('.');
+    // Require the wildcard to be explicitly set to target all versions
+    if (versionParts.length < 3 &&
+        versionParts[versionParts.length - 1] !== WILDCARD) {
+        return false;
+    }
+    // Don't allow the less than or equal to operator to be used with the wildcard
+    // in the major version part (e.g. <=*)
+    if (targetVersionString.startsWith('<=') && versionParts[0] === WILDCARD) {
+        return false;
+    }
+    let targetAnyVersion = false;
+    return targetVersionParts.every((targetPart, i) => {
+        const versionPart = versionParts[i];
+        // Support generic version targeting (like 1.2.*)
+        if (targetPart === WILDCARD || targetAnyVersion) {
+            targetAnyVersion = true;
+            return true;
+        }
+        // Double check that the target part is a number
+        if (isNaN(Number(targetPart))) {
+            return false;
+        }
+        return targetVersionString.startsWith('<=')
+            ? Number(versionPart) <= Number(targetPart)
+            : Number(versionPart) === Number(targetPart);
+    });
+}
+function isCommandTargeted(command, targetCommandsString) {
+    // Require the wildcard to be explicitly set to target all commands
+    if (!targetCommandsString) {
+        return false;
+    }
+    if (targetCommandsString === WILDCARD) {
+        return true;
+    }
+    const targetCommands = targetCommandsString.split(',');
+    return targetCommands.some(cmd => command.startsWith(cmd));
+}
+function filterFireAlarm(fireAlarm, command, version) {
+    const commandIsTargeted = isCommandTargeted(command, fireAlarm.querySelector);
+    const versionIsTargeted = isVersionTargeted(version, fireAlarm.urlRegexPattern);
+    return commandIsTargeted && versionIsTargeted;
+}
+async function getFireAlarms(accountId, command, version) {
+    let relevantAlarms = [];
+    try {
+        const { data: fireAlarms } = await fetchFireAlarms(accountId);
+        relevantAlarms = fireAlarms.filter(fireAlarm => filterFireAlarm(fireAlarm, command, version));
+    }
+    catch (error) {
+        debugError(error);
+    }
+    return relevantAlarms;
+}
+async function logFireAlarms(accountId, command, version) {
+    const alarms = await getFireAlarms(accountId, command, version);
+    if (alarms.length > 0) {
+        const notifications = alarms.reduce((acc, alarm) => {
+            if (alarm.title && alarm.message) {
+                return (acc +
+                    `${acc.length > 0 ? '\n\n' : ''}${chalk.bold(alarm.title)}\n${alarm.message}`);
+            }
+            return acc;
+        }, '');
+        await renderInline(getWarningBox({
+            title: 'Notifications',
+            message: notifications,
+        }));
+    }
+}
+export async function checkFireAlarms(argv) {
+    const { derivedAccountId } = argv;
+    try {
+        if (derivedAccountId) {
+            await logFireAlarms(derivedAccountId, argv._.join(' '), pkg.version);
+        }
+    }
+    catch (error) {
+        debugError(error);
+    }
+}

package/lib/middleware/gitMiddleware.d.ts

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

package/lib/middleware/gitMiddleware.js

@@ -0,0 +1,21 @@
+import { getConfigFilePath, globalConfigFileExists, } from '@hubspot/local-dev-lib/config';
+import { ENVIRONMENT_VARIABLES } from '@hubspot/local-dev-lib/constants/config';
+import { checkAndWarnGitInclusion } from '../ui/git.js';
+import { debugError } from '../errorHandlers/index.js';
+export function checkAndWarnGitInclusionMiddleware(argv) {
+    // Skip this when no command is provided or if using environment config
+    if (argv._.length &&
+        !process.env[ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG]) {
+        // Skip if using global config
+        if (globalConfigFileExists()) {
+            return;
+        }
+        try {
+            const configPath = getConfigFilePath();
+            checkAndWarnGitInclusion(configPath);
+        }
+        catch (error) {
+            debugError(error);
+        }
+    }
+}

package/lib/middleware/requestMiddleware.d.ts

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

package/lib/middleware/requestMiddleware.js

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

package/lib/middleware/spinniesMiddleware.d.ts

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

package/lib/middleware/spinniesMiddleware.js

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

package/lib/middleware/usageTrackingMiddleware.d.ts

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

package/lib/middleware/usageTrackingMiddleware.js

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

package/lib/middleware/yargsChecksMiddleware.d.ts

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

package/lib/middleware/yargsChecksMiddleware.js

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

package/lib/npm/npmCli.d.ts

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

package/lib/npm/npmCli.js

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

package/lib/npm/packageJson.d.ts

@@ -0,0 +1,24 @@
+import type { PackageJson } from '../../types/PackageJson.js';
+export interface PackageJsonWithMetadata {
+    packageJsonFilename: string;
+    packageRootDirectory: string;
+    packageJson: PackageJson;
+}
+/**
+ * Reads and parses a package.json file, with caching.
+ *
+ * @param packageJsonPath - Absolute path to the package.json file
+ * @returns The parsed PackageJson object, or null if the file doesn't exist or is invalid
+ */
+export declare const safeGetPackageJsonCached: (packageJsonPath: string) => PackageJson | null;
+/**
+ * Clears all cached package.json data and file paths.
+ * Use this when package.json files may have been modified externally.
+ */
+export declare const clearPackageJsonCache: () => void;
+/**
+ * Finds all package.json files in the project, with caching.
+ *
+ * @returns Array of absolute paths to package.json files in the project
+ */
+export declare function findAllPackageJsonFilesInProjectCached(): Promise<string[]>;

package/lib/npm/packageJson.js

@@ -0,0 +1,102 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { walk } from '@hubspot/local-dev-lib/fs';
+import { getProjectConfig } from '../projects/config.js';
+const packageJsonCache = new Map();
+const packageJsonFilesCache = new Map();
+const safeReadTextFile = (filePath) => {
+    try {
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+};
+const safeReadJsonFile = (filePath) => {
+    const text = safeReadTextFile(filePath);
+    if (text === null) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+};
+const safeReadPackageJsonWithMetadataUncached = (packageJsonPath) => {
+    const manifest = safeReadJsonFile(packageJsonPath);
+    if (!manifest) {
+        return null;
+    }
+    return {
+        packageJsonFilename: packageJsonPath,
+        packageRootDirectory: path.dirname(packageJsonPath),
+        packageJson: manifest,
+    };
+};
+const safeReadPackageJsonWithMetadataCached = (packageJsonPath) => {
+    const maybeCachedPackageJsonWithMetadata = packageJsonCache.get(packageJsonPath);
+    if (maybeCachedPackageJsonWithMetadata !== undefined) {
+        return maybeCachedPackageJsonWithMetadata;
+    }
+    // If not cached, read the package.json file and cache the result.
+    const packageJsonWithMetadata = safeReadPackageJsonWithMetadataUncached(packageJsonPath);
+    packageJsonCache.set(packageJsonPath, packageJsonWithMetadata);
+    return packageJsonWithMetadata;
+};
+/**
+ * Reads and parses a package.json file, with caching.
+ *
+ * @param packageJsonPath - Absolute path to the package.json file
+ * @returns The parsed PackageJson object, or null if the file doesn't exist or is invalid
+ */
+export const safeGetPackageJsonCached = (packageJsonPath) => {
+    const maybePackageJsonWithMetadata = safeReadPackageJsonWithMetadataCached(packageJsonPath);
+    return maybePackageJsonWithMetadata?.packageJson || null;
+};
+/**
+ * Clears all cached package.json data and file paths.
+ * Use this when package.json files may have been modified externally.
+ */
+export const clearPackageJsonCache = () => {
+    packageJsonCache.clear();
+    packageJsonFilesCache.clear();
+};
+const findAllPackageJsonFilesInDirectoryUncached = async (directory) => {
+    const packageJsonFiles = (await walk(directory)).filter(file => file.includes('package.json') &&
+        !file.includes('node_modules') &&
+        !file.includes('.vite'));
+    return packageJsonFiles;
+};
+/**
+ * Finds all package.json files in a directory recursively, with caching.
+ * Excludes files in node_modules and .vite directories.
+ *
+ * @param directory - Root directory to search from
+ * @returns Array of absolute paths to package.json files
+ */
+const findAllPackageJsonFilesInDirectoryCached = async (directory) => {
+    const maybeCachedPackageJsonFiles = packageJsonFilesCache.get(directory);
+    if (maybeCachedPackageJsonFiles) {
+        return maybeCachedPackageJsonFiles;
+    }
+    // If not cached, find all package.json files in the directory and cache the result.
+    const packageJsonFiles = await findAllPackageJsonFilesInDirectoryUncached(directory);
+    packageJsonFilesCache.set(directory, packageJsonFiles);
+    return packageJsonFiles;
+};
+/**
+ * Finds all package.json files in the project, with caching.
+ *
+ * @returns Array of absolute paths to package.json files in the project
+ */
+export async function findAllPackageJsonFilesInProjectCached() {
+    const projectConfig = await getProjectConfig();
+    const { projectDir } = projectConfig;
+    if (!projectDir) {
+        return [];
+    }
+    const packageJsonFiles = await findAllPackageJsonFilesInDirectoryCached(projectDir);
+    return packageJsonFiles;
+}

package/lib/npm/workspaces.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Finds the npm workspace root directory that contains the given package location, with caching.
+ *
+ * Searches through all package.json files in the project to find one that defines
+ * workspaces (via the "workspaces" field) and includes the specified directory
+ * within those workspace patterns.
+ *
+ * @param targetPackageDirectory - The absolute path to the package directory to find the workspace root for
+ * @returns The absolute path to the workspace root directory, or null if the package is not part of any workspace
+ *
+ */
+export declare const getNpmWorkspaceDirectoryForPackageAtLocationCached: (targetPackageDirectory: string) => Promise<string | null>;

package/lib/npm/workspaces.js

@@ -0,0 +1,48 @@
+import { minimatch } from 'minimatch';
+import path from 'path';
+import { safeGetPackageJsonCached, findAllPackageJsonFilesInProjectCached, } from './packageJson.js';
+/**
+ * Checks if a package directory matches any of the workspace glob patterns.
+ *
+ * @param directory - The absolute path to the package directory to check
+ * @param workspaceRoot - The absolute path to the workspace root directory
+ * @param workspaces - Array of glob patterns defining workspace locations (e.g., ['packages/*', 'apps/*'])
+ * @returns True if the directory matches any workspace pattern, false otherwise
+ */
+const isPackageLocationInWorkspaces = (directory, workspaceRoot, workspaces) => {
+    const relativePath = path.relative(workspaceRoot, directory);
+    return workspaces.some(workspace => minimatch(relativePath, workspace));
+};
+/**
+ * Finds the npm workspace root directory that contains the given package location, with caching.
+ *
+ * Searches through all package.json files in the project to find one that defines
+ * workspaces (via the "workspaces" field) and includes the specified directory
+ * within those workspace patterns.
+ *
+ * @param targetPackageDirectory - The absolute path to the package directory to find the workspace root for
+ * @returns The absolute path to the workspace root directory, or null if the package is not part of any workspace
+ *
+ */
+export const getNpmWorkspaceDirectoryForPackageAtLocationCached = async (targetPackageDirectory) => {
+    const allPackageJsonFilesInProject = await findAllPackageJsonFilesInProjectCached();
+    if (allPackageJsonFilesInProject.length === 0) {
+        return null;
+    }
+    for (const currentPackageJsonFile of allPackageJsonFilesInProject) {
+        const packageJson = safeGetPackageJsonCached(currentPackageJsonFile);
+        const workspaces = packageJson?.workspaces;
+        if (!Array.isArray(workspaces) || workspaces.length === 0) {
+            // If the package.json file does not define any workspaces, skip it, since
+            // it cannot be an npm workspace root.
+            continue;
+        }
+        // We found a package.json file that defines workspaces, so we can now check if the given
+        // directory is part of any of the workspace patterns.
+        const currentPackageDirectory = path.dirname(currentPackageJsonFile);
+        if (isPackageLocationInWorkspaces(targetPackageDirectory, currentPackageDirectory, workspaces)) {
+            return currentPackageDirectory;
+        }
+    }
+    return null;
+};

package/lib/oauth.d.ts

@@ -0,0 +1,2 @@
+import { OAuthConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+export declare function authenticateWithOauth(accountConfig: OAuthConfigAccount): Promise<void>;

package/lib/oauth.js

@@ -0,0 +1,93 @@
+import express from 'express';
+import open from 'open';
+import { OAuth2Manager } from '@hubspot/local-dev-lib/models/OAuth2Manager';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { uiLogger } from './ui/logger.js';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { DEFAULT_OAUTH_SCOPES } from '@hubspot/local-dev-lib/constants/auth';
+import { handleExit } from './process.js';
+import { lib } from '../lang/en.js';
+const PORT = 3000;
+const redirectUri = `http://localhost:${PORT}/oauth-callback`;
+function buildAuthUrl(oauthManager) {
+    const { env: accountEnv, auth } = oauthManager.account;
+    const env = accountEnv || ENVIRONMENTS.PROD;
+    const scopes = auth.scopes.length > 0 ? auth.scopes : DEFAULT_OAUTH_SCOPES;
+    if (!auth.clientId) {
+        throw new Error(lib.oauth.missingClientId);
+    }
+    return (`${getHubSpotWebsiteOrigin(env)}/oauth/${oauthManager.account.accountId}/authorize` +
+        `?client_id=${encodeURIComponent(auth.clientId)}` + // app's client ID
+        `&scope=${encodeURIComponent(scopes.join(' '))}` + // scopes being requested by the app
+        `&redirect_uri=${encodeURIComponent(redirectUri)}` // where to send the user after the consent page
+    );
+}
+function handleServerOnProcessEnd(server) {
+    const shutdownServerIfRunning = () => {
+        server?.close();
+    };
+    handleExit(shutdownServerIfRunning);
+}
+async function authorize(oauthManager) {
+    if (process.env.BROWSER !== 'none') {
+        open(buildAuthUrl(oauthManager), { url: true });
+    }
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve, reject) => {
+        let server;
+        const app = express();
+        app.get('/oauth-callback', async (req, res) => {
+            if (req.query.code) {
+                const authCodeProof = {
+                    grant_type: 'authorization_code',
+                    client_id: oauthManager.account.auth.clientId,
+                    client_secret: oauthManager.account.auth.clientSecret,
+                    redirect_uri: redirectUri,
+                    code: req.query.code,
+                };
+                try {
+                    await oauthManager.exchangeForTokens(authCodeProof);
+                    res.send(`
+          <body>
+            <h2>Authorization succeeded (you can close this page)</h2>
+          </body>
+          `);
+                }
+                catch (e) {
+                    res.send(`
+          <body>
+            <h2>Authorization failed (you can close this page)</h2>
+          </body>
+          `);
+                }
+            }
+            if (server) {
+                server.close();
+                server = null;
+            }
+            if (req.query.code) {
+                resolve();
+            }
+            else {
+                reject();
+            }
+        });
+        server = app.listen(PORT, () => uiLogger.log(`Waiting for authorization...`));
+        handleServerOnProcessEnd(server);
+    });
+}
+function setupOauth(accountConfig) {
+    const config = getConfigAccountById(accountConfig.accountId);
+    return new OAuth2Manager({
+        ...accountConfig,
+        env: accountConfig.env || config?.env || ENVIRONMENTS.PROD,
+    });
+}
+export async function authenticateWithOauth(accountConfig) {
+    const oauthManager = setupOauth(accountConfig);
+    uiLogger.log('Authorizing');
+    await authorize(oauthManager);
+    addOauthToAccountConfig(oauthManager);
+}

package/lib/parsing.d.ts

@@ -0,0 +1 @@
+export declare function parseStringToNumber(maybeNumber: string): number;

package/lib/parsing.js

@@ -0,0 +1,8 @@
+import { lib } from '../lang/en.js';
+export function parseStringToNumber(maybeNumber) {
+    const result = parseInt(maybeNumber, 10);
+    if (Number.isNaN(result) || !/^-?\d+$/.test(maybeNumber)) {
+        throw new Error(lib.parsing.unableToParseStringToNumber);
+    }
+    return result;
+}

package/lib/polling.d.ts

@@ -0,0 +1,21 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+export declare const DEFAULT_POLLING_STATES: {
+    readonly STARTED: "STARTED";
+    readonly SUCCESS: "SUCCESS";
+    readonly ERROR: "ERROR";
+    readonly REVERTED: "REVERTED";
+    readonly FAILURE: "FAILURE";
+};
+export declare const DEFAULT_POLLING_STATUS_LOOKUP: {
+    successStates: "SUCCESS"[];
+    errorStates: ("FAILURE" | "ERROR" | "REVERTED")[];
+};
+type GenericPollingResponse = {
+    status: string;
+};
+type PollingCallback<T extends GenericPollingResponse> = () => HubSpotPromise<T>;
+export declare function poll<T extends GenericPollingResponse>(callback: PollingCallback<T>, statusLookup?: {
+    successStates: string[];
+    errorStates: string[];
+}, timeoutMs?: number): Promise<T>;
+export {};

package/lib/polling.js

@@ -0,0 +1,48 @@
+import { DEFAULT_POLLING_DELAY } from './constants.js';
+import { lib } from '../lang/en.js';
+export const DEFAULT_POLLING_STATES = {
+    STARTED: 'STARTED',
+    SUCCESS: 'SUCCESS',
+    ERROR: 'ERROR',
+    REVERTED: 'REVERTED',
+    FAILURE: 'FAILURE',
+};
+export const DEFAULT_POLLING_STATUS_LOOKUP = {
+    successStates: [DEFAULT_POLLING_STATES.SUCCESS],
+    errorStates: [
+        DEFAULT_POLLING_STATES.ERROR,
+        DEFAULT_POLLING_STATES.REVERTED,
+        DEFAULT_POLLING_STATES.FAILURE,
+    ],
+};
+export function poll(callback, statusLookup = DEFAULT_POLLING_STATUS_LOOKUP, timeoutMs = 60000 // Default 60 second timeout
+) {
+    return new Promise((resolve, reject) => {
+        const pollInterval = setInterval(async () => {
+            try {
+                const { data: pollResp } = await callback();
+                const { status } = pollResp;
+                if (statusLookup.successStates.includes(status)) {
+                    clearInterval(pollInterval);
+                    clearTimeout(timeoutId);
+                    resolve(pollResp);
+                }
+                else if (statusLookup.errorStates.includes(status)) {
+                    clearInterval(pollInterval);
+                    clearTimeout(timeoutId);
+                    reject(pollResp);
+                }
+            }
+            catch (error) {
+                clearInterval(pollInterval);
+                clearTimeout(timeoutId);
+                reject(error);
+            }
+        }, DEFAULT_POLLING_DELAY);
+        // Set a timeout to stop polling after specified duration
+        const timeoutId = setTimeout(() => {
+            clearInterval(pollInterval);
+            reject(new Error(lib.polling.timeoutError(timeoutMs)));
+        }, timeoutMs);
+    });
+}