@hubspot/local-dev-lib 5.8.2-beta.0 → 5.9.0-beta.0

package/api/appsDev.d.ts

@@ -5,5 +5,6 @@ export declare function fetchPublicAppDeveloperTestAccountInstallData(appId: num
 export declare function fetchPublicAppProductionInstallCounts(appId: number, accountId: number): HubSpotPromise<PublicAppInstallCounts>;
 export declare function fetchPublicAppMetadata(appId: number, accountId: number): HubSpotPromise<PublicApp>;
 export declare function installStaticAuthAppOnTestAccount(appId: number, accountId: number, scopeGroupIds: number[]): HubSpotPromise<void>;
+export declare function installStaticAuthAppOnCurrentAccount(appId: number, accountId: number, scopeGroupIds: number[]): HubSpotPromise<void>;
 export declare function fetchAppMetadataByUid(appUid: string, accountId: number): HubSpotPromise<PublicApp>;
 export declare function fetchAppMetadataBySourceId(projectId: number, appUid: string, accountId: number): HubSpotPromise<PublicApp>;

package/api/appsDev.js

@@ -31,6 +31,16 @@ export function installStaticAuthAppOnTestAccount(appId, accountId, scopeGroupId
         },
     });
 }
+export function installStaticAuthAppOnCurrentAccount(appId, accountId, scopeGroupIds) {
+    return http.post(accountId, {
+        url: `${APPS_HUBLETS_API_PATH}/current-account`,
+        data: {
+            appId,
+            targetInstallPortalId: accountId,
+            scopeGroupIds,
+        },
+    });
+}
 export function fetchAppMetadataByUid(appUid, accountId) {
     return http.get(accountId, {
         url: `${APPS_DEV_API_PATH}/full/portal/sourceId`,

package/api/developerTestAccounts.js

@@ -5,6 +5,7 @@ const TEST_ACCOUNTS_API_PATH_V3 = 'integrators/test-portals/v3';
 export function fetchDeveloperTestAccounts(accountId) {
     return http.get(accountId, {
         url: TEST_ACCOUNTS_API_PATH,
+        timeout: SANDBOX_TIMEOUT,
     });
 }
 export function createDeveloperTestAccount(accountId, accountInfo) {

package/api/fileMapper.d.ts

@@ -1,5 +1,5 @@
 import { AxiosResponse } from 'axios';
-import { FileMapperNode, FileMapperOptions, FileTree } from '../types/Files.js';
+import { DirectoryMetaNode, FileMapperNode, FileMapperOptions, FileTree } from '../types/Files.js';
 import { HubSpotPromise } from '../types/Http.js';
 export declare function createFileMapperNodeFromStreamResponse(filePath: string, response: Partial<AxiosResponse>): FileMapperNode;
 export declare function upload(accountId: number, src: string, dest: string, options?: FileMapperOptions): HubSpotPromise<void>;
@@ -10,3 +10,4 @@ export declare function downloadDefault(accountId: number, filepath: string, opt
 export declare function deleteFile(accountId: number, filePath: string): HubSpotPromise<void>;
 export declare function moveFile(accountId: number, srcPath: string, destPath: string): HubSpotPromise<void>;
 export declare function getDirectoryContentsByPath(accountId: number, path: string): HubSpotPromise<FileMapperNode>;
+export declare function getDirectoryMetaByPath(accountId: number, path: string, options?: FileMapperOptions): HubSpotPromise<DirectoryMetaNode>;

package/api/fileMapper.js

@@ -89,3 +89,10 @@ export function getDirectoryContentsByPath(accountId, path) {
         url: `${FILE_MAPPER_API_PATH}/meta/${path}`,
     });
 }
+// getDirectoryContentsByPath has the wrong return type for /meta/ — children are strings, not FileMapperNodes
+export function getDirectoryMetaByPath(accountId, path, options = {}) {
+    return http.get(accountId, {
+        url: `${FILE_MAPPER_API_PATH}/meta/${path.split('/').map(encodeURIComponent).join('/')}`,
+        ...options,
+    });
+}

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.MCP_PROMOTION_LAST_SHOWN_AT]: undefined,
     [STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION]: undefined,
 };
 function ensureCLIDirectory() {

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 MCP_PROMOTION_LAST_SHOWN_AT: "mcpPromotionLastShownAt";
     readonly USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION: "usageTrackingMessageLastShowVersion";
 };
 export declare const CONFIG_FLAGS: {

package/constants/config.js

@@ -59,6 +59,7 @@ export const HUBSPOT_ACCOUNT_TYPE_STRINGS = {
 };
 export const STATE_FLAGS = {
     MCP_TOTAL_TOOL_CALLS: 'mcpTotalToolCalls',
+    MCP_PROMOTION_LAST_SHOWN_AT: 'mcpPromotionLastShownAt',
     USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION: 'usageTrackingMessageLastShowVersion',
 };
 export const CONFIG_FLAGS = {

package/lib/fileMapper.d.ts

@@ -3,10 +3,15 @@ export declare function isPathToFile(filepath: string): boolean;
 export declare function isPathToModule(filepath: string): boolean;
 export declare function isPathToRoot(filepath: string): boolean;
 export declare function isPathToHubspot(filepath: string): boolean;
-export declare function getFileMapperQueryValues(cmsPublishMode?: CmsPublishMode | null, { staging, assetVersion }?: FileMapperInputOptions): FileMapperOptions;
+export declare function getFileMapperQueryValues(cmsPublishMode?: CmsPublishMode | null, { staging, assetVersion, timeout }?: FileMapperInputOptions): FileMapperOptions;
 export declare function getTypeDataFromPath(src: string): PathTypeData;
 export declare function recurseFolder(node: FileMapperNode, callback: RecursiveFileMapperCallback, filepath?: string, depth?: number): boolean;
 export declare function writeUtimes(accountId: number, filepath: string, node: FileMapperNode): Promise<void>;
+/**
+ * @deprecated Use downloadFileOrFolder instead. This function fetches the
+ * entire directory tree in a single request, which times out for large
+ * directories.
+ */
 export declare function fetchFolderFromApi(accountId: number, src: string, cmsPublishMode?: CmsPublishMode, options?: FileMapperInputOptions): Promise<FileMapperNode>;
 /**
  * Fetch a file/folder and write to local file system.

package/lib/fileMapper.js

@@ -4,16 +4,13 @@ import path from 'path';
 import PQueue from 'p-queue';
 import { getCwd, getExt, convertToLocalFileSystemPath, isAllowedExtension, } from './path.js';
 import { logger } from './logger.js';
-import { fetchFileStream, download, downloadDefault, } from '../api/fileMapper.js';
+import { fetchFileStream, download, downloadDefault, getDirectoryMetaByPath, } from '../api/fileMapper.js';
 import { MODULE_EXTENSION, FUNCTIONS_EXTENSION, JSR_ALLOWED_EXTENSIONS, } from '../constants/extensions.js';
 import { CMS_PUBLISH_MODE } from '../constants/files.js';
 import { isTimeoutError } from '../errors/index.js';
 import { i18n } from '../utils/lang.js';
 import { FileSystemError } from '../models/FileSystemError.js';
 const i18nKey = 'lib.fileMapper';
-const queue = new PQueue({
-    concurrency: 10,
-});
 export function isPathToFile(filepath) {
     const ext = getExt(filepath);
     return !!ext && ext !== MODULE_EXTENSION && ext !== FUNCTIONS_EXTENSION;
@@ -37,13 +34,14 @@ function useApiBuffer(cmsPublishMode) {
     return cmsPublishMode === CMS_PUBLISH_MODE.draft;
 }
 // Determines API param based on publish mode and options
-export function getFileMapperQueryValues(cmsPublishMode, { staging, assetVersion } = {}) {
+export function getFileMapperQueryValues(cmsPublishMode, { staging, assetVersion, timeout } = {}) {
     return {
         params: {
             buffer: useApiBuffer(cmsPublishMode),
             environmentId: staging ? 2 : 1,
             version: assetVersion,
         },
+        ...(timeout !== undefined && { timeout }),
     };
 }
 // Determines version number to log based on input.options
@@ -141,40 +139,6 @@ async function fetchAndWriteFileStream(accountId, srcPath, filepath, cmsPublishM
     const node = await fetchFileStream(accountId, srcPath, filepath, getFileMapperQueryValues(cmsPublishMode, options));
     await writeUtimes(accountId, filepath, node);
 }
-// Writes an individual file or folder (not recursive).  If file source is missing, the
-//file is fetched.
-async function writeFileMapperNode(accountId, filepath, node, cmsPublishMode, options = {}) {
-    const localFilepath = convertToLocalFileSystemPath(path.resolve(filepath));
-    if (await skipExisting(localFilepath, options.overwrite)) {
-        logger.log(i18n(`${i18nKey}.skippedExisting`, {
-            filepath: localFilepath,
-        }));
-        return true;
-    }
-    if (!node.folder) {
-        try {
-            await fetchAndWriteFileStream(accountId, node.path, localFilepath, cmsPublishMode, options);
-            return true;
-        }
-        catch (err) {
-            return false;
-        }
-    }
-    try {
-        await fs.ensureDir(localFilepath);
-        logger.log(i18n(`${i18nKey}.wroteFolder`, {
-            filepath: localFilepath,
-        }));
-    }
-    catch (err) {
-        throw new FileSystemError({ cause: err }, {
-            filepath: localFilepath,
-            accountId,
-            operation: 'write',
-        });
-    }
-    return true;
-}
 async function downloadFile(accountId, src, destPath, cmsPublishMode, options = {}) {
     const { isFile, isHubspot } = getTypeDataFromPath(src);
     if (!isFile) {
@@ -201,7 +165,6 @@ async function downloadFile(accountId, src, destPath, cmsPublishMode, options =
         }
         const localFsPath = convertToLocalFileSystemPath(filepath);
         await fetchAndWriteFileStream(accountId, src, localFsPath, cmsPublishMode, options);
-        await queue.onIdle();
         logger.success(i18n(`${i18nKey}.completedFetch`, {
             src,
             version: getAssetVersionIdentifier(options.assetVersion, src),
@@ -218,6 +181,11 @@ async function downloadFile(accountId, src, destPath, cmsPublishMode, options =
         }
     }
 }
+/**
+ * @deprecated Use downloadFileOrFolder instead. This function fetches the
+ * entire directory tree in a single request, which times out for large
+ * directories.
+ */
 export async function fetchFolderFromApi(accountId, src, cmsPublishMode, options = {}) {
     const { isRoot, isFolder, isHubspot } = getTypeDataFromPath(src);
     if (!isFolder) {
@@ -233,44 +201,82 @@ export async function fetchFolderFromApi(accountId, src, cmsPublishMode, options
     logger.log(i18n(`${i18nKey}.folderFetch`, { src, accountId }));
     return node;
 }
+async function queueFolderTree(accountId, src, localPath, directoryNode, ctx) {
+    const { cmsPublishMode, options, failedPaths, queue } = ctx;
+    if (!directoryNode.folder)
+        return;
+    const { isRoot } = getTypeDataFromPath(src);
+    let children = directoryNode.children || [];
+    if (isRoot) {
+        children = ['@hubspot', ...children];
+    }
+    try {
+        await fs.ensureDir(localPath);
+    }
+    catch (err) {
+        throw new FileSystemError({ cause: err }, { filepath: localPath, accountId, operation: 'write' });
+    }
+    logger.log(i18n(`${i18nKey}.wroteFolder`, { filepath: localPath }));
+    const queryValues = getFileMapperQueryValues(cmsPublishMode, options);
+    const queueFileDownload = (remotePath, destPath) => {
+        queue.add(async () => {
+            try {
+                await fetchAndWriteFileStream(accountId, remotePath, destPath, cmsPublishMode, options);
+            }
+            catch (err) {
+                failedPaths.add(remotePath);
+                logger.debug(i18n(`${i18nKey}.errors.failedToFetchFile`, {
+                    src: remotePath,
+                    dest: destPath,
+                }));
+            }
+        });
+    };
+    for (const childName of children) {
+        const childRemotePath = isRoot ? childName : `${src}/${childName}`;
+        const childLocalPath = convertToLocalFileSystemPath(path.join(localPath, childName));
+        if (isAllowedExtension(childRemotePath, [...JSR_ALLOWED_EXTENSIONS])) {
+            queueFileDownload(childRemotePath, childLocalPath);
+        }
+        else {
+            const { data: childNode } = await getDirectoryMetaByPath(accountId, childRemotePath, queryValues);
+            if (childNode) {
+                if (childNode.folder) {
+                    await queueFolderTree(accountId, childRemotePath, childLocalPath, childNode, ctx);
+                }
+                else {
+                    queueFileDownload(childRemotePath, childLocalPath);
+                }
+            }
+        }
+    }
+}
 async function downloadFolder(accountId, src, destPath, cmsPublishMode, options = {}) {
+    src = src.length > 1 ? src.replace(/\/+$/, '') : src;
+    const dest = path.resolve(destPath);
+    const { isRoot } = getTypeDataFromPath(src);
+    const metaPath = isRoot ? '/' : src;
+    const queryValues = getFileMapperQueryValues(cmsPublishMode, options);
+    const failedPaths = new Set();
+    const queue = new PQueue({ concurrency: 10 });
     try {
-        const node = await fetchFolderFromApi(accountId, src, cmsPublishMode, options);
-        if (!node) {
+        const { data: rootMeta } = await getDirectoryMetaByPath(accountId, metaPath, queryValues);
+        if (!rootMeta)
             return;
-        }
-        const dest = path.resolve(destPath);
+        logger.log(i18n(`${i18nKey}.folderFetch`, { src, accountId }));
         const rootPath = dest === getCwd()
-            ? convertToLocalFileSystemPath(path.resolve(dest, node.name))
+            ? convertToLocalFileSystemPath(path.resolve(dest, rootMeta.name || path.basename(src)))
             : dest;
-        let success = true;
-        recurseFolder(node, (childNode, filepath) => {
-            queue.add(async () => {
-                const succeeded = await writeFileMapperNode(accountId, filepath || '', childNode, cmsPublishMode, options);
-                if (succeeded === false) {
-                    success = false;
-                    logger.debug(i18n(`${i18nKey}.errors.failedToFetchFile`, {
-                        src: childNode.path,
-                        dest: filepath || '',
-                    }));
-                }
-            });
-            return success;
-        }, rootPath);
+        await queueFolderTree(accountId, src, rootPath, rootMeta, {
+            cmsPublishMode,
+            options,
+            failedPaths,
+            queue,
+        });
         await queue.onIdle();
-        if (success) {
-            logger.success(i18n(`${i18nKey}.completedFolderFetch`, {
-                src,
-                version: getAssetVersionIdentifier(options.assetVersion, src),
-                dest,
-            }));
-        }
-        else {
-            // TODO: Fix this exception. It is triggering the catch block so this error is being rewritten
-            throw new Error(i18n(`${i18nKey}.errors.incompleteFetch`, { src }));
-        }
     }
     catch (err) {
+        queue.clear();
         const error = err;
         if (isTimeoutError(error)) {
             throw new Error(i18n(`${i18nKey}.errors.assetTimeout`), { cause: error });
@@ -279,6 +285,14 @@ async function downloadFolder(accountId, src, destPath, cmsPublishMode, options
             throw new Error(i18n(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }), { cause: err });
         }
     }
+    if (failedPaths.size > 0) {
+        throw new Error(i18n(`${i18nKey}.errors.incompleteFetch`, { src }));
+    }
+    logger.success(i18n(`${i18nKey}.completedFolderFetch`, {
+        src,
+        version: getAssetVersionIdentifier(options.assetVersion, src),
+        dest,
+    }));
 }
 /**
  * Fetch a file/folder and write to local file system.

package/package.json

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

package/types/Config.d.ts

@@ -29,6 +29,7 @@ export type GitInclusionResult = {
 export type ConfigFlag = ValueOf<typeof CONFIG_FLAGS>;
 export type HubSpotState = {
     [STATE_FLAGS.MCP_TOTAL_TOOL_CALLS]: number;
+    [STATE_FLAGS.MCP_PROMOTION_LAST_SHOWN_AT]?: string;
     [STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION]?: string;
 };
 export type HubSpotConfigErrorType = ValueOf<typeof HUBSPOT_CONFIG_ERROR_TYPES>;

package/types/Files.d.ts

@@ -18,6 +18,14 @@ export type FileMapperNode = {
     folder: boolean;
     children: Array<FileMapperNode>;
 };
+export type DirectoryMetaNode = {
+    name: string;
+    path: string;
+    folder: boolean;
+    children: Array<string>;
+    createdAt?: number;
+    updatedAt?: number;
+};
 export type CmsPublishMode = ValueOf<typeof CMS_PUBLISH_MODE>;
 export type FileMapperOptions = Omit<HttpOptions, 'url'>;
 export type FileMapperInputOptions = {