@hubspot/local-dev-lib 0.7.7-experimental.0 → 0.7.9-experimental.0

package/api/projects.d.ts

@@ -1,5 +1,5 @@
 import { HubSpotPromise, QueryParams } from '../types/Http.js';
-import { Project, FetchProjectResponse, UploadProjectResponse, ProjectSettings, FetchPlatformVersionResponse, WarnLogsResponse, UploadIRResponse } from '../types/Project.js';
+import { Project, FetchProjectResponse, UploadProjectResponse, ProjectSettings, FetchPlatformVersionResponse, WarnLogsResponse, UploadIRResponse, Release, FetchListReleasesResponse, AutoReleaseResponse, AutoReleaseStatusResponse } from '../types/Project.js';
 import { Build, FetchProjectBuildsResponse } from '../types/Build.js';
 import { ComponentStructureResponse, ProjectComponentsMetadata } from '../types/ComponentStructure.js';
 import { Deploy, ProjectDeployResponse, ProjectDeployResponseV1, ProjectDeletionResponse } from '../types/Deploy.js';
@@ -39,6 +39,11 @@ export declare function deleteFileFromBuild(accountId: number, projectName: stri
 export declare function cancelStagedBuild(accountId: number, projectName: string): HubSpotPromise<void>;
 export declare function fetchBuildWarnLogs(accountId: number, projectName: string, buildId: number): HubSpotPromise<WarnLogsResponse>;
 export declare function fetchDeployWarnLogs(accountId: number, projectName: string, deployId: number): HubSpotPromise<WarnLogsResponse>;
+export declare function createRelease(accountId: number, projectName: string, buildId: number): HubSpotPromise<Release>;
+export declare function listReleases(accountId: number, projectName: string, params?: QueryParams): HubSpotPromise<FetchListReleasesResponse>;
+export declare function getReleaseInfo(accountId: number, projectName: string, releaseTag: string): HubSpotPromise<Release>;
+export declare function triggerAutoRelease(accountId: number, projectId: number, buildId: number, targetPortalId: number): HubSpotPromise<AutoReleaseResponse>;
+export declare function getAutoReleaseStatus(accountId: number, projectId: number, targetPortalId: number, expectedReleaseTag: string, appId: number): HubSpotPromise<AutoReleaseStatusResponse>;
 /**
  * @deprecated
  */

package/api/projects.js

@@ -215,6 +215,44 @@ export function fetchDeployWarnLogs(accountId, projectName, deployId) {
         url: `${PROJECTS_LOGS_API_PATH}/logs/projects/${encodeURIComponent(projectName)}/deploys/${deployId}/combined/warn`,
     });
 }
