@hubspot/cli 8.0.8-experimental.5 → 8.0.8-experimental.7

package/mcp-server/tools/project/constants.js

@@ -6,19 +6,23 @@ export const absoluteCurrentWorkingDirectory = z
     .string()
     .describe('The absolute path to the current working directory.');
 export const features = z
-    .array(z.enum([
-    'card',
-    'settings',
-    'app-function',
-    'webhooks',
-    'workflow-action',
-    'workflow-action-tool',
-    'app-object',
-    'app-event',
-    'scim',
-    'page',
+    .array(z.union([
+    z.literal('card'),
+    z.literal('settings'),
+    z
+        .literal('app-function')
+        .describe('Also known as a public serverless function'),
+    z.literal('webhooks'),
+    z
+        .literal('workflow-action')
+        .describe('Also known as a custom workflow action.'),
+    z.literal('workflow-action-tool').describe('Also known as agent tools.'),
+    z.literal('app-object'),
+    z.literal('app-event'),
+    z.literal('scim'),
+    z.literal('page'),
 ]))
-    .describe('The features to include in the project, multiple options can be selected. "app-function" is also known as a public serverless function. "workflow-action" is also known as a custom workflow action. "workflow-action-tool" is also known as agent tools.')
+    .describe('The features to include in the project, multiple options can be selected')
     .optional();
 export const docsSearchQuery = z
     .string()

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

@@ -1,20 +1,6 @@
-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);
+import { addFlag } from '../command.js';
+vi.mock('child_process');
+vi.mock('util');
 describe('mcp-server/utils/command', () => {
     describe('addFlag', () => {
         it('should add string flag to command', () => {
@@ -56,220 +42,4 @@ 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__/project.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,140 @@
+import { runCommandInDir } from '../project.js';
+import { execAsync } from '../command.js';
+import fs from 'fs';
+import path from 'path';
+vi.mock('../command', () => ({
+    execAsync: vi.fn(),
+    addFlag: vi.fn((command, flagName, value) => {
+        if (Array.isArray(value)) {
+            return `${command} --${flagName} ${value.map(item => `"${item}"`).join(' ')}`;
+        }
+        return `${command} --${flagName} "${value}"`;
+    }),
+}));
+vi.mock('fs');
+vi.mock('path');
+const mockExecAsync = execAsync;
+const mockExistsSync = fs.existsSync;
+const mockMkdirSync = fs.mkdirSync;
+const mockResolve = path.resolve;
+describe('mcp-server/utils/project', () => {
+    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),
+            }));
+        });
+    });
+});

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

@@ -1,8 +1,3 @@
 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,5 +1,3 @@
-import path from 'path';
-import fs from 'fs';
 import util from 'util';
 import { exec } from 'node:child_process';
 export const execAsync = util.promisify(exec);
@@ -9,25 +7,3 @@ 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/project.d.ts

@@ -0,0 +1,5 @@
+export interface CommandResults {
+    stderr: string;
+    stdout: string;
+}
+export declare function runCommandInDir(directory: string, command: string): Promise<CommandResults>;

package/mcp-server/utils/project.js

@@ -0,0 +1,18 @@
+import { addFlag, execAsync } from './command.js';
+import path from 'path';
+import fs from 'fs';
+export async function runCommandInDir(directory, command) {
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory);
+    }
+    let finalCommand = command;
+    if (command.startsWith('hs ')) {
+        finalCommand = addFlag(finalCommand, 'disable-usage-tracking', true);
+    }
+    return execAsync(finalCommand, {
+        cwd: path.resolve(directory),
+        env: {
+            ...process.env,
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.0.8-experimental.5",
+    "version": "8.0.8-experimental.7",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",

package/ui/components/getStarted/GetStartedFlow.js

@@ -1,15 +1,12 @@
 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, pollAppInstallation, trackGetStartedUsage, uploadAndDeployAction, } from '../../../lib/getStartedV2Actions.js';
-import { validateProjectDirectory } from '../../../lib/prompts/projectNameAndDestPrompt.js';
+import { createProjectAction, trackGetStartedUsage, uploadAndDeployAction, } from '../../../lib/getStartedV2Actions.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';
@@ -47,7 +44,6 @@ 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());
@@ -72,16 +68,6 @@ 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({
@@ -122,57 +108,6 @@ 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 });
     }, []);
@@ -181,8 +116,7 @@ export function GetStartedFlow({ derivedAccountId, initialName, initialDest, })
     }, []);
     useInput((_, key) => {
         const hasError = state.statuses.create === ACTION_STATUSES.ERROR ||
-            state.statuses.upload === ACTION_STATUSES.ERROR ||
-            state.statuses.installApp === ACTION_STATUSES.ERROR;
+            state.statuses.upload === ACTION_STATUSES.ERROR;
         if (hasError) {
             exit();
             return;
@@ -192,22 +126,11 @@ 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 }));
 }