@hubspot/cli 8.2.0-experimental.2 → 8.2.1-experimental.0

package/lib/mcp/setup.js

@@ -11,29 +11,36 @@ import fs from 'fs-extra';
 import { existsSync } from 'fs';
 const mcpServerName = MCP_SERVER_NAME;
 const claudeCode = 'claude';
-const windsurf = 'windsurf';
 const cursor = 'cursor';
+const devin = 'devin';
 const vscode = 'vscode';
 const codex = 'codex';
 const gemini = 'gemini';
+const opencode = 'opencode';
+const OTHER_TOOL = 'other';
 const clientLabels = {
     codex: commands.mcp.setup.codex,
     claude: commands.mcp.setup.claudeCode,
     cursor: commands.mcp.setup.cursor,
+    devin: commands.mcp.setup.devin,
     gemini: commands.mcp.setup.gemini,
+    opencode: commands.mcp.setup.opencode,
     vscode: commands.mcp.setup.vsCode,
-    windsurf: commands.mcp.setup.windsurf,
 };
-export const supportedTools = MCP_CLIENTS.map(client => ({
-    name: clientLabels[client.id],
-    value: client.id,
-}));
+export const supportedTools = [
+    ...MCP_CLIENTS.map(client => ({
+        name: clientLabels[client.id],
+        value: client.id,
+    })),
+    { name: commands.mcp.setup.other, value: OTHER_TOOL },
+];
 const defaultMcpCommand = {
     command: 'hs',
     args: ['mcp', 'start'],
 };
