@hubspot/cli 8.0.11-experimental.2 → 8.0.12-experimental.1

package/lib/link/index.js

@@ -0,0 +1,185 @@
+import { getAllConfigAccounts, getConfigDefaultAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { confirmPrompt } from '../prompts/promptUtils.js';
+import { promptForAccountsToLink, promptForAccountsToUnlink, promptForAction, promptForDefaultAccount, } from './prompts.js';
+import { ACTION_RESULT_STATUS, } from '../../types/Link.js';
+import { getDefaultAccountOverrideFilePath, removeDefaultAccountOverrideFile, } from '@hubspot/local-dev-lib/config/defaultAccountOverride';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { authenticateNewAccount } from '../accountAuth.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+export class ActionHandlers {
+    static async link({ state, context, }) {
+        const { eligibleAccounts, inEligibleAccounts } = context.globalAccountsList.reduce((accumulator, account) => {
+            if (state.accounts.includes(account.accountId)) {
+                accumulator.inEligibleAccounts.push(account);
+            }
+            else {
+                accumulator.eligibleAccounts.push(account);
+            }
+            return accumulator;
+        }, { eligibleAccounts: [], inEligibleAccounts: [] });
+        const toAdd = await promptForAccountsToLink(context, eligibleAccounts, inEligibleAccounts, state.localDefaultAccount);
+        const accounts = [...state.accounts, ...toAdd];
+        uiLogger.info(commands.account.subcommands.link.events.accountsLinked(toAdd.length));
+        const overrideFilePath = getDefaultAccountOverrideFilePath();
+        if (overrideFilePath &&
+            context.accountOverrideId &&
+            accounts.includes(context.accountOverrideId)) {
+            uiLogger.log(commands.account.subcommands.link.events.overrideAccountDetected(context.accountOverrideId));
+            uiLogger.log('');
+            const useOverride = await confirmPrompt(commands.account.subcommands.link.prompts.keepAsDefault);
+            removeDefaultAccountOverrideFile();
+            uiLogger.success(commands.account.subcommands.link.events.overrideFileRemoved);
+            if (useOverride) {
+                uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(context.accountOverrideId));
+                return {
+                    status: ACTION_RESULT_STATUS.SUCCESS,
+                    settings: {
+                        accounts,
+                        localDefaultAccount: context.accountOverrideId,
+                    },
+                };
+            }
+        }
+        const localDefaultAccount = await resolveDefaultAccount({
+            accounts,
+            currentDefault: state.localDefaultAccount,
+        });
+        return {
+            status: ACTION_RESULT_STATUS.SUCCESS,
+            settings: { accounts, localDefaultAccount },
+        };
+    }
+    static async unlink({ state }) {
+        const toRemove = await promptForAccountsToUnlink(state.accounts, state.localDefaultAccount);
+        if (toRemove.length === 0) {
+            return { status: ACTION_RESULT_STATUS.NOOP };
+        }
+        const remainingAccounts = state.accounts.filter(account => !toRemove.includes(account));
+        const defaultWasRemoved = state.localDefaultAccount !== undefined &&
+            toRemove.includes(state.localDefaultAccount);
+        // All accounts removed
+        if (remainingAccounts.length === 0) {
+            uiLogger.success(commands.account.subcommands.link.events.noAccountsLinked);
+            return {
+                status: ACTION_RESULT_STATUS.SUCCESS,
+                settings: {
+                    accounts: remainingAccounts,
+                    localDefaultAccount: undefined,
+                },
+            };
+        }
+        //  Default was NOT removed — accounts remain, default unchanged
+        if (!defaultWasRemoved) {
+            uiLogger.success(commands.account.subcommands.link.events.accountsUnlinked(toRemove.length));
+            uiLogger.success(commands.account.subcommands.link.events.defaultAccountRemains(state.localDefaultAccount));
+            return {
+                status: ACTION_RESULT_STATUS.SUCCESS,
+                settings: {
+                    accounts: remainingAccounts,
+                    localDefaultAccount: state.localDefaultAccount,
+                },
+            };
+        }
+        //  Default WAS removed — need a new default
+        uiLogger.warn(commands.account.subcommands.link.events.defaultAccountRemoved(remainingAccounts.length !== 1));
+        const localDefaultAccount = await resolveDefaultAccount({
+            accounts: remainingAccounts,
+            currentDefault: undefined,
+        });
+        if (remainingAccounts.length === 1) {
+            uiLogger.success(commands.account.subcommands.link.events.updatedLinkedAccounts);
+        }
+        return {
+            status: ACTION_RESULT_STATUS.SUCCESS,
+            settings: { accounts: remainingAccounts, localDefaultAccount },
+        };
+    }
+    static async authenticate({ state, context, args, }) {
+        const updatedConfig = await authenticateNewAccount({
+            env: args.qa ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD,
+            setAsDefaultAccount: false,
+        });
+        if (!updatedConfig) {
+            return {
+                status: ACTION_RESULT_STATUS.ERROR,
+                reason: commands.account.subcommands.link.errors.authFailed,
+            };
+        }
+        const updatedContext = {
+            globalAccountsList: getAllConfigAccounts(),
+            globalDefaultAccount: getConfigDefaultAccountIfExists(),
+            accountOverrideId: context.accountOverrideId,
+            preselectedAccountId: updatedConfig.accountId,
+        };
+        return ActionHandlers.link({ state, context: updatedContext, args });
+    }
+    static async cancel() {
+        return {
+            status: ACTION_RESULT_STATUS.NOOP,
+        };
+    }
+}
+export async function handleLinkFlow({ settings, accountOverrideId, args, }) {
+    const context = {
+        globalAccountsList: getAllConfigAccounts(),
+        globalDefaultAccount: getConfigDefaultAccountIfExists(),
+        accountOverrideId,
+    };
+    const accounts = settings.accounts ?? [];
+    // The default account must be one of the linked accounts. This can get
+    // out of sync if the settings file is manually edited.
+    const hasInvalidDefault = settings.localDefaultAccount !== undefined &&
+        !accounts.includes(settings.localDefaultAccount);
+    if (hasInvalidDefault) {
+        uiLogger.warn(commands.account.subcommands.link.events.invalidDefaultAccount(settings.localDefaultAccount));
+    }
+    const initialState = {
+        localDefaultAccount: hasInvalidDefault
+            ? undefined
+            : settings.localDefaultAccount,
+        accounts,
+    };
+    return runAction(initialState, context, args);
+}
+async function runAction(state, context, args) {
+    const action = await promptForAction(state);
+    return ActionHandlers[action]({ state, context, args });
+}
+async function resolveDefaultAccount({ accounts, currentDefault, prompt = '', }) {
+    if (accounts.length === 1) {
+        uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(accounts[0]));
+        return accounts[0];
+    }
+    return promptForDefaultAccount(accounts, currentDefault, prompt);
+}
+export async function handleLinkedUseAction({ state, targetAccountId, }) {
+    if (targetAccountId !== undefined) {
+        if (state.accounts.includes(targetAccountId)) {
+            uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(targetAccountId));
+            return {
+                status: ACTION_RESULT_STATUS.SUCCESS,
+                settings: {
+                    accounts: state.accounts,
+                    localDefaultAccount: targetAccountId,
+                },
+            };
+        }
+        const accounts = [...state.accounts, targetAccountId];
+        uiLogger.info(commands.account.subcommands.link.events.accountsLinked(1));
+        uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(targetAccountId));
+        return {
+            status: ACTION_RESULT_STATUS.SUCCESS,
+            settings: { accounts, localDefaultAccount: targetAccountId },
+        };
+    }
+    const localDefaultAccount = await resolveDefaultAccount({
+        accounts: state.accounts,
+        currentDefault: state.localDefaultAccount,
+    });
+    uiLogger.success(commands.account.subcommands.link.events.defaultAccountSet(localDefaultAccount));
+    return {
+        status: ACTION_RESULT_STATUS.SUCCESS,
+        settings: { accounts: state.accounts, localDefaultAccount },
+    };
+}

