@hubspot/cli 8.0.7-experimental.0 → 8.0.8-experimental.1

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

@@ -1,11 +1,11 @@
 import { AddFeatureToProjectTool, } from '../AddFeatureToProjectTool.js';
-import { runCommandInDir } from '../../../utils/command.js';
+import { runCommandInDir } from '../../../utils/project.js';
 import { addFlag } from '../../../utils/command.js';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../../lib/constants.js';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
+vi.mock('../../../utils/project');
 vi.mock('../../../utils/command');
 vi.mock('../../../../lib/constants');
 vi.mock('../../../utils/toolUsageTracking');

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

@@ -1,11 +1,11 @@
 import { CreateProjectTool, } from '../CreateProjectTool.js';
-import { runCommandInDir } from '../../../utils/command.js';
+import { runCommandInDir } from '../../../utils/project.js';
 import { addFlag } from '../../../utils/command.js';
 import { APP_DISTRIBUTION_TYPES, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../../lib/constants.js';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
+vi.mock('../../../utils/project');
 vi.mock('../../../utils/command');
 vi.mock('../../../../lib/constants');
 vi.mock('../../../../lib/projects/create/v2');

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

@@ -1,12 +1,12 @@
 import { CreateTestAccountTool, } from '../CreateTestAccountTool.js';
-import { runCommandInDir } from '../../../utils/command.js';
+import { runCommandInDir } from '../../../utils/project.js';
 import { addFlag } from '../../../utils/command.js';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
 import fs from 'fs';
 import * as config from '@hubspot/local-dev-lib/config';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
+vi.mock('../../../utils/project');
 vi.mock('../../../utils/command');
 vi.mock('../../../utils/toolUsageTracking');
 vi.mock('../../../utils/feedbackTracking');

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

@@ -1,10 +1,10 @@
 import { DeployProjectTool } from '../DeployProjectTool.js';
-import { runCommandInDir } from '../../../utils/command.js';
+import { runCommandInDir } from '../../../utils/project.js';
 import { addFlag } from '../../../utils/command.js';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
+vi.mock('../../../utils/project');
 vi.mock('../../../utils/command');
 vi.mock('../../../utils/toolUsageTracking');
 vi.mock('../../../utils/feedbackTracking');

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

@@ -1,21 +1,13 @@
 import { UploadProjectTools } from '../UploadProjectTools.js';
 import { getAllHsProfiles } from '@hubspot/project-parsing-lib/profiles';
 import { getProjectConfig } from '../../../../lib/projects/config.js';
-import { runCommandInDir } from '../../../utils/command.js';
+import { runCommandInDir } from '../../../utils/project.js';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('@hubspot/project-parsing-lib/profiles');
 vi.mock('../../../../lib/projects/config.js');
-vi.mock('../../../utils/command', () => ({
-    runCommandInDir: vi.fn(),
-    addFlag: vi.fn((command, flagName, value) => {
-        if (Array.isArray(value)) {
-            return `${command} --${flagName} ${value.map(item => `"${item}"`).join(' ')}`;
-        }
-        return `${command} --${flagName} "${value}"`;
-    }),
-}));
+vi.mock('../../../utils/project');
 vi.mock('../../../utils/toolUsageTracking');
 vi.mock('../../../utils/feedbackTracking');
 const mockTrackToolUsage = trackToolUsage;

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

@@ -1,9 +1,9 @@
 import { ValidateProjectTool, } from '../ValidateProjectTool.js';
-import { runCommandInDir } from '../../../utils/command.js';
+import { runCommandInDir } from '../../../utils/project.js';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
+vi.mock('../../../utils/project');
 vi.mock('../../../utils/toolUsageTracking');
 vi.mock('../../../utils/feedbackTracking');
 const mockTrackToolUsage = trackToolUsage;

package/mcp-server/utils/__tests__/command.test.js

@@ -1,20 +1,6 @@
-import fs from 'fs';
-import path from 'path';
-const mockExecAsync = vi.fn();
-vi.mock('node:child_process');
-vi.mock('util', () => ({
-    default: {
-        promisify: () => mockExecAsync,
-    },
-    promisify: () => mockExecAsync,
-}));
-vi.mock('fs');
-vi.mock('path');
-// Import after mocks are set up
-const { addFlag, runCommandInDir } = await import('../command.js');
-const mockExistsSync = vi.mocked(fs.existsSync);
-const mockMkdirSync = vi.mocked(fs.mkdirSync);
-const mockResolve = vi.mocked(path.resolve);
+import { addFlag } from '../command.js';
+vi.mock('child_process');
+vi.mock('util');
 describe('mcp-server/utils/command', () => {
     describe('addFlag', () => {
         it('should add string flag to command', () => {
@@ -56,220 +42,4 @@ describe('mcp-server/utils/command', () => {
             expect(result).toBe('hs project create --features "card with spaces" "settings"');
         });
     });
-    describe('runCommandInDir', () => {
-        const mockDirectory = '/test/directory';
-        const mockCommand = 'npm install';
-        const mockResolvedPath = '/resolved/test/directory';
-        beforeEach(() => {
-            mockResolve.mockReturnValue(mockResolvedPath);
-        });
-        it('should run command in existing directory', async () => {
-            const expectedResult = {
-                stdout: 'command output',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await runCommandInDir(mockDirectory, mockCommand);
-            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
-            expect(mockMkdirSync).not.toHaveBeenCalled();
-            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
-            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            expect(result).toEqual(expectedResult);
-        });
-        it('should create directory if it does not exist', async () => {
-            const expectedResult = {
-                stdout: 'command output',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(false);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await runCommandInDir(mockDirectory, mockCommand);
-            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
-            expect(mockMkdirSync).toHaveBeenCalledWith(mockDirectory);
-            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
-            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            expect(result).toEqual(expectedResult);
-        });
-        it('should propagate execAsync errors', async () => {
-            const error = new Error('Command failed');
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockRejectedValue(error);
-            await expect(runCommandInDir(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
-            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should handle stderr in results', async () => {
-            const expectedResult = {
-                stdout: 'some output',
-                stderr: 'warning message',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await runCommandInDir(mockDirectory, mockCommand);
-            expect(result.stdout).toBe('some output');
-            expect(result.stderr).toBe('warning message');
-        });
-        it('should add --disable-usage-tracking flag to hs commands', async () => {
-            const hsCommand = 'hs project upload';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should not add --disable-usage-tracking flag to non-hs commands', async () => {
-            const nonHsCommand = 'npm install';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, nonHsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('npm install', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should add --disable-usage-tracking flag to hs commands with existing flags', async () => {
-            const hsCommand = 'hs project upload --profile prod';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --profile prod --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should handle hs commands that start with whitespace', async () => {
-            const hsCommand = 'hs init';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('hs init --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should use npx -p @hubspot/cli when HUBSPOT_MCP_STANDALONE is true', async () => {
-            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
-            process.env.HUBSPOT_MCP_STANDALONE = 'true';
-            const hsCommand = 'hs project upload';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('npx -y -p @hubspot/cli hs project upload --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            // Restore original env
-            if (originalEnv === undefined) {
-                delete process.env.HUBSPOT_MCP_STANDALONE;
-            }
-            else {
-                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
-            }
-        });
-        it('should use regular hs command when HUBSPOT_MCP_STANDALONE is not set', async () => {
-            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
-            delete process.env.HUBSPOT_MCP_STANDALONE;
-            const hsCommand = 'hs project upload';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            // Restore original env
-            if (originalEnv !== undefined) {
-                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
-            }
-        });
-        it('should use npx -p @hubspot/cli for hs commands with flags in standalone mode', async () => {
-            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
-            process.env.HUBSPOT_MCP_STANDALONE = 'true';
-            const hsCommand = 'hs project upload --profile prod';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('npx -y -p @hubspot/cli hs project upload --profile prod --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            // Restore original env
-            if (originalEnv === undefined) {
-                delete process.env.HUBSPOT_MCP_STANDALONE;
-            }
-            else {
-                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
-            }
-        });
-        it('should use pinned CLI version when HUBSPOT_CLI_VERSION is set in standalone mode', async () => {
-            const originalStandaloneEnv = process.env.HUBSPOT_MCP_STANDALONE;
-            const originalVersionEnv = process.env.HUBSPOT_CLI_VERSION;
-            process.env.HUBSPOT_MCP_STANDALONE = 'true';
-            process.env.HUBSPOT_CLI_VERSION = '8.1.0';
-            const hsCommand = 'hs project upload';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('npx -y -p @hubspot/cli@8.1.0 hs project upload --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            // Restore original env
-            if (originalStandaloneEnv === undefined) {
-                delete process.env.HUBSPOT_MCP_STANDALONE;
-            }
-            else {
-                process.env.HUBSPOT_MCP_STANDALONE = originalStandaloneEnv;
-            }
-            if (originalVersionEnv === undefined) {
-                delete process.env.HUBSPOT_CLI_VERSION;
-            }
-            else {
-                process.env.HUBSPOT_CLI_VERSION = originalVersionEnv;
-            }
-        });
-    });
 });

package/mcp-server/utils/__tests__/project.test.d.ts

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

package/mcp-server/utils/__tests__/project.test.js

@@ -0,0 +1,140 @@
+import { runCommandInDir } from '../project.js';
+import { execAsync } from '../command.js';
+import fs from 'fs';
+import path from 'path';
+vi.mock('../command', () => ({
+    execAsync: vi.fn(),
+    addFlag: vi.fn((command, flagName, value) => {
+        if (Array.isArray(value)) {
+            return `${command} --${flagName} ${value.map(item => `"${item}"`).join(' ')}`;
+        }
+        return `${command} --${flagName} "${value}"`;
+    }),
+}));
+vi.mock('fs');
+vi.mock('path');
+const mockExecAsync = execAsync;
+const mockExistsSync = fs.existsSync;
+const mockMkdirSync = fs.mkdirSync;
+const mockResolve = path.resolve;
+describe('mcp-server/utils/project', () => {
+    describe('runCommandInDir', () => {
+        const mockDirectory = '/test/directory';
+        const mockCommand = 'npm install';
+        const mockResolvedPath = '/resolved/test/directory';
+        beforeEach(() => {
+            mockResolve.mockReturnValue(mockResolvedPath);
+        });
+        it('should run command in existing directory', async () => {
+            const expectedResult = {
+                stdout: 'command output',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).not.toHaveBeenCalled();
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            expect(result).toEqual(expectedResult);
+        });
+        it('should create directory if it does not exist', async () => {
+            const expectedResult = {
+                stdout: 'command output',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(false);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockMkdirSync).toHaveBeenCalledWith(mockDirectory);
+            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            expect(result).toEqual(expectedResult);
+        });
+        it('should propagate execAsync errors', async () => {
+            const error = new Error('Command failed');
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockRejectedValue(error);
+            await expect(runCommandInDir(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
+            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should handle stderr in results', async () => {
+            const expectedResult = {
+                stdout: 'some output',
+                stderr: 'warning message',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
+            expect(result.stdout).toBe('some output');
+            expect(result.stderr).toBe('warning message');
+        });
+        it('should add --disable-usage-tracking flag to hs commands', async () => {
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should not add --disable-usage-tracking flag to non-hs commands', async () => {
+            const nonHsCommand = 'npm install';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, nonHsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npm install', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should add --disable-usage-tracking flag to hs commands with existing flags', async () => {
+            const hsCommand = 'hs project upload --profile prod';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --profile prod --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+        it('should handle hs commands that start with whitespace', async () => {
+            const hsCommand = 'hs init';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('hs init --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+        });
+    });
+});

package/mcp-server/utils/command.d.ts

@@ -1,8 +1,3 @@
 import { exec } from 'node:child_process';
 export declare const execAsync: typeof exec.__promisify__;
 export declare function addFlag(command: string, flagName: string, value: string | number | boolean | string[]): string;
-export interface CommandResults {
-    stderr: string;
-    stdout: string;
-}
-export declare function runCommandInDir(directory: string, command: string): Promise<CommandResults>;

package/mcp-server/utils/command.js

@@ -1,5 +1,3 @@
-import path from 'path';
-import fs from 'fs';
 import util from 'util';
 import { exec } from 'node:child_process';
 export const execAsync = util.promisify(exec);
@@ -9,25 +7,3 @@ export function addFlag(command, flagName, value) {
     }
     return `${command} --${flagName} "${value}"`;
 }
-export async function runCommandInDir(directory, command) {
-    if (!fs.existsSync(directory)) {
-        fs.mkdirSync(directory);
-    }
-    let finalCommand = command;
-    if (command.startsWith('hs ')) {
-        // Check if running in standalone mode
-        if (process.env.HUBSPOT_MCP_STANDALONE === 'true') {
-            const cliPackage = process.env.HUBSPOT_CLI_VERSION
-                ? `@hubspot/cli@${process.env.HUBSPOT_CLI_VERSION}`
-                : '@hubspot/cli';
-            finalCommand = command.replace(/^hs /, `npx -y -p ${cliPackage} hs `);
-        }
-        finalCommand = addFlag(finalCommand, 'disable-usage-tracking', true);
-    }
-    return execAsync(finalCommand, {
-        cwd: path.resolve(directory),
-        env: {
-            ...process.env,
-        },
-    });
-}

package/mcp-server/utils/project.d.ts

@@ -0,0 +1,5 @@
+export interface CommandResults {
+    stderr: string;
+    stdout: string;
+}
+export declare function runCommandInDir(directory: string, command: string): Promise<CommandResults>;

package/mcp-server/utils/project.js

@@ -0,0 +1,18 @@
+import { addFlag, execAsync } from './command.js';
+import path from 'path';
+import fs from 'fs';
+export async function runCommandInDir(directory, command) {
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory);
+    }
+    let finalCommand = command;
+    if (command.startsWith('hs ')) {
+        finalCommand = addFlag(finalCommand, 'disable-usage-tracking', true);
+    }
+    return execAsync(finalCommand, {
+        cwd: path.resolve(directory),
+        env: {
+            ...process.env,
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.0.7-experimental.0",
+    "version": "8.0.8-experimental.1",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
@@ -119,6 +119,12 @@
         "registry": "https://registry.npmjs.org/"
     },
     "resolutions": {
-        "eslint-visitor-keys": "4.2.0"
+        "eslint-visitor-keys": "4.2.0",
+        "react": "19.2.3",
+        "react-dom": "19.2.3"
+    },
+    "overrides": {
+        "react": "19.2.3",
+        "react-dom": "19.2.3"
     }
 }