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

package/lib/prompts/sandboxesPrompt.js

@@ -0,0 +1,63 @@
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { isSandbox } from '../accountTypes.js';
+import { getConfigDefaultAccountIfExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
+function mapSandboxAccountChoices(portals) {
+    return (portals
+        ?.filter(p => isSandbox(p))
+        .map(p => ({
+        name: uiAccountDescription(p.accountId, false),
+        value: p.accountId,
+    })) || []);
+}
+function mapNonSandboxAccountChoices(portals) {
+    return (portals
+        ?.filter(p => !isSandbox(p))
+        .map(p => ({
+        name: `${p.name} (${p.accountId})`,
+        value: p.accountId,
+    })) || []);
+}
+export async function sandboxTypePrompt() {
+    return promptUser([
+        {
+            name: 'type',
+            message: lib.prompts.sandboxesPrompt.type.message,
+            type: 'list',
+            choices: [
+                {
+                    name: lib.prompts.sandboxesPrompt.type.developer,
+                    value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                },
+                {
+                    name: lib.prompts.sandboxesPrompt.type.standard,
+                    value: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+                },
+            ],
+            default: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        },
+    ]);
+}
+export function deleteSandboxPrompt(promptParentAccount = false) {
+    const accountsList = getAllConfigAccounts();
+    const choices = promptParentAccount
+        ? mapNonSandboxAccountChoices(accountsList)
+        : mapSandboxAccountChoices(accountsList);
+    if (!choices.length) {
+        return Promise.resolve(undefined);
+    }
+    return promptUser([
+        {
+            name: 'account',
+            message: promptParentAccount
+                ? lib.prompts.sandboxesPrompt.selectParentAccountName
+                : lib.prompts.sandboxesPrompt.selectAccountName,
+            type: 'list',
+            pageSize: 20,
+            choices,
+            default: getConfigDefaultAccountIfExists()?.accountId,
+        },
+    ]);
+}

package/lib/prompts/secretPrompt.d.ts

@@ -0,0 +1,13 @@
+type SecretValuePromptResponse = {
+    secretValue: string;
+};
+export declare function secretValuePrompt(): Promise<SecretValuePromptResponse>;
+type SecretNamePromptResponse = {
+    secretName: string;
+};
+export declare function secretNamePrompt(): Promise<SecretNamePromptResponse>;
+type SecretListPromptResponse = {
+    secretToModify: string;
+};
+export declare function secretListPrompt(secrets: string[], message: string): Promise<SecretListPromptResponse>;
+export {};

package/lib/prompts/secretPrompt.js

@@ -0,0 +1,31 @@
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+export function secretValuePrompt() {
+    return promptUser([
+        {
+            name: 'secretValue',
+            type: 'password',
+            mask: '*',
+            message: lib.prompts.secretPrompt.enterValue,
+        },
+    ]);
+}
+export function secretNamePrompt() {
+    return promptUser([
+        {
+            name: 'secretName',
+            type: 'input',
+            message: lib.prompts.secretPrompt.enterName,
+        },
+    ]);
+}
+export function secretListPrompt(secrets, message) {
+    return promptUser([
+        {
+            name: 'secretToModify',
+            type: 'list',
+            choices: secrets,
+            message,
+        },
+    ]);
+}

package/lib/prompts/selectAppPrompt.d.ts

@@ -0,0 +1,2 @@
+import { PublicApp } from '@hubspot/local-dev-lib/types/Apps';
+export declare function selectAppPrompt(accountId: number, appId?: number): Promise<PublicApp | null>;

package/lib/prompts/selectAppPrompt.js

@@ -0,0 +1,37 @@
+import { uiLogger } from '../ui/logger.js';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { debugError } from '../errorHandlers/index.js';
+import { lib } from '../../lang/en.js';
+import { listPrompt } from '../prompts/promptUtils.js';
+export async function selectAppPrompt(accountId, appId) {
+    let availableApps = [];
+    try {
+        const appsResponse = await fetchPublicAppsForPortal(accountId);
+        if (appsResponse.data.results) {
+            availableApps = appsResponse.data.results;
+        }
+    }
+    catch (err) {
+        debugError(err);
+    }
+    if (availableApps.length === 0) {
+        uiLogger.error(lib.prompts.selectAppPrompt.errors.noApps);
+        return null;
+    }
+    if (appId) {
+        const targetApp = availableApps.find(app => app.id === appId);
+        if (targetApp) {
+            return targetApp;
+        }
+        else {
+            uiLogger.error(lib.prompts.selectAppPrompt.errors.invalidAppId);
+        }
+    }
+    const appPromptValue = await listPrompt(lib.prompts.selectAppPrompt.selectAppId, {
+        choices: availableApps.map(app => ({
+            name: `${app.name} (${app.id})`,
+            value: app,
+        })),
+    });
+    return appPromptValue;
+}

package/lib/prompts/selectHubDBTablePrompt.d.ts

@@ -0,0 +1,12 @@
+export declare function selectHubDBTablePrompt({ accountId, options, skipDestPrompt, }: {
+    accountId: number;
+    options: {
+        tableId?: number;
+        dest?: string;
+    };
+    skipDestPrompt?: boolean;
+}): Promise<{
+    tableId: any;
+} & {
+    dest: any;
+}>;

package/lib/prompts/selectHubDBTablePrompt.js

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { debugError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
+import { isValidPath, untildify } from '@hubspot/local-dev-lib/path';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+async function fetchHubDBOptions(accountId) {
+    try {
+        const { data: { results: tables }, } = await fetchTables(accountId);
+        if (tables.length === 0) {
+            uiLogger.log(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()));
+            throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()), EXIT_CODES.SUCCESS);
+        }
+        return tables;
+    }
+    catch (error) {
+        if (error instanceof PromptExitError) {
+            throw error;
+        }
+        debugError(error, { accountId });
+        uiLogger.error(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()));
+        throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()), EXIT_CODES.ERROR);
+    }
+}
+export async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
+    const hubdbTables = await fetchHubDBOptions(accountId);
+    const id = options.tableId?.toString();
+    const isValidTable = options.tableId && hubdbTables.find(table => table.id === id);
+    return promptUser([
+        {
+            name: 'tableId',
+            message: lib.prompts.selectHubDBTablePrompt.selectTable,
+            when: !id && !isValidTable,
+            type: 'list',
+            choices: hubdbTables.map(table => {
+                return {
+                    name: `${table.label} (${table.id})`,
+                    value: table.id,
+                };
+            }),
+        },
+        {
+            name: 'dest',
+            message: lib.prompts.selectHubDBTablePrompt.enterDest,
+            when: !options.dest && !skipDestPrompt,
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.selectHubDBTablePrompt.errors.destRequired;
+                }
+                if (fs.existsSync(input)) {
+                    return lib.prompts.selectHubDBTablePrompt.errors.invalidDest;
+                }
+                if (!isValidPath(input)) {
+                    return lib.prompts.selectHubDBTablePrompt.errors.invalidCharacters;
+                }
+                return true;
+            },
+            filter: (input) => {
+                return untildify(input);
+            },
+        },
+    ]);
+}

