@hubspot/cli 8.1.0 → 8.2.0

package/mcp-server/utils/__tests__/command.test.js

@@ -1,6 +1,20 @@
-import { addFlag } from '../command.js';
-vi.mock('child_process');
-vi.mock('util');
+import fs from 'fs';
+import path from 'path';
+const mockExecAsync = vi.fn();
+vi.mock('node:child_process');
+vi.mock('util', () => ({
+    default: {
+        promisify: () => mockExecAsync,
+    },
+    promisify: () => mockExecAsync,
+}));
+vi.mock('fs');
+vi.mock('path');
+// Import after mocks are set up
+const { addFlag, runCommandInDir } = await import('../command.js');
+const mockExistsSync = vi.mocked(fs.existsSync);
+const mockMkdirSync = vi.mocked(fs.mkdirSync);
+const mockResolve = vi.mocked(path.resolve);
 describe('mcp-server/utils/command', () => {
     describe('addFlag', () => {
         it('should add string flag to command', () => {
@@ -42,4 +56,220 @@ describe('mcp-server/utils/command', () => {
             expect(result).toBe('hs project create --features "card with spaces" "settings"');
         });
     });
+    describe('runCommandInDir', () => {
+        const mockDirectory = '/test/directory';
+        const mockCommand = 'npm install';
+        const mockResolvedPath = '/resolved/test/directory';
+        beforeEach(() => {
+            mockResolve.mockReturnValue(mockResolvedPath);
+        });
+        it('should run command in existing directory', async () => {
+            const expectedResult = {
+                stdout: 'command output',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).not.toHaveBeenCalled();
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            expect(result).toEqual(expectedResult);
+        });
+        it('should create directory if it does not exist', async () => {
+            const expectedResult = {
+                stdout: 'command output',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(false);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            expect(result).toEqual(expectedResult);
+        });
+        it('should propagate execAsync errors', async () => {
+            const error = new Error('Command failed');
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockRejectedValue(error);
+            await expect(runCommandInDir(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should handle stderr in results', async () => {
+            const expectedResult = {
+                stdout: 'some output',
+                stderr: 'warning message',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(result.stdout).toBe('some output');
+            expect(result.stderr).toBe('warning message');
+        });
+        it('should add --disable-usage-tracking flag to hs commands', async () => {
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should not add --disable-usage-tracking flag to non-hs commands', async () => {
+            const nonHsCommand = 'npm install';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, nonHsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npm install', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should add --disable-usage-tracking flag to hs commands with existing flags', async () => {
+            const hsCommand = 'hs project upload --profile prod';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --profile prod --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should handle hs commands that start with whitespace', async () => {
+            const hsCommand = 'hs init';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('hs init --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should use npx -p @hubspot/cli when HUBSPOT_MCP_STANDALONE is true', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -y -p @hubspot/cli hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should use regular hs command when HUBSPOT_MCP_STANDALONE is not set', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            delete process.env.HUBSPOT_MCP_STANDALONE;
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalEnv !== undefined) {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should use npx -p @hubspot/cli for hs commands with flags in standalone mode', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            const hsCommand = 'hs project upload --profile prod';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -y -p @hubspot/cli hs project upload --profile prod --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should use pinned CLI version when HUBSPOT_CLI_VERSION is set in standalone mode', async () => {
+            const originalStandaloneEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            const originalVersionEnv = process.env.HUBSPOT_CLI_VERSION;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            process.env.HUBSPOT_CLI_VERSION = '8.1.0';
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -y -p @hubspot/cli@8.1.0 hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalStandaloneEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalStandaloneEnv;
+            }
+            if (originalVersionEnv === undefined) {
+                delete process.env.HUBSPOT_CLI_VERSION;
+            }
+            else {
+                process.env.HUBSPOT_CLI_VERSION = originalVersionEnv;
+            }
+        });
+    });
 });

package/mcp-server/utils/__tests__/feedbackTracking.test.js

@@ -1,17 +1,10 @@
 import { mcpFeedbackRequest } from '../feedbackTracking.js';
 import { getStateValue, setStateValue, } from '@hubspot/local-dev-lib/config/state';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { hasFeature } from '../../../lib/hasFeature.js';
-import { FEATURES } from '../../../lib/constants.js';
+import { FEEDBACK_URL } from '../../../lib/constants.js';
 vi.mock('@hubspot/local-dev-lib/config/state');
-vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('@hubspot/local-dev-lib/logger');
-vi.mock('../../../lib/hasFeature');
-vi.mock('../../../lib/errorHandlers/index');
 const mockGetStateValue = getStateValue;
 const mockSetStateValue = setStateValue;
-const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
-const mockHasFeature = hasFeature;
 describe('mcp-server/utils/feedbackTracking', () => {
     describe('mcpFeedbackRequest', () => {
         it('should return empty string when not at a threshold', async () => {
@@ -22,83 +15,29 @@ describe('mcp-server/utils/feedbackTracking', () => {
         });
         it('should return feedback message at threshold 50', async () => {
             mockGetStateValue.mockReturnValue(49);
-            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
             const result = await mcpFeedbackRequest();
             expect(mockSetStateValue).toHaveBeenCalledWith('mcpTotalToolCalls', 50);
             expect(result).toContain('FEEDBACK REQUEST');
-            expect(result).toContain('https://app.hubspot.com/l/product-updates/in-beta?rollout=239890');
+            expect(result).toContain(FEEDBACK_URL);
         });
         it('should return feedback message at threshold 250', async () => {
             mockGetStateValue.mockReturnValue(249);
-            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
             const result = await mcpFeedbackRequest();
             expect(mockSetStateValue).toHaveBeenCalledWith('mcpTotalToolCalls', 250);
             expect(result).toContain('FEEDBACK REQUEST');
         });
         it('should return feedback message at threshold 550', async () => {
             mockGetStateValue.mockReturnValue(549);
-            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
             const result = await mcpFeedbackRequest();
             expect(mockSetStateValue).toHaveBeenCalledWith('mcpTotalToolCalls', 550);
             expect(result).toContain('FEEDBACK REQUEST');
         });
         it('should return feedback message at threshold 1050', async () => {
             mockGetStateValue.mockReturnValue(1049);
-            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
             const result = await mcpFeedbackRequest();
             expect(mockSetStateValue).toHaveBeenCalledWith('mcpTotalToolCalls', 1050);
             expect(result).toContain('FEEDBACK REQUEST');
         });
-        it('should use account-specific URL when account has MCP access', async () => {
-            const accountId = 12345;
-            mockGetStateValue.mockReturnValue(49);
-            mockGetConfigDefaultAccountIfExists.mockReturnValue({
-                accountId,
-            });
-            mockHasFeature.mockResolvedValue(true);
-            const result = await mcpFeedbackRequest();
-            expect(mockGetConfigDefaultAccountIfExists).toHaveBeenCalled();
-            expect(mockHasFeature).toHaveBeenCalledWith(accountId, FEATURES.MCP_ACCESS);
-            expect(result).toContain(`https://app.hubspot.com/product-updates/${accountId}/in-beta?rollout=239890`);
-        });
-        it('should use default URL when account does not have MCP access', async () => {
-            const accountId = 12345;
-            mockGetStateValue.mockReturnValue(49);
-            mockGetConfigDefaultAccountIfExists.mockReturnValue({
-                accountId,
-            });
-            mockHasFeature.mockResolvedValue(false);
-            const result = await mcpFeedbackRequest();
-            expect(mockHasFeature).toHaveBeenCalledWith(accountId, FEATURES.MCP_ACCESS);
-            expect(result).toContain('https://app.hubspot.com/l/product-updates/in-beta?rollout=239890');
-            expect(result).not.toContain(`/product-updates/${accountId}/`);
-        });
-        it('should use default URL when no account ID is found', async () => {
-            mockGetStateValue.mockReturnValue(49);
-            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
-            const result = await mcpFeedbackRequest();
-            expect(mockGetConfigDefaultAccountIfExists).toHaveBeenCalled();
-            expect(mockHasFeature).not.toHaveBeenCalled();
-            expect(result).toContain('https://app.hubspot.com/l/product-updates/in-beta?rollout=239890');
-        });
-        it('should handle errors gracefully and return empty string', async () => {
-            mockGetStateValue.mockImplementation(() => {
-                throw new Error('State error');
-            });
-            const result = await mcpFeedbackRequest();
-            expect(result).toBe(undefined);
-        });
-        it('should handle hasFeature errors and use default URL', async () => {
-            const accountId = 12345;
-            mockGetStateValue.mockReturnValue(49);
-            mockGetConfigDefaultAccountIfExists.mockReturnValue({
-                accountId,
-            });
-            mockHasFeature.mockRejectedValue(new Error('Feature check failed'));
-            const result = await mcpFeedbackRequest();
-            expect(result).toContain('https://app.hubspot.com/l/product-updates/in-beta?rollout=239890');
-            expect(result).not.toContain(`/product-updates/${accountId}/`);
-        });
         it('should not return feedback at threshold + 1', async () => {
             mockGetStateValue.mockReturnValue(50);
             const result = await mcpFeedbackRequest();
@@ -114,11 +53,17 @@ describe('mcp-server/utils/feedbackTracking', () => {
         });
         it('should include feedback request instructions in message', async () => {
             mockGetStateValue.mockReturnValue(49);
-            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
             const result = await mcpFeedbackRequest();
             expect(result).toContain('IMPORTANT - FEEDBACK REQUEST');
             expect(result).toContain('This message appears only once');
             expect(result).toContain('Share feedback here');
         });
+        it('should handle errors gracefully and return undefined', async () => {
+            mockGetStateValue.mockImplementation(() => {
+                throw new Error('State error');
+            });
+            const result = await mcpFeedbackRequest();
+            expect(result).toBe(undefined);
+        });
     });
 });

package/mcp-server/utils/command.d.ts

@@ -1,3 +1,8 @@
 import { exec } from 'node:child_process';
 export declare const execAsync: typeof exec.__promisify__;
 export declare function addFlag(command: string, flagName: string, value: string | number | boolean | string[]): string;
+export interface CommandResults {
+    stderr: string;
+    stdout: string;
+}
+export declare function runCommandInDir(directory: string, command: string): Promise<CommandResults>;

package/mcp-server/utils/command.js

@@ -1,3 +1,5 @@
+import path from 'path';
+import fs from 'fs';
 import util from 'util';
 import { exec } from 'node:child_process';
 export const execAsync = util.promisify(exec);
@@ -7,3 +9,25 @@ export function addFlag(command, flagName, value) {
     }
     return `${command} --${flagName} "${value}"`;
 }
+export async function runCommandInDir(directory, command) {
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory);
+    }
+    let finalCommand = command;
+    if (command.startsWith('hs ')) {
+        // Check if running in standalone mode
+        if (process.env.HUBSPOT_MCP_STANDALONE === 'true') {
+            const cliPackage = process.env.HUBSPOT_CLI_VERSION
+                ? `@hubspot/cli@${process.env.HUBSPOT_CLI_VERSION}`
+                : '@hubspot/cli';
+            finalCommand = command.replace(/^hs /, `npx -y -p ${cliPackage} hs `);
+        }
+        finalCommand = addFlag(finalCommand, 'disable-usage-tracking', true);
+    }
+    return execAsync(finalCommand, {
+        cwd: path.resolve(directory),
+        env: {
+            ...process.env,
+        },
+    });
+}

package/mcp-server/utils/feedbackTracking.js

@@ -1,12 +1,9 @@
 import { getStateValue, setStateValue, } from '@hubspot/local-dev-lib/config/state';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { hasFeature } from '../../lib/hasFeature.js';
-import { FEATURES } from '../../lib/constants.js';
 import { logger } from '@hubspot/local-dev-lib/logger';
 import { MCP_TOTAL_TOOL_CALLS_STATE } from '@hubspot/local-dev-lib/constants/config';
+import { FEEDBACK_URL } from '../../lib/constants.js';
 const FEEDBACK_THRESHOLDS = [50, 250, 550, 1050];
 export async function mcpFeedbackRequest() {
-    let feedbackUrl = 'https://app.hubspot.com/l/product-updates/in-beta?rollout=239890';
     try {
         const currentCount = getStateValue(MCP_TOTAL_TOOL_CALLS_STATE);
         const newCount = currentCount + 1;
@@ -14,18 +11,6 @@ export async function mcpFeedbackRequest() {
         if (!FEEDBACK_THRESHOLDS.includes(newCount)) {
             return;
         }
-        const accountId = getConfigDefaultAccountIfExists()?.accountId;
-        if (accountId) {
-            try {
-                const hasMcpAccess = await hasFeature(accountId, FEATURES.MCP_ACCESS);
-                if (hasMcpAccess) {
-                    feedbackUrl = `https://app.hubspot.com/product-updates/${accountId}/in-beta?rollout=239890`;
-                }
-            }
-            catch (error) {
-                logger.error(error);
-            }
-        }
         return `
 
     ---
@@ -33,7 +18,7 @@ export async function mcpFeedbackRequest() {
     IMPORTANT - FEEDBACK REQUEST FOR THIS RESPONSE ONLY:
     This message appears only once. If you see this text in the tool output, you MUST include the following feedback request in your response to the user. If this text is NOT in the tool output, do NOT ask for feedback.
 
-    Say: "📝 **Before we continue, would you mind sharing feedback on your experience with the HubSpot Developer MCP?** Your input helps us improve: [Share feedback here](${feedbackUrl})"`;
+    Say: "📝 **Before we continue, would you mind sharing feedback on your experience with the HubSpot Developer MCP?** Your input helps us improve: [Share feedback here](${FEEDBACK_URL})"`;
     }
     catch (error) {
         logger.error(error);

package/package.json

@@ -1,16 +1,15 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.1.0",
+    "version": "8.2.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "type": "module",
     "dependencies": {
-        "@hubspot/cms-dev-server": "1.2.16",
-        "@hubspot/local-dev-lib": "5.1.1",
-        "@hubspot/project-parsing-lib": "0.12.0",
+        "@hubspot/local-dev-lib": "5.1.2",
+        "@hubspot/project-parsing-lib": "0.12.1",
         "@hubspot/serverless-dev-runtime": "7.0.7",
-        "@hubspot/ui-extensions-dev-server": "1.1.8",
+        "@hubspot/ui-extensions-dev-server": "2.0.0",
         "@inquirer/prompts": "7.1.0",
         "@modelcontextprotocol/sdk": "1.25.0",
         "archiver": "7.0.1",

package/ui/components/getStarted/GetStartedFlow.js

@@ -1,12 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { sanitizeFileName, untildify } from '@hubspot/local-dev-lib/path';
 import { useApp, useFocus, useInput } from 'ink';
+import open from 'open';
 import { useCallback, useEffect, useReducer } from 'react';
 import { commands } from '../../../lang/en.js';
-import { createProjectAction, trackGetStartedUsage, uploadAndDeployAction, } from '../../../lib/getStartedV2Actions.js';
+import { createProjectAction, pollAppInstallation, trackGetStartedUsage, uploadAndDeployAction, } from '../../../lib/getStartedV2Actions.js';
+import { validateProjectDirectory } from '../../../lib/prompts/projectNameAndDestPrompt.js';
 import { uiAccountDescription } from '../../../lib/ui/index.js';
 import { ACTION_STATUSES, GET_STARTED_FLOW_STEPS, } from '../../lib/constants.js';
 import { flowReducer } from './reducer.js';
+import { InstallationScreen } from './screens/InstallationScreen.js';
 import { ProjectSetupScreen } from './screens/ProjectSetupScreen.js';
 import { UploadScreen } from './screens/UploadScreen.js';
 import { getProject } from './selectors.js';
@@ -44,6 +47,7 @@ export function GetStartedFlow({ derivedAccountId, initialName, initialDest, })
         statuses: {
             create: initialName ? ACTION_STATUSES.RUNNING : ACTION_STATUSES.IDLE,
             upload: ACTION_STATUSES.IDLE,
+            installApp: ACTION_STATUSES.IDLE,
         },
     });
     const [state, dispatch] = useReducer(flowReducer, getInitialState());
@@ -68,6 +72,16 @@ export function GetStartedFlow({ derivedAccountId, initialName, initialDest, })
         dispatch({ type: 'SET_STEP', payload: GET_STARTED_FLOW_STEPS.DEST_INPUT });
     }, []);
     const handleDestSubmit = useCallback(async () => {
+        const validationResult = validateProjectDirectory(project.destination);
+        if (validationResult !== true) {
+            dispatch({
+                type: 'SET_DEST_ERROR',
+                payload: typeof validationResult === 'string'
+                    ? validationResult
+                    : commands.getStarted.v2.unknownError,
+            });
+            return;
+        }
         dispatch({ type: 'SET_STEP', payload: GET_STARTED_FLOW_STEPS.CREATING });
         try {
             await createProjectAction({
@@ -108,6 +122,57 @@ export function GetStartedFlow({ derivedAccountId, initialName, initialDest, })
             dispatch({ type: 'UPLOAD_ERROR', payload: errorMessage });
         }
     }, [derivedAccountId, project.destination]);
+    const handlePollInstallation = useCallback(async () => {
+        const uploadApp = project.uploadResult?.app;
+        const projectId = project.uploadResult?.projectId;
+        if (!projectId || !uploadApp?.uid) {
+            dispatch({
+                type: 'INSTALL_APP_ERROR',
+                payload: commands.getStarted.v2.unknownError,
+            });
+            return;
+        }
+        try {
+            await pollAppInstallation({
+                accountId: derivedAccountId,
+                projectId,
+                appUid: uploadApp.uid,
+                requiredScopes: uploadApp.config?.auth?.requiredScopes,
+                optionalScopes: uploadApp.config?.auth?.optionalScopes,
+                onTimeout: () => {
+                    dispatch({ type: 'SET_POLLING_TIMED_OUT', payload: true });
+                },
+            });
+            dispatch({ type: 'INSTALL_APP_DONE' });
+        }
+        catch (error) {
+            dispatch({
+                type: 'INSTALL_APP_ERROR',
+                payload: error instanceof Error
+                    ? error.message
+                    : commands.getStarted.v2.unknownError,
+            });
+        }
+    }, [project.uploadResult, derivedAccountId]);
+    const handleBrowserOpen = useCallback(async (shouldOpen) => {
+        await trackGetStartedUsage({
+            step: 'open-install-page',
+            type: shouldOpen ? 'opened' : 'declined',
+        }, derivedAccountId);
+        if (shouldOpen && project.uploadResult?.installUrl) {
+            try {
+                await open(project.uploadResult.installUrl, { url: true });
+            }
+            catch (error) {
+                dispatch({
+                    type: 'SET_BROWSER_FAILED_URL',
+                    payload: project.uploadResult.installUrl,
+                });
+            }
+        }
+        dispatch({ type: 'START_INSTALL_APP' });
+        await handlePollInstallation();
+    }, [project.uploadResult, derivedAccountId, handlePollInstallation]);
     const handleNameChange = useCallback((value) => {
         dispatch({ type: 'SET_PROJECT_NAME', payload: value });
     }, []);
@@ -116,7 +181,8 @@ export function GetStartedFlow({ derivedAccountId, initialName, initialDest, })
     }, []);
     useInput((_, key) => {
         const hasError = state.statuses.create === ACTION_STATUSES.ERROR ||
-            state.statuses.upload === ACTION_STATUSES.ERROR;
+            state.statuses.upload === ACTION_STATUSES.ERROR ||
+            state.statuses.installApp === ACTION_STATUSES.ERROR;
         if (hasError) {
             exit();
             return;
@@ -126,11 +192,22 @@ export function GetStartedFlow({ derivedAccountId, initialName, initialDest, })
         if (state.step === GET_STARTED_FLOW_STEPS.COMPLETE) {
             handleUploadStart();
         }
+        else if (state.step === GET_STARTED_FLOW_STEPS.OPEN_APP_PROMPT) {
+            handleBrowserOpen(true);
+        }
+        else if (state.step === GET_STARTED_FLOW_STEPS.INSTALLING_APP &&
+            state.statuses.installApp === ACTION_STATUSES.DONE) {
+            // Ready for card setup - will be handled in PR3
+            exit();
+        }
     });
     if (state.step === GET_STARTED_FLOW_STEPS.UPLOADING ||
         state.step === GET_STARTED_FLOW_STEPS.OPEN_APP_PROMPT) {
         return _jsx(UploadScreen, { state: state, accountName: accountName });
     }
+    if (state.step === GET_STARTED_FLOW_STEPS.INSTALLING_APP) {
+        return _jsx(InstallationScreen, { state: state, accountName: accountName });
+    }
     // Show project setup screen for initial flow
     return (_jsx(ProjectSetupScreen, { state: state, onSelectOption: handleSelect, onNameChange: handleNameChange, onNameSubmit: handleNameSubmit, onDestChange: handleDestChange, onDestSubmit: handleDestSubmit }));
 }

package/ui/components/getStarted/reducer.d.ts

@@ -14,6 +14,7 @@ export type AppState = {
 export type ActionStatuses = {
     create: ActionStatus;
     upload: ActionStatus;
+    installApp: ActionStatus;
 };
 export type FlowState = {
     step: FlowStep;
@@ -21,6 +22,9 @@ export type FlowState = {
     app: AppState;
     statuses: ActionStatuses;
     error?: string;
+    destError?: string;
+    browserFailedUrl?: string;
+    pollingTimedOut?: boolean;
 };
 type FlowAction = {
     type: 'SET_STEP';
@@ -37,6 +41,9 @@ type FlowAction = {
 } | {
     type: 'SET_ERROR';
     payload: string;
+} | {
+    type: 'SET_DEST_ERROR';
+    payload: string;
 } | {
     type: 'CLEAR_ERROR';
 } | {
@@ -54,6 +61,19 @@ type FlowAction = {
 } | {
     type: 'UPLOAD_ERROR';
     payload: string;
+} | {
+    type: 'START_INSTALL_APP';
+} | {
+    type: 'INSTALL_APP_DONE';
+} | {
+    type: 'INSTALL_APP_ERROR';
+    payload: string;
+} | {
+    type: 'SET_BROWSER_FAILED_URL';
+    payload: string;
+} | {
+    type: 'SET_POLLING_TIMED_OUT';
+    payload: boolean;
 };
 export declare function flowReducer(state: FlowState, action: FlowAction): FlowState;
 export {};