package/lib/link/linkUtils.d.ts

@@ -0,0 +1,5 @@
+import { HsSettingsFile } from '@hubspot/local-dev-lib/types/HsSettings';
+export declare function isDirectoryLinked(settings: HsSettingsFile | null): settings is HsSettingsFile;
+export declare function hasDeprecatedConfigConflict(commandArgs: (string | number)[]): boolean;
+export declare function addAccountToLinkedSettings(accountId: number): void;
+export declare function writeLinkedSettings(settings: HsSettingsFile, settingsPath: string): boolean;

package/lib/link/linkUtils.js

@@ -0,0 +1,49 @@
+import { localConfigFileExists } from '@hubspot/local-dev-lib/config';
+import { getHsSettingsFileIfExists, writeHsSettingsFile, } from '@hubspot/local-dev-lib/config/hsSettings';
+import { uiLogger } from '../ui/logger.js';
+import { debugError } from '../errorHandlers/index.js';
+import { commands } from '../../lang/en.js';
+export function isDirectoryLinked(settings) {
+    return settings !== null && settings.accounts.length > 0;
+}
+export function hasDeprecatedConfigConflict(commandArgs) {
+    if (localConfigFileExists()) {
+        uiLogger.error(commands.account.subcommands.link.shared.deprecatedConfigNotSupported(`hs ${commandArgs.join(' ')}`));
+        return true;
+    }
+    return false;
+}
+export function addAccountToLinkedSettings(accountId) {
+    if (localConfigFileExists()) {
+        return;
+    }
+    const settings = getHsSettingsFileIfExists();
+    if (!settings || settings.accounts.length === 0) {
+        return;
+    }
+    if (settings.accounts.includes(accountId)) {
+        return;
+    }
+    const updated = {
+        ...settings,
+        accounts: [...settings.accounts, accountId],
+    };
+    try {
+        writeHsSettingsFile(updated);
+        uiLogger.info(commands.account.subcommands.link.shared.accountAutoLinked(accountId));
+    }
+    catch (err) {
+        uiLogger.warn(commands.account.subcommands.link.shared.accountAutoLinkFailed(accountId));
+        debugError(err);
+    }
+}
+export function writeLinkedSettings(settings, settingsPath) {
+    try {
+        writeHsSettingsFile(settings);
+        return true;
+    }
+    catch (err) {
+        uiLogger.error(commands.account.subcommands.link.shared.writeSettingsFailed(settingsPath, err));
+        return false;
+    }
+}

