@hubspot/cli 8.0.2-experimental.0 → 8.0.3-experimental.1

package/lib/__tests__/accountAuth.test.js

@@ -0,0 +1,258 @@
+import { updateConfigAccount, createEmptyConfigFile, getConfigFilePath, localConfigFileExists, globalConfigFileExists, setConfigAccountAsDefault, } from '@hubspot/local-dev-lib/config';
+import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
+import { toKebabCase } from '@hubspot/local-dev-lib/text';
+import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
+import { handleMerge, handleMigration } from '../configMigrate.js';
+import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
+import { cliAccountNamePrompt } from '../prompts/accountNamePrompt.js';
+import { setAsDefaultAccountPrompt } from '../prompts/setAsDefaultAccountPrompt.js';
+import { authenticateNewAccount } from '../accountAuth.js';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+vi.mock('@hubspot/local-dev-lib/text');
+vi.mock('../configMigrate.js');
+vi.mock('../errorHandlers/index.js');
+vi.mock('../prompts/personalAccessKeyPrompt.js');
+vi.mock('../prompts/accountNamePrompt.js');
+vi.mock('../prompts/setAsDefaultAccountPrompt.js');
+vi.mock('../ui/logger.js', () => ({
+    uiLogger: {
+        log: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+const mockedUpdateConfigAccount = updateConfigAccount;
+const mockedCreateEmptyConfigFile = createEmptyConfigFile;
+const mockedGetConfigFilePath = getConfigFilePath;
+const mockedLocalConfigFileExists = localConfigFileExists;
+const mockedGlobalConfigFileExists = globalConfigFileExists;
+const mockedSetConfigAccountAsDefault = setConfigAccountAsDefault;
+const mockedGetAccessToken = getAccessToken;
+const mockedUpdateConfigWithAccessToken = updateConfigWithAccessToken;
+const mockedToKebabCase = toKebabCase;
+const mockedHandleMerge = handleMerge;
+const mockedHandleMigration = handleMigration;
+const mockedPersonalAccessKeyPrompt = personalAccessKeyPrompt;
+const mockedCliAccountNamePrompt = cliAccountNamePrompt;
+const mockedSetAsDefaultAccountPrompt = setAsDefaultAccountPrompt;
+describe('lib/accountAuth', () => {
+    describe('authenticateNewAccount()', () => {
+        const mockAccessToken = {
+            portalId: 123456,
+            accessToken: 'test-token',
+            expiresAt: '2025-01-01',
+            scopeGroups: ['test-scope'],
+            enabledFeatures: { 'test-feature': 1 },
+            encodedOAuthRefreshToken: 'test-refresh-token',
+            hubName: 'Test Hub',
+            accountType: 'STANDARD',
+        };
+        const mockAccountConfig = {
+            name: 'test-hub',
+            accountId: 123456,
+            env: 'prod',
+            accountType: 'STANDARD',
+            authType: PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
+            personalAccessKey: 'test-key',
+            auth: {
+                tokenInfo: {
+                    accessToken: 'test-token',
+                    expiresAt: '2025-01-01',
+                },
+            },
+        };
+        beforeEach(() => {
+            vi.clearAllMocks();
+            mockedLocalConfigFileExists.mockReturnValue(false);
+            mockedGlobalConfigFileExists.mockReturnValue(false);
+            mockedGetAccessToken.mockResolvedValue(mockAccessToken);
+            mockedUpdateConfigWithAccessToken.mockResolvedValue(mockAccountConfig);
+            mockedToKebabCase.mockReturnValue('test-hub');
+            mockedCliAccountNamePrompt.mockResolvedValue({ name: 'test-hub' });
+            mockedGetConfigFilePath.mockReturnValue('/path/to/config');
+            mockedPersonalAccessKeyPrompt.mockResolvedValue({
+                personalAccessKey: 'test-key',
+            });
+        });
+        it('should create config file if it does not exist', async () => {
+            mockedGlobalConfigFileExists.mockReturnValue(false);
+            await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(mockedCreateEmptyConfigFile).toHaveBeenCalledWith(true);
+        });
+        it('should not create config file if it already exists', async () => {
+            mockedGlobalConfigFileExists.mockReturnValue(true);
+            await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(mockedCreateEmptyConfigFile).not.toHaveBeenCalled();
+        });
+        it('should use provided personal access key without prompting', async () => {
+            await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(mockedPersonalAccessKeyPrompt).not.toHaveBeenCalled();
+            expect(mockedGetAccessToken).toHaveBeenCalledWith('test-key', 'prod');
+        });
+        it('should prompt for personal access key if not provided', async () => {
+            await authenticateNewAccount({
+                env: 'prod',
+                accountId: 123456,
+            });
+            expect(mockedPersonalAccessKeyPrompt).toHaveBeenCalledWith({
+                env: 'prod',
+                account: 123456,
+            });
+            expect(mockedGetAccessToken).toHaveBeenCalledWith('test-key', 'prod');
+        });
+        it('should prompt for account name if config does not exist', async () => {
+            mockedGlobalConfigFileExists.mockReturnValue(false);
+            await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(mockedCliAccountNamePrompt).toHaveBeenCalledWith('test-hub');
+        });
+        it('should not prompt for account name if config already exists', async () => {
+            mockedGlobalConfigFileExists.mockReturnValue(true);
+            await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(mockedCliAccountNamePrompt).not.toHaveBeenCalled();
+        });
+        it('should set account as default when setAsDefaultAccount is true', async () => {
+            mockedGlobalConfigFileExists.mockReturnValue(true);
+            await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+                setAsDefaultAccount: true,
+            });
+            expect(mockedSetConfigAccountAsDefault).toHaveBeenCalledWith('test-hub');
+        });
+        it('should prompt to set as default when setAsDefaultAccount is not provided and config exists', async () => {
+            mockedGlobalConfigFileExists.mockReturnValue(true);
+            await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(mockedSetAsDefaultAccountPrompt).toHaveBeenCalledWith('test-hub');
+        });
+        it('should return the updated account config on success', async () => {
+            const result = await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(result).toEqual(mockAccountConfig);
+        });
+        it('should return null if access token fetch fails', async () => {
+            mockedGetAccessToken.mockRejectedValue(new Error('Invalid token'));
+            const result = await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(result).toBeNull();
+        });
+        it('should return null if config update fails', async () => {
+            mockedUpdateConfigWithAccessToken.mockResolvedValue(null);
+            const result = await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(result).toBeNull();
+        });
+        it('should handle missing account name and prompt for it', async () => {
+            mockedGlobalConfigFileExists.mockReturnValue(true);
+            mockedUpdateConfigWithAccessToken.mockResolvedValue({
+                ...mockAccountConfig,
+                name: undefined,
+            });
+            mockedCliAccountNamePrompt.mockResolvedValue({
+                name: 'new-account-name',
+            });
+            await authenticateNewAccount({
+                env: 'prod',
+                providedPersonalAccessKey: 'test-key',
+                accountId: 123456,
+            });
+            expect(mockedCliAccountNamePrompt).toHaveBeenCalledWith('test-hub');
+            expect(mockedUpdateConfigAccount).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'new-account-name',
+            }));
+        });
+        describe('config migration', () => {
+            it('should handle migration when local config exists and global does not', async () => {
+                mockedLocalConfigFileExists.mockReturnValue(true);
+                mockedGlobalConfigFileExists.mockReturnValue(false);
+                mockedHandleMigration.mockResolvedValue(true);
+                await authenticateNewAccount({
+                    env: 'prod',
+                    providedPersonalAccessKey: 'test-key',
+                    accountId: 123456,
+                });
+                expect(mockedHandleMigration).toHaveBeenCalled();
+                expect(mockedHandleMerge).not.toHaveBeenCalled();
+            });
+            it('should handle merge when both local and global configs exist', async () => {
+                mockedLocalConfigFileExists.mockReturnValue(true);
+                mockedGlobalConfigFileExists.mockReturnValue(true);
+                mockedHandleMerge.mockResolvedValue(true);
+                await authenticateNewAccount({
+                    env: 'prod',
+                    providedPersonalAccessKey: 'test-key',
+                    accountId: 123456,
+                });
+                expect(mockedHandleMerge).toHaveBeenCalled();
+                expect(mockedHandleMigration).not.toHaveBeenCalled();
+            });
+            it('should return null if migration is not confirmed', async () => {
+                mockedLocalConfigFileExists.mockReturnValue(true);
+                mockedGlobalConfigFileExists.mockReturnValue(false);
+                mockedHandleMigration.mockResolvedValue(false);
+                const result = await authenticateNewAccount({
+                    env: 'prod',
+                    providedPersonalAccessKey: 'test-key',
+                    accountId: 123456,
+                });
+                expect(result).toBeNull();
+            });
+            it('should return null if merge is not confirmed', async () => {
+                mockedLocalConfigFileExists.mockReturnValue(true);
+                mockedGlobalConfigFileExists.mockReturnValue(true);
+                mockedHandleMerge.mockResolvedValue(false);
+                const result = await authenticateNewAccount({
+                    env: 'prod',
+                    providedPersonalAccessKey: 'test-key',
+                    accountId: 123456,
+                });
+                expect(result).toBeNull();
+            });
+            it('should return null if migration throws error', async () => {
+                mockedLocalConfigFileExists.mockReturnValue(true);
+                mockedGlobalConfigFileExists.mockReturnValue(false);
+                mockedHandleMigration.mockRejectedValue(new Error('Migration failed'));
+                const result = await authenticateNewAccount({
+                    env: 'prod',
+                    providedPersonalAccessKey: 'test-key',
+                    accountId: 123456,
+                });
+                expect(result).toBeNull();
+            });
+        });
+    });
+});

