@hubspot/cli 8.0.1-experimental.0 → 8.0.3-experimental.0

package/lib/mcp/setup.js

@@ -47,44 +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 mcpCommand = useStandaloneMode
-            ? {
-                command: 'npx',
-                args: [
-                    '-y',
-                    '-p',
-                    '@hubspot/cli@8.0.1-experimental.0',
-                    'hs',
-                    'mcp',
-                    'start',
-                ],
-                env: { HUBSPOT_MCP_STANDALONE: 'true' },
-            }
-            : 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;
@@ -143,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', {
@@ -171,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,
@@ -211,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', {
@@ -283,8 +237,16 @@ export async function setupCodex(mcpCommand = defaultMcpCommand) {
         SpinniesManager.add('codexSpinner', {
             text: commands.mcp.setup.spinners.configuringCodex,
         });
-        // Check if codex command is available
-        await execAsync('codex --version');
+        try {
+            // Check if codex command is available
+            await execAsync('codex --version');
+        }
+        catch (error) {
+            SpinniesManager.fail('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexNotFound,
+            });
+            return false;
+        }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, codex);
         await execAsync(`codex mcp add "${mcpServerName}" -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('codexSpinner', {
@@ -293,17 +255,10 @@ export async function setupCodex(mcpCommand = defaultMcpCommand) {
         return true;
     }
     catch (error) {
-        if (error instanceof Error && error.message.includes('codex')) {
-            SpinniesManager.fail('codexSpinner', {
-                text: commands.mcp.setup.spinners.codexNotFound,
-            });
-        }
-        else {
-            SpinniesManager.fail('codexSpinner', {
-                text: commands.mcp.setup.spinners.codexInstallFailed,
-            });
-            logError(error);
-        }
+        SpinniesManager.fail('codexSpinner', {
+            text: commands.mcp.setup.spinners.codexInstallFailed,
+        });
+        logError(error);
         return false;
     }
 }
@@ -312,7 +267,15 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
         SpinniesManager.add('geminiSpinner', {
             text: commands.mcp.setup.spinners.configuringGemini,
         });
-        await execAsync('gemini --version');
+        try {
+            await execAsync('gemini --version');
+        }
+        catch (e) {
+            SpinniesManager.fail('geminiSpinner', {
+                text: commands.mcp.setup.spinners.geminiNotFound,
+            });
+            return false;
+        }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, gemini);
         await execAsync(`gemini mcp add -s user "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('geminiSpinner', {
@@ -321,17 +284,10 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
         return true;
     }
     catch (error) {
-        if (error instanceof Error && error.message.includes('gemini')) {
-            SpinniesManager.fail('geminiSpinner', {
-                text: commands.mcp.setup.spinners.geminiNotFound,
-            });
-        }
-        else {
-            SpinniesManager.fail('geminiSpinner', {
-                text: commands.mcp.setup.spinners.geminiInstallFailed,
-            });
-            logError(error);
-        }
+        SpinniesManager.fail('geminiSpinner', {
+            text: commands.mcp.setup.spinners.geminiInstallFailed,
+        });
+        logError(error);
         return false;
     }
 }

package/lib/projects/ProjectLogsManager.d.ts

