@hubspot/cli 8.2.0 → 8.2.1-experimental.1

package/lib/getStartedV2Actions.js

@@ -11,9 +11,9 @@ import { translate, } from '@hubspot/project-parsing-lib/translate';
 import { commands, lib } from '../lang/en.js';
 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 { ProjectNestingError, ProjectUploadError, ProjectBuildDeployError, } from './errors/ProjectErrors.js';
+import { getProjectConfig, writeProjectConfig, } from '../lib/projects/config.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';
@@ -29,15 +29,21 @@ export async function createProjectAction({ projectName, projectDest, }) {
             : 'Invalid project directory');
     }
     const projectDestAbsolute = path.resolve(getCwd(), projectDest);
-    const { projectConfig: existingProjectConfig, projectDir: existingProjectDir, } = await getProjectConfig(projectDestAbsolute);
-    if (existingProjectConfig &&
-        existingProjectDir &&
-        projectDestAbsolute.startsWith(existingProjectDir)) {
-        throw new ProjectNestingError(commands.project.create.errors.cannotNestProjects(existingProjectDir));
+    try {
+        const { projectDir: existingProjectDir } = getProjectConfig(projectDestAbsolute);
+        if (projectDestAbsolute.startsWith(existingProjectDir)) {
+            throw new ProjectNestingError(commands.project.create.errors.cannotNestProjects(existingProjectDir));
+        }
+    }
+    catch (error) {
+        if (error instanceof ProjectNestingError) {
+            throw error;
+        }
+        // Not in a project directory, which is the expected case
     }
     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);
