@hubspot/cli 7.7.35-experimental.0 → 7.8.1-experimental.0

package/lib/theme/__tests__/migrate.test.js

@@ -0,0 +1,233 @@
+import { getProjectThemeDetails, migrateThemes, } from '@hubspot/project-parsing-lib';
+import { confirmPrompt } from '../../prompts/promptUtils.js';
+import { writeProjectConfig, } from '../../projects/config.js';
+import { ensureProjectExists } from '../../projects/ensureProjectExists.js';
+import { useV3Api } from '../../projects/platformVersion.js';
+import { fetchMigrationApps } from '../../app/migrate.js';
+import { getHasMigratableThemes, validateMigrationAppsAndThemes, handleThemesMigration, migrateThemes2025_2, } from '../migrate.js';
+import { lib } from '../../../lang/en.js';
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('../../prompts/promptUtils');
+vi.mock('../../projects/config');
+vi.mock('../../projects/ensureProjectExists');
+vi.mock('../../projects/platformVersion');
+vi.mock('../../app/migrate');
+const mockedGetProjectThemeDetails = getProjectThemeDetails;
+const mockedMigrateThemes = migrateThemes;
+const mockedConfirmPrompt = confirmPrompt;
+const mockedWriteProjectConfig = writeProjectConfig;
+const mockedEnsureProjectExists = ensureProjectExists;
+const mockedUseV3Api = useV3Api;
+const mockedFetchMigrationApps = fetchMigrationApps;
+const ACCOUNT_ID = 123;
+const PROJECT_NAME = 'Test Project';
+const PLATFORM_VERSION = '2025.2';
+const MOCK_PROJECT_DIR = '/mock/project/dir';
+const createLoadedProjectConfig = (name) => ({
+    projectConfig: { name, srcDir: 'src', platformVersion: '2024.1' },
+    projectDir: MOCK_PROJECT_DIR,
+});
+describe('lib/theme/migrate', () => {
+    beforeEach(() => {
+        mockedUseV3Api.mockReturnValue(false);
+    });
+    describe('getHasMigratableThemes', () => {
+        it('should return false when no projectConfig is provided', async () => {
+            const result = await getHasMigratableThemes();
+            expect(result).toEqual({
+                hasMigratableThemes: false,
+                migratableThemesCount: 0,
+            });
+        });
+        it('should return false when projectConfig is missing required properties', async () => {
+            const invalidProjectConfig = {
+                projectConfig: { name: undefined, srcDir: 'src' },
+                projectDir: undefined,
+            };
+            const result = await getHasMigratableThemes(invalidProjectConfig);
+            expect(result).toEqual({
+                hasMigratableThemes: false,
+                migratableThemesCount: 0,
+            });
+        });
+        it('should return true when there are legacy themes', async () => {
+            mockedGetProjectThemeDetails.mockResolvedValue({
+                legacyThemeDetails: [
+                    {
+                        configFilepath: 'src/theme.json',
+                        themePath: 'src/theme',
+                        themeConfig: {
+                            secret_names: ['my-secret'],
+                        },
+                    },
+                ],
+                legacyReactThemeDetails: [],
+            });
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            const result = await getHasMigratableThemes(projectConfig);
+            expect(result).toEqual({
+                hasMigratableThemes: true,
+                migratableThemesCount: 1,
+            });
+        });
+        it('should return true when there are legacy React themes', async () => {
+            mockedGetProjectThemeDetails.mockResolvedValue({
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [
+                    {
+                        configFilepath: 'src/react-theme.json',
+                        themePath: 'src/react-theme',
+                        themeConfig: {
+                            secretNames: ['my-secret'],
+                        },
+                    },
+                ],
+            });
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            const result = await getHasMigratableThemes(projectConfig);
+            expect(result).toEqual({
+                hasMigratableThemes: true,
+                migratableThemesCount: 1,
+            });
+        });
+        it('should return true when there are both legacy and React themes', async () => {
+            mockedGetProjectThemeDetails.mockResolvedValue({
+                legacyThemeDetails: [
+                    {
+                        configFilepath: 'src/theme.json',
+                        themePath: 'src/theme',
+                        themeConfig: {
+                            secret_names: ['my-secret'],
+                        },
+                    },
+                ],
+                legacyReactThemeDetails: [
+                    {
+                        configFilepath: 'src/react-theme.json',
+                        themePath: 'src/react-theme',
+                        themeConfig: {
+                            secretNames: ['my-secret'],
+                        },
+                    },
+                ],
+            });
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            const result = await getHasMigratableThemes(projectConfig);
+            expect(result).toEqual({
+                hasMigratableThemes: true,
+                migratableThemesCount: 2,
+            });
+        });
+    });
+    describe('validateMigrationAppsAndThemes', () => {
+        it('should throw an error when themes are already migrated (v3 API)', async () => {
+            mockedUseV3Api.mockReturnValue(true);
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            await expect(validateMigrationAppsAndThemes(0, projectConfig)).rejects.toThrow(lib.migrate.errors.project.themesAlreadyMigrated);
+        });
+        it('should throw an error when apps and themes are both present', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            await expect(validateMigrationAppsAndThemes(1, projectConfig)).rejects.toThrow(lib.migrate.errors.project.themesAndAppsNotAllowed);
+        });
+        it('should throw an error when no project config is provided', async () => {
+            await expect(validateMigrationAppsAndThemes(0)).rejects.toThrow(lib.migrate.errors.project.noProjectForThemesMigration);
+        });
+        it('should not throw an error when validation passes', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            await expect(validateMigrationAppsAndThemes(0, projectConfig)).resolves.not.toThrow();
+        });
+    });
+    describe('handleThemesMigration', () => {
+        const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+        beforeEach(() => {
+            mockedMigrateThemes.mockResolvedValue({
+                migrated: true,
+                failureReason: undefined,
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [],
+            });
+            mockedWriteProjectConfig.mockReturnValue(true);
+        });
+        it('should throw an error when project config is invalid', async () => {
+            const invalidProjectConfig = {
+                projectConfig: { name: PROJECT_NAME, srcDir: undefined },
+                projectDir: undefined,
+            };
+            await expect(handleThemesMigration(invalidProjectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.invalidConfig);
+        });
+        it('should successfully migrate themes and update project config', async () => {
+            await handleThemesMigration(projectConfig, PLATFORM_VERSION);
+            expect(mockedMigrateThemes).toHaveBeenCalledWith(MOCK_PROJECT_DIR, `${MOCK_PROJECT_DIR}/src`);
+            expect(mockedWriteProjectConfig).toHaveBeenCalledWith(`${MOCK_PROJECT_DIR}/hsproject.json`, expect.objectContaining({
+                platformVersion: PLATFORM_VERSION,
+            }));
+        });
+        it('should throw an error when theme migration fails', async () => {
+            mockedMigrateThemes.mockResolvedValue({
+                migrated: false,
+                failureReason: 'Migration failed',
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [],
+            });
+            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow('Migration failed');
+        });
+        it('should throw an error when project config write fails', async () => {
+            mockedWriteProjectConfig.mockReturnValue(false);
+            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.failedToUpdateProjectConfig);
+        });
+        it('should throw an error when migrateThemes throws an exception', async () => {
+            mockedMigrateThemes.mockRejectedValue(new Error('Unexpected error'));
+            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.failedToMigrateThemes);
+        });
+    });
+    describe('migrateThemes2025_2', () => {
+        const options = {
+            platformVersion: PLATFORM_VERSION,
+        };
+        const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+        const themeCount = 2;
+        beforeEach(() => {
+            mockedEnsureProjectExists.mockResolvedValue({ projectExists: true });
+            mockedFetchMigrationApps.mockResolvedValue({
+                migratableApps: [],
+                unmigratableApps: [],
+            });
+            mockedConfirmPrompt.mockResolvedValue(true);
+            mockedMigrateThemes.mockResolvedValue({
+                migrated: true,
+                failureReason: undefined,
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [],
+            });
+            mockedWriteProjectConfig.mockReturnValue(true);
+        });
+        it('should throw an error when project config is invalid', async () => {
+            const invalidProjectConfig = {
+                projectConfig: undefined,
+                projectDir: MOCK_PROJECT_DIR,
+            };
+            await expect(migrateThemes2025_2(ACCOUNT_ID, options, themeCount, invalidProjectConfig)).rejects.toThrow(lib.migrate.errors.project.invalidConfig);
+        });
+        it('should throw an error when project does not exist', async () => {
+            mockedEnsureProjectExists.mockResolvedValue({ projectExists: false });
+            await expect(migrateThemes2025_2(ACCOUNT_ID, options, themeCount, projectConfig)).rejects.toThrow(lib.migrate.errors.project.doesNotExist(ACCOUNT_ID));
+        });
+        it('should proceed with migration when user confirms', async () => {
+            await migrateThemes2025_2(ACCOUNT_ID, options, themeCount, projectConfig);
+            expect(mockedFetchMigrationApps).toHaveBeenCalledWith(ACCOUNT_ID, PLATFORM_VERSION, projectConfig);
+            expect(mockedConfirmPrompt).toHaveBeenCalledWith(lib.migrate.prompt.proceed, { defaultAnswer: false });
+            expect(mockedMigrateThemes).toHaveBeenCalledWith(MOCK_PROJECT_DIR, `${MOCK_PROJECT_DIR}/src`);
+        });
+        it('should exit without migrating when user cancels', async () => {
+            mockedConfirmPrompt.mockResolvedValue(false);
+            await migrateThemes2025_2(ACCOUNT_ID, options, themeCount, projectConfig);
+            expect(mockedMigrateThemes).not.toHaveBeenCalled();
+        });
+        it('should validate migration apps and themes', async () => {
+            await migrateThemes2025_2(ACCOUNT_ID, options, themeCount, projectConfig);
+            // The validation is called internally, so we verify it through the error handling
+            expect(mockedFetchMigrationApps).toHaveBeenCalled();
+        });
+    });
+});