-export async function configureMcpServer(targets) {
+export async function configureMcpServer(options) {
     try {
+        const { targets, standalone, cliVersion: cliVersionFlag } = options;
         let derivedTargets = [];
         if (!targets || targets.length === 0) {
             const { selectedTargets } = await promptUser({
@@ -41,6 +48,7 @@ export async function configureMcpServer(targets) {
                 type: 'checkbox',
                 message: commands.mcp.setup.prompts.targets,
                 choices: supportedTools,
+                pageSize: supportedTools.length,
                 validate: (choices) => {
                     return choices.length === 0
                         ? commands.mcp.setup.prompts.targetsRequired
@@ -52,23 +60,34 @@ export async function configureMcpServer(targets) {
         else {
             derivedTargets = targets;
         }
-        // Prompt for standalone mode
-        const { useStandaloneMode } = await promptUser({
-            name: 'useStandaloneMode',
-            type: 'confirm',
-            message: commands.mcp.setup.prompts.standaloneMode,
-            default: false,
-        });
-        const { cliVersion } = useStandaloneMode
-            ? await promptUser({
-                name: 'cliVersion',
-                type: 'input',
-                message: commands.mcp.setup.prompts.cliVersion,
-                validate: (v) => !v || /^[\d]+\.[\d]+\.[\d]+([-+][\w.]+)?$/.test(v.trim())
-                    ? true
-                    : 'Please enter a valid semver version (e.g. 8.0.1) or leave blank for latest.',
-            })
-            : { cliVersion: '' };
+        const onlyOther = derivedTargets.length === 1 && derivedTargets[0] === OTHER_TOOL;
+        let useStandaloneMode = onlyOther ? false : standalone;
+        if (useStandaloneMode === undefined) {
+            const response = await promptUser({
+                name: 'useStandaloneMode',
+                type: 'confirm',
+                message: commands.mcp.setup.prompts.standaloneMode,
+                default: false,
+            });
+            useStandaloneMode = response.useStandaloneMode;
+        }
+        let cliVersion = '';
+        if (useStandaloneMode) {
+            if (cliVersionFlag !== undefined) {
+                cliVersion = cliVersionFlag;
+            }
+            else {
+                const response = await promptUser({
+                    name: 'cliVersion',
+                    type: 'input',
+                    message: commands.mcp.setup.prompts.cliVersion,
+                    validate: (v) => !v || /^[\d]+\.[\d]+\.[\d]+([-+][\w.]+)?$/.test(v.trim())
+                        ? true
+                        : 'Please enter a valid semver version (e.g. 8.0.1) or leave blank for latest.',
+                });
+                cliVersion = response.cliVersion;
+            }
+        }
         const cliPackage = cliVersion
             ? `@hubspot/cli@${cliVersion}`
             : '@hubspot/cli';
@@ -91,8 +110,8 @@ export async function configureMcpServer(targets) {
         if (derivedTargets.includes(cursor)) {
             await runSetupFunction(() => setupCursor(mcpCommand));
         }
-        if (derivedTargets.includes(windsurf)) {
-            await runSetupFunction(() => setupWindsurf(mcpCommand));
+        if (derivedTargets.includes(devin)) {
+            await runSetupFunction(() => setupDevin(mcpCommand));
         }
         if (derivedTargets.includes(vscode)) {
             await runSetupFunction(() => setupVsCode(mcpCommand));
@@ -103,8 +122,17 @@ export async function configureMcpServer(targets) {
         if (derivedTargets.includes(gemini)) {
             await runSetupFunction(() => setupGemini(mcpCommand));
         }
-        uiLogger.info(commands.mcp.setup.success(derivedTargets));
-        return derivedTargets;
+        if (derivedTargets.includes(opencode)) {
+            await runSetupFunction(() => setupOpenCode(mcpCommand));
+        }
+        if (derivedTargets.includes(OTHER_TOOL)) {
+            logOtherToolInstructions(mcpCommand);
+        }
+        const configuredTargets = derivedTargets.filter(t => t !== OTHER_TOOL);
+        if (configuredTargets.length > 0) {
+            uiLogger.info(commands.mcp.setup.success(configuredTargets));
+        }
+        return configuredTargets;
     }
     catch (error) {
         SpinniesManager.fail('mcpSetup', {
@@ -261,14 +289,14 @@ export function setupCursor(mcpCommand = defaultMcpCommand) {
         mcpCommand: buildCommandWithAgentString(mcpCommand, cursor),
     });
 }
-export function setupWindsurf(mcpCommand = defaultMcpCommand) {
-    const windsurfConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(windsurf));
+export function setupDevin(mcpCommand = defaultMcpCommand) {
+    const devinConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(devin));
     return setupMcpConfigFile({
-        configPath: windsurfConfigPath,
-        configuringMessage: commands.mcp.setup.spinners.configuringWindsurf,
-        configuredMessage: commands.mcp.setup.spinners.configuredWindsurf,
-        failedMessage: commands.mcp.setup.spinners.failedToConfigureWindsurf,
-        mcpCommand: buildCommandWithAgentString(mcpCommand, windsurf),
+        configPath: devinConfigPath,
+        configuringMessage: commands.mcp.setup.spinners.configuringDevin,
+        configuredMessage: commands.mcp.setup.spinners.configuredDevin,
+        failedMessage: commands.mcp.setup.spinners.failedToConfigureDevin,
+        mcpCommand: buildCommandWithAgentString(mcpCommand, devin),
     });
 }
 export async function setupCodex(mcpCommand = defaultMcpCommand) {
@@ -330,6 +358,58 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
         return false;
     }
 }
+export async function setupOpenCode(mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add('openCodeSpinner', {
+            text: commands.mcp.setup.spinners.configuringOpenCode,
+        });
+        try {
+            await execAsync('opencode --version');
+        }
+        catch (error) {
+            SpinniesManager.fail('openCodeSpinner', {
+                text: commands.mcp.setup.spinners.openCodeNotFound,
+            });
+            return false;
+        }
+        const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, opencode);
+        await execAsync(`opencode mcp add "${mcpServerName}"${buildEnvFlagString(mcpCommand)} -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
+        SpinniesManager.succeed('openCodeSpinner', {
+            text: commands.mcp.setup.spinners.configuredOpenCode,
+        });
+        return true;
+    }
+    catch (error) {
+        SpinniesManager.fail('openCodeSpinner', {
+            text: commands.mcp.setup.spinners.openCodeInstallFailed,
+        });
+        logError(error);
+        return false;
+    }
+}
+function logOtherToolInstructions(mcpCommand) {
+    const { otherInstructions } = commands.mcp.setup;
+    uiLogger.log('');
+    uiLogger.log(otherInstructions.header);
+    uiLogger.log(otherInstructions.docsNote);
+    uiLogger.log('');
+    uiLogger.log(`  ${otherInstructions.commandLabel}`);
+    uiLogger.log(`    ${mcpCommand.command} ${mcpCommand.args.join(' ')}`);
+    uiLogger.log('');
+    uiLogger.log(`  ${otherInstructions.jsonLabel}`);
+    uiLogger.log('');
+    const jsonConfig = {
+        mcpServers: {
+            [mcpServerName]: mcpCommand,
+        },
+    };
+    const indented = JSON.stringify(jsonConfig, null, 2)
+        .split('\n')
+        .map(line => `    ${line}`)
+        .join('\n');
+    uiLogger.log(indented);
+    uiLogger.log('');
+}
 function buildCommandWithAgentString(mcpCommand, agent) {
     const mcpCommandCopy = structuredClone(mcpCommand);
     mcpCommandCopy.args.push('--ai-agent', agent);

package/lib/npm/npmCli.d.ts

@@ -4,6 +4,7 @@ export declare function getLatestPackageVersion(packageName: string): Promise<{
     latest: string | null;
     next: string | null;
 }>;
+export declare function getNpmExecErrorOutput(error: unknown): string | null;
 export declare function executeInstall(packages?: string[], flags?: string | null, options?: {
     cwd?: string;
 }): Promise<void>;

package/lib/npm/npmCli.js

@@ -23,6 +23,19 @@ export async function getLatestPackageVersion(packageName) {
         return { latest: null, next: null };
     }
 }
+function isNpmExecError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        ('stderr' in error || 'stdout' in error));
+}
+export function getNpmExecErrorOutput(error) {
+    if (!isNpmExecError(error)) {
+        return null;
+    }
+    const stderr = error.stderr?.trim();
+    const stdout = error.stdout?.trim();
+    return stderr || stdout || null;
+}
 export async function executeInstall(packages = [], flags, options) {
     const installCommand = `${DEFAULT_PACKAGE_MANAGER} install${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
     uiLogger.debug('Running', installCommand);

package/lib/projects/builds.d.ts

@@ -0,0 +1,2 @@
+import { type Build } from '@hubspot/local-dev-lib/types/Build';
+export declare function getLastSuccessfulBuild(accountId: number, projectName: string, latestBuild?: Build): Promise<Build | undefined>;

package/lib/projects/builds.js

@@ -0,0 +1,22 @@
+import { fetchProjectBuilds } from '@hubspot/local-dev-lib/api/projects';
+import { BUILD_STATUS } from '@hubspot/local-dev-lib/enums/build';
+export async function getLastSuccessfulBuild(accountId, projectName, latestBuild) {
+    if (latestBuild?.status === BUILD_STATUS.SUCCESS) {
+        return latestBuild;
+    }
+    let after;
+    let hasMore = true;
+    while (hasMore) {
+        const { data: { results, paging }, } = await fetchProjectBuilds(accountId, projectName, {
+            limit: 100,
+            ...(after ? { after } : {}),
+        });
+        const successfulBuild = results.find(build => build.status === BUILD_STATUS.SUCCESS);
+        if (successfulBuild) {
+            return successfulBuild;
+        }
+        after = paging?.next?.after;
+        hasMore = !!after;
+    }
+    return undefined;
+}

package/lib/projects/create/v2.js

@@ -48,6 +48,7 @@ export async function createV2App(providedAuth, providedDistribution) {
 const componentTypeToGateMap = {
     [AppEventsKey]: FEATURES.APP_EVENTS,
     'workflow-action-tool': FEATURES.AGENT_TOOLS,
+    'crm-bulk-action': FEATURES.APP_ACTIONS,
 };
 export async function calculateComponentTemplateChoices(components, authType, distribution, accountId, projectMetadata) {
     const enabledComponents = [];

package/lib/projects/installApp.d.ts

@@ -43,7 +43,7 @@ export declare function resolveProjectAccountId(derivedAccountId: number, projec
     accountId: number;
     profileName?: string;
 } | null>;
-export declare function loadInstallableAppNode(projectConfig: ProjectConfig, projectDir: string, accountId: number): Promise<AppIRNode | null>;
+export declare function loadInstallableAppNode(projectConfig: ProjectConfig, projectDir: string, accountId: number, force?: boolean): Promise<AppIRNode | null>;
 export declare function resolveValidInstallAccount(targetAccountId: number, force: boolean, formatOutputAsJson: boolean): Promise<number | null>;
 export declare function resolveProjectId(options: UploadAndDeployOptions): Promise<number | null>;
 export declare function resolveAppMetadata(options: UploadAndDeployOptions & {

package/lib/projects/installApp.js

@@ -6,6 +6,7 @@ import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
 import { getAllConfigAccounts, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { translateForLocalDev } from '@hubspot/project-parsing-lib/translate';
 import { commands } from '../../lang/en.js';
+import { warnAboutSkippedHsMetaFiles } from './ui.js';
 import { isAppDeveloperAccount } from '../accountTypes.js';
 import { ApiErrorContext, debugError, logError, } from '../errorHandlers/index.js';
 import { confirmPrompt, listPrompt } from '../prompts/promptUtils.js';
@@ -33,15 +34,19 @@ export async function resolveProjectAccountId(derivedAccountId, projectConfig, p
         return null;
     }
 }
-export async function loadInstallableAppNode(projectConfig, projectDir, accountId) {
+export async function loadInstallableAppNode(projectConfig, projectDir, accountId, force = false) {
     let appNode;
     try {
-        const { intermediateNodesIndexedByUid } = await translateForLocalDev({
+        const { intermediateRepresentation, skippedHsMetaFiles } = await translateForLocalDev({
             projectSourceDir: path.join(projectDir, projectConfig.srcDir),
             platformVersion: projectConfig.platformVersion,
             accountId,
         }, { skipValidation: true });
-        appNode = getAppNodeFromProjectNodes(intermediateNodesIndexedByUid);
+        const shouldContinue = await warnAboutSkippedHsMetaFiles(skippedHsMetaFiles, force, false);
+        if (!shouldContinue) {
+            return null;
+        }
+        appNode = getAppNodeFromProjectNodes(intermediateRepresentation.intermediateNodesIndexedByUid);
     }
     catch (error) {
         debugError(error);

package/lib/projects/localDev/DevSessionManager.d.ts

@@ -2,11 +2,11 @@ import LocalDevLogger from './LocalDevLogger.js';
 import { ExitFunction } from '../../../types/Yargs.js';
 type DevSessionManagerConstructorOptions = {
     targetTestingAccountId: number;
-    localDevLogger?: LocalDevLogger;
+    localDevLogger: LocalDevLogger;
     exit: ExitFunction;
 };
 declare class DevSessionManager {
-    localDevLogger?: LocalDevLogger;
+    localDevLogger: LocalDevLogger;
     targetTestingAccountId: number;
     protected devSessionId: number | undefined;
     private heartbeatInterval;

package/lib/projects/localDev/DevSessionManager.js

@@ -1,9 +1,7 @@
 import { getActiveServers } from '@hubspot/local-dev-lib/portManager';
 import { devSessionHeartbeat, registerDevSession, deleteDevSession, } from './helpers/devSessionsApi.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { uiLogger } from '../../ui/logger.js';
 import { lib } from '../../../lang/en.js';
-import { getErrorMessage } from '../../errorHandlers/index.js';
 class DevSessionManager {
     localDevLogger;
     targetTestingAccountId;
@@ -21,13 +19,7 @@ class DevSessionManager {
     }
     validateSessionIdExists() {
         if (!this.devSessionId) {
-            if (this.localDevLogger) {
-                this.localDevLogger.devSessionMissingSessionIdError();
-            }
-            else {
-                // Fallback for deprecated local dev manager
-                uiLogger.error(lib.LocalDevManager.devSession.missingSessionIdError);
-            }
+            this.localDevLogger.devSessionMissingSessionIdError();
             throw new Error(lib.LocalDevManager.devSession.missingSessionIdError);
         }
     }
@@ -39,13 +31,7 @@ class DevSessionManager {
             this.devSessionId = registerDevSessionResponse.data.sessionId;
         }
         catch (e) {
-            if (this.localDevLogger) {
-                this.localDevLogger.devSessionRegistrationError(e);
-            }
-            else {
-                // Fallback for deprecated local dev manager
-                uiLogger.error(lib.LocalDevManager.devSession.registrationError(getErrorMessage(e)));
-            }
+            this.localDevLogger.devSessionRegistrationError(e);
             return false;
         }
         try {
@@ -73,13 +59,7 @@ class DevSessionManager {
                     this.heartbeatRetries++;
                     return;
                 }
-                if (this.localDevLogger) {
-                    this.localDevLogger.devSessionHeartbeatError(e);
-                }
-                else {
-                    // Fallback for deprecated local dev manager
-                    uiLogger.error(lib.LocalDevManager.devSession.heartbeatError(getErrorMessage(e)));
-                }
+                this.localDevLogger.devSessionHeartbeatError(e);
                 return this.exit(EXIT_CODES.ERROR);
             }
         }, 30000);
@@ -91,13 +71,7 @@ class DevSessionManager {
                 await deleteDevSession(this.targetTestingAccountId, this.devSessionId);
             }
             catch (e) {
-                if (this.localDevLogger) {
-                    this.localDevLogger.devSessionDeletionError(e);
-                }
-                else {
-                    // Fallback for deprecated local dev manager
-                    uiLogger.error(lib.LocalDevManager.devSession.deletionError(getErrorMessage(e)));
-                }
+                this.localDevLogger.devSessionDeletionError(e);
                 return false;
             }
         }

package/lib/projects/localDev/LocalDevProcess.js

@@ -95,8 +95,8 @@ class LocalDevProcess {
         });
         return true;
     }
-    getIntermediateRepresentation(projectNodesAtLastDeploy) {
-        return translateForLocalDev({
+    async getIntermediateRepresentation(projectNodesAtLastDeploy) {
+        const { intermediateRepresentation } = await translateForLocalDev({
             projectSourceDir: path.join(this.state.projectDir, this.state.projectConfig.srcDir),
             platformVersion: this.state.projectConfig.platformVersion,
             accountId: this.state.targetProjectAccountId,
@@ -104,6 +104,7 @@ class LocalDevProcess {
             projectNodesAtLastUpload: projectNodesAtLastDeploy,
             profile: this.state.profile,
         });
+        return intermediateRepresentation;
     }
     async updateProjectNodes() {
         const intermediateRepresentation = await this.getIntermediateRepresentation(this.state.projectNodesAtLastDeploy);
@@ -152,14 +153,14 @@ class LocalDevProcess {
             return this.state.actions.exit(EXIT_CODES.ERROR);
         }
         this.logger.startupMessage();
-        if (isConfigFlagEnabled(CONFIG_FLAGS.AUTO_OPEN_BROWSER, true)) {
-            this.openLocalDevUi();
-        }
         await this.startDevServers();
         const devSessionRegistered = await this.devSessionManager.registerSession();
         if (!devSessionRegistered) {
             return this.state.actions.exit(EXIT_CODES.ERROR);
         }
+        if (isConfigFlagEnabled(CONFIG_FLAGS.AUTO_OPEN_BROWSER, true)) {
+            this.openLocalDevUi();
+        }
         this.state.devServersStarted = true;
         this.logger.monitorConsoleOutput();
     }
@@ -197,6 +198,7 @@ class LocalDevProcess {
             projectDir: this.state.projectDir,
             callbackFunc: pollProjectBuildAndDeploy,
             sendIR: true,
+            force: true,
         });
         const deploy = result?.deployResult;
         if (uploadError) {

package/lib/projects/localDev/helpers/account.d.ts

@@ -1,13 +1,6 @@
 import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
 import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
-import { ProjectDevTargetAccountPromptResponse } from '../../../prompts/projectDevTargetAccountPrompt.js';
-import { ExitFunction } from '../../../../types/Yargs.js';
-export declare function confirmDefaultAccountIsTarget(accountConfig: HubSpotConfigAccount, exit: ExitFunction): Promise<void>;
-export declare function checkIfDefaultAccountIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean, exit: ExitFunction): Promise<void>;
-export declare function checkIfParentAccountIsAuthed(accountConfig: HubSpotConfigAccount): void;
-export declare function checkIfAccountFlagIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): void;
-export declare function suggestRecommendedNestedAccount(accounts: HubSpotConfigAccount[], accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
 export declare function createSandboxForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment): Promise<number>;
 export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment, useV2?: boolean): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<boolean>;

package/lib/projects/localDev/helpers/account.js

@@ -1,5 +1,3 @@
-import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
-import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
@@ -7,15 +5,6 @@ import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constant
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { uiLogger } from '../../../ui/logger.js';
 import { lib } from '../../../../lang/en.js';
-import { EXIT_CODES } from '../../../enums/exitCodes.js';
-import { confirmDefaultAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
-import { isUnifiedAccount } from '../../../accountTypes.js';
-import { isAppDeveloperAccount } from '../../../accountTypes.js';
-import { isDeveloperTestAccount } from '../../../accountTypes.js';
-import { uiAccountDescription } from '../../../ui/index.js';
-import { uiLine } from '../../../ui/index.js';
-import { selectDeveloperTestTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
-import { selectSandboxTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
 import { validateSandboxUsageLimits } from '../../../sandboxes.js';
 import { logError } from '../../../errorHandlers/index.js';
 import { hubspotAccountNamePrompt } from '../../../prompts/accountNamePrompt.js';
@@ -25,73 +14,6 @@ import { buildDeveloperTestAccount, saveAccountToConfig, buildV2Sandbox, } from
 import { debugError } from '../../../errorHandlers/index.js';
 import { listPrompt } from '../../../prompts/promptUtils.js';
 import { confirmUseExistingDeveloperTestAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
-// If the user passed in the --account flag, confirm they want to use that account as
-// their target account, otherwise exit
-export async function confirmDefaultAccountIsTarget(accountConfig, exit) {
-    if (!accountConfig.name || !accountConfig.accountType) {
-        uiLogger.error(lib.localDevHelpers.account.confirmDefaultAccountIsTarget.configError);
-        return exit(EXIT_CODES.ERROR);
-    }
-    uiLogger.log('');
-    const useDefaultAccount = await confirmDefaultAccountPrompt(accountConfig.name, HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
-    if (!useDefaultAccount) {
-        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
-            .declineDefaultAccountExplanation);
-        return exit(EXIT_CODES.SUCCESS);
-    }
-}
-// Confirm the default account is supported for the type of apps being developed
-export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps, exit) {
-    const defaultAccountIsUnified = await isUnifiedAccount(accountConfig);
-    if (hasPublicApps &&
-        !(isAppDeveloperAccount(accountConfig) ||
-            isDeveloperTestAccount(accountConfig) ||
-            defaultAccountIsUnified)) {
-        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.publicApp);
-        return exit(EXIT_CODES.SUCCESS);
-    }
-    else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
-        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.privateApp);
-        return exit(EXIT_CODES.SUCCESS);
-    }
-}
-export function checkIfParentAccountIsAuthed(accountConfig) {
-    if (!accountConfig.parentAccountId ||
-        !getConfigAccountIfExists(accountConfig.parentAccountId)?.accountId) {
-        throw new Error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(accountConfig.accountId)));
-    }
-}
-// Confirm the default account is a developer account if developing public apps
-export function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
-    if (hasPublicApps) {
-        if (!isDeveloperTestAccount(accountConfig)) {
-            throw new Error(lib.localDevHelpers.account.validateAccountOption
-                .invalidPublicAppAccount);
-        }
-        checkIfParentAccountIsAuthed(accountConfig);
-    }
-    else if (isAppDeveloperAccount(accountConfig)) {
-        throw new Error(lib.localDevHelpers.account.validateAccountOption.invalidPrivateAppAccount);
-    }
-}
-// If the user isn't using the recommended account type, prompt them to use or create one
-export async function suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps) {
-    uiLogger.log('');
-    uiLine();
-    if (hasPublicApps) {
-        uiLogger.log(lib.localDevHelpers.account.validateAccountOption
-            .publicAppNonDeveloperTestAccountWarning);
-    }
-    else {
-        uiLogger.log(lib.localDevHelpers.account.validateAccountOption.nonSandboxWarning);
-    }
-    uiLine();
-    uiLogger.log('');
-    const targetAccountPrompt = hasPublicApps
-        ? selectDeveloperTestTargetAccountPrompt
-        : selectSandboxTargetAccountPrompt;
-    return targetAccountPrompt(accounts, accountConfig);
-}
 // Create a new sandbox and return its accountId
 export async function createSandboxForLocalDev(accountId, accountConfig, env) {
     try {
@@ -166,8 +88,7 @@ export async function useExistingDevTestAccount(env, account) {
     const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(account);
     if (!useExistingDevTestAcct) {
         uiLogger.log('');
-        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
-            .declineDefaultAccountExplanation);
+        uiLogger.log(lib.localDevHelpers.account.declineDefaultAccountExplanation);
         uiLogger.log('');
         return false;
     }

package/lib/projects/localDev/helpers/project.js

@@ -85,6 +85,7 @@ export async function createInitialBuildForNewProject(projectConfig, projectDir,
         skipValidation: true,
         sendIR,
         profile,
+        force: true,
     });
     if (uploadError) {
         if (isSpecifiedError(uploadError, {
@@ -173,12 +174,12 @@ export async function getDeployedProjectNodes(projectConfig, accountId, deployed
             }
         }
         const deployedProjectSourceDir = path.join(tempDir, deployedSrcDir);
-        const { intermediateNodesIndexedByUid } = await translate({
+        const { intermediateRepresentation } = await translate({
             projectSourceDir: deployedProjectSourceDir,
             platformVersion: projectConfig.platformVersion,
             accountId: accountId,
         }, { profile });
-        return intermediateNodesIndexedByUid;
+        return intermediateRepresentation.intermediateNodesIndexedByUid;
     }
     finally {
         if (tempDir && (await fs.pathExists(tempDir))) {

package/lib/projects/release.d.ts

@@ -0,0 +1,4 @@
+import { type Release } from '../../api/releases.js';
+export declare function resolveBuildId(accountId: number, projectName: string, buildOption?: number, force?: boolean): Promise<number | null | undefined>;
+export declare function validateBuildForRelease(accountId: number, projectName: string, buildId: number): Promise<boolean>;
+export declare function executeRelease(accountId: number, projectName: string, buildId: number): Promise<Release>;