@hubspot/cli 8.2.0 → 8.2.1-experimental.0

package/lib/app/logs.js

@@ -0,0 +1,225 @@
+import moment from 'moment';
+import { getAppLogDetails, searchAppLogs, } from '@hubspot/local-dev-lib/api/appLogs';
+import { outputAppLogDetails, outputAppLogs } from '../ui/appLogs.js';
+import { uiLogger } from '../ui/logger.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { handleExit, handleKeypress } from '../process.js';
+import { commands } from '../../lang/en.js';
+export const SYSTEM_TYPE_DISPLAY_NAMES = {
+    WEBHOOKS: 'Webhooks',
+    API_CALL: 'API Call',
+    SERVERLESS_EXECUTION: 'Serverless Function',
+    CRM_EXTENSIBILITY_CARD: 'CRM Card',
+    CRM_LEGACY_CARD: 'CRM Legacy Card',
+    EXTENSION_LOG: 'Extension Log',
+    EXTENSION_RENDER: 'Extension Render',
+    APP_SETTINGS: 'App Settings',
+    PROXY_EXECUTION: 'Proxy Execution',
+    SERVERLESS_GATEWAY_EXECUTION: 'Serverless Gateway Execution',
+    ACCEPTANCE_TEST: 'Acceptance Test',
+    OAUTH_AUTHORIZATION: 'OAuth Authorization',
+};
+export const SYSTEM_TYPE_CHOICES = Object.keys(SYSTEM_TYPE_DISPLAY_NAMES).map(toTypeChoice);
+export function parseSinceTime(sinceInput) {
+    const now = moment();
+    const relativeTimePattern = /^(\d+)([mhd])$/;
+    const match = sinceInput.match(relativeTimePattern);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        let startTime;
+        switch (unit) {
+            case 'm':
+                startTime = now.clone().subtract(value, 'minutes');
+                break;
+            case 'h':
+                startTime = now.clone().subtract(value, 'hours');
+                break;
+            case 'd':
+                startTime = now.clone().subtract(value, 'days');
+                break;
+            default:
+                throw new Error(`Invalid time unit: ${unit}`);
+        }
+        return {
+            startTime: startTime.valueOf(),
+            endTime: now.valueOf(),
+        };
+    }
+    const isoTime = moment(sinceInput, moment.ISO_8601, true);
+    if (isoTime.isValid()) {
+        return {
+            startTime: isoTime.valueOf(),
+            endTime: now.valueOf(),
+        };
+    }
+    throw new Error(`Invalid time format: ${sinceInput}`);
+}
+export function transformApiLogEntry(apiLog) {
+    return {
+        id: apiLog.id,
+        createdAt: apiLog.requestExecutionTimestamp,
+        executionTimeMillis: apiLog.duration,
+        portalId: apiLog.portalId,
+        traceId: apiLog.traceId,
+        status: apiLog.errorType ? 'ERROR' : 'SUCCESS',
+        errorType: apiLog.errorType,
+        errorMessage: apiLog.errorMessage,
+    };
+}
+const TAIL_DELAY = 5000;
+export function toTypeChoice(systemType) {
+    return systemType.toLowerCase().replaceAll('_', '-');
+}
+export function toSystemType(choice) {
+    return choice.toUpperCase().replaceAll('-', '_');
+}
+export function getTypeChoices() {
+    return Object.entries(SYSTEM_TYPE_DISPLAY_NAMES).map(([key, name]) => ({
+        name,
+        value: key,
+    }));
+}
+function buildTransformedResponse(data) {
+    return {
+        results: data.results.map(transformApiLogEntry),
+        hasMore: !!data.paging?.next,
+        offset: 0,
+        total: data.results.length,
+    };
+}
+export const handleLogsRequest = async (accountId, appId, systemType, options) => {
+    const { since, compact, json, limit, errorsOnly } = options;
+    const resolvedLimit = limit ?? 50;
+    let timeRange;
+    if (since) {
+        timeRange = parseSinceTime(since);
+    }
+    const query = {
+        loggingSystemType: systemType,
+        limit: resolvedLimit,
+        offset: 0,
+        errorTypes: errorsOnly ? ['*'] : [],
+        resultsOrder: 'DESC',
+        ...timeRange,
+    };
+    const requestBody = {
+        query,
+        limit: resolvedLimit,
+    };
+    const { data } = await searchAppLogs(accountId, appId, requestBody);
+    if (json) {
+        uiLogger.json(data);
+    }
+    else {
+        await outputAppLogs(buildTransformedResponse(data), {
+            compact: !!compact,
+            accountId,
+            appId,
+            systemType,
+            typeName: SYSTEM_TYPE_DISPLAY_NAMES[systemType],
+        });
+    }
+};
+export const tailAppLogs = async (accountId, appId, systemType, options) => {
+    const { compact, since, errorsOnly } = options;
+    let currentAfter;
+    let currentStartTime;
+    if (since) {
+        currentStartTime = parseSinceTime(since).startTime;
+    }
+    return new Promise(resolve => {
+        function cleanup() {
+            SpinniesManager.remove('tailLogs');
+            SpinniesManager.remove('stopMessage');
+        }
+        let resolved = false;
+        // eslint-disable-next-line prefer-const -- assigned after onTerminate is defined due to circular reference
+        let removeExitListeners;
+        let timeoutHandle;
+        const onTerminate = async () => {
+            if (resolved)
+                return;
+            resolved = true;
+            removeExitListeners?.();
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            cleanup();
+            resolve();
+        };
+        removeExitListeners = handleExit(onTerminate);
+        handleKeypress(key => {
+            if ((key.ctrl && key.name === 'c') || key.name === 'q') {
+                onTerminate();
+            }
+        });
+        async function tail() {
+            try {
+                const query = {
+                    loggingSystemType: systemType,
+                    limit: 50,
+                    offset: 0,
+                    errorTypes: errorsOnly ? ['*'] : [],
+                    resultsOrder: 'ASC',
+                    ...(currentStartTime !== undefined && {
+                        startTime: currentStartTime,
+                    }),
+                };
+                const requestBody = {
+                    query,
+                    limit: 50,
+                    ...(currentAfter && { after: currentAfter }),
+                };
+                const { data } = await searchAppLogs(accountId, appId, requestBody);
+                if (data.results && data.results.length > 0) {
+                    await outputAppLogs(buildTransformedResponse(data), {
+                        compact: !!compact,
+                        tail: true,
+                        accountId,
+                        appId,
+                        systemType,
+                        typeName: SYSTEM_TYPE_DISPLAY_NAMES[systemType],
+                    });
+                    if (data.paging?.next?.after) {
+                        currentAfter = data.paging.next.after;
+                    }
+                    else {
+                        const lastResult = data.results[data.results.length - 1];
+                        currentStartTime = lastResult.requestExecutionTimestamp + 1;
+                        currentAfter = undefined;
+                    }
+                }
+                timeoutHandle = setTimeout(() => {
+                    tail();
+                }, TAIL_DELAY);
+            }
+            catch (e) {
+                await onTerminate();
+                throw e;
+            }
+        }
+        const tailCopy = commands.app.subcommands.logs.outputMessages.tailMessages;
+        SpinniesManager.add('tailLogs', {
+            text: tailCopy.following(appId),
+        });
+        SpinniesManager.add('stopMessage', {
+            text: tailCopy.stop,
+            status: 'non-spinnable',
+        });
+        void tail();
+    });
+};
+export const handleLogDetailsRequest = async (accountId, appId, logId, systemType, options) => {
+    const { json } = options;
+    const { data } = await getAppLogDetails(accountId, appId, systemType, logId);
+    if (json) {
+        uiLogger.json(data);
+    }
+    else {
+        outputAppLogDetails(data.log, {
+            accountId,
+            appId,
+        });
+    }
+};