package/lib/prompts/selectProjectTemplatePrompt.d.ts

@@ -0,0 +1,27 @@
+import { Separator } from '@inquirer/prompts';
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplate } from '../../types/Projects.js';
+export type SelectProjectTemplatePromptResponse = {
+    projectTemplate?: ProjectTemplate;
+    componentTemplates?: ComponentTemplate[];
+};
+type SelectProjectTemplatePromptResponseProjectTemplate = {
+    projectTemplate: ProjectTemplate;
+    componentTemplates: undefined;
+};
+type SelectProjectTemplatePromptResponseComponentTemplates = {
+    projectTemplate?: undefined;
+    componentTemplates?: ComponentTemplate[];
+};
+export type ProjectNameAndDestPromptResponse = {
+    name: string;
+    dest: string;
+};
+export type PromptOptionsArg = {
+    name?: string;
+    dest?: string;
+    template?: string;
+    features?: string[];
+};
+export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: ProjectTemplate[], componentTemplates?: undefined): Promise<SelectProjectTemplatePromptResponseProjectTemplate>;
+export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined, componentTemplates?: (ComponentTemplateChoice | Separator)[]): Promise<SelectProjectTemplatePromptResponseComponentTemplates>;
+export {};

package/lib/prompts/selectProjectTemplatePrompt.js

