@hubspot/cli 7.8.12-experimental.1 → 7.9.0-beta.0

package/lib/projects/localDev/DevServerManager_DEPRECATED.js

@@ -0,0 +1,120 @@
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { DevModeInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
+import { startPortManagerServer, stopPortManagerServer, requestPorts, } from '@hubspot/local-dev-lib/portManager';
+import { getHubSpotApiOrigin, getHubSpotWebsiteOrigin, } from '@hubspot/local-dev-lib/urls';
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { ComponentTypes, } from '../../../types/Projects.js';
+import { lib } from '../../../lang/en.js';
+import { uiLogger } from '../../ui/logger.js';
+const SERVER_KEYS = {
+    privateApp: 'privateApp',
+    publicApp: 'publicApp',
+};
+class DevServerManager_DEPRECATED {
+    initialized;
+    started;
+    componentsByType;
+    devServers;
+    constructor() {
+        this.initialized = false;
+        this.started = false;
+        this.componentsByType = {};
+        this.devServers = {
+            [SERVER_KEYS.privateApp]: {
+                componentType: ComponentTypes.PrivateApp,
+                serverInterface: UIEDevModeInterface,
+            },
+            [SERVER_KEYS.publicApp]: {
+                componentType: ComponentTypes.PublicApp,
+                serverInterface: UIEDevModeInterface,
+            },
+        };
+    }
+    async iterateDevServers(callback) {
+        const serverKeys = Object.keys(this.devServers);
+        for (let i = 0; i < serverKeys.length; i++) {
+            const serverKey = serverKeys[i];
+            const devServer = this.devServers[serverKey];
+            const compatibleComponents = this.componentsByType[devServer.componentType] || {};
+            if (Object.keys(compatibleComponents).length) {
+                await callback(devServer.serverInterface, compatibleComponents);
+            }
+            else {
+                uiLogger.debug(lib.DevServerManager.noCompatibleComponents(serverKey));
+            }
+        }
+    }
+    arrangeComponentsByType(components) {
+        return components.reduce((acc, component) => {
+            if (!acc[component.type]) {
+                acc[component.type] = {};
+            }
+            if ('name' in component.config && component.config.name) {
+                acc[component.type][component.config.name] = component;
+            }
+            return acc;
+        }, {});
+    }
+    async setup({ components, onUploadRequired, accountId, setActiveApp, }) {
+        this.componentsByType = this.arrangeComponentsByType(components);
+        let env;
+        const accountConfig = getAccountConfig(accountId);
+        if (accountConfig) {
+            env = accountConfig.env;
+        }
+        await startPortManagerServer();
+        await this.iterateDevServers(async (serverInterface, compatibleComponents) => {
+            if (serverInterface.setup) {
+                await serverInterface.setup({
+                    components: compatibleComponents,
+                    onUploadRequired,
+                    logger,
+                    urls: {
+                        api: getHubSpotApiOrigin(env),
+                        web: getHubSpotWebsiteOrigin(env),
+                    },
+                    setActiveApp,
+                });
+            }
+        });
+        this.initialized = true;
+    }
+    async start({ accountId, projectConfig, }) {
+        if (this.initialized) {
+            await this.iterateDevServers(async (serverInterface) => {
+                if (serverInterface.start) {
+                    await serverInterface.start({
+                        accountId,
+                        projectConfig,
+                        requestPorts,
+                    });
+                }
+            });
+        }
+        else {
+            throw new Error(lib.DevServerManager.notInitialized);
+        }
+        this.started = true;
+    }
+    async fileChange({ filePath, event, }) {
+        if (this.started) {
+            this.iterateDevServers(async (serverInterface) => {
+                if (serverInterface.fileChange) {
+                    await serverInterface.fileChange(filePath, event);
+                }
+            });
+        }
+    }
+    async cleanup() {
+        if (this.started) {
+            await this.iterateDevServers(async (serverInterface) => {
+                if (serverInterface.cleanup) {
+                    await serverInterface.cleanup();
+                }
+            });
+            await stopPortManagerServer();
+        }
+    }
+}
+const Manager = new DevServerManager_DEPRECATED();
+export default Manager;

package/lib/projects/localDev/{LocalDevManager.js → LocalDevManager_DEPRECATED.js}

@@ -6,10 +6,10 @@ import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts, } from
 import { getAccountId, getConfigDefaultAccount, } from '@hubspot/local-dev-lib/config';
 import { PROJECT_CONFIG_FILE } from '../../constants.js';
 import SpinniesManager from '../../ui/SpinniesManager.js';