package/lib/theme/migrate.d.ts

@@ -0,0 +1,13 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { LoadedProjectConfig } from '../projects/config.js';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs.js';
+export type MigrateThemesArgs = CommonArgs & AccountArgs & EnvironmentArgs & ConfigArgs & {
+    platformVersion: string;
+};
+export declare function getHasMigratableThemes(projectConfig?: LoadedProjectConfig): Promise<{
+    hasMigratableThemes: boolean;
+    migratableThemesCount: number;
+}>;
+export declare function validateMigrationAppsAndThemes(hasApps: number, projectConfig?: LoadedProjectConfig): Promise<void>;
+export declare function handleThemesMigration(projectConfig: LoadedProjectConfig, platformVersion: string): Promise<void>;
+export declare function migrateThemes2025_2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateThemesArgs>, themeCount: number, projectConfig: LoadedProjectConfig): Promise<void>;

package/lib/theme/migrate.js

@@ -0,0 +1,90 @@
+import path from 'path';
+import { migrateThemes, getProjectThemeDetails, } from '@hubspot/project-parsing-lib';
+import { writeProjectConfig } from '../projects/config.js';
+import { ensureProjectExists } from '../projects/ensureProjectExists.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { lib } from '../../lang/en.js';
+import { PROJECT_CONFIG_FILE } from '../constants.js';
+import { uiLogger } from '../ui/logger.js';
+import { debugError } from '../errorHandlers/index.js';
+import { useV3Api } from '../projects/platformVersion.js';
+import { confirmPrompt } from '../prompts/promptUtils.js';
+import { fetchMigrationApps } from '../app/migrate.js';
+export async function getHasMigratableThemes(projectConfig) {
+    if (!projectConfig?.projectConfig?.name || !projectConfig?.projectDir) {
+        return { hasMigratableThemes: false, migratableThemesCount: 0 };
+    }
+    const projectSrcDir = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
+    const { legacyThemeDetails, legacyReactThemeDetails } = await getProjectThemeDetails(projectSrcDir);
+    return {
+        hasMigratableThemes: legacyThemeDetails.length > 0 || legacyReactThemeDetails.length > 0,
+        migratableThemesCount: legacyThemeDetails.length + legacyReactThemeDetails.length,
+    };
+}
+export async function validateMigrationAppsAndThemes(hasApps, projectConfig) {
+    if (useV3Api(projectConfig?.projectConfig?.platformVersion)) {
+        throw new Error(lib.migrate.errors.project.themesAlreadyMigrated);
+    }
+    if (hasApps > 0 && projectConfig) {
+        throw new Error(lib.migrate.errors.project.themesAndAppsNotAllowed);
+    }
+    if (!projectConfig) {
+        throw new Error(lib.migrate.errors.project.noProjectForThemesMigration);
+    }
+}
+export async function handleThemesMigration(projectConfig, platformVersion) {
+    if (!projectConfig?.projectDir || !projectConfig?.projectConfig?.srcDir) {
+        throw new Error(lib.migrate.errors.project.invalidConfig);
+    }
+    const projectSrcDir = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
+    let migrated = false;
+    let failureReason;
+    try {
+        const migrationResult = await migrateThemes(projectConfig.projectDir, projectSrcDir);
+        migrated = migrationResult.migrated;
+        failureReason = migrationResult.failureReason;
+    }
+    catch (error) {
+        debugError(error);
+        throw new Error(lib.migrate.errors.project.failedToMigrateThemes);
+    }
+    if (!migrated) {
+        throw new Error(failureReason || lib.migrate.errors.project.failedToMigrateThemes);
+    }
+    const newProjectConfig = { ...projectConfig.projectConfig };
+    newProjectConfig.platformVersion = platformVersion;
+    const projectConfigPath = path.join(projectConfig.projectDir, PROJECT_CONFIG_FILE);
+    const success = writeProjectConfig(projectConfigPath, newProjectConfig);
+    if (!success) {
+        throw new Error(lib.migrate.errors.project.failedToUpdateProjectConfig);
+    }
+    uiLogger.log('');
+    uiLogger.log(lib.migrate.success.themesMigrationSuccess(platformVersion));
+}
+export async function migrateThemes2025_2(derivedAccountId, options, themeCount, projectConfig) {
+    SpinniesManager.init();
+    if (!projectConfig?.projectConfig || !projectConfig?.projectDir) {
+        throw new Error(lib.migrate.errors.project.invalidConfig);
+    }
+    const { projectExists } = await ensureProjectExists(derivedAccountId, projectConfig.projectConfig.name, { allowCreate: false, noLogs: true });
+    if (!projectExists) {
+        throw new Error(lib.migrate.errors.project.doesNotExist(derivedAccountId));
+    }
+    SpinniesManager.add('checkingForMigratableComponents', {
+        text: lib.migrate.spinners.checkingForMigratableComponents,
+    });
+    const { migratableApps, unmigratableApps } = await fetchMigrationApps(derivedAccountId, options.platformVersion, projectConfig);
+    const hasApps = [...migratableApps, ...unmigratableApps].length;
+    SpinniesManager.remove('checkingForMigratableComponents');
+    await validateMigrationAppsAndThemes(hasApps, projectConfig);
+    uiLogger.log(lib.migrate.prompt.themesMigration(themeCount));
+    const proceed = await confirmPrompt(lib.migrate.prompt.proceed, {
+        defaultAnswer: false,
+    });
+    if (proceed) {
+        await handleThemesMigration(projectConfig, options.platformVersion);
+    }
+    else {
+        uiLogger.log(lib.migrate.exitWithoutMigrating);
+    }
+}