@@ -0,0 +1,75 @@
+import { Separator } from '@inquirer/prompts';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+function findTemplateByNameOrLabel(projectTemplates, templateNameOrLabel) {
+    return projectTemplates.find(t => t.name === templateNameOrLabel || t.label === templateNameOrLabel);
+}
+export async function selectProjectTemplatePrompt(promptOptions, projectTemplates, componentTemplates) {
+    const createProjectFromTemplate = !!projectTemplates && projectTemplates.length > 0;
+    const createProjectFromComponents = Array.isArray(componentTemplates) && componentTemplates?.length > 0;
+    const selectedComponents = [];
+    if (createProjectFromComponents && promptOptions.features) {
+        componentTemplates.forEach(template => {
+            if (template instanceof Separator || !template.value) {
+                return;
+            }
+            if (promptOptions.features?.includes(template.value.cliSelector || template.value.type)) {
+                if (template.disabled) {
+                    throw new Error(`Cannot create project with template '${template.value.type}'. Reasons: ${template.disabled}`);
+                }
+                selectedComponents.push(template.value);
+            }
+        });
+    }
+    const providedTemplateIsValid = createProjectFromTemplate &&
+        !!promptOptions.template &&
+        !!findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
+    const result = await promptUser([
+        {
+            name: 'projectTemplate',
+            message: () => {
+                return promptOptions.template && !providedTemplateIsValid
+                    ? lib.prompts.selectProjectTemplatePrompt.errors.invalidTemplate(promptOptions.template)
+                    : lib.prompts.selectProjectTemplatePrompt.selectTemplate;
+            },
+            when: createProjectFromTemplate && !providedTemplateIsValid,
+            type: 'list',
+            choices: createProjectFromTemplate
+                ? projectTemplates.map(template => {
+                    return {
+                        name: template.label,
+                        value: template,
+                    };
+                })
+                : undefined,
+        },
+        {
+            name: 'componentTemplates',
+            message: lib.prompts.selectProjectTemplatePrompt.features,
+            when: !promptOptions.features &&
+                createProjectFromComponents &&
+                selectedComponents.length === 0,
+            type: 'checkbox',
+            choices: componentTemplates,
+            loop: false,
+            pageSize: componentTemplates?.length,
+        },
+    ]);
+    if (result.componentTemplates?.length === 0) {
+        uiLogger.log(lib.projects.add.nothingAdded);
+    }
+    if (!result.componentTemplates) {
+        result.componentTemplates = selectedComponents;
+    }
+    if (providedTemplateIsValid) {
+        result.projectTemplate = findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
+    }
+    if (projectTemplates && projectTemplates.length > 0) {
+        if (!result.projectTemplate) {
+            throw new Error(lib.prompts.selectProjectTemplatePrompt.errors.projectTemplateRequired);
+        }
+        return result;
+    }
+    return result;
+}

package/lib/prompts/selectPublicAppForMigrationPrompt.d.ts

@@ -0,0 +1,9 @@
+type PublicAppPromptResponse = {
+    appId: number;
+};
+export declare function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp, }: {
+    accountId: number | null;
+    accountName: string;
+    isMigratingApp?: boolean;
+}): Promise<PublicAppPromptResponse>;
+export {};

package/lib/prompts/selectPublicAppForMigrationPrompt.js

@@ -0,0 +1,68 @@
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiLine } from '../ui/index.js';
+import { logError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = false) {
+    if (!accountId) {
+        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId, EXIT_CODES.ERROR);
+    }
+    try {
+        const { data: { results: publicApps }, } = await fetchPublicAppsForPortal(accountId);
+        const filteredPublicApps = publicApps.filter(app => !app.projectId && !app.sourceId);
+        if (!filteredPublicApps.length ||
+            (isMigratingApp &&
+                !filteredPublicApps.some(app => !app.preventProjectMigrations || !app.listingInfo))) {
+            uiLine();
+            if (isMigratingApp) {
+                uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigrationMessage(accountName)}`);
+            }
+            else {
+                uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsCloneMessage(accountName)}`);
+            }
+            uiLine();
+            throw new PromptExitError(isMigratingApp
+                ? lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration
+                : lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone, EXIT_CODES.SUCCESS);
+        }
+        return filteredPublicApps;
+    }
+    catch (error) {
+        if (error instanceof PromptExitError) {
+            throw error;
+        }
+        logError(error, accountId ? { accountId } : undefined);
+        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps, EXIT_CODES.ERROR);
+    }
+}
+export async function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp = false, }) {
+    const publicApps = await fetchPublicAppOptions(accountId, accountName, isMigratingApp);
+    return promptUser([
+        {
+            name: 'appId',
+            message: isMigratingApp
+                ? lib.prompts.selectPublicAppForMigrationPrompt.selectAppIdMigrate(accountName)
+                : lib.prompts.selectPublicAppForMigrationPrompt.selectAppIdClone(accountName),
+            type: 'list',
+            choices: publicApps.map(app => {
+                const { preventProjectMigrations, listingInfo } = app;
+                if (isMigratingApp && preventProjectMigrations && listingInfo) {
+                    return {
+                        name: `${app.name} (${app.id})`,
+                        disabled: lib.prompts.selectPublicAppForMigrationPrompt.errors
+                            .cannotBeMigrated,
+                    };
+                }
+                return {
+                    name: `${app.name} (${app.id})`,
+                    value: app.id,
+                };
+            }),
+        },
+    ]);
+}