+export function createRelease(accountId, projectName, buildId) {
+    return http.post(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}/releases`,
+        data: { buildId },
+    });
+}
+export function listReleases(accountId, projectName, params = {}) {
+    return http.get(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}/releases`,
+        params,
+    });
+}
+export function getReleaseInfo(accountId, projectName, releaseTag) {
+    return http.get(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}/releases/${encodeURIComponent(releaseTag)}`,
+    });
+}
+export function triggerAutoRelease(accountId, projectId, buildId, targetPortalId) {
+    return http.post(accountId, {
+        url: `${PROJECTS_DEPLOY_API_PATH}/auto-release`,
+        data: {
+            projectId,
+            buildId,
+            targetPortalId,
+        },
+    });
+}
+export function getAutoReleaseStatus(accountId, projectId, targetPortalId, expectedReleaseTag, appId) {
+    return http.get(accountId, {
+        url: `${PROJECTS_DEPLOY_API_PATH}/auto-release/status`,
+        params: {
+            projectId,
+            targetPortalId,
+            expectedReleaseTag,
+            appId,
+        },
+    });
+}
 /**
  * @deprecated
  */

package/api/sandboxHubs.js

@@ -16,6 +16,7 @@ export function createSandbox(accountId, name, type) {
 export function deleteSandbox(parentAccountId, sandboxAccountId) {
     return http.delete(parentAccountId, {
         url: `${SANDBOX_API_PATH}/${sandboxAccountId}`,
+        timeout: SANDBOX_TIMEOUT,
     });
 }
 export function getSandboxUsageLimits(parentAccountId) {
@@ -27,6 +28,7 @@ export function createV2Sandbox(accountId, name, type, syncObjectRecords) {
     return http.post(accountId, {
         url: `${SANDBOX_API_PATH_V2}/sandboxes`,
         data: { name, type, syncObjectRecords },
+        timeout: SANDBOX_TIMEOUT,
     });
 }
 export function getSandboxPersonalAccessKey(accountId, sandboxId) {

package/config/defaultAccountOverride.d.ts

@@ -1,3 +1,4 @@
 import { HubSpotConfigAccount } from '../types/Accounts.js';
 export declare function getDefaultAccountOverrideAccountId(accounts: Array<HubSpotConfigAccount>): number | null;
+export declare function removeDefaultAccountOverrideFile(): void;
 export declare function getDefaultAccountOverrideFilePath(): string | null;

package/config/defaultAccountOverride.js

@@ -40,6 +40,21 @@ export function getDefaultAccountOverrideAccountId(accounts) {
     }
     return account.accountId;
 }
+export function removeDefaultAccountOverrideFile() {
+    const filePath = getDefaultAccountOverrideFilePath();
+    if (!filePath) {
+        return;
+    }
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch (e) {
+        throw new FileSystemError({ cause: e }, {
+            filepath: filePath,
+            operation: 'write',
+        });
+    }
+}
 export function getDefaultAccountOverrideFilePath() {
     return findup([DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME], {
         cwd: getCwd(),

package/config/hsSettings.d.ts

@@ -0,0 +1,4 @@
+import { HsSettingsFile } from '../types/HsSettings.js';
+export declare function getHsSettingsFilePath(): string | null;
+export declare function getHsSettingsFileIfExists(): HsSettingsFile | null;
+export declare function writeHsSettingsFile(settingsFile: HsSettingsFile): void;

package/config/hsSettings.js

@@ -0,0 +1,58 @@
+import findupSync from 'findup-sync';
+import fs from 'fs';
+import path from 'path';
+import { HS_FOLDER, HS_README_FILENAME, HS_SETTINGS_FILENAME, } from '../constants/config.js';
+import { getCwd } from '../lib/path.js';
+import { FileSystemError } from '../models/FileSystemError.js';
+const HS_README_CONTENTS = `Why do I have a folder named ".hs" in my project?
+The ".hs" folder is created when you link a directory to a HubSpot project.
+
+What does the "settings.json" file contain?
+The "settings.json" file contains:
+- The ID(s) of the HubSpot account(s) that you linked ("accounts")
+- The ID of the HubSpot account that you set as the default for this directory ("linkedDefaultAccount")
+
+Should I commit the ".hs" folder?
+No, the ".hs" folder should not be committed to version control. It is automatically added to your .gitignore file when the directory is linked.
+`;
+export function getHsSettingsFilePath() {
+    return findupSync([`${HS_FOLDER}/${HS_SETTINGS_FILENAME}`], {
+        cwd: getCwd(),
+    });
+}
+export function getHsSettingsFileIfExists() {
+    const hsSettingsFilePath = getHsSettingsFilePath();
+    if (!hsSettingsFilePath) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(hsSettingsFilePath, 'utf-8'));
+    }
+    catch (e) {
+        throw new FileSystemError({ cause: e }, {
+            filepath: hsSettingsFilePath,
+            operation: 'read',
+        });
+    }
+}
+export function writeHsSettingsFile(settingsFile) {
+    const existingFilePath = getHsSettingsFilePath();
+    const dir = getCwd();
+    const hsFolderPath = existingFilePath
+        ? path.dirname(existingFilePath)
+        : path.join(dir, HS_FOLDER);
+    const isFirstScaffold = !fs.existsSync(hsFolderPath);
+    try {
+        fs.mkdirSync(hsFolderPath, { recursive: true });
+        fs.writeFileSync(path.join(hsFolderPath, HS_SETTINGS_FILENAME), JSON.stringify(settingsFile, null, 2), 'utf8');
+        if (isFirstScaffold) {
+            fs.writeFileSync(path.join(hsFolderPath, HS_README_FILENAME), HS_README_CONTENTS, 'utf8');
+        }
+    }
+    catch (err) {
+        throw new FileSystemError({ cause: err }, {
+            filepath: dir,
+            operation: 'write',
+        });
+    }
+}

package/config/index.d.ts

@@ -18,6 +18,7 @@ export declare function getConfigAccountIfExists(identifier: number | string): H
 export declare function getConfigDefaultAccount(): HubSpotConfigAccount;
 export declare function getConfigDefaultAccountIfExists(): HubSpotConfigAccount | undefined;
 export declare function getAllConfigAccounts(): HubSpotConfigAccount[];
+export declare function getLinkedOrAllConfigAccounts(): HubSpotConfigAccount[];
 export declare function getConfigAccountEnvironment(identifier: number | string): Environment;
 export declare function addConfigAccount(accountToAdd: HubSpotConfigAccount): void;
 export declare function updateConfigAccount(updatedAccount: HubSpotConfigAccount): void;

package/config/index.js

@@ -11,6 +11,7 @@ import { HubSpotConfigError } from '../models/HubSpotConfigError.js';
 import { HUBSPOT_CONFIG_ERROR_TYPES } from '../constants/config.js';
 import { isDeepEqual } from '../lib/isDeepEqual.js';
 import { getCwd } from '../lib/path.js';
+import { getHsSettingsFileIfExists } from './hsSettings.js';
 const EMPTY_CONFIG = { accounts: [] };
 export function getGlobalConfigFilePath() {
     return GLOBAL_CONFIG_PATH;
@@ -152,11 +153,17 @@ export function getConfigAccountIfExists(identifier) {
 export function getConfigDefaultAccount() {
     const { accounts, defaultAccount } = getConfig();
     let defaultAccountToUse = defaultAccount;
-    const currentConfigPath = getConfigFilePath();
-    const globalConfigPath = getGlobalConfigFilePath();
-    if (currentConfigPath === globalConfigPath && globalConfigFileExists()) {
-        const defaultAccountOverrideAccountId = getDefaultAccountOverrideAccountId(accounts);
-        defaultAccountToUse = defaultAccountOverrideAccountId || defaultAccount;
+    const hsSettingsFile = getHsSettingsFileIfExists();
+    if (hsSettingsFile && hsSettingsFile.localDefaultAccount) {
+        defaultAccountToUse = hsSettingsFile.localDefaultAccount;
+    }
+    else {
+        const currentConfigPath = getConfigFilePath();
+        const globalConfigPath = getGlobalConfigFilePath();
+        if (currentConfigPath === globalConfigPath && globalConfigFileExists()) {
+            const defaultAccountOverrideAccountId = getDefaultAccountOverrideAccountId(accounts);
+            defaultAccountToUse = defaultAccountOverrideAccountId || defaultAccount;
+        }
     }
     if (!defaultAccountToUse) {
         throw new HubSpotConfigError(i18n('config.getConfigDefaultAccount.fieldMissingError'), HUBSPOT_CONFIG_ERROR_TYPES.NO_DEFAULT_ACCOUNT, HUBSPOT_CONFIG_OPERATIONS.READ);
@@ -172,12 +179,17 @@ export function getConfigDefaultAccount() {
 export function getConfigDefaultAccountIfExists() {
     const { accounts, defaultAccount } = getConfig();
     let defaultAccountToUse = defaultAccount;
-    // Only check for default account override if we're using the global config
-    const currentConfigPath = getConfigFilePath();
-    const globalConfigPath = getGlobalConfigFilePath();
-    if (currentConfigPath === globalConfigPath && globalConfigFileExists()) {
-        const defaultAccountOverrideAccountId = getDefaultAccountOverrideAccountId(accounts);
-        defaultAccountToUse = defaultAccountOverrideAccountId || defaultAccount;
+    const hsSettingsFile = getHsSettingsFileIfExists();
+    if (hsSettingsFile && hsSettingsFile.localDefaultAccount) {
+        defaultAccountToUse = hsSettingsFile.localDefaultAccount;
+    }
+    else {
+        const currentConfigPath = getConfigFilePath();
+        const globalConfigPath = getGlobalConfigFilePath();
+        if (currentConfigPath === globalConfigPath && globalConfigFileExists()) {
+            const defaultAccountOverrideAccountId = getDefaultAccountOverrideAccountId(accounts);
+            defaultAccountToUse = defaultAccountOverrideAccountId || defaultAccount;
+        }
     }
     if (!defaultAccountToUse) {
         return;
@@ -189,6 +201,14 @@ export function getAllConfigAccounts() {
     const { accounts } = getConfig();
     return accounts;
 }
+export function getLinkedOrAllConfigAccounts() {
+    const { accounts } = getConfig();
+    const hsSettingsFile = getHsSettingsFileIfExists();
+    if (!hsSettingsFile || hsSettingsFile.accounts.length === 0) {
+        return accounts;
+    }
+    return accounts.filter(a => hsSettingsFile.accounts.includes(a.accountId));
+}
 export function getConfigAccountEnvironment(identifier) {
     const config = getConfig();
     const account = getConfigAccountByInferredIdentifier(config.accounts, identifier);

package/config/state.js

@@ -7,6 +7,7 @@ import { STATE_FLAGS } from '../constants/config.js';
 const i18nKey = 'config.state';
 const DEFAULT_STATE = {
     [STATE_FLAGS.MCP_TOTAL_TOOL_CALLS]: 0,
+    [STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION]: undefined,
 };
 function ensureCLIDirectory() {
     try {
@@ -21,19 +22,16 @@ function ensureCLIDirectory() {
         }));
     }
 }
-function sanitizeAndMerge(parsed) {
+function parseState(parsed) {
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
         return structuredClone(DEFAULT_STATE);
     }
-    const state = parsed;
+    const record = parsed;
     const result = structuredClone(DEFAULT_STATE);
-    for (const key in DEFAULT_STATE) {
-        const typedKey = key;
-        if (key in state &&
-            typeof state[typedKey] === typeof DEFAULT_STATE[typedKey]) {
-            result[typedKey] = state[typedKey];
+    for (const key of Object.keys(DEFAULT_STATE)) {
+        if (key in record && record[key] !== undefined) {
+            Object.assign(result, { [key]: record[key] });
         }
-        // keys not in parsed file remain as DEFAULT values
     }
     return result;
 }
@@ -48,7 +46,7 @@ function getCurrentState() {
             return structuredClone(DEFAULT_STATE);
         }
         const parsed = JSON.parse(data);
-        return sanitizeAndMerge(parsed);
+        return parseState(parsed);
     }
     catch (error) {
         logger.debug(i18n(`${i18nKey}.getCurrentState.errors.errorReading`, {

package/constants/config.d.ts

@@ -56,6 +56,7 @@ export declare const HUBSPOT_ACCOUNT_TYPE_STRINGS: {
 };
 export declare const STATE_FLAGS: {
     readonly MCP_TOTAL_TOOL_CALLS: "mcpTotalToolCalls";
+    readonly USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION: "usageTrackingMessageLastShowVersion";
 };
 export declare const CONFIG_FLAGS: {
     readonly DEFAULT_CMS_PUBLISH_MODE: "defaultCmsPublishMode";
@@ -102,3 +103,11 @@ export declare const HUBSPOT_CONFIG_OPERATIONS: {
     readonly WRITE: "WRITE";
     readonly DELETE: "DELETE";
 };
+export declare const HS_FOLDER = ".hs";
+export declare const HS_SETTINGS_FILENAME = "settings.json";
+export declare const HS_README_FILENAME = "README.txt";
+export declare const DEFAULT_HS_SETTINGS_PATH = ".hs/settings.json";
+export declare const EMPTY_HS_SETTINGS_FILE: {
+    localDefaultAccount: undefined;
+    accounts: never[];
+};

package/constants/config.js

@@ -59,6 +59,7 @@ export const HUBSPOT_ACCOUNT_TYPE_STRINGS = {
 };
 export const STATE_FLAGS = {
     MCP_TOTAL_TOOL_CALLS: 'mcpTotalToolCalls',
+    USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION: 'usageTrackingMessageLastShowVersion',
 };
 export const CONFIG_FLAGS = {
     DEFAULT_CMS_PUBLISH_MODE: 'defaultCmsPublishMode',
@@ -105,3 +106,11 @@ export const HUBSPOT_CONFIG_OPERATIONS = {
     WRITE: 'WRITE',
     DELETE: 'DELETE',
 };
+export const HS_FOLDER = '.hs';
+export const HS_SETTINGS_FILENAME = 'settings.json';
+export const HS_README_FILENAME = 'README.txt';
+export const DEFAULT_HS_SETTINGS_PATH = `${HS_FOLDER}/${HS_SETTINGS_FILENAME}`;
+export const EMPTY_HS_SETTINGS_FILE = {
+    localDefaultAccount: undefined,
+    accounts: [],
+};

package/constants/ports.js

@@ -1,3 +1,5 @@
 export const MIN_PORT_NUMBER = 1024;
 export const MAX_PORT_NUMBER = 65535;
+// TODO: rename to PORT_MANAGER_SERVER_DEFAULT_PORT and update value to 4828
+// on the next major version of @hubspot/local-dev-lib
 export const PORT_MANAGER_SERVER_PORT = 8080;

package/constants/projects.d.ts

@@ -10,5 +10,6 @@ export declare const PLATFORM_VERSIONS: {
     v2025_2: string;
     v2026_03_beta: string;
     v2026_03: string;
+    v2026_09_beta: string;
     unstable: string;
 };

package/constants/projects.js

@@ -10,5 +10,6 @@ export const PLATFORM_VERSIONS = {
     v2025_2: '2025.2',
     v2026_03_beta: '2026.03-beta',
     v2026_03: '2026.03',
+    v2026_09_beta: '2026.09-beta',
     unstable: 'unstable',
 };

package/lib/cms/functions.js

@@ -19,7 +19,7 @@ export function createEndpoint(endpointMethod, filename) {
 }
 export function createConfig({ endpointPath, endpointMethod, functionFile, }) {
     return {
-        runtime: 'nodejs18.x',
+        runtime: 'nodejs20.x',
         version: '1.0',
         environment: {},
         secrets: [],

package/lib/github.js

@@ -96,7 +96,7 @@ export async function fetchGitHubRepoContentFromDownloadUrl(dest, downloadUrl) {
     const resp = await fetchRepoFileByDownloadUrl(downloadUrl);
     const contentType = resp.headers['content-type'];
     let fileContents;
-    if (contentType.startsWith('text')) {
+    if (typeof contentType === 'string' && contentType.startsWith('text')) {
         fileContents = Buffer.from(resp.data).toString('utf8');
     }
     else {

package/lib/gitignore.d.ts

@@ -1,3 +1,4 @@
 import { GitInclusionResult } from '../types/Config.js';
 export declare function checkAndAddConfigToGitignore(configPath: string): void;
+export declare function checkAndAddHsFolderToGitignore(settingsPath: string): void;
 export declare function checkGitInclusion(configPath: string): GitInclusionResult;

package/lib/gitignore.js

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import { isConfigPathInGitRepo, getGitignoreFiles, configFilenameIsIgnoredByGitignore, } from '../utils/git.js';
-import { DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME } from '../constants/config.js';
+import { DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME, HS_FOLDER, } from '../constants/config.js';
 import { i18n } from '../utils/lang.js';
 const i18nKey = 'lib.gitignore';
 const GITIGNORE_FILE = '.gitignore';
@@ -23,6 +23,27 @@ export function checkAndAddConfigToGitignore(configPath) {
         throw new Error(i18n(`${i18nKey}.errors.configIgnore`), { cause: e });
     }
 }
+export function checkAndAddHsFolderToGitignore(settingsPath) {
+    try {
+        const hsDirPath = path.resolve(path.dirname(settingsPath));
+        const { configIgnored, gitignoreFiles } = checkGitInclusion(hsDirPath);
+        if (configIgnored)
+            return;
+        let gitignoreFilePath = gitignoreFiles && gitignoreFiles.length ? gitignoreFiles[0] : null;
+        if (!gitignoreFilePath) {
+            gitignoreFilePath = path.join(path.dirname(hsDirPath), GITIGNORE_FILE);
+            fs.writeFileSync(gitignoreFilePath, '');
+        }
+        const gitignoreContents = fs.readFileSync(gitignoreFilePath).toString();
+        if (gitignoreContents.includes(HS_FOLDER))
+            return;
+        const updatedContents = `${gitignoreContents.trim()}\n\n# HubSpot link folder\n${HS_FOLDER}\n`;
+        fs.writeFileSync(gitignoreFilePath, updatedContents);
+    }
+    catch (e) {
+        throw new Error(i18n(`${i18nKey}.errors.configIgnore`), { cause: e });
+    }
+}
 export function checkGitInclusion(configPath) {
     const result = {
         inGit: false,

package/lib/portManager.d.ts

@@ -1,8 +1,8 @@
 import { RequestPortsData, ServerPortMap } from '../types/PortManager.js';
-export declare const BASE_URL = "http://localhost:8080";
+export declare function isPortAvailable(port: number): Promise<boolean>;
 export declare function isPortManagerPortAvailable(): Promise<boolean>;
 export declare function isPortManagerServerRunning(): Promise<boolean>;
-export declare function startPortManagerServer(): Promise<void>;
+export declare function startPortManagerServer(port?: number): Promise<void>;
 export declare function stopPortManagerServer(): Promise<void>;
 export declare function requestPorts(portData: Array<RequestPortsData>): Promise<{
     [instanceId: string]: number;

package/lib/portManager.js

@@ -1,14 +1,16 @@
 import axios from 'axios';
 import { HEALTH_CHECK_PATH, PortManagerServer, SERVICE_HEALTHY, } from '../utils/PortManagerServer.js';
-import { PORT_MANAGER_SERVER_PORT } from '../constants/ports.js';
+import { detectPort } from '../utils/detectPort.js';
 import { logger } from './logger.js';
-export const BASE_URL = `http://localhost:${PORT_MANAGER_SERVER_PORT}`;
+export async function isPortAvailable(port) {
+    return (await detectPort(port)) === port;
+}
 export async function isPortManagerPortAvailable() {
     return PortManagerServer.portAvailable();
 }
 export async function isPortManagerServerRunning() {
     try {
-        const { data } = await axios.get(`${BASE_URL}${HEALTH_CHECK_PATH}`);
+        const { data } = await axios.get(`${PortManagerServer.baseUrl}${HEALTH_CHECK_PATH}`);
         return data.status === SERVICE_HEALTHY;
     }
     catch (e) {
@@ -16,36 +18,36 @@ export async function isPortManagerServerRunning() {
         return false;
     }
 }
-export async function startPortManagerServer() {
+export async function startPortManagerServer(port) {
     const isRunning = await isPortManagerServerRunning();
     if (!isRunning) {
-        await PortManagerServer.init();
+        await PortManagerServer.init(port);
     }
 }
 export async function stopPortManagerServer() {
     const isRunning = await isPortManagerServerRunning();
     if (isRunning) {
-        await axios.post(`${BASE_URL}/close`);
+        await axios.post(`${PortManagerServer.baseUrl}/close`);
     }
 }
 export async function requestPorts(portData) {
-    const { data } = await axios.post(`${BASE_URL}/servers`, {
+    const { data } = await axios.post(`${PortManagerServer.baseUrl}/servers`, {
         portData: portData,
     });
     return data.ports;
 }
 export async function getActiveServers() {
-    const { data } = await axios.get(`${BASE_URL}/servers`);
+    const { data } = await axios.get(`${PortManagerServer.baseUrl}/servers`);
     return data.servers;
 }
 export async function getServerPortByInstanceId(serverInstanceId) {
-    const { data } = await axios.get(`${BASE_URL}/servers/${serverInstanceId}`);
+    const { data } = await axios.get(`${PortManagerServer.baseUrl}/servers/${serverInstanceId}`);
     return data.port;
 }
 export async function deleteServerInstance(serverInstanceId) {
-    await axios.delete(`${BASE_URL}/servers/${serverInstanceId}`);
+    await axios.delete(`${PortManagerServer.baseUrl}/servers/${serverInstanceId}`);
 }
 export async function portManagerHasActiveServers() {
-    const { data } = await axios.get(`${BASE_URL}/servers`);
+    const { data } = await axios.get(`${PortManagerServer.baseUrl}/servers`);
     return data.count > 0;
 }

package/models/HubSpotHttpError.js

@@ -101,7 +101,13 @@ export class HubSpotHttpError extends Error {
             return;
         }
         generatedContext.accountId = cause.config?.params?.portalId;
-        generatedContext.payload = JSON.stringify(cause.config?.data);
+        // Axios serializes request bodies before the error fires, so `config.data`
+        // is often already a JSON string. Avoid re-stringifying so debug output is
+        // readable instead of escape-soup.
+        generatedContext.payload =
+            typeof cause.config?.data === 'string'
+                ? cause.config.data
+                : JSON.stringify(cause.config?.data);
         // This will just be the url path
         generatedContext.request = cause.config?.url;
         // Allow the provided context to override the generated context

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/local-dev-lib",
-    "version": "0.7.7-experimental.0",
+    "version": "0.7.9-experimental.0",
     "type": "module",
     "description": "Provides library functionality for HubSpot local development tooling, including the HubSpot CLI",
     "files": [
@@ -59,6 +59,7 @@
         "./config/defaultAccountOverride": "./config/defaultAccountOverride.js",
         "./config/migrate": "./config/migrate.js",
         "./config/state": "./config/state.js",
+        "./config/hsSettings": "./config/hsSettings.js",
         "./config": "./config/index.js",
         "./constants/*": "./constants/*.js",
         "./enums/*": "./enums/*.js",
@@ -70,13 +71,13 @@
     },
     "dependencies": {
         "address": "2.0.2",
-        "axios": "1.12.0",
+        "axios": "1.15.2",
         "chalk": "5.6.2",
         "chokidar": "3.6.0",
         "content-disposition": "0.5.4",
         "cors": "2.8.5",
         "debounce": "1.2.1",
-        "express": "4.21.2",
+        "express": "4.22.1",
         "extract-zip": "2.0.1",
         "findup-sync": "5.0.0",
         "form-data": "^4.0.4",

package/types/Config.d.ts

@@ -1,4 +1,4 @@
-import { CONFIG_FLAGS, HUBSPOT_CONFIG_ERROR_TYPES, HUBSPOT_CONFIG_OPERATIONS } from '../constants/config.js';
+import { CONFIG_FLAGS, HUBSPOT_CONFIG_ERROR_TYPES, HUBSPOT_CONFIG_OPERATIONS, STATE_FLAGS } from '../constants/config.js';
 import { DeprecatedHubSpotConfigAccountFields, Environment, HubSpotConfigAccount } from './Accounts.js';
 import { CmsPublishMode } from './Files.js';
 import { ValueOf } from './Utils.js';
@@ -28,7 +28,8 @@ export type GitInclusionResult = {
 };
 export type ConfigFlag = ValueOf<typeof CONFIG_FLAGS>;
 export type HubSpotState = {
-    mcpTotalToolCalls: number;
+    [STATE_FLAGS.MCP_TOTAL_TOOL_CALLS]: number;
+    [STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION]?: string;
 };
 export type HubSpotConfigErrorType = ValueOf<typeof HUBSPOT_CONFIG_ERROR_TYPES>;
 export type HubSpotConfigOperation = ValueOf<typeof HUBSPOT_CONFIG_OPERATIONS>;

package/types/Config.js

@@ -1 +1 @@
-export {};
+import { STATE_FLAGS, } from '../constants/config.js';

package/types/HsSettings.d.ts

@@ -0,0 +1,4 @@
+export type HsSettingsFile = {
+    localDefaultAccount: number | undefined;
+    accounts: number[];
+};

package/types/HsSettings.js

@@ -0,0 +1 @@
+export {};

package/types/Project.d.ts

@@ -1,6 +1,8 @@
 import type { Build } from './Build.js';
 import { GithubSourceData } from './Github.js';
 import { ProjectLog } from './ProjectLog.js';
+import { ValueOf } from './Utils.js';
+import { SUBBUILD_TYPES } from '../enums/build.js';
 export type Project = {
     createdAt: number;
     deletedAt: number;
@@ -48,3 +50,31 @@ export type FetchPlatformVersionResponse = {
 export type WarnLogsResponse = {
     logs: Array<ProjectLog>;
 };
+export type Release = {
+    releaseTag: string;
+    buildId: number;
+    createdAt: string;
+    components?: Array<{
+        buildType: ValueOf<typeof SUBBUILD_TYPES>;
+        buildName?: string;
+        rootPath?: string;
+        id?: string;
+    }>;
+};
+export type FetchListReleasesResponse = {
+    results: Array<Release>;
+    paging: {
+        next: {
+            after: string;
+        };
+    };
+};
+export type AutoReleaseResponse = {
+    releaseTag: string;
+    status: string;
+    appId: number;
+};
+export type AutoReleaseStatusResponse = {
+    status: 'PENDING' | 'COMPLETE';
+    currentReleaseTag?: string;
+};

package/utils/PortManagerServer.d.ts

@@ -1,14 +1,13 @@
-import { Express } from 'express';
-import { Server } from 'http';
-import { ServerPortMap } from '../types/PortManager.js';
 export declare const HEALTH_CHECK_PATH = "/port-manager-health-check";
 export declare const SERVICE_HEALTHY = "OK";
 declare class _PortManagerServer {
-    app?: Express;
-    server?: Server;
-    serverPortMap: ServerPortMap;
+    private app?;
+    private server?;
+    private serverPortMap;
+    private port;
     constructor();
-    init(): Promise<void>;
+    get baseUrl(): string;
+    init(port?: number): Promise<void>;
     private reset;
     portAvailable(): Promise<boolean>;
     private listen;

package/utils/PortManagerServer.js

@@ -11,13 +11,21 @@ class _PortManagerServer {
     app;
     server;
     serverPortMap;
+    port;
     constructor() {
         this.serverPortMap = {};
+        this.port = PORT_MANAGER_SERVER_PORT;
     }
-    async init() {
+    get baseUrl() {
+        return `http://localhost:${this.port}`;
+    }
+    async init(port) {
+        if (port) {
+            this.port = port;
+        }
         if (!(await this.portAvailable())) {
             throw new Error(i18n(`${i18nKey}.errors.portInUse`, {
-                port: PORT_MANAGER_SERVER_PORT,
+                port: this.port,
             }));
         }
         if (this.app) {
@@ -34,15 +42,16 @@ class _PortManagerServer {
         this.app = undefined;
         this.server = undefined;
         this.serverPortMap = {};
+        this.port = PORT_MANAGER_SERVER_PORT;
     }
     async portAvailable() {
-        return ((await detectPort(PORT_MANAGER_SERVER_PORT)) === PORT_MANAGER_SERVER_PORT);
+        return (await detectPort(this.port)) === this.port;
     }
     listen() {
         return new Promise((resolve, reject) => {
-            const server = this.app.listen(PORT_MANAGER_SERVER_PORT, () => {
+            const server = this.app.listen(this.port, () => {
                 logger.debug(i18n(`${i18nKey}.started`, {
-                    port: PORT_MANAGER_SERVER_PORT,
+                    port: this.port,
                 }));
                 resolve(server);
             }).on('error', (err) => {