package/lib/accountAuth.d.ts

@@ -0,0 +1,10 @@
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+type AuthenticateNewAccountOptions = {
+    env: Environment;
+    providedPersonalAccessKey?: string;
+    accountId?: number;
+    setAsDefaultAccount?: boolean;
+};
+export declare function authenticateNewAccount({ env, providedPersonalAccessKey, accountId, setAsDefaultAccount, }: AuthenticateNewAccountOptions): Promise<HubSpotConfigAccount | null>;
+export {};

package/lib/accountAuth.js

@@ -0,0 +1,105 @@
+import { updateConfigAccount, createEmptyConfigFile, getConfigFilePath, localConfigFileExists, globalConfigFileExists, setConfigAccountAsDefault, } from '@hubspot/local-dev-lib/config';
+import { getAccessToken, updateConfigWithAccessToken, } from '@hubspot/local-dev-lib/personalAccessKey';
+import { toKebabCase } from '@hubspot/local-dev-lib/text';
+import { handleMerge, handleMigration } from './configMigrate.js';
+import { debugError, logError } from './errorHandlers/index.js';
+import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
+import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
+import { setAsDefaultAccountPrompt } from './prompts/setAsDefaultAccountPrompt.js';
+import { commands } from '../lang/en.js';
+import { uiLogger } from './ui/logger.js';
+async function updateConfigWithNewAccount(env, configAlreadyExists, providedPersonalAccessKey, accountId) {
+    try {
+        const { personalAccessKey } = providedPersonalAccessKey
+            ? { personalAccessKey: providedPersonalAccessKey }
+            : await personalAccessKeyPrompt({
+                env,
+                account: accountId,
+            });
+        const token = await getAccessToken(personalAccessKey, env);
+        const defaultAccountName = token.hubName
+            ? toKebabCase(token.hubName)
+            : undefined;
+        const accountName = configAlreadyExists
+            ? undefined
+            : (await cliAccountNamePrompt(defaultAccountName)).name;
+        const updatedConfig = await updateConfigWithAccessToken(token, personalAccessKey, env, accountName, !configAlreadyExists);
+        if (!updatedConfig)
+            return null;
+        // Can happen if the user is re-authenticating an account with no name
+        if (configAlreadyExists && !updatedConfig.name) {
+            updatedConfig.name = (await cliAccountNamePrompt(defaultAccountName)).name;
+            updateConfigAccount({
+                ...updatedConfig,
+            });
+        }
+        return updatedConfig;
+    }
+    catch (e) {
+        debugError(e);
+        return null;
+    }
+}
+async function handleConfigMigration() {
+    const deprecatedConfigExists = localConfigFileExists();
+    const globalConfigExists = globalConfigFileExists();
+    if (!deprecatedConfigExists) {
+        return true;
+    }
+    if (globalConfigExists) {
+        try {
+            const mergeConfirmed = await handleMerge();
+            if (!mergeConfirmed) {
+                uiLogger.log('');
+                uiLogger.log(commands.account.subcommands.auth.errors.mergeNotConfirmed);
+            }
+            return mergeConfirmed;
+        }
+        catch (error) {
+            logError(error);
+            return false;
+        }
+    }
+    try {
+        const migrationConfirmed = await handleMigration();
+        if (!migrationConfirmed) {
+            uiLogger.log('');
+            uiLogger.log(commands.account.subcommands.auth.errors.migrationNotConfirmed);
+        }
+        return migrationConfirmed;
+    }
+    catch (error) {
+        logError(error);
+        return false;
+    }
+}
+export async function authenticateNewAccount({ env, providedPersonalAccessKey, accountId, setAsDefaultAccount, }) {
+    const configMigrationSuccess = await handleConfigMigration();
+    if (!configMigrationSuccess) {
+        return null;
+    }
+    const configAlreadyExists = globalConfigFileExists();
+    if (!configAlreadyExists) {
+        createEmptyConfigFile(true);
+    }
+    const updatedConfig = await updateConfigWithNewAccount(env, configAlreadyExists, providedPersonalAccessKey, accountId);
+    if (!updatedConfig) {
+        uiLogger.error(commands.account.subcommands.auth.errors.failedToUpdateConfig);
+        return null;
+    }
+    const { accountId: newAccountId, name } = updatedConfig;
+    if (!configAlreadyExists) {
+        uiLogger.log('');
+        uiLogger.success(commands.account.subcommands.auth.success.configFileCreated(getConfigFilePath()));
+        uiLogger.success(commands.account.subcommands.auth.success.configFileUpdated(newAccountId));
+    }
+    else if (setAsDefaultAccount) {
+        setConfigAccountAsDefault(name);
+        uiLogger.log('');
+        uiLogger.success(commands.account.subcommands.auth.success.configFileUpdated(newAccountId));
+    }
+    else {
+        await setAsDefaultAccountPrompt(name);
+    }
+    return updatedConfig;
+}