package/lib/link/prompts.d.ts

@@ -0,0 +1,7 @@
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { ActionName, LinkContext } from '../../types/Link.js';
+import { HsSettingsFile } from '@hubspot/local-dev-lib/types/HsSettings';
+export declare function promptForAction(state: HsSettingsFile): Promise<ActionName>;
+export declare function promptForDefaultAccount(accounts: number[], currentDefaultAccount: number | undefined, prompt?: string): Promise<number>;
+export declare function promptForAccountsToLink(context: LinkContext, eligibleAccounts: HubSpotConfigAccount[], inEligibleAccounts: HubSpotConfigAccount[], localDefaultAccount: number | undefined): Promise<number[]>;
+export declare function promptForAccountsToUnlink(accounts: number[], localDefaultAccount: number | undefined): Promise<number[]>;

package/lib/link/prompts.js

@@ -0,0 +1,126 @@
+import { promptUser } from '../prompts/promptUtils.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { buildAccountRow, getNameColumnWidth, buildAccountHeader, sortDefaultFirst, } from './accountTableUtils.js';
+import { Separator } from '@inquirer/prompts';
+function buildColumnarChoices(accounts, localDefaultAccount) {
+    const rows = accounts.map(a => ({
+        ...buildAccountRow(a.accountId, a.accountId === localDefaultAccount),
+        disabled: a.disabled,
+        checked: a.checked,
+        hint: a.hint,
+    }));
+    const nameWidth = getNameColumnWidth(rows);
+    const header = buildAccountHeader(nameWidth);
+    return [
+        new Separator(header),
+        ...rows.map(row => {
+            const label = `${row.name.padEnd(nameWidth)}  ${row.accountId}`;
+            return {
+                name: row.hint ? `${label}  ${row.hint}` : label,
+                short: uiAccountDescription(Number(row.accountId), false),
+                value: Number(row.accountId),
+                disabled: row.disabled,
+                checked: row.checked,
+            };
+        }),
+    ];
+}
+function mapLinkAccountChoices(eligibleAccounts, inEligibleAccounts, accountOverrideId, localDefaultAccount, preselectedAccountId) {
+    const sortedIneligible = sortDefaultFirst(inEligibleAccounts, localDefaultAccount);
+    const accounts = [
+        ...eligibleAccounts.map(a => ({
+            accountId: a.accountId,
+            disabled: false,
+            checked: a.accountId === accountOverrideId ||
+                a.accountId === preselectedAccountId,
+            hint: a.accountId === accountOverrideId
+                ? commands.account.subcommands.link.prompts.fromHsAccount
+                : a.accountId === preselectedAccountId
+                    ? commands.account.subcommands.link.prompts.newlyAuthenticated
+                    : undefined,
+        })),
+        ...sortedIneligible.map(a => ({
+            accountId: a.accountId,
+            disabled: commands.account.subcommands.link.prompts.alreadyLinked,
+            checked: false,
+        })),
+    ];
+    return buildColumnarChoices(accounts, localDefaultAccount);
+}
+export async function promptForAction(state) {
+    const isSettingsEmpty = state.accounts.length === 0 && state.localDefaultAccount === undefined;
+    const { accountEditOption } = await promptUser({
+        type: 'list',
+        name: 'accountEditOption',
+        message: isSettingsEmpty
+            ? commands.account.subcommands.link.prompts.howToProceed
+            : commands.account.subcommands.link.prompts.whatToDo,
+        choices: [
+            {
+                name: commands.account.subcommands.link.prompts.linkExisting,
+                value: 'link',
+            },
+            {
+                name: commands.account.subcommands.link.prompts.authenticateNew,
+                value: 'authenticate',
+            },
+            {
+                name: commands.account.subcommands.link.prompts.cancel,
+                value: 'cancel',
+            },
+        ],
+    });
+    uiLogger.log('');
+    return accountEditOption;
+}
+export async function promptForDefaultAccount(accounts, currentDefaultAccount, prompt = '') {
+    const choiceAccounts = accounts.map(accountId => ({
+        accountId,
+    }));
+    const choices = buildColumnarChoices(choiceAccounts, currentDefaultAccount);
+    const { defaultAccount } = await promptUser({
+        type: 'list',
+        name: 'defaultAccount',
+        pageSize: 20,
+        message: prompt || commands.account.subcommands.link.prompts.selectDefault,
+        choices,
+        default: currentDefaultAccount ?? undefined,
+    });
+    uiLogger.log('');
+    return defaultAccount;
+}
+export async function promptForAccountsToLink(context, eligibleAccounts, inEligibleAccounts, localDefaultAccount) {
+    const { accountsToAdd } = await promptUser({
+        type: 'checkbox',
+        name: 'accountsToAdd',
+        pageSize: 20,
+        message: commands.account.subcommands.link.prompts.selectToLink,
+        choices: mapLinkAccountChoices(eligibleAccounts, inEligibleAccounts, context.accountOverrideId, localDefaultAccount, context.preselectedAccountId),
+        validate: (answer) => {
+            if (answer.length === 0) {
+                return commands.account.subcommands.link.prompts.mustSelectOne;
+            }
+            return true;
+        },
+    });
+    uiLogger.log('');
+    return accountsToAdd;
+}
+export async function promptForAccountsToUnlink(accounts, localDefaultAccount) {
+    const sortedAccounts = sortDefaultFirst(accounts, localDefaultAccount);
+    const choiceAccounts = sortedAccounts.map(accountId => ({
+        accountId,
+    }));
+    const choices = buildColumnarChoices(choiceAccounts, localDefaultAccount);
+    const { accountsToRemove } = await promptUser({
+        type: 'checkbox',
+        name: 'accountsToRemove',
+        pageSize: 20,
+        message: commands.account.subcommands.link.prompts.selectToUnlink,
+        choices,
+    });
+    uiLogger.log('');
+    return accountsToRemove;
+}