@@ -73,7 +79,7 @@ async function fetchAppAfterDeploy(accountId, env) {
 async function buildProjectMetadata(projectDir, projectConfig, accountId) {
     const srcDir = path.join(projectDir, projectConfig.srcDir);
     const projectMetadata = await getProjectMetadata(srcDir);
-    const intermediateRepresentation = await translate({
+    const { intermediateRepresentation } = await translate({
         projectSourceDir: srcDir,
         platformVersion: projectConfig.platformVersion,
         accountId,
@@ -88,17 +94,7 @@ async function buildProjectMetadata(projectDir, projectConfig, accountId) {
     };
 }
 export async function uploadAndDeployAction({ accountId, projectDest, }) {
-    const { projectConfig, projectDir } = await getProjectConfig(projectDest);
-    if (!projectConfig || !projectDir) {
-        throw new ProjectConfigNotFoundError(commands.getStarted.errors.configFileNotFound);
-    }
-    try {
-        validateProjectConfig(projectConfig, projectDir);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new ProjectValidationError(message);
-    }
+    const { projectConfig, projectDir } = getProjectConfig(projectDest);
     const env = getConfigAccountEnvironment(accountId);
     try {
         const { result, uploadError } = await handleProjectUpload({
@@ -109,8 +105,9 @@ 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,
+            force: true,
         });
         if (uploadError) {
             throw new ProjectUploadError(commands.getStarted.errors.uploadActionFailed, 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/importData.js

@@ -1,16 +1,15 @@
-import { getConfigAccountById, getConfigAccountEnvironment, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
 import { createImport } from '@hubspot/local-dev-lib/api/crm';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { getHubSpotWebsiteOriginByAccountId } from '@hubspot/local-dev-lib/urls';
 import { importDataTestAccountSelectPrompt } from './prompts/importDataTestAccountSelectPrompt.js';
 import { lib } from '../lang/en.js';
 import { isAppDeveloperAccount, isDeveloperTestAccount, isStandardAccount, } from './accountTypes.js';
 import { uiLogger } from './ui/logger.js';
 export async function handleImportData(targetAccountId, dataFileNames, importRequest) {
     try {
-        const baseUrl = getHubSpotWebsiteOrigin(getConfigAccountEnvironment(targetAccountId));
         const response = await createImport(targetAccountId, importRequest, dataFileNames);
         const importId = response.data.id;
-        uiLogger.info(lib.importData.viewImportLink(baseUrl, targetAccountId, importId));
+        uiLogger.info(lib.importData.viewImportLink(getHubSpotWebsiteOriginByAccountId(targetAccountId), targetAccountId, importId));
     }
     catch (error) {
         uiLogger.error(lib.importData.errors.failedToImportData);

package/lib/jsonOutput.d.ts

@@ -0,0 +1,195 @@
+import { z } from 'zod';
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Release } from '../api/releases.js';
+declare const ReleaseComponentSchema: z.ZodObject<{
+    buildType: z.ZodString;
+    buildName: z.ZodOptional<z.ZodString>;
+    rootPath: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ReleaseSchema: z.ZodObject<{
+    releaseTag: z.ZodString;
+    buildId: z.ZodNumber;
+    createdAt: z.ZodString;
+    components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        buildType: z.ZodString;
+        buildName: z.ZodOptional<z.ZodString>;
+        rootPath: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ReleaseListSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        releaseTag: z.ZodString;
+        buildId: z.ZodNumber;
+        createdAt: z.ZodString;
+        components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            buildType: z.ZodString;
+            buildName: z.ZodOptional<z.ZodString>;
+            rootPath: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    paging: z.ZodOptional<z.ZodObject<{
+        next: z.ZodObject<{
+            after: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const BuildSubbuildStatusSchema: z.ZodObject<{
+    buildName: z.ZodString;
+    buildType: z.ZodString;
+    status: z.ZodString;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    rootPath: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    visible: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const BuildSchema: z.ZodObject<{
+    buildId: z.ZodNumber;
+    status: z.ZodString;
+    isDeployed: z.ZodBoolean;
+    isAutoDeployEnabled: z.ZodOptional<z.ZodBoolean>;
+    deployableState: z.ZodOptional<z.ZodString>;
+    platformVersion: z.ZodOptional<z.ZodString>;
+    uploadMessage: z.ZodOptional<z.ZodString>;
+    enqueuedAt: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    subbuildStatuses: z.ZodArray<z.ZodObject<{
+        buildName: z.ZodString;
+        buildType: z.ZodString;
+        status: z.ZodString;
+        errorMessage: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        rootPath: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        visible: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ProjectBuildsListSchema: z.ZodObject<{
+    projectName: z.ZodString;
+    deployedBuildId: z.ZodOptional<z.ZodNumber>;
+    results: z.ZodArray<z.ZodObject<{
+        buildId: z.ZodNumber;
+        status: z.ZodString;
+        isDeployed: z.ZodBoolean;
+        isAutoDeployEnabled: z.ZodOptional<z.ZodBoolean>;
+        deployableState: z.ZodOptional<z.ZodString>;
+        platformVersion: z.ZodOptional<z.ZodString>;
+        uploadMessage: z.ZodOptional<z.ZodString>;
+        enqueuedAt: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        subbuildStatuses: z.ZodArray<z.ZodObject<{
+            buildName: z.ZodString;
+            buildType: z.ZodString;
+            status: z.ZodString;
+            errorMessage: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodOptional<z.ZodString>;
+            finishedAt: z.ZodOptional<z.ZodString>;
+            rootPath: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            visible: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    paging: z.ZodOptional<z.ZodObject<{
+        next: z.ZodObject<{
+            after: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ProjectInfoSchema: z.ZodObject<{
+    projectName: z.ZodString;
+    platformVersion: z.ZodString;
+    projectId: z.ZodNumber;
+    deployedBuildId: z.ZodNumber;
+    autoDeployEnabled: z.ZodBoolean;
+    projectUrl: z.ZodOptional<z.ZodString>;
+    app: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodNumber;
+        uid: z.ZodString;
+        authType: z.ZodOptional<z.ZodString>;
+        distributionType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    components: z.ZodArray<z.ZodObject<{
+        uid: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const PreviewSchema: z.ZodObject<{
+    releaseTag: z.ZodOptional<z.ZodString>;
+    succeeded: z.ZodBoolean;
+}, z.core.$strip>;
+declare const TargetAccountSchema: z.ZodObject<{
+    accountId: z.ZodNumber;
+    accountName: z.ZodOptional<z.ZodString>;
+    accountType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const UploadSchema: z.ZodObject<{
+    targetAccount: z.ZodOptional<z.ZodObject<{
+        accountId: z.ZodNumber;
+        accountName: z.ZodOptional<z.ZodString>;
+        accountType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    buildId: z.ZodOptional<z.ZodNumber>;
+    deployId: z.ZodOptional<z.ZodNumber>;
+    preview: z.ZodOptional<z.ZodObject<{
+        releaseTag: z.ZodOptional<z.ZodString>;
+        succeeded: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const DeploySchema: z.ZodObject<{
+    deployId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const InstallStatusSchema: z.ZodObject<{
+    appId: z.ZodOptional<z.ZodNumber>;
+    appUid: z.ZodString;
+    accountId: z.ZodNumber;
+    projectId: z.ZodNumber;
+    isInstalled: z.ZodBoolean;
+    isInstalledWithCurrentScopes: z.ZodBoolean;
+    previouslyAuthorizedScopeGroups: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const InstallAppSchema: z.ZodObject<{
+    appId: z.ZodNumber;
+    appUid: z.ZodString;
+    accountId: z.ZodNumber;
+    projectId: z.ZodNumber;
+    installationState: z.ZodString;
+    installed: z.ZodBoolean;
+    reinstalled: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const CreateTestAccountSchema: z.ZodObject<{
+    accountName: z.ZodOptional<z.ZodString>;
+    accountId: z.ZodOptional<z.ZodNumber>;
+    personalAccessKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ReleaseComponentJsonOutput = z.infer<typeof ReleaseComponentSchema>;
+export type ReleaseJsonOutput = z.infer<typeof ReleaseSchema>;
+export type ReleaseListJsonOutput = z.infer<typeof ReleaseListSchema>;
+export type BuildSubbuildStatusJsonOutput = z.infer<typeof BuildSubbuildStatusSchema>;
+export type BuildJsonOutput = z.infer<typeof BuildSchema>;
+export type ProjectBuildsListJsonOutput = z.infer<typeof ProjectBuildsListSchema>;
+export type ProjectInfoJsonOutput = z.infer<typeof ProjectInfoSchema>;
+export type PreviewJsonOutput = z.infer<typeof PreviewSchema>;
+export type TargetAccountJsonOutput = z.infer<typeof TargetAccountSchema>;
+export type UploadJsonOutput = z.infer<typeof UploadSchema>;
+export type DeployJsonOutput = z.infer<typeof DeploySchema>;
+export type InstallStatusJsonOutput = z.infer<typeof InstallStatusSchema>;
+export type InstallAppJsonOutput = z.infer<typeof InstallAppSchema>;
+export type CreateTestAccountJsonOutput = z.infer<typeof CreateTestAccountSchema>;
+export declare function mapAccountToTargetAccount(accountId: number, account?: HubSpotConfigAccount | null): TargetAccountJsonOutput;
+export declare function mapBuildToJsonOutput(build: Build, deployedBuildId?: number): BuildJsonOutput;
+export declare function mapReleaseToJsonOutput(release: Release): ReleaseJsonOutput;
+export {};

package/lib/jsonOutput.js

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+const ReleaseComponentSchema = z.object({
+    buildType: z.string(),
+    buildName: z.string().optional(),
+    rootPath: z.string().optional(),
+    id: z.string().optional(),
+});
+export const ReleaseSchema = z.object({
+    releaseTag: z.string(),
+    buildId: z.number(),
+    createdAt: z.string(),
+    components: z.array(ReleaseComponentSchema).optional(),
+});
+export const ReleaseListSchema = z.object({
+    results: z.array(ReleaseSchema),
+    paging: z
+        .object({
+        next: z.object({
+            after: z.string(),
+        }),
+    })
+        .optional(),
+});
+const BuildSubbuildStatusSchema = z.object({
+    buildName: z.string(),
+    buildType: z.string(),
+    status: z.string(),
+    errorMessage: z.string().optional(),
+    startedAt: z.string().optional(),
+    finishedAt: z.string().optional(),
+    rootPath: z.string().optional(),
+    id: z.string().optional(),
+    visible: z.boolean().optional(),
+});
+export const BuildSchema = z.object({
+    buildId: z.number(),
+    status: z.string(),
+    isDeployed: z.boolean(),
+    isAutoDeployEnabled: z.boolean().optional(),
+    deployableState: z.string().optional(),
+    platformVersion: z.string().optional(),
+    uploadMessage: z.string().optional(),
+    enqueuedAt: z.string().optional(),
+    startedAt: z.string().optional(),
+    finishedAt: z.string().optional(),
+    createdAt: z.string().optional(),
+    subbuildStatuses: z.array(BuildSubbuildStatusSchema),
+});
+export const ProjectBuildsListSchema = z.object({
+    projectName: z.string(),
+    deployedBuildId: z.number().optional(),
+    results: z.array(BuildSchema),
+    paging: z
+        .object({
+        next: z.object({
+            after: z.string(),
+        }),
+    })
+        .optional(),
+});
+export const ProjectInfoSchema = z.object({
+    projectName: z.string(),
+    platformVersion: z.string(),
+    projectId: z.number(),
+    deployedBuildId: z.number(),
+    autoDeployEnabled: z.boolean(),
+    projectUrl: z.string().optional(),
+    app: z
+        .object({
+        name: z.string(),
+        id: z.number(),
+        uid: z.string(),
+        authType: z.string().optional(),
+        distributionType: z.string().optional(),
+    })
+        .optional(),
+    components: z.array(z.object({ uid: z.string(), type: z.string() })),
+});
+const PreviewSchema = z.object({
+    releaseTag: z.string().optional(),
+    succeeded: z.boolean(),
+});
+const TargetAccountSchema = z.object({
+    accountId: z.number(),
+    accountName: z.string().optional(),
+    accountType: z.string().optional(),
+});
+export const UploadSchema = z.object({
+    targetAccount: TargetAccountSchema.optional(),
+    buildId: z.number().optional(),
+    deployId: z.number().optional(),
+    preview: PreviewSchema.optional(),
+});
+export const DeploySchema = z.object({
+    deployId: z.number().optional(),
+});
+const ScopeGroupSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+});
+export const InstallStatusSchema = z.object({
+    appId: z.number().optional(),
+    appUid: z.string(),
+    accountId: z.number(),
+    projectId: z.number(),
+    isInstalled: z.boolean(),
+    isInstalledWithCurrentScopes: z.boolean(),
+    previouslyAuthorizedScopeGroups: z.array(ScopeGroupSchema),
+});
+export const InstallAppSchema = z.object({
+    appId: z.number(),
+    appUid: z.string(),
+    accountId: z.number(),
+    projectId: z.number(),
+    installationState: z.string(),
+    installed: z.boolean(),
+    reinstalled: z.boolean(),
+});
+export const CreateTestAccountSchema = z.object({
+    accountName: z.string().optional(),
+    accountId: z.number().optional(),
+    personalAccessKey: z.string().optional(),
+});
+export function mapAccountToTargetAccount(accountId, account) {
+    return {
+        accountId,
+        accountName: account?.name,
+        accountType: account?.accountType,
+    };
+}
+export function mapBuildToJsonOutput(build, deployedBuildId) {
+    const { buildId, status, isAutoDeployEnabled, deployableState, platformVersion, uploadMessage, enqueuedAt, startedAt, finishedAt, createdAt, subbuildStatuses, } = build;
+    return {
+        buildId,
+        status,
+        isDeployed: buildId === deployedBuildId,
+        isAutoDeployEnabled,
+        deployableState,
+        platformVersion,
+        uploadMessage,
+        enqueuedAt,
+        startedAt,
+        finishedAt,
+        createdAt,
+        subbuildStatuses: subbuildStatuses.map(subbuild => ({
+            buildName: subbuild.buildName,
+            buildType: subbuild.buildType,
+            status: subbuild.status,
+            errorMessage: subbuild.errorMessage,
+            startedAt: subbuild.startedAt,
+            finishedAt: subbuild.finishedAt,
+            rootPath: subbuild.rootPath,
+            id: subbuild.id,
+            visible: subbuild.visible,
+        })),
+    };
+}
+export function mapReleaseToJsonOutput(release) {
+    const { releaseTag, buildId, createdAt, components } = release;
+    return {
+        releaseTag,
+        buildId,
+        createdAt,
+        components: components?.map(({ buildType, buildName, rootPath, id }) => ({
+            buildType,
+            buildName,
+            rootPath,
+            id,
+        })),
+    };
+}

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>;