package/lib/app/urls.d.ts

@@ -13,4 +13,5 @@ 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 {};

package/lib/app/urls.js

@@ -10,3 +10,7 @@ export function getStaticAuthAppInstallUrl({ targetAccountId, env, appId, }) {
     const websiteOrigin = getHubSpotWebsiteOrigin(env);
     return `${websiteOrigin}/static-token/${targetAccountId}/authorize?appId=${appId}`;
 }
+export function getAppCardSetupUrl({ targetAccountId, env, appId, }) {
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    return `${websiteOrigin}/integrations-settings/${targetAccountId}/installed/framework/${appId}/app-cards?tourId=get-started`;
+}

package/lib/errors/ProjectErrors.d.ts

@@ -0,0 +1,15 @@
+export declare class ProjectNestingError extends Error {
+    constructor(message: string);
+}
+export declare class ProjectConfigNotFoundError extends Error {
+    constructor(message: string);
+}
+export declare class ProjectValidationError extends Error {
+    constructor(message: string);
+}
+export declare class ProjectUploadError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+export declare class ProjectBuildDeployError extends Error {
+    constructor(message: string);
+}

package/lib/errors/ProjectErrors.js

@@ -0,0 +1,30 @@
+export class ProjectNestingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectNestingError';
+    }
+}
+export class ProjectConfigNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectConfigNotFoundError';
+    }
+}
+export class ProjectValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectValidationError';
+    }
+}
+export class ProjectUploadError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+        this.name = 'ProjectUploadError';
+    }
+}
+export class ProjectBuildDeployError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectBuildDeployError';
+    }
+}