package/lib/link/renderLinkedAccountsTable.d.ts

@@ -0,0 +1,2 @@
+import { HsSettingsFile } from '@hubspot/local-dev-lib/types/HsSettings';
+export declare function renderLinkedAccountsTable(settings: HsSettingsFile): Promise<void>;

package/lib/link/renderLinkedAccountsTable.js

@@ -0,0 +1,14 @@
+import { commands } from '../../lang/en.js';
+import { renderTable } from '../../ui/render.js';
+import { buildAccountRow, sortDefaultFirst } from './accountTableUtils.js';
+export async function renderLinkedAccountsTable(settings) {
+    const labels = commands.account.subcommands.list.labels;
+    const tableHeader = [labels.name, labels.accountId];
+    const sortedAccounts = sortDefaultFirst(settings.accounts, settings.localDefaultAccount);
+    const tableData = sortedAccounts.map(accountId => {
+        const isDefault = accountId === settings.localDefaultAccount;
+        const row = buildAccountRow(accountId, isDefault);
+        return [row.name, row.accountId];
+    });
+    await renderTable(tableHeader, tableData, true);
+}

package/lib/link/warnIfLinkedDirectory.d.ts

@@ -0,0 +1 @@
+export declare function warnIfLinkedDirectory(args: (string | number)[]): void;

