@hubspot/cli 8.0.10-experimental.6 → 8.0.10-experimental.7

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -0,0 +1,169 @@
+import { addLocalStateFlag } from '@hubspot/local-dev-lib/config';
+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 { removeAnsiCodes } from '../../ui/removeAnsiCodes.js';
+import { isDeployWebsocketMessage, isViewedWelcomeScreenWebsocketMessage, isUploadWebsocketMessage, isAppInstallFailureWebsocketMessage, isAppInstallSuccessWebsocketMessage, isAppInstallInitiatedWebsocketMessage, } from './localDevWebsocketServerUtils.js';
+import CLIWebSocketServer from '../../CLIWebSocketServer.js';
+const LOCAL_DEV_WEBSOCKET_SERVER_VERSION = 2;
+const LOG_PREFIX = '[LocalDevWebsocketServer]';
+class LocalDevWebsocketServer {
+    cliWebSocketServer;
+    localDevProcess;
+    constructor(localDevProcess, debug) {
+        this.localDevProcess = localDevProcess;
+        this.cliWebSocketServer = new CLIWebSocketServer({
+            instanceId: LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID,
+            logPrefix: LOG_PREFIX,
+            debug,
+        });
+    }
+    async handleUpload(websocket) {
+        const { uploadSuccess, buildSuccess, deploySuccess, deployId } = await this.localDevProcess.uploadProject();
+        this.cliWebSocketServer.sendMessage(websocket, {
+            type: uploadSuccess
+                ? LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS
+                : LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
+            data: {
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                buildSuccess,
+                deploySuccess,
+                deployId,
+            },
+        });
+    }
+    async handleDeploy(websocket, force) {
+        const { success, deployId } = await this.localDevProcess.deployLatestBuild(force);
+        this.cliWebSocketServer.sendMessage(websocket, {
+            type: success
+                ? LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEPLOY_SUCCESS
+                : LOCAL_DEV_UI_MESSAGE_SEND_TYPES.DEPLOY_FAILURE,
+            data: {
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                latestDeployId: deployId,
+            },
+        });
+    }
+    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);
+    }
+    handleMessage(websocket, message) {
+        if (isUploadWebsocketMessage(message)) {
+            this.handleUpload(websocket);
+            return true;
+        }
+        else if (isDeployWebsocketMessage(message)) {
+            this.handleDeploy(websocket, message.data.force);
+            return true;
+        }
+        else if (isViewedWelcomeScreenWebsocketMessage(message)) {
+            addLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
+            return true;
+        }
+        else if (isAppInstallSuccessWebsocketMessage(message)) {
+            this.handleAppInstallSuccess();
+            return true;
+        }
+        else if (isAppInstallFailureWebsocketMessage(message)) {
+            this.handleAppInstallFailure();
+            return true;
+        }
+        else if (isAppInstallInitiatedWebsocketMessage(message)) {
+            this.handleAppInstallInitiated();
+            return true;
+        }
+        return false;
+    }
+    sendProjectData(websocket) {
+        this.cliWebSocketServer.sendMessage(websocket, {
+            type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+            data: {
+                projectName: this.localDevProcess.projectData.name,
+                projectId: this.localDevProcess.projectData.id,
+                latestBuild: this.localDevProcess.projectData.latestBuild,
+                deployedBuild: this.localDevProcess.projectData.deployedBuild,
+                targetProjectAccountId: this.localDevProcess.targetProjectAccountId,
+                targetTestingAccountId: this.localDevProcess.targetTestingAccountId,
+            },
+        });
+    }
+    setupProjectNodesListener(websocket) {
+        const listener = (nodes) => {
+            this.cliWebSocketServer.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
+                data: nodes,
+            });
+        };
+        this.localDevProcess.addStateListener('projectNodes', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('projectNodes', listener);
+        });
+    }
+    setupAppDataListener(websocket) {
+        const listener = (appData) => {
+            this.cliWebSocketServer.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_APP_DATA,
+                data: appData,
+            });
+        };
+        this.localDevProcess.addStateListener('appData', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('appData', listener);
+        });
+    }
+    setupUploadWarningsListener(websocket) {
+        const listener = (uploadWarnings) => {
+            const formattedUploadWarnings = Array.from(uploadWarnings).map(removeAnsiCodes);
+            this.cliWebSocketServer.sendMessage(websocket, {
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_UPLOAD_WARNINGS,
+                data: { uploadWarnings: formattedUploadWarnings },
+            });
+        };
+        this.localDevProcess.addStateListener('uploadWarnings', listener);
+        websocket.on('close', () => {
+            this.localDevProcess.removeStateListener('uploadWarnings', listener);
+        });
+    }
+    setupDevServersStartedListener(websocket) {
+        const listener = (devServersStarted) => {
+            if (devServersStarted) {
+                this.cliWebSocketServer.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() {
+        return this.cliWebSocketServer.start({
+            metadata: {
+                localDevWebsocketServerVersion: LOCAL_DEV_WEBSOCKET_SERVER_VERSION,
+            },
+            onConnection: ws => {
+                this.sendProjectData(ws);
+                this.setupStateListeners(ws);
+                this.localDevProcess.sendDevServerMessage(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+            },
+            onMessage: (ws, message) => this.handleMessage(ws, message),
+        });
+    }
+    shutdown() {
+        this.cliWebSocketServer.shutdown();
+    }
+}
+export default LocalDevWebsocketServer;

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

@@ -0,0 +1,14 @@
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
+import { ProjectDevTargetAccountPromptResponse } from '../../../prompts/projectDevTargetAccountPrompt.js';
+export declare function confirmDefaultAccountIsTarget(accountConfig: HubSpotConfigAccount): Promise<void>;
+export declare function checkIfDefaultAccountIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): Promise<void>;
+export declare function checkIfParentAccountIsAuthed(accountConfig: HubSpotConfigAccount): void;
+export declare function checkIfAccountFlagIsSupported(accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): void;
+export declare function suggestRecommendedNestedAccount(accounts: HubSpotConfigAccount[], accountConfig: HubSpotConfigAccount, hasPublicApps: boolean): Promise<ProjectDevTargetAccountPromptResponse>;
+export declare function createSandboxForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment): Promise<number>;
+export declare function createDeveloperTestAccountForLocalDev(accountId: number, accountConfig: HubSpotConfigAccount, env: Environment, useV2?: boolean): Promise<number>;
+export declare function useExistingDevTestAccount(env: Environment, account: DeveloperTestAccount): Promise<void>;
+export declare function hasSandboxes(account: HubSpotConfigAccount): Promise<boolean>;
+export declare function selectAccountTypePrompt(accountConfig: HubSpotConfigAccount): Promise<string | null>;

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

@@ -0,0 +1,222 @@
+import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
+import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { isMissingScopeError } from '@hubspot/local-dev-lib/errors/index';
+import { PERSONAL_ACCESS_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { uiLogger } from '../../../ui/logger.js';
+import { lib } from '../../../../lang/en.js';
+import { EXIT_CODES } from '../../../enums/exitCodes.js';
+import { confirmDefaultAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
+import { isUnifiedAccount } from '../../../accountTypes.js';
+import { isAppDeveloperAccount } from '../../../accountTypes.js';
+import { isDeveloperTestAccount } from '../../../accountTypes.js';
+import { uiAccountDescription } from '../../../ui/index.js';
+import { uiLine } from '../../../ui/index.js';
+import { selectDeveloperTestTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
+import { selectSandboxTargetAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
+import { validateSandboxUsageLimits } from '../../../sandboxes.js';
+import { logError } from '../../../errorHandlers/index.js';
+import { hubspotAccountNamePrompt } from '../../../prompts/accountNamePrompt.js';
+import { trackCommandMetadataUsage } from '../../../usageTracking.js';
+import { validateDevTestAccountUsageLimits } from '../../../developerTestAccounts.js';
+import { buildDeveloperTestAccount, saveAccountToConfig, buildV2Sandbox, } from '../../../buildAccount.js';
+import { debugError } from '../../../errorHandlers/index.js';
+import { listPrompt } from '../../../prompts/promptUtils.js';
+import { confirmUseExistingDeveloperTestAccountPrompt } from '../../../prompts/projectDevTargetAccountPrompt.js';
+// If the user passed in the --account flag, confirm they want to use that account as
+// their target account, otherwise exit
+export async function confirmDefaultAccountIsTarget(accountConfig) {
+    if (!accountConfig.name || !accountConfig.accountType) {
+        uiLogger.error(lib.localDevHelpers.account.confirmDefaultAccountIsTarget.configError);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    uiLogger.log('');
+    const useDefaultAccount = await confirmDefaultAccountPrompt(accountConfig.name, HUBSPOT_ACCOUNT_TYPE_STRINGS[accountConfig.accountType]);
+    if (!useDefaultAccount) {
+        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
+            .declineDefaultAccountExplanation);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+// Confirm the default account is supported for the type of apps being developed
+export async function checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps) {
+    const defaultAccountIsUnified = await isUnifiedAccount(accountConfig);
+    if (hasPublicApps &&
+        !(isAppDeveloperAccount(accountConfig) ||
+            isDeveloperTestAccount(accountConfig) ||
+            defaultAccountIsUnified)) {
+        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.publicApp);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    else if (!hasPublicApps && isAppDeveloperAccount(accountConfig)) {
+        uiLogger.error(lib.localDevHelpers.account.checkIfDefaultAccountIsSupported.privateApp);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+export function checkIfParentAccountIsAuthed(accountConfig) {
+    if (!accountConfig.parentAccountId ||
+        !getConfigAccountIfExists(accountConfig.parentAccountId)?.accountId) {
+        uiLogger.error(lib.localDevHelpers.account.checkIfParentAccountIsAuthed.notAuthedError(accountConfig.parentAccountId || '', uiAccountDescription(accountConfig.accountId)));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+// Confirm the default account is a developer account if developing public apps
+export function checkIfAccountFlagIsSupported(accountConfig, hasPublicApps) {
+    if (hasPublicApps) {
+        if (!isDeveloperTestAccount(accountConfig)) {
+            uiLogger.error(lib.localDevHelpers.account.validateAccountOption
+                .invalidPublicAppAccount);
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        checkIfParentAccountIsAuthed(accountConfig);
+    }
+    else if (isAppDeveloperAccount(accountConfig)) {
+        uiLogger.error(lib.localDevHelpers.account.validateAccountOption.invalidPrivateAppAccount);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+// If the user isn't using the recommended account type, prompt them to use or create one
+export async function suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps) {
+    uiLogger.log('');
+    uiLine();
+    if (hasPublicApps) {
+        uiLogger.log(lib.localDevHelpers.account.validateAccountOption
+            .publicAppNonDeveloperTestAccountWarning);
+    }
+    else {
+        uiLogger.log(lib.localDevHelpers.account.validateAccountOption.nonSandboxWarning);
+    }
+    uiLine();
+    uiLogger.log('');
+    const targetAccountPrompt = hasPublicApps
+        ? selectDeveloperTestTargetAccountPrompt
+        : selectSandboxTargetAccountPrompt;
+    return targetAccountPrompt(accounts, accountConfig);
+}
+// Create a new sandbox and return its accountId
+export async function createSandboxForLocalDev(accountId, accountConfig, env) {
+    try {
+        await validateSandboxUsageLimits(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, env);
+    }
+    catch (err) {
+        if (isMissingScopeError(err)) {
+            uiLogger.error(lib.sandbox.create.developer.failure.scopes.message);
+            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+            const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+            uiLogger.info(lib.sandbox.create.developer.failure.scopes.instructions(accountConfig.name || accountId, url));
+        }
+        else {
+            logError(err);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        const { name } = await hubspotAccountNamePrompt({
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        });
+        trackCommandMetadataUsage('sandbox-create', { step: 'project-dev' }, accountId);
+        const result = await buildV2Sandbox(name, accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, false, // syncObjectRecords
+        env);
+        return result.sandbox.sandboxHubId;
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+// Create a developer test account and return its accountId
+export async function createDeveloperTestAccountForLocalDev(accountId, accountConfig, env, useV2 = false) {
+    let currentPortalCount = 0;
+    let maxTestPortals = 10;
+    try {
+        const validateResult = await validateDevTestAccountUsageLimits(accountConfig);
+        if (validateResult) {
+            currentPortalCount = validateResult.results
+                ? validateResult.results.length
+                : 0;
+            maxTestPortals = validateResult.maxTestPortals;
+        }
+    }
+    catch (err) {
+        if (isMissingScopeError(err)) {
+            uiLogger.error(lib.developerTestAccount.create.failure.scopes.message);
+            const websiteOrigin = getHubSpotWebsiteOrigin(env);
+            const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+            uiLogger.info(lib.developerTestAccount.create.failure.scopes.instructions(accountConfig.name || accountId, url));
+        }
+        else {
+            logError(err);
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    try {
+        const { name } = await hubspotAccountNamePrompt({
+            currentPortalCount,
+            accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        });
+        trackCommandMetadataUsage('developer-test-account-create', { step: 'project-dev' }, accountId);
+        const result = await buildDeveloperTestAccount(name, accountConfig, env, maxTestPortals, useV2);
+        return result;
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+// Prompt user to confirm usage of an existing developer test account that is not currently in the config
+export async function useExistingDevTestAccount(env, account) {
+    const useExistingDevTestAcct = await confirmUseExistingDeveloperTestAccountPrompt(account);
+    if (!useExistingDevTestAcct) {
+        uiLogger.log('');
+        uiLogger.log(lib.localDevHelpers.account.confirmDefaultAccountIsTarget
+            .declineDefaultAccountExplanation);
+        uiLogger.log('');
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    const devTestAcctConfigName = await saveAccountToConfig(account.id, account.accountName, env);
+    uiLogger.success(lib.developerTestAccount.create.success.configFileUpdated(devTestAcctConfigName, PERSONAL_ACCESS_KEY_AUTH_METHOD.name));
+}
+export async function hasSandboxes(account) {
+    const accountId = account.accountId;
+    if (!accountId) {
+        return false;
+    }
+    try {
+        const { data: { usage }, } = await getSandboxUsageLimits(accountId);
+        return usage.STANDARD.limit > 0 || usage.DEVELOPER.limit > 0;
+    }
+    catch (e) {
+        debugError(e);
+        return false;
+    }
+}
+// Top level prompt to choose the type of account to test on
+export async function selectAccountTypePrompt(accountConfig) {
+    const hasAccessToSandboxes = await hasSandboxes(accountConfig);
+    const accountId = accountConfig.accountId;
+    const result = await listPrompt(lib.localDevHelpers.account.selectAccountTypePrompt.message, {
+        choices: [
+            {
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
+                    .developerTestAccountOption,
+                value: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+            },
+            {
+                name: lib.localDevHelpers.account.selectAccountTypePrompt
+                    .sandboxAccountOption,
+                value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                disabled: !hasAccessToSandboxes
+                    ? lib.localDevHelpers.account.selectAccountTypePrompt
+                        .sandboxAccountOptionDisabled
+                    : false,
+            },
+            {
+                name: lib.localDevHelpers.account.selectAccountTypePrompt.productionAccountOption(accountId),
+                value: null,
+            },
+        ],
+    });
+    return result;
+}

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

@@ -0,0 +1,9 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+export declare function registerDevSession(accountId: number, ports: {
+    serverId: string;
+    port: number;
+}[], force?: boolean): HubSpotPromise<{
+    sessionId: number;
+}>;
+export declare function devSessionHeartbeat(accountId: number, sessionId: number): HubSpotPromise<void>;
+export declare function deleteDevSession(accountId: number, sessionId: number): HubSpotPromise<void>;

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

@@ -0,0 +1,19 @@
+import { http } from '@hubspot/local-dev-lib/http';
+const DEV_SESSIONS_API_PATH = 'projects-localdev/2025-09/dev-sessions';
+export async function registerDevSession(accountId, ports, force) {
+    return http.post(accountId, {
+        url: `${DEV_SESSIONS_API_PATH}/register${force ? '?force=true' : ''}`,
+        data: { ports },
+    });
+}
+export async function devSessionHeartbeat(accountId, sessionId) {
+    return http.post(accountId, {
+        url: `${DEV_SESSIONS_API_PATH}/${sessionId}/heartbeat`,
+        data: {},
+    });
+}
+export async function deleteDevSession(accountId, sessionId) {
+    return http.delete(accountId, {
+        url: `${DEV_SESSIONS_API_PATH}/${sessionId}`,
+    });
+}

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,17 @@
+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 {
+        const existingPortInUse = await getServerPortByInstanceId(LOCAL_DEV_WEBSOCKET_SERVER_INSTANCE_ID);
+        if (existingPortInUse) {
+            uiLogger.error(commands.project.dev.errors.localDevAlreadyRunning);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    catch (error) {
+        return;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { type IntermediateRepresentationNode, type IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+import { ProjectConfig } from '../../../../types/Projects.js';
+export declare function createNewProjectForLocalDev(projectConfig: ProjectConfig, targetAccountId: number, shouldCreateWithoutConfirmation: boolean, hasPublicApps: boolean): Promise<Project>;
+export declare function createInitialBuildForNewProject(projectConfig: ProjectConfig, projectDir: string, targetAccountId: number, sendIR?: boolean, profile?: string): Promise<Build>;
+export declare function compareLocalProjectToDeployed(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number | undefined, localProjectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}, profile?: string): Promise<void>;
+export declare function getDeployedProjectNodes(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, profile?: string): Promise<{
+    [key: string]: IntermediateRepresentationNode;
+}>;
+export declare function isDeployedProjectUpToDateWithLocal(projectConfig: ProjectConfig, accountId: number, deployedBuildId: number, localProjectNodes: {
+    [key: string]: IntermediateRepresentationNodeLocalDev;
+}, profile?: string): Promise<boolean>;
+export declare function checkAndInstallDependencies(): Promise<void>;