@hubspot/cli 8.2.0-beta.0 → 8.2.0-experimental.1

package/lib/auth/awaitPersonalAccessKeyOverWebsocket.js

@@ -0,0 +1,145 @@
+import readline from 'readline';
+import { randomUUID } from 'crypto';
+import open from 'open';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import CLIWebSocketServer from '../CLIWebSocketServer.js';
+import { ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES, ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES, ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION, } from '../constants.js';
+import { personalAccessKeyPrompt } from '../prompts/personalAccessKeyPrompt.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { uiLogger } from '../ui/logger.js';
+import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+const LOG_PREFIX = '[AccountAuthWebsocketServer]';
+const SPINNER_ID = 'pak-websocket';
+const CTRL_C = 3;
+function isPersonalAccessKeyMessageData(data) {
+    if (typeof data !== 'object' || data === null)
+        return false;
+    const d = data;
+    return (typeof d.personalAccessKey === 'string' &&
+        typeof d.cliCallbackToken === 'string');
+}
+function buildPakUrl(env, account, cliCallbackPort, cliCallbackToken) {
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    const baseUrl = account
+        ? `${websiteOrigin}/personal-access-key/${account}`
+        : `${websiteOrigin}/l/personal-access-key`;
+    return `${baseUrl}?cliCallbackPort=${cliCallbackPort}&cliCallbackToken=${cliCallbackToken}`;
+}
+function createMessageHandler(server, cliCallbackToken, resolveWebsocketPak) {
+    return (ws, message) => {
+        if (message.type !== ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES.PERSONAL_ACCESS_KEY) {
+            return false;
+        }
+        if (!isPersonalAccessKeyMessageData(message.data)) {
+            return true;
+        }
+        const { cliCallbackToken: receivedToken, personalAccessKey } = message.data;
+        if (receivedToken !== cliCallbackToken) {
+            server.sendMessage(ws, {
+                type: ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES.AUTH_FAILED,
+                data: { reason: 'cliCallbackTokenMismatch' },
+            });
+            return true;
+        }
+        if (personalAccessKey.length === 0) {
+            return true;
+        }
+        server.sendMessage(ws, {
+            type: ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES.AUTH_RECEIVED,
+        });
+        resolveWebsocketPak(personalAccessKey);
+        return true;
+    };
+}
+async function awaitKeypressOrWebsocketPak(websocketPakPromise) {
+    if (!process.stdin.isTTY) {
+        return { type: 'keypress' };
+    }
+    SpinniesManager.init();
+    SpinniesManager.add(SPINNER_ID, {
+        text: lib.accountAuthWebsocket.logs.spinner,
+    });
+    let cleanupStdin;
+    const keypressPromise = new Promise((resolve, reject) => {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        const onData = (chunk) => {
+            doCleanup();
+            if (chunk[0] === CTRL_C) {
+                return reject(new PromptExitError(lib.prompts.personalAccessKeyPrompt.errors.authCancelled, EXIT_CODES.SUCCESS));
+            }
+            resolve({ type: 'keypress' });
+        };
+        const doCleanup = () => {
+            process.stdin.removeListener('data', onData);
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch { }
+            process.stdin.pause();
+        };
+        cleanupStdin = doCleanup;
+        process.stdin.on('data', onData);
+    });
+    try {
+        const result = await Promise.race([
+            websocketPakPromise.then(pak => ({ type: 'pak', pak })),
+            keypressPromise,
+        ]);
+        if (result.type === 'pak') {
+            SpinniesManager.succeed(SPINNER_ID, {
+                text: lib.accountAuthWebsocket.logs.received,
+            });
+        }
+        else {
+            SpinniesManager.remove(SPINNER_ID);
+        }
+        return result;
+    }
+    catch (e) {
+        SpinniesManager.remove(SPINNER_ID);
+        throw e;
+    }
+    finally {
+        cleanupStdin?.();
+    }
+}
+export async function awaitPersonalAccessKeyOverWebsocket({ env, account, }) {
+    const cliCallbackToken = randomUUID();
+    const server = new CLIWebSocketServer({ logPrefix: LOG_PREFIX });
+    let resolveWebsocketPak;
+    const websocketPakPromise = new Promise(resolve => {
+        resolveWebsocketPak = resolve;
+    });
+    try {
+        const cliCallbackPort = await server.start({
+            metadata: {
+                accountAuthWebsocketServerVersion: ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION,
+            },
+            onMessage: createMessageHandler(server, cliCallbackToken, resolveWebsocketPak),
+        });
+        const url = buildPakUrl(env, account, cliCallbackPort, cliCallbackToken);
+        await open(url, { url: true });
+        uiLogger.log(lib.accountAuthWebsocket.logs.openingWebBrowser(url));
+        const waitResult = await awaitKeypressOrWebsocketPak(websocketPakPromise);
+        if (waitResult.type === 'pak') {
+            return waitResult.pak;
+        }
+        let pastePhaseActive = true;
+        websocketPakPromise
+            .then(pak => {
+            if (pastePhaseActive) {
+                process.stdin.push(`${pak}\n`);
+            }
+        })
+            .catch(() => { });
+        const personalAccessKey = await personalAccessKeyPrompt();
+        pastePhaseActive = false;
+        return personalAccessKey;
+    }
+    finally {
+        server.shutdown();
+    }
+}