package/lib/link/warnIfLinkedDirectory.js

@@ -0,0 +1,9 @@
+import { getHsSettingsFilePath } from '@hubspot/local-dev-lib/config/hsSettings';
+import { uiLogger } from '../ui/logger.js';
+import { lib } from '../../lang/en.js';
+export function warnIfLinkedDirectory(args) {
+    if (getHsSettingsFilePath() === null) {
+        return;
+    }
+    uiLogger.warn(lib.linkedDirectory.warning(`hs ${args.join(' ')}`, getHsSettingsFilePath()));
+}

package/lib/projects/ProjectLogsManager.js

@@ -134,9 +134,12 @@ class _ProjectLogsManager {
         return this.functions.map(serverlessFunction => serverlessFunction.componentName);
     }
     setFunction(functionName) {
-        if (!functionName || this.functions.length === 0) {
+        if (this.functions.length === 0) {
             throw new Error(commands.project.logs.errors.noFunctionsInProject);
         }
+        if (!functionName) {
+            throw new Error(commands.project.logs.errors.functionNameRequired);
+        }
         this.selectedFunction = this.functions.find(serverlessFunction => serverlessFunction.componentName === functionName);
         if (!this.selectedFunction) {
             throw new Error(commands.project.logs.errors.noFunctionWithName(functionName));

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

@@ -21,12 +21,13 @@ declare class DevServerManager_DEPRECATED {
         [key: string]: Component;
     }) => Promise<void>): Promise<void>;
     arrangeComponentsByType(components: Component[]): ComponentsByType;
-    setup({ components, onUploadRequired, accountId, setActiveApp, exit, }: {
+    setup({ components, onUploadRequired, accountId, setActiveApp, exit, port, }: {
         components: Component[];
         onUploadRequired: () => void;
         accountId: number;
         setActiveApp: (appUid: string | undefined) => Promise<void>;
         exit: ExitFunction;
+        port?: number;
     }): Promise<void>;
     start({ accountId, projectConfig, }: {
         accountId: number;

package/lib/projects/localDev/DevServerManager_DEPRECATED.js

@@ -57,7 +57,7 @@ class DevServerManager_DEPRECATED {
             return acc;
         }, {});
     }
-    async setup({ components, onUploadRequired, accountId, setActiveApp, exit, }) {
+    async setup({ components, onUploadRequired, accountId, setActiveApp, exit, port, }) {
         this.componentsByType = this.arrangeComponentsByType(components);
         let env;
         const accountConfig = getConfigAccountById(accountId);
@@ -65,7 +65,7 @@ class DevServerManager_DEPRECATED {
             env = accountConfig.env;
         }
         try {
-            await startPortManagerServer();
+            await startPortManagerServer(port);
         }
         catch (e) {
             logError(e);

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

@@ -16,6 +16,7 @@ type LocalDevManagerConstructorOptions = {
     runnableComponents: Component[];
     env: Environment;
     exit: ExitFunction;
+    port?: number;
 };
 declare class LocalDevManager_DEPRECATED {
     targetAccountId: number;
@@ -39,6 +40,7 @@ declare class LocalDevManager_DEPRECATED {
     mostRecentUploadWarning: string | null;
     private devSessionManager;
     private exit;
+    private port?;
     constructor(options: LocalDevManagerConstructorOptions);
     setActiveApp(appUid?: string): Promise<void>;
     setActivePublicAppData(): Promise<void>;

package/lib/projects/localDev/LocalDevManager_DEPRECATED.js

@@ -48,6 +48,7 @@ class LocalDevManager_DEPRECATED {
     mostRecentUploadWarning;
     devSessionManager;
     exit;
+    port;
     constructor(options) {
         this.targetAccountId = options.targetAccountId;
         // The account that the project exists in. This is not always the targetAccountId
@@ -67,6 +68,7 @@ class LocalDevManager_DEPRECATED {
         this.publicAppActiveInstalls = null;
         this.mostRecentUploadWarning = null;
         this.exit = options.exit;
+        this.port = options.port;
         this.projectSourceDir = path.join(this.projectDir, this.projectConfig.srcDir);
         if (!this.targetAccountId || !this.projectConfig || !this.projectDir) {
             uiLogger.error(lib.LocalDevManager.failedToInitialize);
@@ -337,6 +339,7 @@ class LocalDevManager_DEPRECATED {
                 accountId: this.targetAccountId,
                 setActiveApp: this.setActiveApp.bind(this),
                 exit: this.exit,
+                port: this.port,
             });
             return true;
         }

package/lib/projects/preview.d.ts

@@ -0,0 +1,7 @@
+type PreviewResult = {
+    succeeded: boolean;
+    releaseTag?: string;
+    appId?: number;
+};
+export declare function triggerAndPollPreview(accountId: number, projectId: number, buildId: number, targetPortalId: number): Promise<PreviewResult>;
+export {};

package/lib/projects/preview.js

@@ -0,0 +1,58 @@
+import { triggerAutoRelease, getAutoReleaseStatus, } from '@hubspot/local-dev-lib/api/projects';
+import { DEFAULT_POLLING_DELAY, PREVIEW_POLL_TIMEOUT } from '../constants.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { lib } from '../../lang/en.js';
+export async function triggerAndPollPreview(accountId, projectId, buildId, targetPortalId) {
+    let triggerResponse;
+    SpinniesManager.add('preview', {
+        text: lib.projectPreview.triggeringPreview(buildId, targetPortalId),
+        succeedColor: 'white',
+    });
+    try {
+        const { data } = await triggerAutoRelease(accountId, projectId, buildId, targetPortalId);
+        triggerResponse = data;
+    }
+    catch (e) {
+        SpinniesManager.fail('preview', {
+            text: lib.projectPreview.triggerFailed,
+        });
+        logError(e, new ApiErrorContext({
+            accountId,
+            request: 'preview trigger',
+        }));
+        return { succeeded: false };
+    }
+    const { releaseTag, appId } = triggerResponse;
+    SpinniesManager.update('preview', {
+        text: lib.projectPreview.pollingStatus(releaseTag, targetPortalId),
+    });
+    try {
+        await pollPreviewStatus(accountId, projectId, targetPortalId, releaseTag, appId);
+    }
+    catch (e) {
+        SpinniesManager.fail('preview', {
+            text: lib.projectPreview.pollFailed,
+        });
+        logError(e, new ApiErrorContext({
+            accountId,
+            request: 'preview status',
+        }));
+        return { succeeded: false, releaseTag, appId };
+    }
+    SpinniesManager.succeed('preview', {
+        text: lib.projectPreview.succeeded(releaseTag, targetPortalId),
+    });
+    return { succeeded: true, releaseTag, appId };
+}
+async function pollPreviewStatus(accountId, projectId, targetPortalId, expectedReleaseTag, appId) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < PREVIEW_POLL_TIMEOUT) {
+        await new Promise(resolve => setTimeout(resolve, DEFAULT_POLLING_DELAY));
+        const { data } = await getAutoReleaseStatus(accountId, projectId, targetPortalId, expectedReleaseTag, appId);
+        if (data.status === 'COMPLETE') {
+            return;
+        }
+    }
+    throw new Error(lib.projectPreview.timeout);
+}

package/lib/projects/uieLinting.d.ts

@@ -1,10 +1,19 @@
 export declare const REQUIRED_PACKAGES_AND_MIN_VERSIONS: {
     readonly eslint: "9.0.0";
-    readonly '@typescript-eslint/eslint-plugin': "8.46.4";
-    readonly '@typescript-eslint/parser': "8.46.4";
+    readonly '@eslint/js': "9.0.0";
     readonly 'typescript-eslint': "8.46.4";
+    readonly '@hubspot/eslint-config-ui-extensions': "1.0.0";
+    readonly 'eslint-config-prettier': "10.0.0";
+    readonly 'eslint-plugin-react': "7.0.0";
+    readonly 'eslint-plugin-react-hooks': "7.0.0";
+    readonly 'eslint-plugin-unused-imports': "4.0.0";
+    readonly prettier: "3.0.0";
     readonly jiti: "2.6.1";
 };
+export declare const LINT_SCRIPTS: {
+    readonly lint: "eslint .";
+    readonly 'lint:fix': "eslint . --fix";
+};
 export declare function isEslintInstalled(directory: string): boolean;
 export declare function areAllLintPackagesInstalled(directory: string): boolean;
 export declare function getMissingLintPackages(directory: string): {
@@ -13,7 +22,7 @@ export declare function getMissingLintPackages(directory: string): {
 export declare function hasEslintConfig(directory: string): boolean;
 export declare function hasDeprecatedEslintConfig(directory: string): boolean;
 export declare function getDeprecatedEslintConfigFiles(directory: string): string[];
-export declare function createEslintConfig(directory: string): string;
+export declare function createEslintConfig(directory: string, platformVersion?: string | null): Promise<string>;
 export declare function lintPackagesInDirectory(directory: string, projectDir?: string): Promise<{
     success: boolean;
     output: string;
@@ -31,3 +40,8 @@ export declare function displayLintResults(results: Array<{
     success: boolean;
     output: string;
 }>): void;
+export declare function getMissingLintScripts(directory: string): string[];
+export declare function addLintScriptsToPackageJson(directory: string): {
+    added: string[];
+    relativePath: string;
+};