package/lib/getStarted/getStartedV2.js

@@ -1,54 +1,16 @@
 import { LOG_LEVEL, setLogLevel } from '@hubspot/local-dev-lib/logger';
-import { createProjectAction } from '../getStartedV2Actions.js';
-import { trackCommandMetadataUsage } from '../usageTracking.js';
+import { trackGetStartedUsage } from '../../lib/getStartedV2Actions.js';
 import { renderInteractive } from '../../ui/render.js';
-import { getGetStartedFlow } from '../../ui/components/GetStartedFlow.js';
-import { getErrorMessage } from '../errorHandlers/index.js';
+import { getGetStartedFlow } from '../../ui/components/getStarted/GetStartedFlow.js';
 export async function runGetStartedV2({ derivedAccountId, name, dest, }) {
     setLogLevel(LOG_LEVEL.NONE);
-    const onRunCreateProject = async (args) => {
-        try {
-            const result = await createProjectAction(args);
-            await trackCommandMetadataUsage('get-started', {
-                successful: true,
-                step: 'github-clone',
-            }, derivedAccountId);
-            await trackCommandMetadataUsage('get-started', {
-                successful: true,
-                step: 'project-creation',
-            }, derivedAccountId);
-            return {
-                projectName: result.projectName,
-                projectDest: result.projectDest,
-            };
-        }
-        catch (error) {
-            const errorMessage = getErrorMessage(error);
-            // Check if this is a nested project error (happens before cloning)
-            const isNestedProjectError = errorMessage.includes('Projects cannot be nested within other projects');
-            if (isNestedProjectError) {
-                await trackCommandMetadataUsage('get-started', {
-                    successful: false,
-                    step: 'project-creation',
-                }, derivedAccountId);
-            }
-            else {
-                // Clone or other error (failedToDownloadProject message)
-                await trackCommandMetadataUsage('get-started', {
-                    successful: false,
-                    step: 'github-clone',
-                }, derivedAccountId);
-            }
-            throw error;
-        }
-    };
     try {
         await renderInteractive(getGetStartedFlow({
             derivedAccountId,
-            onRunCreateProject,
             initialName: name,
             initialDest: dest,
         }), { fullScreen: true });
+        await trackGetStartedUsage({ successful: true, step: 'command-completed' }, derivedAccountId);
     }
     finally {
         setLogLevel(LOG_LEVEL.LOG);

package/lib/getStartedV2Actions.d.ts

@@ -1,8 +1,37 @@
+import { type ProjectMetadata } from '@hubspot/project-parsing-lib/projects';
+import { type IntermediateRepresentationNode } from '@hubspot/project-parsing-lib/translate';
 export type CreateProjectResult = {
     projectName: string;
     projectDest: string;
 };
+export type AppConfig = {
+    name?: string;
+    uid?: string;
+    distribution?: string;
+    auth?: {
+        type?: string;
+        requiredScopes?: string[];
+        optionalScopes?: string[];
+    };
+};
+export type AppIRNode = IntermediateRepresentationNode & {
+    config: AppConfig;
+};
 export declare function createProjectAction({ projectName, projectDest, }: {
     projectName: string;
     projectDest: string;
 }): Promise<CreateProjectResult>;
+export type UploadAndDeployResult = {
+    appId: number;
+    projectId: number;
+    installUrl: string;
+    projectDir: string;
+    app: AppIRNode;
+    projectName: string;
+    projectMetadata: ProjectMetadata;
+};
+export declare function uploadAndDeployAction({ accountId, projectDest, }: {
+    accountId: number;
+    projectDest: string;
+}): Promise<UploadAndDeployResult>;
+export declare function trackGetStartedUsage(params: Record<string, unknown>, accountId: number): Promise<void>;

package/lib/getStartedV2Actions.js

@@ -1,18 +1,26 @@
 import fs from 'fs-extra';
 import path from 'path';
-import { getCwd } from '@hubspot/local-dev-lib/path';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
+import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { getProjectMetadata, } from '@hubspot/project-parsing-lib/projects';
+import { translate, } from '@hubspot/project-parsing-lib/translate';
 import { commands, lib } from '../lang/en.js';
+import { getStaticAuthAppInstallUrl } from '../lib/app/urls.js';
 import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_CONFIG_FILE, } from '../lib/constants.js';
-import { getProjectConfig, writeProjectConfig, } from '../lib/projects/config.js';
+import { ProjectNestingError, ProjectConfigNotFoundError, ProjectValidationError, ProjectUploadError, ProjectBuildDeployError, } from './errors/ProjectErrors.js';
+import { getProjectConfig, validateProjectConfig, writeProjectConfig, } from '../lib/projects/config.js';
+import { isV2Project } from '../lib/projects/platformVersion.js';
+import { pollProjectBuildAndDeploy } from '../lib/projects/pollProjectBuildAndDeploy.js';
+import { handleProjectUpload } from '../lib/projects/upload.js';
 import { validateProjectDirectory } from '../lib/prompts/projectNameAndDestPrompt.js';
-import SpinniesManager from '../lib/ui/SpinniesManager.js';
+import { trackCommandMetadataUsage } from './usageTracking.js';
 export async function createProjectAction({ projectName, projectDest, }) {
-    // Validate project name
     if (!projectName || projectName.trim() === '') {
         throw new Error(lib.prompts.projectNameAndDestPrompt.errors.nameRequired);
     }
-    // Validate destination path
     const validationResult = validateProjectDirectory(projectDest);
     if (validationResult !== true) {
         throw new Error(typeof validationResult === 'string'
@@ -24,9 +32,8 @@ export async function createProjectAction({ projectName, projectDest, }) {
     if (existingProjectConfig &&
         existingProjectDir &&
         projectDestAbsolute.startsWith(existingProjectDir)) {
-        throw new Error(commands.project.create.errors.cannotNestProjects(existingProjectDir));
+        throw new ProjectNestingError(commands.project.create.errors.cannotNestProjects(existingProjectDir));
     }
-    SpinniesManager.setDisableOutput(true);
     try {
         await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDestAbsolute, {
             sourceDir: '2025.2/private-app-get-started-template',
@@ -45,7 +52,95 @@ export async function createProjectAction({ projectName, projectDest, }) {
             cause: error,
         });
     }
-    finally {
-        SpinniesManager.setDisableOutput(false);
+}
+async function fetchAppAfterDeploy(accountId, env) {
+    const { data: { results }, } = await fetchPublicAppsForPortal(accountId);
+    const lastCreatedApp = results.sort((a, b) => b.createdAt - a.createdAt)[0];
+    if (!lastCreatedApp) {
+        throw new Error(commands.getStarted.errors.noAppsFound);
+    }
+    const installUrl = getStaticAuthAppInstallUrl({
+        targetAccountId: accountId,
+        env,
+        appId: lastCreatedApp.id,
+    });
+    return {
+        appId: lastCreatedApp.id,
+        installUrl,
+    };
+}
+async function buildProjectMetadata(projectDir, projectConfig, accountId) {
+    const srcDir = path.join(projectDir, projectConfig.srcDir);
+    const projectMetadata = await getProjectMetadata(srcDir);
+    const intermediateRepresentation = await translate({
+        projectSourceDir: srcDir,
+        platformVersion: projectConfig.platformVersion,
+        accountId,
+    }, { skipValidation: false });
+    const apps = Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).filter(node => node.componentType === 'APPLICATION');
+    if (apps.length === 0) {
+        throw new Error(commands.getStarted.errors.noAppsFound);
+    }
+    return {
+        projectMetadata,
+        app: apps[0],
+    };
+}
+export async function uploadAndDeployAction({ accountId, projectDest, }) {
+    const { projectConfig, projectDir } = await getProjectConfig(projectDest);
+    if (!projectConfig || !projectDir) {
+        throw new ProjectConfigNotFoundError(commands.getStarted.errors.configFileNotFound);
     }
+    try {
+        validateProjectConfig(projectConfig, projectDir);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ProjectValidationError(message);
+    }
+    const env = getConfigAccountEnvironment(accountId);
+    try {
+        const { result, uploadError } = await handleProjectUpload({
+            accountId,
+            projectConfig,
+            projectDir,
+            callbackFunc: pollProjectBuildAndDeploy,
+            uploadMessage: commands.getStarted.logs.initialUploadMessage,
+            forceCreate: true,
+            isUploadCommand: false,
+            sendIR: isV2Project(projectConfig.platformVersion),
+            skipValidation: false,
+        });
+        if (uploadError) {
+            throw new ProjectUploadError(commands.getStarted.errors.uploadActionFailed, uploadError);
+        }
+        if (!result || !result.succeeded) {
+            throw new ProjectBuildDeployError(commands.getStarted.errors.buildOrDeployFailed);
+        }
+        const { data: projectData } = await fetchProject(accountId, projectConfig.name);
+        const projectId = projectData.id;
+        const { appId, installUrl } = await fetchAppAfterDeploy(accountId, env);
+        const { projectMetadata, app } = await buildProjectMetadata(projectDir, projectConfig, accountId);
+        return {
+            appId,
+            projectId,
+            installUrl,
+            projectDir,
+            app,
+            projectName: projectConfig.name,
+            projectMetadata,
+        };
+    }
+    catch (error) {
+        if (error instanceof ProjectUploadError ||
+            error instanceof ProjectBuildDeployError) {
+            throw error;
+        }
+        throw new Error(commands.getStarted.errors.failedToUploadAndDeploy, {
+            cause: error,
+        });
+    }
+}
+export function trackGetStartedUsage(params, accountId) {
+    return trackCommandMetadataUsage('get-started', params, accountId);
 }