@hubspot/cli 8.0.8-experimental.0 → 8.0.8-experimental.10

package/commands/cms/theme/preview.js

@@ -1,16 +1,14 @@
 import fs from 'fs';
 import path from 'path';
-import cliProgress from 'cli-progress';
 import { commands } from '../../../lang/en.js';
 import { getCwd } from '@hubspot/local-dev-lib/path';
-import { FILE_UPLOAD_RESULT_TYPES } from '@hubspot/local-dev-lib/constants/files';
 import { getThemeJSONPath } from '@hubspot/local-dev-lib/cms/themes';
-import { createDevServer } from '@hubspot/cms-dev-server';
-import { getUploadableFileList } from '../../../lib/upload.js';
+// Use subprocess approach to avoid React version conflicts
+// import { createDevServer } from '@hubspot/cms-dev-server';
+import { spawnDevServer } from '../../../lib/cms/devServerProcess.js';
 import { trackCommandUsage } from '../../../lib/usageTracking.js';
 import { previewPrompt, previewProjectPrompt, } from '../../../lib/prompts/previewPrompt.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-import { ApiErrorContext, logError } from '../../../lib/errorHandlers/index.js';
 import { getProjectConfig } from '../../../lib/projects/config.js';
 import { findProjectComponents } from '../../../lib/projects/structure.js';
 import { ComponentTypes } from '../../../types/Projects.js';