package/lib/prompts/setAsDefaultAccountPrompt.d.ts

@@ -0,0 +1 @@
+export declare function setAsDefaultAccountPrompt(accountName: string): Promise<boolean>;

package/lib/prompts/setAsDefaultAccountPrompt.js

@@ -0,0 +1,26 @@
+import { setConfigAccountAsDefault, getConfigDefaultAccountIfExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+export async function setAsDefaultAccountPrompt(accountName) {
+    // Accounts for deprecated and new config
+    const defaultAccount = getConfigDefaultAccountIfExists();
+    const accounts = getAllConfigAccounts() || [];
+    const { setAsDefault } = await promptUser([
+        {
+            name: 'setAsDefault',
+            type: 'confirm',
+            when: accounts.length >= 1 && defaultAccount?.name !== accountName,
+            message: lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccountMessage,
+        },
+    ]);
+    uiLogger.log('');
+    if (setAsDefault) {
+        setConfigAccountAsDefault(accountName);
+        uiLogger.success(lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccount(accountName));
+    }
+    else if (defaultAccount) {
+        uiLogger.log(lib.prompts.setAsDefaultAccountPrompt.keepingCurrentDefault(defaultAccount.name));
+    }
+    return setAsDefault;
+}

package/lib/prompts/uploadPrompt.d.ts

@@ -0,0 +1,9 @@
+type UploadPromptResponse = {
+    src: string;
+    dest: string;
+};
+export declare function uploadPrompt(promptOptions?: {
+    src?: string;
+    dest?: string;
+}): Promise<UploadPromptResponse>;
+export {};

package/lib/prompts/uploadPrompt.js

@@ -0,0 +1,32 @@
+import path from 'path';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+export async function uploadPrompt(promptOptions = {}) {
+    return promptUser([
+        {
+            name: 'src',
+            message: lib.prompts.uploadPrompt.enterSrc,
+            when: !promptOptions.src,
+            default: '.',
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.uploadPrompt.errors.srcRequired;
+                }
+                return true;
+            },
+        },
+        {
+            name: 'dest',
+            message: lib.prompts.uploadPrompt.enterDest,
+            when: !promptOptions.dest,
+            default: path.basename(getCwd()),
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.uploadPrompt.errors.destRequired;
+                }
+                return true;
+            },
+        },
+    ]);
+}

package/lib/sandboxes.d.ts