-import DevServerManager from './DevServerManager.js';
+import DevServerManager_DEPRECATED from './DevServerManager_DEPRECATED.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { getAccountHomeUrl } from '../urls.js';
-import { componentIsApp, componentIsPublicApp, CONFIG_FILES, getAppCardConfigs, getComponentUid, } from '../../projects/structure.js';
+import { componentIsApp, componentIsPublicApp, CONFIG_FILES, getAppCardConfigs, getComponentUid, } from '../structure.js';
 import { ComponentTypes, } from '../../../types/Projects.js';
 import { UI_COLORS, uiCommandReference, uiAccountDescription, uiBetaTag, uiLink, uiLine, } from '../../ui/index.js';
 import { logError } from '../../errorHandlers/index.js';
@@ -313,7 +313,7 @@ class LocalDevManager {
     }
     async devServerSetup() {
         try {
-            await DevServerManager.setup({
+            await DevServerManager_DEPRECATED.setup({
                 components: this.runnableComponents,
                 onUploadRequired: this.logUploadWarning.bind(this),
                 accountId: this.targetAccountId,
@@ -331,7 +331,7 @@ class LocalDevManager {
     }
     async devServerStart() {
         try {
-            await DevServerManager.start({
+            await DevServerManager_DEPRECATED.start({
                 accountId: this.targetAccountId,
                 projectConfig: this.projectConfig,
             });
@@ -346,7 +346,7 @@ class LocalDevManager {
     }
     devServerFileChange(filePath, event) {
         try {
-            DevServerManager.fileChange({ filePath, event });
+            DevServerManager_DEPRECATED.fileChange({ filePath, event });
         }
         catch (e) {
             if (this.debug) {
@@ -357,7 +357,7 @@ class LocalDevManager {
     }
     async devServerCleanup() {
         try {
-            await DevServerManager.cleanup();
+            await DevServerManager_DEPRECATED.cleanup();
             return true;
         }
         catch (e) {

package/lib/projects/localDev/LocalDevProcess.js

@@ -5,7 +5,7 @@ import path from 'path';
 import open from 'open';
 import LocalDevState from './LocalDevState.js';
 import LocalDevLogger from './LocalDevLogger.js';
-import DevServerManagerV2 from './DevServerManagerV2.js';
+import DevServerManager from './DevServerManager.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { getProjectConfig } from '../config.js';
 import { handleProjectUpload } from '../upload.js';
@@ -23,7 +23,7 @@ class LocalDevProcess {
     constructor(options) {
         this.state = new LocalDevState(options);
         this._logger = new LocalDevLogger(this.state);
-        this.devServerManager = new DevServerManagerV2({
+        this.devServerManager = new DevServerManager({
             localDevState: this.state,
             logger: this._logger,
         });
@@ -149,6 +149,7 @@ class LocalDevProcess {
             this.openLocalDevUi();
         }
         await this.startDevServers();
+        this.state.devServersStarted = true;
         this.logger.monitorConsoleOutput();
     }
     async stop(showProgress = true) {

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

@@ -19,6 +19,7 @@ declare class LocalDevState {
     private _appData;
     private _devServerMessage;
     private _uploadWarnings;
+    private _devServersStarted;
     constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
@@ -51,6 +52,8 @@ declare class LocalDevState {
     get devServerMessage(): string;
     set devServerMessage(message: LocalDevServerMessage);
     get uploadWarnings(): Set<string>;
+    get devServersStarted(): boolean;
+    set devServersStarted(started: boolean);
     addUploadWarning(warning: string): void;
     clearUploadWarnings(): void;
     addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;

package/lib/projects/localDev/LocalDevState.js

@@ -15,6 +15,7 @@ class LocalDevState {
     _appData;
     _devServerMessage;
     _uploadWarnings;
+    _devServersStarted;
     constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
@@ -30,6 +31,7 @@ class LocalDevState {
         this._appData = {};
         this._devServerMessage = LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
         this._uploadWarnings = new Set();
+        this._devServersStarted = false;
         this._listeners = {};
     }
     runListeners(key) {
@@ -106,6 +108,13 @@ class LocalDevState {
     get uploadWarnings() {
         return this._uploadWarnings;
     }
+    get devServersStarted() {
+        return this._devServersStarted;
+    }
+    set devServersStarted(started) {
+        this._devServersStarted = started;
+        this.runListeners('devServersStarted');
+    }
     addUploadWarning(warning) {
         this.uploadWarnings.add(warning);
         this.runListeners('uploadWarnings');

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

@@ -9,12 +9,16 @@ declare class LocalDevWebsocketServer {
     private sendMessage;
     private handleUpload;
     private handleDeploy;
+    private handleAppInstallSuccess;
+    private handleAppInstallFailure;
+    private handleAppInstallInitiated;
     private setupMessageHandlers;
     private sendCliMetadata;
     private sendProjectData;
     private setupProjectNodesListener;
     private setupAppDataListener;
     private setupUploadWarningsListener;
+    private setupDevServersStartedListener;
     private setupStateListeners;
     start(): Promise<void>;
     shutdown(): void;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -2,13 +2,12 @@ import { WebSocketServer } from 'ws';
 import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
 import { uiLogger } from '../../ui/logger.js';
 import { addLocalStateFlag } from '@hubspot/local-dev-lib/config';
-import { LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, CONFIG_LOCAL_STATE_FLAGS, } from '../../constants.js';
+import { LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, CONFIG_LOCAL_STATE_FLAGS, LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID, } from '../../constants.js';
 import { lib } from '../../../lang/en.js';
 import { removeAnsiCodes } from '../../ui/removeAnsiCodes.js';
-import { isDeployWebsocketMessage, isViewedWelcomeScreenWebsocketMessage, isUploadWebsocketMessage, } from './localDevWebsocketServerUtils.js';
+import { isDeployWebsocketMessage, isViewedWelcomeScreenWebsocketMessage, isUploadWebsocketMessage, isAppInstallFailureWebsocketMessage, isAppInstallSuccessWebsocketMessage, isAppInstallInitiatedWebsocketMessage, } from './localDevWebsocketServerUtils.js';
 import pkg from '../../../package.json' with { type: 'json' };
-const SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
-const LOCAL_DEV_WEBSOCKET_SERVER_VERSION = 1;
+const LOCAL_DEV_WEBSOCKET_SERVER_VERSION = 2;
 const LOG_PREFIX = '[LocalDevWebsocketServer]';
 const DOMAINS = ['hubspot.com', 'hubspotqa.com'];
 const SUBDOMAINS = ['local', 'app', 'app-na2', 'app-na3', 'app-ap1', 'app-eu1'];
@@ -62,6 +61,15 @@ class LocalDevWebsocketServer {
             },
         });
     }
+    async handleAppInstallSuccess() {
+        this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+    }
+    async handleAppInstallFailure() {
+        this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_FAILURE);
+    }
+    async handleAppInstallInitiated() {
+        this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.OAUTH_APP_INSTALL_INITIATED);
+    }
     setupMessageHandlers(websocket) {
         websocket.on('message', data => {
             try {
@@ -79,6 +87,15 @@ class LocalDevWebsocketServer {
                 else if (isViewedWelcomeScreenWebsocketMessage(message)) {
                     addLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
                 }
+                else if (isAppInstallSuccessWebsocketMessage(message)) {
+                    this.handleAppInstallSuccess();
+                }
+                else if (isAppInstallFailureWebsocketMessage(message)) {
+                    this.handleAppInstallFailure();
+                }
+                else if (isAppInstallInitiatedWebsocketMessage(message)) {
+                    this.handleAppInstallInitiated();
+                }
                 else {
                     this.logError(lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
                 }
@@ -147,18 +164,34 @@ class LocalDevWebsocketServer {
             this.localDevProcess.removeStateListener('uploadWarnings', listener);
         });
     }
+    setupDevServersStartedListener(websocket) {
+        const listener = (devServersStarted) => {
+            if (devServersStarted) {
+                this.sendMessage(websocket, {
+                    type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEV_SERVERS_STARTED,
+                });
+            }
+        };
+        this.localDevProcess.addStateListener('devServersStarted', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('devServersStarted', listener);
+        });
+    }
     setupStateListeners(websocket) {
         this.setupProjectNodesListener(websocket);
         this.setupAppDataListener(websocket);
         this.setupUploadWarningsListener(websocket);
+        this.setupDevServersStartedListener(websocket);
     }
     async start() {
         const portManagerIsRunning = await isPortManagerServerRunning();
         if (!portManagerIsRunning) {
             throw new Error(lib.LocalDevWebsocketServer.errors.portManagerNotRunning(LOG_PREFIX));
         }
-        const portData = await requestPorts([{ instanceId: SERVER_INSTANCE_ID }]);
-        const port = portData[SERVER_INSTANCE_ID];
+        const portData = await requestPorts([
+            { instanceId: LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID },
+        ]);
+        const port = portData[LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID];
         this.server = new WebSocketServer({ port });
         this.log(lib.LocalDevWebsocketServer.logs.startup(port));
         this.server.on('connection', (ws, req) => {

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

@@ -0,0 +1,13 @@
+import LocalDevState from './LocalDevState.js';
+type UIExtensionsDevModeInterfaceConstructorOptions = {
+    localDevState: LocalDevState;
+};
+declare class UIExtensionsDevModeInterface {
+    localDevState: LocalDevState;
+    constructor(options: UIExtensionsDevModeInterfaceConstructorOptions);
+    setup(): Promise<void>;
+    start(): Promise<void>;
+    fileChange(filePath: string, event: string): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export default UIExtensionsDevModeInterface;

package/lib/projects/localDev/UIExtensionsDevModeInterface.js

@@ -0,0 +1,37 @@
+import { requestPorts } from '@hubspot/local-dev-lib/portManager';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { DevModeUnifiedInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
+import { getHubSpotApiOrigin, getHubSpotWebsiteOrigin, } from '@hubspot/local-dev-lib/urls';
+class UIExtensionsDevModeInterface {
+    localDevState;
+    constructor(options) {
+        this.localDevState = options.localDevState;
+    }
+    async setup() {
+        return UIEDevModeInterface.setup({
+            // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
+            components: this.localDevState.projectNodes,
+            profileData: this.localDevState.projectProfileData,
+            logger,
+            urls: {
+                api: getHubSpotApiOrigin(this.localDevState.env),
+                web: getHubSpotWebsiteOrigin(this.localDevState.env),
+            },
+        });
+    }
+    async start() {
+        return UIEDevModeInterface.start({
+            accountId: this.localDevState.targetTestingAccountId,
+            // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
+            projectConfig: this.localDevState.projectConfig,
+            requestPorts,
+        });
+    }
+    async fileChange(filePath, event) {
+        return UIEDevModeInterface.fileChange(filePath, event);
+    }
+    async cleanup() {
+        return UIEDevModeInterface.cleanup();
+    }
+}
+export default UIExtensionsDevModeInterface;

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

@@ -8,7 +8,7 @@ export declare function checkIfParentAccountIsAuthed(accountConfig: CLIAccount):
 export declare function checkIfAccountFlagIsSupported(accountConfig: CLIAccount, hasPublicApps: boolean): void;
 export declare function suggestRecommendedNestedAccount(accounts: CLIAccount[], accountConfig: CLIAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
 export declare function createSandboxForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment): Promise<number>;
-export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment, useV3?: boolean): Promise<number>;
+export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: CLIAccount, env: Environment, useV2?: boolean): Promise<number>;
 export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
 export declare function hasSandboxes(account: CLIAccount): Promise<boolean>;
 export declare function selectAccountTypePrompt(accountConfig: CLIAccount): Promise<string | null>;

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

@@ -138,7 +138,7 @@ export async function createSandboxForLocalDev(accountId, accountConfig, env) {
     }
 }
 // Create a developer test account and return its accountId
-export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV3 = false) {
+export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV2 = false) {
     let currentPortalCount = 0;
     let maxTestPortals = 10;
     try {
@@ -168,7 +168,7 @@ export async function createDeveloperTestAccountForLocalDev(accountId, accountCo
             accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         });
         trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
-        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV3);
+        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV2);
         return result;
     }
     catch (err) {

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

@@ -0,0 +1 @@
+export declare function confirmLocalDevIsNotRunning(): Promise<void>;

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

@@ -0,0 +1,15 @@
+import { LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID } from '../../../constants.js';
+import { EXIT_CODES } from '../../../enums/exitCodes.js';
+import { getServerPortByInstanceId } from '@hubspot/local-dev-lib/portManager';
+import { uiLogger } from '../../../ui/logger.js';
+import { commands } from '../../../../lang/en.js';
+export async function confirmLocalDevIsNotRunning() {
+    try {
+        await getServerPortByInstanceId(LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID);
+        uiLogger.error(commands.project.dev.errors.localDevAlreadyRunning);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    catch (error) {
+        return;
+    }
+}

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

@@ -154,9 +154,8 @@ export async function isDeployedProjectUpToDateWithLocal(projectConfig, accountI
     try {
         tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'hubspot-project-compare-'));
         const { data: zippedProject } = await downloadProject(accountId, projectConfig.name, deployedBuildId);
-        const extractedProjectPath = path.join(tempDir, sanitizeFileName(projectConfig.name));
-        await extractZipArchive(zippedProject, sanitizeFileName(projectConfig.name), tempDir, { includesRootDir: false, hideLogs: true });
-        const deployedProjectSourceDir = path.join(extractedProjectPath, projectConfig.srcDir);
+        await extractZipArchive(zippedProject, sanitizeFileName(projectConfig.name), tempDir, { hideLogs: true });
+        const deployedProjectSourceDir = path.join(tempDir, projectConfig.srcDir);
         const { intermediateNodesIndexedByUid: deployedProjectNodes } = await translate({
             projectSourceDir: deployedProjectSourceDir,
             platformVersion: projectConfig.platformVersion,

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

@@ -2,3 +2,6 @@ import { LocalDevDeployWebsocketMessage, LocalDevWebsocketMessage } from '../../
 export declare function isUploadWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
 export declare function isDeployWebsocketMessage(message: LocalDevWebsocketMessage): message is LocalDevDeployWebsocketMessage;
 export declare function isViewedWelcomeScreenWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isAppInstallSuccessWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isAppInstallInitiatedWebsocketMessage(message: LocalDevWebsocketMessage): boolean;
+export declare function isAppInstallFailureWebsocketMessage(message: LocalDevWebsocketMessage): boolean;

package/lib/projects/localDev/localDevWebsocketServerUtils.js

@@ -8,3 +8,12 @@ export function isDeployWebsocketMessage(message) {
 export function isViewedWelcomeScreenWebsocketMessage(message) {
     return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.VIEWED_WELCOME_SCREEN);
 }
+export function isAppInstallSuccessWebsocketMessage(message) {
+    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.APP_INSTALL_SUCCESS);
+}
+export function isAppInstallInitiatedWebsocketMessage(message) {
+    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.APP_INSTALL_INITIATED);
+}
+export function isAppInstallFailureWebsocketMessage(message) {
+    return (message.type === LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.APP_INSTALL_FAILURE);
+}

package/lib/projects/urls.d.ts

@@ -7,4 +7,3 @@ export declare function getProjectBuildDetailUrl(projectName: string, buildId: n
 export declare function getProjectDeployDetailUrl(projectName: string, deployId: number, accountId: number): string;
 export declare function getLocalDevUiUrl(accountId: number, showWelcomeScreen?: boolean): string;
 export declare function getAccountHomeUrl(accountId: number): string;
-export declare function getAppAllowlistUrl(accountId: number, projectName: string, appUid: string): string;

package/lib/projects/urls.js

@@ -41,6 +41,3 @@ export function getAccountHomeUrl(accountId) {
     const baseUrl = getHubSpotWebsiteOrigin(getEnv(accountId) === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
     return `${baseUrl}/home?portalId=${accountId}`;
 }
-export function getAppAllowlistUrl(accountId, projectName, appUid) {
-    return `${getProjectHomeUrl(accountId)}/project/${projectName}/component/${appUid}/distribution?panel=static-token-allowlist`;
-}

package/lib/prompts/__tests__/projectAddPrompt.test.js

@@ -1,5 +1,5 @@
 import { Separator } from '@inquirer/prompts';
-import { projectAddPromptV3 } from '../projectAddPrompt.js';
+import { projectAddPromptV2 } from '../projectAddPrompt.js';
 import { promptUser } from '../promptUtils.js';
 vi.mock('../promptUtils');
 const mockedPromptUser = vi.mocked(promptUser);
@@ -19,7 +19,7 @@ describe('lib/prompts/projectAddPrompt', () => {
         supportedAuthTypes: ['oauth'],
         supportedDistributions: ['private'],
     };
-    describe('projectAddPromptV3()', () => {
+    describe('projectAddPromptV2()', () => {
         beforeEach(() => {
             // Mock returns empty result, logic will use selectedComponents when selectedFeatures provided
             mockedPromptUser.mockResolvedValue({});
@@ -31,7 +31,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [templateChoice];
             const selectedFeatures = ['workflow-action-tool'];
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([
                 mockComponentTemplateWithCliSelector,
             ]);
@@ -49,7 +49,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [templateChoice];
             const selectedFeatures = ['module'];
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([mockComponentTemplate]);
             expect(mockedPromptUser).toHaveBeenCalledWith([
                 expect.objectContaining({
@@ -65,7 +65,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [templateChoice];
             const selectedFeatures = ['workflow-action-tool']; // matches cliSelector
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([
                 mockComponentTemplateWithCliSelector,
             ]);
@@ -78,7 +78,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             const components = [templateChoice];
             const selectedFeatures = ['non-matching-feature'];
             mockedPromptUser.mockResolvedValue({ componentTemplate: [] });
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([]);
         });
         it('should throw error when selected feature component is disabled', async () => {
@@ -89,7 +89,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [disabledTemplateChoice];
             const selectedFeatures = ['workflow-action-tool'];
-            await expect(projectAddPromptV3(components, selectedFeatures)).rejects.toThrow(/Cannot.*feature.*workflow-action/);
+            await expect(projectAddPromptV2(components, selectedFeatures)).rejects.toThrow(/Cannot.*feature.*workflow-action/);
         });
         it('should handle multiple components with mixed cliSelector availability', async () => {
             const choice1 = {
@@ -102,7 +102,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [choice1, choice2];
             const selectedFeatures = ['module', 'workflow-action-tool'];
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([
                 mockComponentTemplate,
                 mockComponentTemplateWithCliSelector,
@@ -116,7 +116,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             };
             const components = [separator, templateChoice];
             const selectedFeatures = ['module'];
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(result.componentTemplate).toEqual([mockComponentTemplate]);
         });
         it('should prompt user when no selectedFeatures provided', async () => {
@@ -129,7 +129,7 @@ describe('lib/prompts/projectAddPrompt', () => {
             mockedPromptUser.mockResolvedValue({
                 componentTemplate: [mockComponentTemplate],
             });
-            const result = await projectAddPromptV3(components, selectedFeatures);
+            const result = await projectAddPromptV2(components, selectedFeatures);
             expect(mockedPromptUser).toHaveBeenCalledWith([
                 expect.objectContaining({
                     name: 'componentTemplate',

package/lib/prompts/installAppPrompt.d.ts

@@ -1,7 +1,2 @@
-export declare function installAppBrowserPrompt(installUrl: string, isReinstall?: boolean, staticAuthInstallOptions?: {
-    testingAccountId: number;
-    projectAccountId: number;
-    projectName: string;
-    appUid: string;
-}): Promise<void>;
+export declare function installAppBrowserPrompt(installUrl: string, isReinstall?: boolean): Promise<void>;
 export declare function installAppAutoPrompt(): Promise<boolean>;

package/lib/prompts/installAppPrompt.js

@@ -3,7 +3,7 @@ import { promptUser } from './promptUtils.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
-export async function installAppBrowserPrompt(installUrl, isReinstall = false, staticAuthInstallOptions) {
+export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     uiLogger.log('');
     if (isReinstall) {
         uiLogger.log(lib.prompts.installAppPrompt.reinstallExplanation);
@@ -11,11 +11,6 @@ export async function installAppBrowserPrompt(installUrl, isReinstall = false, s
     else {
         uiLogger.log(lib.prompts.installAppPrompt.explanation);
     }
-    if (staticAuthInstallOptions) {
-        const { testingAccountId, projectAccountId, projectName, appUid } = staticAuthInstallOptions;
-        uiLogger.log(lib.prompts.installAppPrompt.staticAuthExplanation(projectAccountId, testingAccountId, projectName, appUid));
-        uiLogger.log('');
-    }
     const { shouldOpenBrowser } = await promptUser({
         name: 'shouldOpenBrowser',
         type: 'confirm',

package/lib/prompts/projectAddPrompt.d.ts

@@ -4,12 +4,12 @@ type ProjectAddPromptResponse = {
     componentTemplate: ComponentTemplate;
     name: string;
 };
-type ProjectAddPromptResponseV3 = {
+type ProjectAddPromptResponseV2 = {
     componentTemplate: ComponentTemplate[];
 };
 export declare function projectAddPrompt(components: ComponentTemplate[], promptOptions?: {
     name?: string;
     type?: string;
 }): Promise<ProjectAddPromptResponse>;
-export declare function projectAddPromptV3(components: (ComponentTemplateChoice | Separator)[], selectedFeatures: string[] | undefined): Promise<ProjectAddPromptResponseV3>;
+export declare function projectAddPromptV2(components: (ComponentTemplateChoice | Separator)[], selectedFeatures: string[] | undefined): Promise<ProjectAddPromptResponseV2>;
 export {};

package/lib/prompts/projectAddPrompt.js

@@ -45,7 +45,7 @@ export async function projectAddPrompt(components, promptOptions = {}) {
     }
     return result;
 }
-export async function projectAddPromptV3(components, selectedFeatures) {
+export async function projectAddPromptV2(components, selectedFeatures) {
     const selectedComponents = [];
     if (selectedFeatures) {
         components.forEach(template => {