package/lib/usageTracking.js

@@ -44,7 +44,7 @@ export async function trackCommandUsage(command, meta = {}, accountId) {
         action: 'cli-command',
         command,
         authType,
-        ...meta,
+        meta,
         accountId,
     });
 }
@@ -133,12 +133,12 @@ async function trackCliInteraction({ action, accountId, command, authType, meta
             }
         }
         try {
+            logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
             return trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
         }
         catch (error) {
             debugError(error);
         }
-        logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
     }
     catch (e) {
         debugError(e);

package/mcp-server/tools/project/AddFeatureToProjectTool.d.ts

@@ -12,13 +12,13 @@ declare const inputSchemaZodObject: z.ZodObject<{
     addApp: boolean;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "page" | "settings" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
+    features?: ("card" | "settings" | "page" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
 }, {
     absoluteProjectPath: string;
     addApp: boolean;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "page" | "settings" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
+    features?: ("card" | "settings" | "page" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
 }>;
 export type AddFeatureInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class AddFeatureToProjectTool extends Tool<AddFeatureInputSchema> {

package/mcp-server/tools/project/CreateProjectTool.d.ts

@@ -16,7 +16,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     name?: string | undefined;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "page" | "settings" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
+    features?: ("card" | "settings" | "page" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
 }, {
     projectBase: "app" | "empty";
     absoluteCurrentWorkingDirectory: string;
@@ -24,7 +24,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
     name?: string | undefined;
     auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
-    features?: ("card" | "page" | "settings" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
+    features?: ("card" | "settings" | "page" | "app-event" | "workflow-action-tool" | "workflow-action" | "app-function" | "webhooks" | "app-object" | "scim")[] | undefined;
 }>;
 export type CreateProjectInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class CreateProjectTool extends Tool<CreateProjectInputSchema> {

package/mcp-server/tools/project/DocsSearchTool.d.ts

@@ -2,10 +2,13 @@ import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.
 import z from 'zod';
 import { TextContentResponse, Tool } from '../../types.js';
 declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
     docsSearchQuery: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
     docsSearchQuery: string;
 }, {
+    absoluteCurrentWorkingDirectory: string;
     docsSearchQuery: string;
 }>;
 export interface DocsSearchResponse {
@@ -20,7 +23,7 @@ export interface DocsSearchResponse {
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class DocsSearchTool extends Tool<InputSchemaType> {
     constructor(mcpServer: McpServer);
-    handler({ docsSearchQuery, }: InputSchemaType): Promise<TextContentResponse>;
+    handler({ absoluteCurrentWorkingDirectory, docsSearchQuery, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

package/mcp-server/tools/project/DocsSearchTool.js

@@ -3,10 +3,11 @@ import z from 'zod';
 import { Tool } from '../../types.js';
 import { formatTextContents } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
-import { docsSearchQuery } from './constants.js';
-import { getAccountId, getConfigPath, loadConfig, } from '@hubspot/local-dev-lib/config';
+import { absoluteCurrentWorkingDirectory, docsSearchQuery, } from './constants.js';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { getAccountIdFromCliConfig } from '../../utils/cliConfig.js';
 const inputSchema = {
+    absoluteCurrentWorkingDirectory,
     docsSearchQuery,
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -18,10 +19,9 @@ export class DocsSearchTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ docsSearchQuery, }) {
+    async handler({ absoluteCurrentWorkingDirectory, docsSearchQuery, }) {
         await trackToolUsage(toolName, { mode: docsSearchQuery });
-        loadConfig(getConfigPath());
-        const accountId = getAccountId();
+        const accountId = getAccountIdFromCliConfig(absoluteCurrentWorkingDirectory);
         if (!accountId) {
             const authErrorMessage = `No account ID found. Please run \`hs account auth\` to configure an account, or set a default account with \`hs account use <account>\``;
             return formatTextContents(authErrorMessage);

package/mcp-server/tools/project/GetConfigValuesTool.d.ts

@@ -2,19 +2,22 @@ import { TextContentResponse, Tool } from '../../types.js';
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
     platformVersion: z.ZodString;
     featureType: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     platformVersion: string;
+    absoluteCurrentWorkingDirectory: string;
     featureType: string;
 }, {
     platformVersion: string;
+    absoluteCurrentWorkingDirectory: string;
     featureType: string;
 }>;
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class GetConfigValuesTool extends Tool<InputSchemaType> {
     constructor(mcpServer: McpServer);
-    handler({ platformVersion, featureType, }: InputSchemaType): Promise<TextContentResponse>;
+    handler({ absoluteCurrentWorkingDirectory, platformVersion, featureType, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

package/mcp-server/tools/project/GetConfigValuesTool.js

@@ -1,10 +1,12 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { formatTextContents } from '../../utils/content.js';
+import { absoluteCurrentWorkingDirectory } from './constants.js';
 import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
-import { getAccountId, getConfigPath, loadConfig, } from '@hubspot/local-dev-lib/config';
 import { useV3Api } from '../../../lib/projects/platformVersion.js';
+import { getAccountIdFromCliConfig } from '../../utils/cliConfig.js';
 const inputSchema = {
+    absoluteCurrentWorkingDirectory,
     platformVersion: z
         .string()
         .describe('The platform version for the project. Located in the hsproject.json file.'),
@@ -21,16 +23,20 @@ export class GetConfigValuesTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ platformVersion, featureType, }) {
+    async handler({ absoluteCurrentWorkingDirectory, platformVersion, featureType, }) {
         try {
             if (!useV3Api(platformVersion)) {
                 return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
             }
-            loadConfig(getConfigPath());
+            const accountId = getAccountIdFromCliConfig(absoluteCurrentWorkingDirectory);
+            if (!accountId) {
+                const authErrorMessage = `No account ID found. Please run \`hs account auth\` to configure an account, or set a default account with \`hs account use <account>\``;
+                return formatTextContents(authErrorMessage);
+            }
             const schema = await getIntermediateRepresentationSchema({
                 platformVersion,
                 projectSourceDir: '',
-                accountId: getAccountId(),
+                accountId,
             });
             const internalComponentType = mapToInternalType(featureType);
             if (schema[internalComponentType]) {

package/mcp-server/tools/project/__tests__/DocsSearchTool.test.js

@@ -1,14 +1,14 @@
 import { DocsSearchTool } from '../DocsSearchTool.js';
 import { http } from '@hubspot/local-dev-lib/http';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { getAccountIdFromCliConfig } from '../../../utils/cliConfig.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('@hubspot/local-dev-lib/http');
-vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('@hubspot/local-dev-lib/errors/index');
 vi.mock('../../../utils/toolUsageTracking');
+vi.mock('../../../utils/cliConfig.js');
 const mockHttp = http;
-const mockGetAccountId = getAccountId;
+const mockGetAccountIdFromCliConfig = getAccountIdFromCliConfig;
 const mockIsHubSpotHttpError = vi.mocked(isHubSpotHttpError);
 describe('mcp-server/tools/project/DocsSearchTool', () => {
     let mockMcpServer;
@@ -38,9 +38,10 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
     describe('handler', () => {
         const mockInput = {
             docsSearchQuery: 'test query',
+            absoluteCurrentWorkingDirectory: '/foo',
         };
         it('should return auth error message when no account ID is found', async () => {
-            mockGetAccountId.mockReturnValue(null);
+            mockGetAccountIdFromCliConfig.mockReturnValue(null);
             const result = await tool.handler(mockInput);
             expect(result).toEqual({
                 content: [
@@ -52,7 +53,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should return successful results when docs are found', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockResponse = {
                 results: [
                     {
@@ -76,6 +77,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
                 data: mockResponse,
             });
             const result = await tool.handler(mockInput);
+            expect(mockGetAccountIdFromCliConfig).toHaveBeenCalledWith('/foo');
             expect(mockHttp.post).toHaveBeenCalledWith(12345, {
                 url: 'dev/docs/llms/v1/docs-search',
                 data: {
@@ -103,7 +105,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             expect(resultText).toContain('Test content 2');
         });
         it('should return no results message when no documentation is found', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockResponse = {
                 results: [],
             };
@@ -122,7 +124,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should return no results message when results is null', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockResponse = {
                 results: null,
             };
@@ -141,7 +143,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should handle HubSpot HTTP errors', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockError = {
                 toString: () => 'HubSpot API Error: 404 Not Found',
             };
@@ -158,7 +160,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should handle generic errors', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             const mockError = new Error('Network error');
             mockHttp.post.mockRejectedValue(mockError);
             mockIsHubSpotHttpError.mockReturnValue(false);
@@ -173,7 +175,7 @@ describe('mcp-server/tools/project/DocsSearchTool', () => {
             });
         });
         it('should handle non-Error rejections', async () => {
-            mockGetAccountId.mockReturnValue(12345);
+            mockGetAccountIdFromCliConfig.mockReturnValue(12345);
             mockHttp.post.mockRejectedValue('String error');
             mockIsHubSpotHttpError.mockReturnValue(false);
             const result = await tool.handler(mockInput);

package/mcp-server/tools/project/__tests__/GetConfigValuesTool.test.js

@@ -1,13 +1,13 @@
 import { GetConfigValuesTool } from '../GetConfigValuesTool.js';
 import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getAccountIdFromCliConfig } from '../../../utils/cliConfig.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('@hubspot/project-parsing-lib');
-vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/cliConfig.js');
 vi.mock('../../../utils/toolUsageTracking');
 const mockGetIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
 const mockMapToInternalType = mapToInternalType;
-const mockGetAccountId = getAccountId;
+const mockGetAccountIdFromCliConfig = getAccountIdFromCliConfig;
 describe('mcp-server/tools/project/GetConfigValuesTool', () => {
     let mockMcpServer;
     let tool;
@@ -44,9 +44,10 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
         const input = {
             platformVersion: '2025.2',
             featureType: 'card',
+            absoluteCurrentWorkingDirectory: '/foo',
         };
         beforeEach(() => {
-            mockGetAccountId.mockReturnValue(123456789);
+            mockGetAccountIdFromCliConfig.mockReturnValue(123456789);
         });
         it('should return config schema when component type exists', async () => {
             const mockSchema = {
@@ -61,6 +62,7 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
             mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
             mockMapToInternalType.mockReturnValue('internal-card-type');
             const result = await tool.handler(input);
+            expect(mockGetAccountIdFromCliConfig).toHaveBeenCalledWith('/foo');
             expect(mockGetIntermediateRepresentationSchema).toHaveBeenCalledWith({
                 platformVersion: '2025.2',
                 projectSourceDir: '',
@@ -133,14 +135,13 @@ describe('mcp-server/tools/project/GetConfigValuesTool', () => {
             });
         });
         it('should handle null account id', async () => {
-            mockGetAccountId.mockReturnValue(null);
-            mockGetIntermediateRepresentationSchema.mockRejectedValue(new Error('No account ID'));
+            mockGetAccountIdFromCliConfig.mockReturnValue(null);
             const result = await tool.handler(input);
             expect(result).toEqual({
                 content: [
                     {
                         type: 'text',
-                        text: 'Unable to locate JSON schema for type card',
+                        text: 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`',
                     },
                 ],
             });