@hubspot/local-dev-lib 5.4.0 → 5.5.0

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/portManager.d.ts

@@ -1,8 +1,7 @@
 import { RequestPortsData, ServerPortMap } from '../types/PortManager.js';
-export declare const BASE_URL = "http://localhost:8080";
 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,12 @@
 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 { logger } from './logger.js';
-export const BASE_URL = `http://localhost:${PORT_MANAGER_SERVER_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 +14,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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/local-dev-lib",
-    "version": "5.4.0",
+    "version": "5.5.0",
     "type": "module",
     "description": "Provides library functionality for HubSpot local development tooling, including the HubSpot CLI",
     "files": [

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) => {