@@ -1,10 +1,18 @@
-import { AppFunctionComponentMetadata } from '@hubspot/local-dev-lib/types/ComponentStructure';
+import { ProjectConfig } from '../../types/Projects.js';
+type FunctionInfo = {
+    componentName: string;
+    appId: number;
+    endpoint?: {
+        path: string;
+    };
+};
 declare class _ProjectLogsManager {
     projectName: string | undefined;
+    projectConfig: ProjectConfig | undefined;
     projectId: number | undefined;
     accountId: number | undefined;
-    functions: AppFunctionComponentMetadata[];
-    selectedFunction: AppFunctionComponentMetadata | undefined;
+    functions: FunctionInfo[];
+    selectedFunction: FunctionInfo | undefined;
     functionName: string | undefined;
     appId: number | undefined;
     isPublicFunction: boolean | undefined;
@@ -13,6 +21,7 @@ declare class _ProjectLogsManager {
     constructor();
     init(accountId: number): Promise<void>;
     fetchFunctionDetails(): Promise<void>;
+    fetchFunctionDetailsV2(deployedBuildId: number): Promise<void>;
     getFunctionNames(): string[];
     setFunction(functionName?: string): void;
 }

package/lib/projects/ProjectLogsManager.js

@@ -1,10 +1,15 @@
 import { getProjectConfig } from './config.js';
 import { ensureProjectExists } from './ensureProjectExists.js';
 import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
+import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
 import { uiLogger } from '../ui/logger.js';
 import { commands } from '../../lang/en.js';
+import { isV2Project } from './platformVersion.js';
+import { getDeployedProjectNodes } from './localDev/helpers/project.js';
+import { debugError } from '../errorHandlers/index.js';
 class _ProjectLogsManager {
     projectName;
+    projectConfig;
     projectId;
     accountId;
     functions;
@@ -15,6 +20,7 @@ class _ProjectLogsManager {
     endpointName;
     reset() {
         this.projectName = undefined;
+        this.projectConfig = undefined;
         this.projectId = undefined;
         this.accountId = undefined;
         this.functions = [];
@@ -32,8 +38,8 @@ class _ProjectLogsManager {
         if (!projectConfig || !projectConfig.name) {
             throw new Error(commands.project.logs.errors.noProjectConfig);
         }
-        const { name: projectName } = projectConfig;
-        this.projectName = projectName;
+        this.projectConfig = projectConfig;
+        this.projectName = projectConfig.name;
         this.accountId = accountId;
         this.functions = [];
         const { project } = await ensureProjectExists(this.accountId, this.projectName, {
@@ -45,7 +51,16 @@ class _ProjectLogsManager {
             throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
         }
         this.projectId = project.id;
-        await this.fetchFunctionDetails();
+        if (isV2Project(projectConfig.platformVersion)) {
+            const deployedBuildId = project.deployedBuild.buildId;
+            if (!deployedBuildId) {
+                throw new Error(commands.project.logs.errors.noDeployedBuild);
+            }
+            await this.fetchFunctionDetailsV2(deployedBuildId);
+        }
+        else {
+            await this.fetchFunctionDetails();
+        }
     }
     async fetchFunctionDetails() {
         if (!this.projectId) {
@@ -61,14 +76,60 @@ class _ProjectLogsManager {
             return type && type.name === 'PRIVATE_APP';
         });
         apps.forEach(app => {
-            this.functions.push(
-            // If component type is APP_FUNCTION, we can safely cast as AppFunctionComponentMetadata
-            ...app.featureComponents.filter(component => component.type.name === 'APP_FUNCTION'));
+            const appFunctions = app.featureComponents.filter(component => component.type.name === 'APP_FUNCTION');
+            appFunctions.forEach(fn => {
+                if (fn.deployOutput) {
+                    this.functions.push({
+                        componentName: fn.componentName,
+                        appId: fn.deployOutput.appId,
+                        endpoint: fn.deployOutput.endpoint,
+                    });
+                }
+            });
         });
         if (this.functions.length === 0) {
             throw new Error(commands.project.logs.errors.noFunctionsInProject);
         }
     }
+    async fetchFunctionDetailsV2(deployedBuildId) {
+        if (!this.projectId || !this.accountId || !this.projectConfig) {
+            uiLogger.debug(commands.project.logs.errors.projectLogsManagerNotInitialized);
+            throw new Error(commands.project.logs.errors.generic);
+        }
+        let deployedNodes;
+        try {
+            deployedNodes = await getDeployedProjectNodes(this.projectConfig, this.accountId, deployedBuildId);
+        }
+        catch (err) {
+            debugError(err);
+            throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
+        }
+        const appNode = Object.values(deployedNodes).find(node => node.componentType === 'APPLICATION');
+        if (!appNode) {
+            throw new Error(commands.project.logs.errors.noFunctionsInProject);
+        }
+        let appId;
+        try {
+            const { data: appMetadata } = await fetchAppMetadataBySourceId(this.projectId, appNode.uid, this.accountId);
+            appId = appMetadata.id;
+        }
+        catch (err) {
+            debugError(err);
+            throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
+        }
+        const functionNodes = Object.values(deployedNodes).filter(node => node.componentType === 'APP_FUNCTION');
+        for (const fnNode of functionNodes) {
+            const config = fnNode.config;
+            this.functions.push({
+                componentName: fnNode.uid,
+                appId,
+                endpoint: config.endpoint,
+            });
+        }
+        if (this.functions.length === 0) {
+            throw new Error(commands.project.logs.errors.noFunctionsInProject);
+        }
+    }
     getFunctionNames() {
         return this.functions.map(serverlessFunction => serverlessFunction.componentName);
     }
@@ -81,12 +142,9 @@ class _ProjectLogsManager {
             throw new Error(commands.project.logs.errors.noFunctionWithName(functionName));
         }
         this.functionName = functionName;
-        if (!this.selectedFunction.deployOutput) {
-            throw new Error(commands.project.logs.errors.functionNotDeployed(functionName));
-        }
-        this.appId = this.selectedFunction.deployOutput.appId;
-        if (this.selectedFunction.deployOutput.endpoint) {
-            this.endpointName = this.selectedFunction.deployOutput.endpoint.path;
+        this.appId = this.selectedFunction.appId;
+        if (this.selectedFunction.endpoint) {
+            this.endpointName = this.selectedFunction.endpoint.path;
             this.isPublicFunction = true;
         }
         else {