@@ -0,0 +1,14 @@
+import { AccountType, HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+import { SandboxAccountType } from '../types/Sandboxes.js';
+export declare const SANDBOX_TYPE_MAP: {
+    [key: string]: SandboxAccountType;
+};
+export declare const SANDBOX_TYPE_MAP_V2: {
+    readonly STANDARD_SANDBOX: "STANDARD";
+    readonly DEVELOPMENT_SANDBOX: "DEVELOPER";
+};
+export declare function getSandboxTypeAsString(accountType?: AccountType): string;
+export declare function getHasSandboxesByType(parentAccountConfig: HubSpotConfigAccount, type: AccountType): boolean;
+export declare function validateSandboxUsageLimits(accountConfig: HubSpotConfigAccount, sandboxType: AccountType, env: Environment): Promise<void>;
+export declare function handleSandboxCreateError(err: unknown, env: Environment, name: string, accountId: number): never;

package/lib/sandboxes.js

@@ -0,0 +1,105 @@
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
+import { uiLogger } from './ui/logger.js';
+import { lib } from '../lang/en.js';
+import { logError } from './errorHandlers/index.js';
+import { uiAccountDescription } from './ui/index.js';
+export const SANDBOX_TYPE_MAP = {
+    dev: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+    developer: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+    development: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+    standard: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+};
+export const SANDBOX_TYPE_MAP_V2 = {
+    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 'STANDARD',
+    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 'DEVELOPER',
+};
+export function getSandboxTypeAsString(accountType) {
+    if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+        return 'development'; // Only place we're using this specific name
+    }
+    return 'standard';
+}
+export function getHasSandboxesByType(parentAccountConfig, type) {
+    const parentPortalId = parentAccountConfig.accountId;
+    const accountsList = getAllConfigAccounts();
+    for (const portal of accountsList) {
+        if ((portal.parentAccountId !== null ||
+            portal.parentAccountId !== undefined) &&
+            portal.parentAccountId === parentPortalId &&
+            portal.accountType &&
+            portal.accountType === type) {
+            return true;
+        }
+    }
+    return false;
+}
+export async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
+    const accountId = accountConfig.accountId;
+    if (!accountId) {
+        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
+    }
+    const { data: { usage }, } = await getSandboxUsageLimits(accountId);
+    if (!usage) {
+        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
+    }
+    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+        if (usage['DEVELOPER'].available === 0) {
+            const devSandboxLimit = usage['DEVELOPER'].limit;
+            const hasDevelopmentSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
+            if (hasDevelopmentSandboxes) {
+                throw new Error(lib.sandbox.create.developer.failure.alreadyInConfig(accountId, devSandboxLimit));
+            }
+            else {
+                const baseUrl = getHubSpotWebsiteOrigin(env);
+                throw new Error(lib.sandbox.create.developer.failure.limit(accountId, devSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/development`));
+            }
+        }
+    }
+    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX) {
+        if (usage['STANDARD'].available === 0) {
+            const standardSandboxLimit = usage['STANDARD'].limit;
+            const hasStandardSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX);
+            if (hasStandardSandboxes) {
+                throw new Error(lib.sandbox.create.standard.failure.alreadyInConfig(accountId, standardSandboxLimit));
+            }
+            else {
+                const baseUrl = getHubSpotWebsiteOrigin(env);
+                throw new Error(lib.sandbox.create.standard.failure.limit(accountId, standardSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/standard`));
+            }
+        }
+    }
+}
+export function handleSandboxCreateError(err, env, name, accountId) {
+    if (isMissingScopeError(err)) {
+        uiLogger.error(lib.sandbox.create.failure.scopes.message);
+        const websiteOrigin = getHubSpotWebsiteOrigin(env);
+        const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+        uiLogger.info(lib.sandbox.create.failure.scopes.instructions(uiAccountDescription(accountId), url));
+    }
+    else if (isSpecifiedError(err, {
+        statusCode: 403,
+        category: 'BANNED',
+        subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
+    })) {
+        uiLogger.log('');
+        uiLogger.error(lib.sandbox.create.failure.invalidUser(name, accountId));
+        uiLogger.log('');
+    }
+    else if (isSpecifiedError(err, {
+        statusCode: 403,
+        category: 'BANNED',
+        subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
+    })) {
+        uiLogger.log('');
+        uiLogger.error(lib.sandbox.create.failure['403Gating'](name, accountId));
+        uiLogger.log('');
+    }
+    else {
+        logError(err);
+    }
+    throw err;
+}

package/lib/schema.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@hubspot/local-dev-lib/types/Schemas';
+export declare function logSchemas(schemas: Array<Schema>): void;
+export declare function listSchemas(accountId: number): Promise<void>;

package/lib/schema.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import { table, getBorderCharacters } from 'table';
+import { fetchObjectSchemas } from '@hubspot/local-dev-lib/api/customObjects';
+import { uiLogger } from './ui/logger.js';
+export function logSchemas(schemas) {
+    const data = schemas
+        .map(r => [r.labels.singular, r.name, r.objectTypeId || ''])
+        .sort((a, b) => (a[1] > b[1] ? 1 : -1));
+    if (data.length === 0) {
+        uiLogger.log('No Schemas were found');
+        return;
+    }
+    data.unshift([
+        chalk.bold('Label'),
+        chalk.bold('Name'),
+        chalk.bold('objectTypeId'),
+    ]);
+    const tableConfig = {
+        singleLine: true,
+        border: getBorderCharacters('honeywell'),
+    };
+    uiLogger.log(table(data, tableConfig));
+}
+export async function listSchemas(accountId) {
+    const { data } = await fetchObjectSchemas(accountId);
+    logSchemas(data.results);
+}

package/lib/serverlessLogs.d.ts

@@ -0,0 +1,4 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+import { FunctionLog, GetFunctionLogsResponse } from '@hubspot/local-dev-lib/types/Functions';
+export declare function tailLogs(accountId: number, name: string, fetchLatest: () => HubSpotPromise<FunctionLog>, tailCall: (after?: string) => HubSpotPromise<GetFunctionLogsResponse>, compact?: boolean): Promise<void>;
+export declare function outputBuildLog(buildLogUrl: string): Promise<string>;