@@ -73,67 +71,16 @@ async function determineSrcAndDest(args) {
 async function handler(args) {
     const { derivedAccountId, noSsl, resetSession, port, generateFieldsTypes } = args;
     const { absoluteSrc, dest } = await determineSrcAndDest(args);
-    const filePaths = await getUploadableFileList(absoluteSrc, false);
-    function startProgressBar(numFiles) {
-        const initialUploadProgressBar = new cliProgress.SingleBar({
-            gracefulExit: true,
-            format: '[{bar}] {percentage}% | {value}/{total} | {label}',
-            hideCursor: true,
-        }, cliProgress.Presets.rect);
-        initialUploadProgressBar.start(numFiles, 0, {
-            label: commands.cms.subcommands.theme.subcommands.preview
-                .initialUploadProgressBar.start,
-        });
-        let uploadsHaveStarted = false;
-        const uploadOptions = {
-            onAttemptCallback: () => {
-                /* Intentionally blank */
-            },
-            onSuccessCallback: () => {
-                initialUploadProgressBar.increment();
-                if (!uploadsHaveStarted) {
-                    uploadsHaveStarted = true;
-                    initialUploadProgressBar.update(0, {
-                        label: commands.cms.subcommands.theme.subcommands.preview
-                            .initialUploadProgressBar.uploading,
-                    });
-                }
-            },
-            onFirstErrorCallback: () => {
-                /* Intentionally blank */
-            },
-            onRetryCallback: () => {
-                /* Intentionally blank */
-            },
-            onFinalErrorCallback: () => initialUploadProgressBar.increment(),
-            onFinishCallback: (results) => {
-                initialUploadProgressBar.update(numFiles, {
-                    label: commands.cms.subcommands.theme.subcommands.preview
-                        .initialUploadProgressBar.finish,
-                });
-                initialUploadProgressBar.stop();
-                results.forEach(result => {
-                    if (result.resultType == FILE_UPLOAD_RESULT_TYPES.FAILURE) {
-                        uiLogger.error(commands.cms.subcommands.theme.subcommands.preview.errors.uploadFailed(result.file, dest));
-                        logError(result.error, new ApiErrorContext({
-                            accountId: derivedAccountId,
-                            request: dest,
-                            payload: result.file,
-                        }));
-                    }
-                });
-            },
-        };
-        return uploadOptions;
-    }
     trackCommandUsage('preview', {}, derivedAccountId);
-    if (port) {
-        process.env['PORT'] = port.toString();
-    }
-    createDevServer(absoluteSrc, false, '', '', !noSsl, generateFieldsTypes, {
-        filePaths,
+    // Spawn dev server in isolated subprocess to avoid React version conflicts
+    // File listing and progress bars are handled within the subprocess
+    spawnDevServer({
+        absoluteSrc,
+        accountName: derivedAccountId?.toString(),
+        noSsl,
+        port,
+        generateFieldsTypes,
         resetSession: resetSession || false,
-        startProgressBar,
         dest,
     });
 }

package/commands/mcp/__tests__/start.test.js

@@ -7,20 +7,14 @@ import * as errorHandlers from '../../../lib/errorHandlers/index.js';
 import * as usageTrackingLib from '../../../lib/usageTracking.js';
 import * as processLib from '../../../lib/process.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-// Create a mock execAsync function before importing the module
-const execAsyncMock = vi.fn();
+import startCommand from '../start.js';
 vi.mock('yargs');
 vi.mock('../../../lib/commonOpts');
 vi.mock('node:child_process');
-vi.mock('node:util', () => ({
-    promisify: vi.fn(() => execAsyncMock),
-}));
 vi.mock('fs');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../../lib/errorHandlers/index.js');
 vi.mock('../../../lib/process.js');
-// Import after mocks are set up
-const startCommand = await import('../start.js').then(m => m.default);
 const spawnSpy = vi.mocked(spawn);
 const existsSyncSpy = vi.spyOn(fs, 'existsSync');
 const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
@@ -42,7 +36,6 @@ describe('commands/mcp/start', () => {
         processExitSpy.mockImplementation(() => { });
         // Mock config to prevent reading actual config file in CI
         getConfigAccountIfExistsSpy.mockReturnValue(undefined);
-        execAsyncMock.mockClear();
     });
     describe('command', () => {
         it('should have the correct command structure', () => {

package/commands/mcp/start.js

@@ -28,6 +28,7 @@ async function startMcpServer(aiAgent) {
         uiLogger.debug(commands.mcp.start.startingServer);
         uiLogger.debug(commands.mcp.start.stopInstructions);
         const args = [serverPath];
+        // Start the server using ts-node
         const child = spawn(`node`, args, {
             stdio: 'inherit',
             env: {

package/lang/en.d.ts

@@ -1295,8 +1295,6 @@ export declare const commands: {
             prompts: {
                 targets: string;
                 targetsRequired: string;
-                standaloneMode: string;
-                cliVersion: string;
             };
         };
         start: {

package/lang/en.js

@@ -1311,8 +1311,6 @@ export const commands = {
             prompts: {
                 targets: '[--client] Which tools would you like to add the HubSpot CLI MCP server to?',
                 targetsRequired: 'Must choose at least one app to configure.',
-                standaloneMode: 'Do you want to run in standalone mode? (This will use npx @hubspot/cli instead of the installed hs command)',
-                cliVersion: 'Specify a CLI version to pin (leave blank for latest):',
             },
         },
         start: {

package/lib/__tests__/commandSuggestion.test.js

@@ -71,6 +71,8 @@ describe('lib/commandSuggestion', () => {
             // Create a mock yargs builder with strict method
             const mockYargsBuilder = {
                 strict: vi.fn().mockReturnThis(),
+                help: vi.fn().mockReturnThis(),
+                version: vi.fn().mockReturnThis(),
             };
             await commandModule.builder(mockYargsBuilder);
             expect(mockYargsBuilder.strict).toHaveBeenCalledWith(false);

package/lib/cms/devServerProcess.d.ts

@@ -0,0 +1,13 @@
+import { ChildProcess } from 'child_process';
+interface DevServerOptions {
+    absoluteSrc: string;
+    accountName?: string;
+    configPath?: string;
+    noSsl?: boolean;
+    port?: number;
+    generateFieldsTypes?: boolean;
+    resetSession?: boolean;
+    dest?: string;
+}
+export declare function spawnDevServer(options: DevServerOptions): ChildProcess;
+export {};

package/lib/cms/devServerProcess.js

@@ -0,0 +1,188 @@
+import { spawn, execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { fileURLToPath } from 'url';
+/**
+ * Ensures cms-dev-server is installed in an isolated cache directory.
+ * This prevents React version conflicts with the CLI.
+ */
+function ensureCmsDevServerCache(targetVersion) {
+    const cacheDir = path.join(os.homedir(), '.hubspot', 'cms-dev-server-cache');
+    const packageJsonPath = path.join(cacheDir, 'node_modules', '@hubspot', 'cms-dev-server', 'package.json');
+    // Check if already installed with correct version
+    let needsInstall = true;
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const installedPackage = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            if (installedPackage.version === targetVersion) {
+                needsInstall = false;
+            }
+        }
+        catch (e) {
+            // If we can't read the package.json, reinstall
+            needsInstall = true;
+        }
+    }
+    if (needsInstall) {
+        console.log(`Setting up isolated cms-dev-server ${targetVersion}...`);
+        // Create cache directory
+        fs.mkdirSync(cacheDir, { recursive: true });
+        // Clear old installation if exists
+        const nodeModulesDir = path.join(cacheDir, 'node_modules');
+        if (fs.existsSync(nodeModulesDir)) {
+            fs.rmSync(nodeModulesDir, { recursive: true, force: true });
+        }
+        // Install cms-dev-server with production dependencies only
+        try {
+            execSync(`npm install @hubspot/cms-dev-server@${targetVersion} --production --no-save --loglevel=error`, {
+                cwd: cacheDir,
+                stdio: 'ignore', // Suppress npm output
+            });
+            console.log('✓ cms-dev-server setup complete');
+        }
+        catch (e) {
+            console.error('Failed to install cms-dev-server:', e);
+            process.exit(1);
+        }
+    }
+    return cacheDir;
+}
+export function spawnDevServer(options) {
+    const { absoluteSrc, accountName, noSsl, port, generateFieldsTypes, resetSession, dest, } = options;
+    // Get the version from CLI's package.json
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const cliPackageJsonPath = path.join(__dirname, '../../package.json');
+    const cliPackageJson = JSON.parse(fs.readFileSync(cliPackageJsonPath, 'utf8'));
+    const targetVersion = cliPackageJson.dependencies['@hubspot/cms-dev-server'];
+    if (!targetVersion) {
+        console.error('Could not determine cms-dev-server version from package.json');
+        process.exit(1);
+    }
+    // Ensure cms-dev-server is installed in isolated cache
+    const cacheDir = ensureCmsDevServerCache(targetVersion);
+    // Build a Node script that imports and calls createDevServer
+    // This runs in the isolated cache directory, completely separate from CLI's node_modules
+    const script = `
+    // Suppress library deprecation warnings (e.g., body-parser)
+    process.noDeprecation = true;
+
+    const { createDevServer } = await import('@hubspot/cms-dev-server');
+    const { walk } = await import('@hubspot/local-dev-lib/fs');
+    const { createIgnoreFilter } = await import('@hubspot/local-dev-lib/ignoreRules');
+    const { isAllowedExtension } = await import('@hubspot/local-dev-lib/path');
+    const { FILE_UPLOAD_RESULT_TYPES } = await import('@hubspot/local-dev-lib/constants/files');
+    const cliProgress = (await import('cli-progress')).default;
+
+    ${dest
+        ? `
+    // Get uploadable files for preview
+    let filePaths = [];
+    try {
+      filePaths = await walk(${JSON.stringify(absoluteSrc)});
+    } catch (e) {
+      console.error('Error walking directory:', e);
+    }
+    filePaths = filePaths
+      .filter(file => isAllowedExtension(file))
+      .filter(createIgnoreFilter(false));
+
+    // Create progress bar for initial upload
+    function startProgressBar(numFiles) {
+      const initialUploadProgressBar = new cliProgress.SingleBar(
+        {
+          gracefulExit: true,
+          format: '[{bar}] {percentage}% | {value}/{total} | {label}',
+          hideCursor: true,
+        },
+        cliProgress.Presets.rect
+      );
+      initialUploadProgressBar.start(numFiles, 0, {
+        label: 'Preparing upload...',
+      });
+      let uploadsHaveStarted = false;
+      return {
+        onAttemptCallback: () => {},
+        onSuccessCallback: () => {
+          initialUploadProgressBar.increment();
+          if (!uploadsHaveStarted) {
+            uploadsHaveStarted = true;
+            initialUploadProgressBar.update(0, {
+              label: 'Uploading files...',
+            });
+          }
+        },
+        onFirstErrorCallback: () => {},
+        onRetryCallback: () => {},
+        onFinalErrorCallback: () => initialUploadProgressBar.increment(),
+        onFinishCallback: (results) => {
+          initialUploadProgressBar.update(numFiles, {
+            label: 'Upload complete',
+          });
+          initialUploadProgressBar.stop();
+          results.forEach(result => {
+            if (result.resultType == FILE_UPLOAD_RESULT_TYPES.FAILURE) {
+              console.error(\`Failed to upload \${result.file}\`);
+            }
+          });
+        },
+      };
+    }
+
+    const themePreviewOptions = {
+      filePaths,
+      startProgressBar,
+      resetSession: ${Boolean(resetSession)},
+      dest: ${JSON.stringify(dest)},
+    };
+    `
+        : 'const themePreviewOptions = undefined;'}
+
+    createDevServer(
+      ${JSON.stringify(absoluteSrc)},
+      false, // storybook
+      '', // config (uses env var HUBSPOT_CONFIG_PATH)
+      ${JSON.stringify(accountName || '')},
+      ${!noSsl}, // sslEnabled
+      ${Boolean(generateFieldsTypes)}, // fieldGenEnabled
+      themePreviewOptions
+    );
+  `;
+    // Set environment variables
+    const env = { ...process.env };
+    if (port) {
+        env.PORT = port.toString();
+    }
+    // Suppress Node.js deprecation warnings
+    env.NODE_NO_WARNINGS = '1';
+    // Spawn Node with the inline script from the isolated cache directory
+    // This ensures complete isolation from CLI's React 19
+    const devServer = spawn('node', ['--input-type=module', '-e', script], {
+        stdio: 'inherit',
+        env,
+        cwd: cacheDir,
+    });
+    // Handle process events
+    devServer.on('error', error => {
+        console.error('Failed to start dev server:', error);
+        process.exit(1);
+    });
+    devServer.on('exit', (code, signal) => {
+        if (code !== 0 && code !== null) {
+            console.error(`Dev server exited with code ${code}`);
+            process.exit(code);
+        }
+        if (signal) {
+            console.error(`Dev server killed with signal ${signal}`);
+            process.exit(1);
+        }
+    });
+    // Handle CLI termination
+    process.on('SIGINT', () => {
+        devServer.kill('SIGINT');
+    });
+    process.on('SIGTERM', () => {
+        devServer.kill('SIGTERM');
+    });
+    return devServer;
+}

package/lib/commandSuggestion.js

@@ -18,12 +18,6 @@ export const commandSuggestionMappings = {
     'theme generate-selectors': 'hs cms theme generate-selectors',
     'theme marketplace-validate': 'hs cms theme marketplace-validate',
     'theme preview': 'hs cms theme preview',
-    'custom-object schema create': 'hs custom-object create-schema',
-    'custom-object schema delete': 'hs custom-object delete-schema',
-    'custom-object schema fetch-all': 'hs custom-object fetch-all-schemas',
-    'custom-object schema fetch': 'hs custom-object fetch-schema',
-    'custom-object schema list': 'hs custom-object list-schemas',
-    'custom-object schema update': 'hs custom-object update-schema',
 };
 function createCommandSuggestionHandler(newCommand) {
     return () => {
@@ -35,7 +29,7 @@ function createCommandSuggestion(oldCommand, newCommand) {
     return {
         command: oldCommand,
         builder: async (yargs) => {
-            return yargs.strict(false);
+            return yargs.strict(false).help(false).version(false);
         },
         handler: createCommandSuggestionHandler(newCommand),
     };

package/lib/mcp/__tests__/setup.test.js

@@ -132,21 +132,6 @@ describe('lib/mcp/setup', () => {
             });
             expect(mockedLogError).toHaveBeenCalledWith(error);
         });
-        it('should pass through environment variables in command', async () => {
-            const mockMcpCommandWithEnv = {
-                command: 'test-command',
-                args: ['--arg1'],
-                env: { HUBSPOT_MCP_STANDALONE: 'true' },
-            };
-            mockedExecAsync.mockResolvedValueOnce({
-                stdout: 'codex version 1.0.0',
-                stderr: '',
-            });
-            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
-            const result = await setupCodex(mockMcpCommandWithEnv);
-            expect(result).toBe(true);
-            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- test-command --arg1 --ai-agent codex --env HUBSPOT_MCP_STANDALONE=true');
-        });
     });
     describe('setupGemini', () => {
         const mockMcpCommand = {

package/lib/mcp/setup.d.ts

@@ -5,7 +5,6 @@ export declare const supportedTools: {
 interface McpCommand {
     command: string;
     args: string[];
-    env?: Record<string, string>;
 }
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;

package/lib/mcp/setup.js

@@ -47,56 +47,23 @@ export async function addMcpServerToConfig(targets) {
         else {
             derivedTargets = targets;
         }
-        // Prompt for standalone mode
-        const { useStandaloneMode } = await promptUser({
-            name: 'useStandaloneMode',
-            type: 'confirm',
-            message: commands.mcp.setup.prompts.standaloneMode,
-            default: false,
-        });
-        const { cliVersion } = useStandaloneMode
-            ? await promptUser({
-                name: 'cliVersion',
-                type: 'input',
-                message: commands.mcp.setup.prompts.cliVersion,
-                validate: (v) => !v || /^[\d]+\.[\d]+\.[\d]+([-+][\w.]+)?$/.test(v.trim())
-                    ? true
-                    : 'Please enter a valid semver version (e.g. 8.0.1) or leave blank for latest.',
-            })
-            : { cliVersion: '' };
-        const cliPackage = cliVersion
-            ? `@hubspot/cli@${cliVersion}`
-            : '@hubspot/cli';
-        const standaloneEnv = {
-            HUBSPOT_MCP_STANDALONE: 'true',
-        };
-        if (cliVersion) {
-            standaloneEnv.HUBSPOT_CLI_VERSION = cliVersion;
-        }
-        const mcpCommand = useStandaloneMode
-            ? {
-                command: 'npx',
-                args: ['-y', '-p', cliPackage, 'hs', 'mcp', 'start'],
-                env: standaloneEnv,
-            }
-            : defaultMcpCommand;
         if (derivedTargets.includes(claudeCode)) {
-            await runSetupFunction(() => setupClaudeCode(mcpCommand));
+            await runSetupFunction(setupClaudeCode);
         }
         if (derivedTargets.includes(cursor)) {
-            await runSetupFunction(() => setupCursor(mcpCommand));
+            await runSetupFunction(setupCursor);
         }
         if (derivedTargets.includes(windsurf)) {
-            await runSetupFunction(() => setupWindsurf(mcpCommand));
+            await runSetupFunction(setupWindsurf);
         }
         if (derivedTargets.includes(vscode)) {
-            await runSetupFunction(() => setupVsCode(mcpCommand));
+            await runSetupFunction(setupVsCode);
         }
         if (derivedTargets.includes(codex)) {
-            await runSetupFunction(() => setupCodex(mcpCommand));
+            await runSetupFunction(setupCodex);
         }
         if (derivedTargets.includes(gemini)) {
-            await runSetupFunction(() => setupGemini(mcpCommand));
+            await runSetupFunction(setupGemini);
         }
         uiLogger.info(commands.mcp.setup.success(derivedTargets));
         return derivedTargets;
@@ -155,14 +122,9 @@ function setupMcpConfigFile(config) {
             mcpConfig.mcpServers = {};
         }
         // Add or update HubSpot CLI MCP server
-        const serverConfig = {
-            command: config.mcpCommand.command,
-            args: config.mcpCommand.args,
+        mcpConfig.mcpServers[mcpServerName] = {
+            ...config.mcpCommand,
         };
-        if (config.mcpCommand.env) {
-            serverConfig.env = config.mcpCommand.env;
-        }
-        mcpConfig.mcpServers[mcpServerName] = serverConfig;
         // Write the updated config
         fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
         SpinniesManager.succeed('spinner', {
@@ -183,16 +145,10 @@ export async function setupVsCode(mcpCommand = defaultMcpCommand) {
         SpinniesManager.add('vsCode', {
             text: commands.mcp.setup.spinners.configuringVsCode,
         });
-        const commandWithAgent = buildCommandWithAgentString(mcpCommand, vscode);
-        const configObject = {
+        const mcpConfig = JSON.stringify({
             name: mcpServerName,
-            command: commandWithAgent.command,
-            args: commandWithAgent.args,
-        };
-        if (commandWithAgent.env) {
-            configObject.env = commandWithAgent.env;
-        }
-        const mcpConfig = JSON.stringify(configObject);
+            ...buildCommandWithAgentString(mcpCommand, vscode),
+        });
         await execAsync(`code --add-mcp ${JSON.stringify(mcpConfig)}`);
         SpinniesManager.succeed('vsCode', {
             text: commands.mcp.setup.spinners.configuredVsCode,
@@ -223,44 +179,30 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
         try {
             // Check if claude command is available
             await execAsync('claude --version');
-            // Run claude mcp add command
-            const commandWithAgent = buildCommandWithAgentString(mcpCommand, claudeCode);
-            const configObject = {
-                type: 'stdio',
-                command: commandWithAgent.command,
-                args: commandWithAgent.args,
-            };
-            if (commandWithAgent.env) {
-                configObject.env = commandWithAgent.env;
-            }
-            const mcpConfig = JSON.stringify(configObject);
-            const { stdout } = await execAsync('claude mcp list');
-            if (stdout.includes(mcpServerName)) {
-                SpinniesManager.update('claudeCode', {
-                    text: commands.mcp.setup.spinners.alreadyInstalled,
-                });
-                await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
-            }
-            await execAsync(`claude mcp add-json "${mcpServerName}" ${JSON.stringify(mcpConfig)} --scope user`);
-            SpinniesManager.succeed('claudeCode', {
-                text: commands.mcp.setup.spinners.configuredClaudeCode,
-            });
-            return true;
         }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('claude')) {
-                SpinniesManager.fail('claudeCode', {
-                    text: commands.mcp.setup.spinners.claudeCodeNotFound,
-                });
-            }
-            else {
-                SpinniesManager.fail('claudeCode', {
-                    text: commands.mcp.setup.spinners.claudeCodeInstallFailed,
-                });
-                logError(error);
-            }
+        catch (e) {
+            SpinniesManager.fail('claudeCode', {
+                text: commands.mcp.setup.spinners.claudeCodeNotFound,
+            });
             return false;
         }
+        // Run claude mcp add command
+        const mcpConfig = JSON.stringify({
+            type: 'stdio',
+            ...buildCommandWithAgentString(mcpCommand, claudeCode),
+        });
+        const { stdout } = await execAsync('claude mcp list');
+        if (stdout.includes(mcpServerName)) {
+            SpinniesManager.update('claudeCode', {
+                text: commands.mcp.setup.spinners.alreadyInstalled,
+            });
+            await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
+        }
+        await execAsync(`claude mcp add-json "${mcpServerName}" ${JSON.stringify(mcpConfig)} --scope user`);
+        SpinniesManager.succeed('claudeCode', {
+            text: commands.mcp.setup.spinners.configuredClaudeCode,
+        });
+        return true;
     }
     catch (error) {
         SpinniesManager.fail('claudeCode', {
@@ -306,7 +248,7 @@ export async function setupCodex(mcpCommand = defaultMcpCommand) {
             return false;
         }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, codex);
-        await execAsync(`codex mcp add "${mcpServerName}" -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}${buildEnvFlagString(mcpCommand)}`);
+        await execAsync(`codex mcp add "${mcpServerName}" -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('codexSpinner', {
             text: commands.mcp.setup.spinners.configuredCodex,
         });
@@ -335,7 +277,7 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
             return false;
         }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, gemini);
-        await execAsync(`gemini mcp add -s user "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}${buildEnvFlagString(mcpCommand)}`);
+        await execAsync(`gemini mcp add -s user "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('geminiSpinner', {
             text: commands.mcp.setup.spinners.configuredGemini,
         });
@@ -354,16 +296,3 @@ function buildCommandWithAgentString(mcpCommand, agent) {
     mcpCommandCopy.args.push('--ai-agent', agent);
     return mcpCommandCopy;
 }
-function buildEnvFlagString(mcpCommand) {
-    const envFlags = [];
-    if (mcpCommand.env) {
-        const env = Object.entries(mcpCommand.env);
-        env.forEach(([key, value]) => {
-            envFlags.push(`--env ${key}=${value}`);
-        });
-    }
-    if (envFlags.length === 0) {
-        return '';
-    }
-    return ` ${envFlags.join(' ')}`;
-}

package/mcp-server/tools/cms/HsCreateFunctionTool.js

@@ -1,7 +1,7 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/command.js';
+import { runCommandInDir } from '../../utils/project.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { addFlag } from '../../utils/command.js';

package/mcp-server/tools/cms/HsCreateModuleTool.js

@@ -1,7 +1,7 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/command.js';
+import { runCommandInDir } from '../../utils/project.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { addFlag } from '../../utils/command.js';

package/mcp-server/tools/cms/HsCreateTemplateTool.js

@@ -1,7 +1,7 @@
 import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/command.js';
+import { runCommandInDir } from '../../utils/project.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { addFlag } from '../../utils/command.js';

package/mcp-server/tools/cms/HsFunctionLogsTool.js

@@ -2,7 +2,7 @@ import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { addFlag } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/command.js';
+import { runCommandInDir } from '../../utils/project.js';
 import { formatTextContents } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { setupHubSpotConfig } from '../../utils/config.js';