package/lib/app/migrate.js

@@ -5,6 +5,7 @@ import chalk from 'chalk';
 import { validateUid } from '@hubspot/project-parsing-lib/uid';
 import { UNMIGRATABLE_REASONS } from '@hubspot/local-dev-lib/constants/projects';
 import { mapToUserFacingType } from '@hubspot/project-parsing-lib/transform';
+import { AUTO_GENERATED_COMPONENT_TYPES } from '@hubspot/project-parsing-lib/constants';
 import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
 import { downloadProject, fetchProjectComponentsMetadata, } from '@hubspot/local-dev-lib/api/projects';
 import { Separator } from '@inquirer/prompts';
@@ -123,12 +124,21 @@ export async function selectAppToMigrate(allApps, derivedAccountId, appId) {
     const selectedApp = allApps.find(app => app.appId === appIdToMigrate);
     const migratableComponents = new Set();
     const unmigratableComponents = new Set();
+    let hasLegacyCrmCards = false;
     selectedApp?.migrationComponents.forEach(component => {
-        if (component.isSupported) {
-            migratableComponents.add(mapToUserFacingType(component.componentType));
+        const userFacingComponentType = mapToUserFacingType(component.componentType);
+        if (component.componentType === 'LEGACY_CRM_CARD' &&
+            !component.isSupported) {
+            hasLegacyCrmCards = true;
         }
-        else {
-            unmigratableComponents.add(mapToUserFacingType(component.componentType));
+        const shouldDisplayComponent = !AUTO_GENERATED_COMPONENT_TYPES.includes(userFacingComponentType);
+        if (shouldDisplayComponent) {
+            if (component.isSupported) {
+                migratableComponents.add(userFacingComponentType);
+            }
+            else {
+                unmigratableComponents.add(userFacingComponentType);
+            }
         }
     });
     if (migratableComponents.size !== 0) {
@@ -137,6 +147,9 @@ export async function selectAppToMigrate(allApps, derivedAccountId, appId) {
     if (unmigratableComponents.size !== 0) {
         uiLogger.log(lib.migrate.componentsThatWillNotBeMigrated(`\n - ${[...unmigratableComponents].join('\n - ')}`));
     }
+    if (hasLegacyCrmCards) {
+        uiLogger.info(lib.migrate.legacyCrmCardMigrationDocs());
+    }
     uiLogger.log('');
     const proceed = await confirmPrompt(lib.migrate.prompt.proceed, {
         defaultAnswer: false,
@@ -255,7 +268,7 @@ export async function pollMigrationStatus(derivedAccountId, migrationId, success
     return poll(() => checkMigrationStatusV2(derivedAccountId, migrationId), {
         successStates: [...successStates],
         errorStates: [...DEFAULT_POLLING_STATUS_LOOKUP.errorStates],
-    });
+    }, 300_000);
 }
 export async function finalizeAppMigration(derivedAccountId, migrationId, uidMap, projectName) {
     let pollResponse;

package/lib/app/urls.d.ts

@@ -14,4 +14,6 @@ type PublicAppInstallUrlArgs = {
 export declare function getOauthAppInstallUrl({ targetAccountId, env, clientId, scopes, redirectUrls, }: PublicAppInstallUrlArgs): string;
 export declare function getStaticAuthAppInstallUrl({ targetAccountId, env, appId, }: PrivateAppInstallUrlArgs): string;
 export declare function getAppCardSetupUrl({ targetAccountId, env, appId, }: PrivateAppInstallUrlArgs): string;
+export declare function getAppLogsUrl(accountId: number, appId: number, systemType: string): string;
+export declare function getAppLogDetailsUrl(accountId: number, appId: number, systemType: string, logId: string): string;
 export {};

package/lib/app/urls.js

@@ -1,4 +1,4 @@
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { getHubSpotWebsiteOrigin, getHubSpotWebsiteOriginByAccountId, } from '@hubspot/local-dev-lib/urls';
 export function getOauthAppInstallUrl({ targetAccountId, env, clientId, scopes, redirectUrls, }) {
     const websiteOrigin = getHubSpotWebsiteOrigin(env);
     return (`${websiteOrigin}/oauth/${targetAccountId}/authorize` +
@@ -14,3 +14,9 @@ export function getAppCardSetupUrl({ targetAccountId, env, appId, }) {
     const websiteOrigin = getHubSpotWebsiteOrigin(env);
     return `${websiteOrigin}/integrations-settings/${targetAccountId}/installed/framework/${appId}/app-cards?tourId=get-started`;
 }
+export function getAppLogsUrl(accountId, appId, systemType) {
+    return `${getHubSpotWebsiteOriginByAccountId(accountId)}/developer-monitoring/${accountId}/?logType=${systemType}&appId=${appId}`;
+}
+export function getAppLogDetailsUrl(accountId, appId, systemType, logId) {
+    return `${getAppLogsUrl(accountId, appId, systemType)}&logId=${logId}`;
+}

package/lib/auth/awaitPersonalAccessKeyOverWebsocket.d.ts

@@ -0,0 +1,4 @@
+export declare function awaitPersonalAccessKeyOverWebsocket({ env, account, }: {
+    env: string;
+    account?: number;
+}): Promise<string>;

package/lib/auth/awaitPersonalAccessKeyOverWebsocket.js

@@ -0,0 +1,146 @@
+import readline from 'readline';
+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_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';
+import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+const LOG_PREFIX = '[AccountAuthWebsocketServer]';
+const SPINNER_ID = 'pak-websocket';
+const CTRL_C = 3;
+function isPersonalAccessKeyMessageData(data) {
+    if (typeof data !== 'object' || data === null)
+        return false;
+    const d = data;
+    return (typeof d.personalAccessKey === 'string' &&
+        typeof d.cliCallbackToken === 'string');
+}
+function buildPakUrl(env, account, cliCallbackPort, cliCallbackToken) {
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    const baseUrl = account
+        ? `${websiteOrigin}/personal-access-key/${account}`
+        : `${websiteOrigin}/l/personal-access-key`;
+    return `${baseUrl}?cliCallbackPort=${cliCallbackPort}&cliCallbackToken=${cliCallbackToken}`;
+}
+function createMessageHandler(server, cliCallbackToken, resolveWebsocketPak) {
+    return (ws, message) => {
+        if (message.type !== ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES.PERSONAL_ACCESS_KEY) {
+            return false;
+        }
+        if (!isPersonalAccessKeyMessageData(message.data)) {
+            return true;
+        }
+        const { cliCallbackToken: receivedToken, personalAccessKey } = message.data;
+        if (receivedToken !== cliCallbackToken) {
+            server.sendMessage(ws, {
+                type: ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES.AUTH_FAILED,
+                data: { reason: 'cliCallbackTokenMismatch' },
+            });
+            return true;
+        }
+        if (personalAccessKey.length === 0) {
+            return true;
+        }
+        server.sendMessage(ws, {
+            type: ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES.AUTH_RECEIVED,
+        });
+        resolveWebsocketPak(personalAccessKey);
+        return true;
+    };
+}
+async function awaitKeypressOrWebsocketPak(websocketPakPromise) {
+    if (!process.stdin.isTTY) {
+        const pak = await websocketPakPromise;
+        return { type: 'pak', pak };
+    }
+    SpinniesManager.init();
+    SpinniesManager.add(SPINNER_ID, {
+        text: lib.accountAuthWebsocket.logs.spinner,
+    });
+    let cleanupStdin;
+    const keypressPromise = new Promise((resolve, reject) => {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        const onData = (chunk) => {
+            doCleanup();
+            if (chunk[0] === CTRL_C) {
+                return reject(new PromptExitError(lib.prompts.personalAccessKeyPrompt.errors.authCancelled, EXIT_CODES.SUCCESS));
+            }
+            resolve({ type: 'keypress' });
+        };
+        const doCleanup = () => {
+            process.stdin.removeListener('data', onData);
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch { }
+            process.stdin.pause();
+        };
+        cleanupStdin = doCleanup;
+        process.stdin.on('data', onData);
+    });
+    try {
+        const result = await Promise.race([
+            websocketPakPromise.then(pak => ({ type: 'pak', pak })),
+            keypressPromise,
+        ]);
+        if (result.type === 'pak') {
+            SpinniesManager.succeed(SPINNER_ID, {
+                text: lib.accountAuthWebsocket.logs.received,
+            });
+        }
+        else {
+            SpinniesManager.remove(SPINNER_ID);
+        }
+        return result;
+    }
+    catch (e) {
+        SpinniesManager.remove(SPINNER_ID);
+        throw e;
+    }
+    finally {
+        cleanupStdin?.();
+    }
+}
+export async function awaitPersonalAccessKeyOverWebsocket({ env, account, }) {
+    const cliCallbackToken = randomUUID();
+    const server = new CLIWebSocketServer({ logPrefix: LOG_PREFIX });
+    let resolveWebsocketPak;
+    const websocketPakPromise = new Promise(resolve => {
+        resolveWebsocketPak = resolve;
+    });
+    try {
+        const cliCallbackPort = await server.start({
+            metadata: {
+                accountAuthWebsocketServerVersion: ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION,
+            },
+            onMessage: createMessageHandler(server, cliCallbackToken, resolveWebsocketPak),
+        });
+        const url = buildPakUrl(env, account, cliCallbackPort, cliCallbackToken);
+        await open(url, { url: true });
+        uiLogger.log(lib.accountAuthWebsocket.logs.openingWebBrowser(url));
+        const waitResult = await awaitKeypressOrWebsocketPak(websocketPakPromise);
+        if (waitResult.type === 'pak') {
+            return waitResult.pak;
+        }
+        let pastePhaseActive = true;
+        websocketPakPromise
+            .then(pak => {
+            if (pastePhaseActive) {
+                process.stdin.push(`${pak}\n`);
+            }
+        })
+            .catch(() => { });
+        const personalAccessKey = await personalAccessKeyPrompt();
+        pastePhaseActive = false;
+        return personalAccessKey;
+    }
+    finally {
+        server.shutdown();
+    }
+}

package/lib/buildAccount.d.ts

@@ -1,7 +1,7 @@
 import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
 import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxResponse, V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
+import { V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
 import { SandboxAccountType } from '../types/Sandboxes.js';
 export declare function saveAccountToConfig(accountId: number | undefined, accountName: string, env: Environment, personalAccessKey?: string, force?: boolean): Promise<string>;
 export declare function createDeveloperTestAccountV2(parentAccountId: number, testAccountConfig: DeveloperTestAccountConfig): Promise<{
@@ -10,11 +10,6 @@ export declare function createDeveloperTestAccountV2(parentAccountId: number, te
     personalAccessKey?: string;
 }>;
 export declare function buildDeveloperTestAccount(testAccountName: string, parentAccountConfig: HubSpotConfigAccount, env: Environment, portalLimit: number, useV2?: boolean): Promise<number>;
-type SandboxAccount = SandboxResponse & {
-    name: string;
-};
-export declare function buildSandbox(sandboxName: string, parentAccountConfig: HubSpotConfigAccount, sandboxType: SandboxAccountType, env: Environment, force?: boolean): Promise<SandboxAccount>;
 export declare function buildV2Sandbox(sandboxName: string, parentAccountConfig: HubSpotConfigAccount, sandboxType: SandboxAccountType, syncObjectRecords: boolean, env: Environment, force?: boolean): Promise<{
     sandbox: V2Sandbox;
 }>;
-export {};

package/lib/buildAccount.js

@@ -3,13 +3,14 @@ import { getConfigAccountIfExists, updateConfigAccount, } from '@hubspot/local-d
 import { uiLogger } from './ui/logger.js';
 import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, generateDeveloperTestAccountPersonalAccessKey, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { createSandbox, createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
+import { createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { isPromptExitError } from './errors/PromptExitError.js';
+import { legacyPersonalAccessKeyPrompt as personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
 import { createDeveloperTestAccountConfigPrompt } from './prompts/createDeveloperTestAccountConfigPrompt.js';
 import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
 import SpinniesManager from './ui/SpinniesManager.js';
 import { debugError, logError } from './errorHandlers/index.js';
-import { SANDBOX_API_TYPE_MAP, SANDBOX_TYPE_MAP_V2, handleSandboxCreateError, } from './sandboxes.js';
+import { SANDBOX_TYPE_MAP_V2, handleSandboxCreateError } from './sandboxes.js';
 import { handleDeveloperTestAccountCreateError } from './developerTestAccounts.js';
 import { lib } from '../lang/en.js';
 import { poll } from './polling.js';
@@ -127,51 +128,14 @@ export async function buildDeveloperTestAccount(testAccountName, parentAccountCo
         await saveAccountToConfig(developerTestAccountId, testAccountName, env, developerTestAccountPersonalAccessKey);
     }
     catch (err) {
+        if (isPromptExitError(err)) {
+            throw err;
+        }
         logError(err);
         throw err;
     }
     return developerTestAccountId;
 }
-export async function buildSandbox(sandboxName, parentAccountConfig, sandboxType, env, force = false) {
-    const sandboxTypeKey = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX
-        ? 'standard'
-        : 'developer';
-    const parentAccountId = parentAccountConfig.accountId;
-    if (!parentAccountId) {
-        throw new Error(lib.sandbox.create[sandboxTypeKey].loading.fail(''));
-    }
-    SpinniesManager.init({
-        succeedColor: 'white',
-    });
-    uiLogger.log('');
-    SpinniesManager.add('buildSandbox', {
-        text: lib.sandbox.create[sandboxTypeKey].loading.add(sandboxName),
-    });
-    let sandbox;
-    try {
-        const sandboxApiType = SANDBOX_API_TYPE_MAP[sandboxType];
-        const { data } = await createSandbox(parentAccountId, sandboxName, sandboxApiType);
-        sandbox = { name: sandboxName, ...data };
-        SpinniesManager.succeed('buildSandbox', {
-            text: lib.sandbox.create[sandboxTypeKey].loading.succeed(sandboxName, sandbox.sandbox.sandboxHubId.toString()),
-        });
-    }
-    catch (e) {
-        debugError(e);
-        SpinniesManager.fail('buildSandbox', {
-            text: lib.sandbox.create[sandboxTypeKey].loading.fail(sandboxName),
-        });
-        handleSandboxCreateError(e, env, sandboxName, parentAccountId);
-    }
-    try {
-        await saveAccountToConfig(sandbox.sandbox.sandboxHubId, sandboxName, env, sandbox.personalAccessKey, force);
-    }
-    catch (err) {
-        logError(err);
-        throw err;
-    }
-    return sandbox;
-}
 export async function buildV2Sandbox(sandboxName, parentAccountConfig, sandboxType, syncObjectRecords, env, force = false) {
     const sandboxTypeKey = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX
         ? 'standard'
@@ -210,6 +174,9 @@ export async function buildV2Sandbox(sandboxName, parentAccountConfig, sandboxTy
         await saveAccountToConfig(sandbox.sandboxHubId, sandboxName, env, pak, force);
     }
     catch (err) {
+        if (isPromptExitError(err)) {
+            throw err;
+        }
         logError(err);
         throw err;
     }

package/lib/commonOpts.js

@@ -72,12 +72,16 @@ export function addUseEnvironmentOptions(yargs) {
     return yargs;
 }
 export function addJSONOutputOptions(yargs) {
-    return yargs.option('json', {
+    yargs.option('json', {
         alias: 'format-output-as-json',
         describe: lib.commonOpts.options.jsonOutput,
         type: 'boolean',
-        hidden: true,
     });
+    yargs.option('json-schema', {
+        describe: lib.commonOpts.options.jsonSchema,
+        type: 'boolean',
+    });
+    return yargs;
 }
 // Remove this once we've upgraded to yargs 18.0.0
 function uiBetaTagWithColor(message) {

package/lib/configOptions.d.ts

@@ -1,21 +1,21 @@
 import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
-export declare function setAllowUsageTracking({ accountId, allowUsageTracking, }: {
+export declare function setAllowUsageTracking({ allowUsageTracking, }: {
     accountId: number;
     allowUsageTracking?: boolean;
-}): Promise<void>;
-export declare function setAllowAutoUpdates({ accountId, allowAutoUpdates, }: {
+}): Promise<boolean>;
+export declare function setAllowAutoUpdates({ allowAutoUpdates, }: {
     accountId: number;
     allowAutoUpdates?: boolean;
-}): Promise<void>;
-export declare function setDefaultCmsPublishMode({ accountId, defaultCmsPublishMode, }: {
+}): Promise<boolean>;
+export declare function setDefaultCmsPublishMode({ defaultCmsPublishMode, }: {
     accountId: number;
     defaultCmsPublishMode?: CmsPublishMode;
-}): Promise<void>;
-export declare function setHttpTimeout({ accountId, httpTimeout, }: {
+}): Promise<CmsPublishMode>;
+export declare function setHttpTimeout({ httpTimeout, }: {
     accountId: number;
     httpTimeout?: string;
-}): Promise<void>;
-export declare function setAutoOpenBrowser({ accountId, autoOpenBrowser, }: {
+}): Promise<string>;
+export declare function setAutoOpenBrowser({ autoOpenBrowser, }: {
     accountId: number;
     autoOpenBrowser: boolean;
-}): Promise<void>;
+}): Promise<boolean>;