package/lib/buildAccount.d.ts

@@ -1,7 +1,7 @@
 import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
 import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxResponse, V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
+import { V2Sandbox } from '@hubspot/local-dev-lib/types/Sandbox';
 import { SandboxAccountType } from '../types/Sandboxes.js';
 export declare function saveAccountToConfig(accountId: number | undefined, accountName: string, env: Environment, personalAccessKey?: string, force?: boolean): Promise<string>;
 export declare function createDeveloperTestAccountV2(parentAccountId: number, testAccountConfig: DeveloperTestAccountConfig): Promise<{
@@ -10,11 +10,6 @@ export declare function createDeveloperTestAccountV2(parentAccountId: number, te
     personalAccessKey?: string;
 }>;
 export declare function buildDeveloperTestAccount(testAccountName: string, parentAccountConfig: HubSpotConfigAccount, env: Environment, portalLimit: number, useV2?: boolean): Promise<number>;
-type SandboxAccount = SandboxResponse & {
-    name: string;
-};
-export declare function buildSandbox(sandboxName: string, parentAccountConfig: HubSpotConfigAccount, sandboxType: SandboxAccountType, env: Environment, force?: boolean): Promise<SandboxAccount>;
 export declare function buildV2Sandbox(sandboxName: string, parentAccountConfig: HubSpotConfigAccount, sandboxType: SandboxAccountType, syncObjectRecords: boolean, env: Environment, force?: boolean): Promise<{
     sandbox: V2Sandbox;
 }>;
-export {};

package/lib/buildAccount.js

@@ -3,13 +3,14 @@ import { getConfigAccountIfExists, updateConfigAccount, } from '@hubspot/local-d
 import { uiLogger } from './ui/logger.js';
 import { createDeveloperTestAccount, fetchDeveloperTestAccountGateSyncStatus, generateDeveloperTestAccountPersonalAccessKey, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { createSandbox, createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
+import { createV2Sandbox, getSandboxPersonalAccessKey, } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { isPromptExitError } from './errors/PromptExitError.js';
+import { legacyPersonalAccessKeyPrompt as personalAccessKeyPrompt } from './prompts/personalAccessKeyPrompt.js';
 import { createDeveloperTestAccountConfigPrompt } from './prompts/createDeveloperTestAccountConfigPrompt.js';
 import { cliAccountNamePrompt } from './prompts/accountNamePrompt.js';
 import SpinniesManager from './ui/SpinniesManager.js';
 import { debugError, logError } from './errorHandlers/index.js';
-import { SANDBOX_API_TYPE_MAP, SANDBOX_TYPE_MAP_V2, handleSandboxCreateError, } from './sandboxes.js';
+import { SANDBOX_TYPE_MAP_V2, handleSandboxCreateError } from './sandboxes.js';
 import { handleDeveloperTestAccountCreateError } from './developerTestAccounts.js';
 import { lib } from '../lang/en.js';
 import { poll } from './polling.js';
@@ -127,51 +128,14 @@ export async function buildDeveloperTestAccount(testAccountName, parentAccountCo
         await saveAccountToConfig(developerTestAccountId, testAccountName, env, developerTestAccountPersonalAccessKey);
     }
     catch (err) {
+        if (isPromptExitError(err)) {
+            throw err;
+        }
         logError(err);
         throw err;
     }
     return developerTestAccountId;
 }
-export async function buildSandbox(sandboxName, parentAccountConfig, sandboxType, env, force = false) {
-    const sandboxTypeKey = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX
-        ? 'standard'
-        : 'developer';
-    const parentAccountId = parentAccountConfig.accountId;
-    if (!parentAccountId) {
-        throw new Error(lib.sandbox.create[sandboxTypeKey].loading.fail(''));
-    }
-    SpinniesManager.init({
-        succeedColor: 'white',
-    });
-    uiLogger.log('');
-    SpinniesManager.add('buildSandbox', {
-        text: lib.sandbox.create[sandboxTypeKey].loading.add(sandboxName),
-    });
-    let sandbox;
-    try {
-        const sandboxApiType = SANDBOX_API_TYPE_MAP[sandboxType];
-        const { data } = await createSandbox(parentAccountId, sandboxName, sandboxApiType);
-        sandbox = { name: sandboxName, ...data };
-        SpinniesManager.succeed('buildSandbox', {
-            text: lib.sandbox.create[sandboxTypeKey].loading.succeed(sandboxName, sandbox.sandbox.sandboxHubId.toString()),
-        });
-    }
-    catch (e) {
-        debugError(e);
-        SpinniesManager.fail('buildSandbox', {
-            text: lib.sandbox.create[sandboxTypeKey].loading.fail(sandboxName),
-        });
-        handleSandboxCreateError(e, env, sandboxName, parentAccountId);
-    }
-    try {
-        await saveAccountToConfig(sandbox.sandbox.sandboxHubId, sandboxName, env, sandbox.personalAccessKey, force);
-    }
-    catch (err) {
-        logError(err);
-        throw err;
-    }
-    return sandbox;
-}
 export async function buildV2Sandbox(sandboxName, parentAccountConfig, sandboxType, syncObjectRecords, env, force = false) {
     const sandboxTypeKey = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX
         ? 'standard'
@@ -210,6 +174,9 @@ export async function buildV2Sandbox(sandboxName, parentAccountConfig, sandboxTy
         await saveAccountToConfig(sandbox.sandboxHubId, sandboxName, env, pak, force);
     }
     catch (err) {
+        if (isPromptExitError(err)) {
+            throw err;
+        }
         logError(err);
         throw err;
     }

package/lib/commonOpts.js

@@ -76,7 +76,6 @@ export function addJSONOutputOptions(yargs) {
         alias: 'format-output-as-json',
         describe: lib.commonOpts.options.jsonOutput,
         type: 'boolean',
-        hidden: true,
     });
 }
 // Remove this once we've upgraded to yargs 18.0.0

package/lib/constants.d.ts

@@ -4,6 +4,7 @@ export declare const FEEDBACK_INTERVAL: 10;
 export declare const HUBSPOT_FOLDER: "@hubspot";
 export declare const MARKETPLACE_FOLDER: "@marketplace";
 export declare const DEFAULT_POLLING_DELAY = 2000;
+export declare const PREVIEW_POLL_TIMEOUT: number;
 export declare const PROJECT_CONFIG_FILE: "hsproject.json";
 export declare const PROJECT_BUILD_STATES: {
     readonly BUILDING: "BUILDING";
@@ -77,10 +78,7 @@ export declare const APP_AUTH_TYPES: {
 };
 export declare const FEATURES: {
     readonly UNIFIED_APPS: "Developers:UnifiedApps:PrivateBeta";
-    readonly SANDBOXES_V2: "sandboxes:v2:enabled";
-    readonly SANDBOXES_V2_CLI: "sandboxes:v2:cliEnabled";
     readonly APP_EVENTS: "Developers:UnifiedApps:AppEventsAccess";
-    readonly APPS_HOME: "UIE:AppHome";
     readonly THEME_MIGRATION_2025_2: "Developers:ProjectThemeMigrations:2025.2";
     readonly AGENT_TOOLS: "ThirdPartyAgentTools";
 };
@@ -126,6 +124,14 @@ export declare const LOCAL_DEV_SERVER_MESSAGE_TYPES: {
     readonly OAUTH_APP_INSTALL_INITIATED: "APP_INSTALL_INITIATED";
 };
 export declare const LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID = "local-dev-ui-websocket-server";
+export declare const ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES: {
+    readonly AUTH_RECEIVED: "server:authReceived";
+    readonly AUTH_FAILED: "server:authFailed";
+};
+export declare const ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES: {
+    readonly PERSONAL_ACCESS_KEY: "client:personalAccessKey";
+};
+export declare const ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION = 1;
 export declare const CONFIG_LOCAL_STATE_FLAGS: {
     readonly LOCAL_DEV_UI_WELCOME: "LOCAL_DEV_UI_WELCOME";
 };
@@ -145,3 +151,4 @@ export declare const ACCOUNT_LEVELS: {
 };
 export declare const ACCOUNT_LEVEL_CHOICES: readonly ["FREE", "STARTER", "PROFESSIONAL", "ENTERPRISE"];
 export declare const FEEDBACK_URL = "https://developers.hubspot.com/feedback";
+export declare const LOCAL_DEV_DEFAULT_PORT = 4828;

package/lib/constants.js

@@ -4,6 +4,7 @@ export const FEEDBACK_INTERVAL = 10;
 export const HUBSPOT_FOLDER = '@hubspot';
 export const MARKETPLACE_FOLDER = '@marketplace';
 export const DEFAULT_POLLING_DELAY = 2000;
+export const PREVIEW_POLL_TIMEOUT = 5 * 60 * 1000;
 export const PROJECT_CONFIG_FILE = 'hsproject.json';
 export const PROJECT_BUILD_STATES = {
     BUILDING: 'BUILDING',
@@ -69,10 +70,7 @@ export const APP_AUTH_TYPES = {
 };
 export const FEATURES = {
     UNIFIED_APPS: 'Developers:UnifiedApps:PrivateBeta',
-    SANDBOXES_V2: 'sandboxes:v2:enabled',
-    SANDBOXES_V2_CLI: 'sandboxes:v2:cliEnabled',
     APP_EVENTS: 'Developers:UnifiedApps:AppEventsAccess',
-    APPS_HOME: 'UIE:AppHome',
     THEME_MIGRATION_2025_2: 'Developers:ProjectThemeMigrations:2025.2',
     AGENT_TOOLS: 'ThirdPartyAgentTools',
 };
@@ -118,6 +116,14 @@ export const LOCAL_DEV_SERVER_MESSAGE_TYPES = {
     OAUTH_APP_INSTALL_INITIATED: 'APP_INSTALL_INITIATED',
 };
 export const LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID = 'local-dev-ui-websocket-server';
+export const ACCOUNT_AUTH_UI_MESSAGE_SEND_TYPES = {
+    AUTH_RECEIVED: 'server:authReceived',
+    AUTH_FAILED: 'server:authFailed',
+};
+export const ACCOUNT_AUTH_UI_MESSAGE_RECEIVE_TYPES = {
+    PERSONAL_ACCESS_KEY: 'client:personalAccessKey',
+};
+export const ACCOUNT_AUTH_WEBSOCKET_SERVER_VERSION = 1;
 export const CONFIG_LOCAL_STATE_FLAGS = {
     LOCAL_DEV_UI_WELCOME: 'LOCAL_DEV_UI_WELCOME',
 };
@@ -146,3 +152,6 @@ export const ACCOUNT_LEVEL_CHOICES = [
     ACCOUNT_LEVELS.ENTERPRISE,
 ];
 export const FEEDBACK_URL = 'https://developers.hubspot.com/feedback';
+// TODO: remove this constant and use PORT_MANAGER_SERVER_PORT from
+// @hubspot/local-dev-lib once LDL changes its default to 4828.
+export const LOCAL_DEV_DEFAULT_PORT = 4828;

package/lib/doctor/Diagnosis.js

@@ -1,4 +1,4 @@
-import { prefixOptions } from '../ui/spinniesUtils.js';
+import { getLabels } from '@hubspot/local-dev-lib/logger';
 import chalk from 'chalk';
 import { helpers } from '../interpolation.js';
 import { uiAccountDescription } from '../ui/index.js';
@@ -10,11 +10,11 @@ export class Diagnosis {
     errorCount = 0;
     warningCount = 0;
     constructor({ diagnosticInfo, accountId }) {
-        const { succeedPrefix, failPrefix } = prefixOptions({});
+        const labels = getLabels();
         this.prefixes = {
-            success: chalk.green(succeedPrefix),
-            error: chalk.red(failPrefix),
-            warning: helpers.orange('!'),
+            success: chalk.green(labels.success),
+            error: chalk.red(labels.error),
+            warning: helpers.orange(labels.warning),
         };
         this.diagnosis = {
             cli: {

package/lib/doctor/Doctor.js

@@ -10,8 +10,8 @@ import fs from 'fs';
 import path from 'path';
 import { Diagnosis } from './Diagnosis.js';
 import { DiagnosticInfoBuilder, } from './DiagnosticInfoBuilder.js';
-import { isPortManagerPortAvailable } from '@hubspot/local-dev-lib/portManager';
-import { PORT_MANAGER_SERVER_PORT } from '@hubspot/local-dev-lib/constants/ports';
+import { isPortAvailable } from '@hubspot/local-dev-lib/portManager';
+import { LOCAL_DEV_DEFAULT_PORT } from '../constants.js';
 import { accessTokenForPersonalAccessKey,
 // scopesOnAccessToken,
  } from '@hubspot/local-dev-lib/personalAccessKey';
@@ -26,7 +26,7 @@ import { isServerRunningAtUrl } from '../http.js';
 import { WEBHOOKS_KEY, APP_KEY } from '@hubspot/project-parsing-lib/constants';
 import { validateProjectConfig } from '../projects/config.js';
 import { validateSourceDirectory, handleTranslate, } from '../projects/upload.js';
-import { isV2Project } from '../projects/platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { validateProjectForProfile } from '../projects/projectProfiles.js';
 import { getAllHsProfiles } from '@hubspot/project-parsing-lib/profiles';
 const minMajorNodeVersion = 20;
@@ -322,16 +322,16 @@ export class Doctor {
         }
     }
     async checkIfPortsAreAvailable() {
-        if (await isPortManagerPortAvailable()) {
+        if (await isPortAvailable(LOCAL_DEV_DEFAULT_PORT)) {
             this.diagnosis?.addProjectSection({
                 type: 'success',
-                message: lib.doctor.port.available(PORT_MANAGER_SERVER_PORT),
+                message: lib.doctor.port.available(LOCAL_DEV_DEFAULT_PORT),
             });
             return;
         }
         this.diagnosis?.addProjectSection({
             type: 'warning',
-            message: lib.doctor.port.inUse(PORT_MANAGER_SERVER_PORT),
+            message: lib.doctor.port.inUse(LOCAL_DEV_DEFAULT_PORT),
             secondaryMessaging: lib.doctor.port.inUseSecondary,
         });
     }
@@ -534,7 +534,7 @@ export class Doctor {
             if (!this.validateProjectConfigWrapper(projectConfig, projectDir)) {
                 return;
             }
-            if (!isV2Project(projectConfig.platformVersion)) {
+            if (isLegacyProject(projectConfig.platformVersion)) {
                 this.diagnosis?.addProjectSection({
                     type: 'success',
                     message: lib.doctor.projectValidation.valid,

package/lib/errorHandlers/index.js

@@ -7,11 +7,12 @@ import util from 'util';
 import { isProjectValidationError } from '../errors/ProjectValidationError.js';
 export function logError(error, context) {
     debugError(error, context);
-    if (isProjectValidationError(error)) {
-        uiLogger.error(error.message);
+    // This should be right after debugError.  Add anything else below it
+    if (shouldSuppressError(error, context)) {
         return;
     }
-    if (shouldSuppressError(error, context)) {
+    if (isProjectValidationError(error)) {
+        uiLogger.error(error.message);
         return;
     }
     if (isHubSpotHttpError(error)) {

package/lib/errorHandlers/suppressError.js

@@ -3,6 +3,7 @@ import { uiLogger } from '../ui/logger.js';
 import { PLATFORM_VERSION_ERROR_TYPES } from '../constants.js';
 import { lib } from '../../lang/en.js';
 import { uiAccountDescription, uiLine, uiLink } from '../ui/index.js';
+import { isPromptExitError } from '../errors/PromptExitError.js';
 function createPlatformVersionError(err, subCategory) {
     let translationKey = 'unspecifiedPlatformVersion';
     let platformVersion = 'unspecified platformVersion';
@@ -27,6 +28,9 @@ function createPlatformVersionError(err, subCategory) {
     uiLine();
 }
 export function shouldSuppressError(err, context) {
+    if (isPromptExitError(err)) {
+        return true;
+    }
     if (isMissingScopeError(err)) {
         uiLogger.error(lib.errorHandlers.suppressErrors.missingScopeError(context?.request || 'request', context?.accountId ? uiAccountDescription(context.accountId) : ''));
         return true;

package/lib/errors/PromptExitError.d.ts

@@ -0,0 +1,6 @@
+import { ExitCode } from '../../types/Yargs.js';
+export declare class PromptExitError extends Error {
+    exitCode: ExitCode;
+    constructor(message: string, exitCode: ExitCode);
+}
+export declare function isPromptExitError(e: unknown): e is PromptExitError;

package/lib/errors/PromptExitError.js

@@ -0,0 +1,11 @@
+export class PromptExitError extends Error {
+    exitCode;
+    constructor(message, exitCode) {
+        super(message);
+        this.name = 'PromptExitError';
+        this.exitCode = exitCode;
+    }
+}
+export function isPromptExitError(e) {
+    return e instanceof PromptExitError;
+}

package/lib/getStartedV2Actions.js

@@ -13,7 +13,7 @@ import { getStaticAuthAppInstallUrl } from '../lib/app/urls.js';
 import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_CONFIG_FILE, } from '../lib/constants.js';
 import { ProjectNestingError, ProjectConfigNotFoundError, ProjectValidationError, ProjectUploadError, ProjectBuildDeployError, } from './errors/ProjectErrors.js';
 import { getProjectConfig, validateProjectConfig, writeProjectConfig, } from '../lib/projects/config.js';
-import { isV2Project } from '../lib/projects/platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { pollProjectBuildAndDeploy } from '../lib/projects/pollProjectBuildAndDeploy.js';
 import { handleProjectUpload } from '../lib/projects/upload.js';
 import { validateProjectDirectory } from '../lib/prompts/projectNameAndDestPrompt.js';
@@ -37,7 +37,7 @@ export async function createProjectAction({ projectName, projectDest, }) {
     }
     try {
         await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDestAbsolute, {
-            sourceDir: '2025.2/private-app-get-started-template',
+            sourceDir: '2026.03/private-app-get-started-template',
             hideLogs: true,
         });
         const projectConfigPath = path.join(projectDestAbsolute, PROJECT_CONFIG_FILE);
@@ -109,7 +109,7 @@ export async function uploadAndDeployAction({ accountId, projectDest, }) {
             uploadMessage: commands.getStarted.logs.initialUploadMessage,
             forceCreate: true,
             isUploadCommand: false,
-            sendIR: isV2Project(projectConfig.platformVersion),
+            sendIR: !isLegacyProject(projectConfig.platformVersion),
             skipValidation: false,
         });
         if (uploadError) {

package/lib/hasFeature.js

@@ -1,7 +1,6 @@
 import { http } from '@hubspot/local-dev-lib/http';
 import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { FEATURES } from './constants.js';
-const FEATURES_THAT_DEFAULT_ON = [FEATURES.APPS_HOME];
+const FEATURES_THAT_DEFAULT_ON = [];
 export async function hasFeature(accountId, feature) {
     const { data: { enabledFeatures }, } = await fetchEnabledFeatures(accountId);
     if (enabledFeatures[feature] === undefined &&

package/lib/link/accountTableUtils.d.ts

@@ -0,0 +1,10 @@
+export interface AccountRow {
+    name: string;
+    accountId: string;
+}
+export declare function buildAccountRow(accountId: number, isDefault: boolean): AccountRow;
+export declare function buildAccountHeader(nameColumnWidth: number): string;
+export declare function getNameColumnWidth(rows: AccountRow[]): number;
+export declare function sortDefaultFirst<T extends number | {
+    accountId: number;
+}>(items: T[], defaultAccount: number | undefined): T[];

package/lib/link/accountTableUtils.js

@@ -0,0 +1,39 @@
+import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
+import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
+import chalk from 'chalk';
+import { commands } from '../../lang/en.js';
+import { indent } from '../ui/index.js';
+import { INK_COLORS } from '../../ui/styles.js';
+export function buildAccountRow(accountId, isDefault) {
+    const account = getConfigAccountIfExists(accountId);
+    let name = String(accountId);
+    if (account && account.accountType) {
+        const typeStr = HUBSPOT_ACCOUNT_TYPE_STRINGS[account.accountType];
+        name = `${account.name} [${typeStr}]`;
+    }
+    if (isDefault) {
+        name = `${name} (default)`;
+    }
+    return { name, accountId: String(accountId) };
+}
+export function buildAccountHeader(nameColumnWidth) {
+    const labels = commands.account.subcommands.list.labels;
+    const paddedName = chalk.bold(chalk.hex(INK_COLORS.INFO_BLUE)(labels.name.padEnd(nameColumnWidth)));
+    const accountId = chalk.bold(chalk.hex(INK_COLORS.INFO_BLUE)(labels.accountId));
+    return `${indent(1)}${paddedName}  ${accountId}`;
+}
+export function getNameColumnWidth(rows) {
+    const labels = commands.account.subcommands.list.labels;
+    return Math.max(labels.name.length, ...rows.map(r => r.name.length));
+}
+export function sortDefaultFirst(items, defaultAccount) {
+    return [...items].sort((a, b) => {
+        const aId = typeof a === 'number' ? a : a.accountId;
+        const bId = typeof b === 'number' ? b : b.accountId;
+        if (aId === defaultAccount)
+            return -1;
+        if (bId === defaultAccount)
+            return 1;
+        return 0;
+    });
+}

package/lib/link/index.d.ts

@@ -0,0 +1,18 @@
+import { HsSettingsFile } from '@hubspot/local-dev-lib/types/HsSettings';
+import { ActionHandlerParams, ActionResult, LinkArgs } from '../../types/Link.js';
+import { ArgumentsCamelCase } from 'yargs';
+export declare class ActionHandlers {
+    static link({ state, context, }: ActionHandlerParams): Promise<ActionResult>;
+    static unlink({ state }: ActionHandlerParams): Promise<ActionResult>;
+    static authenticate({ state, context, args, }: ActionHandlerParams): Promise<ActionResult>;
+    static cancel(): Promise<ActionResult>;
+}
+export declare function handleLinkFlow({ settings, accountOverrideId, args, }: {
+    settings: HsSettingsFile;
+    accountOverrideId: number | null;
+    args: ArgumentsCamelCase<LinkArgs>;
+}): Promise<ActionResult>;
+export declare function handleLinkedUseAction({ state, targetAccountId, }: {
+    state: HsSettingsFile;
+    targetAccountId?: number;
+}): Promise<ActionResult>;