@hubspot/cli 7.7.0-experimental.2 → 7.7.0-experimental.3

package/mcp-server/tools/GenerateAppComponentTool.js

@@ -1,193 +0,0 @@
-import { MCPTool } from 'mcp-framework';
-import { z } from 'zod';
-class GenerateAppComponentTool extends MCPTool {
-    name = 'generateAppComponent';
-    description = 'Generates an app component (top-level) with proper folder structure and hsmeta.json configuration file. Apps provide OAuth authentication that sub-components depend on.';
-    schema = {
-        appName: {
-            type: z.string(),
-            description: 'Name of the app (used for file naming and default display name)',
-        },
-        uid: {
-            type: z.string(),
-            description: 'Unique identifier for the app component (must be unique per-project)',
-        },
-        description: {
-            type: z.string().optional(),
-            description: "Description of the app. Defaults to 'A public app'",
-        },
-        displayName: {
-            type: z.string().optional(),
-            description: 'Display name of the app. Defaults to the appName',
-        },
-        distribution: {
-            type: z.string().optional(),
-            description: "Distribution type (one of 'marketplace' or 'private'). Defaults to 'marketplace'",
-        },
-        supportEmail: {
-            type: z.string().optional(),
-            description: "Support email address. Defaults to 'support@example.com'",
-        },
-        documentationUrl: {
-            type: z.string().optional(),
-            description: "Documentation URL. Defaults to 'https://example.com/docs'",
-        },
-        supportUrl: {
-            type: z.string().optional(),
-            description: "Support URL. Defaults to 'https://example.com/support'",
-        },
-        supportPhone: {
-            type: z.string().optional(),
-            description: "Support phone number. Defaults to '+18005555555'",
-        },
-        redirectUrls: {
-            type: z.array(z.string()).optional(),
-            description: "OAuth redirect URLs. Defaults to ['http://localhost:3000/oauth-callback']",
-        },
-        requiredScopes: {
-            type: z.array(z.string()).optional(),
-            description: 'Required OAuth scopes. Consider what sub-components you plan to add. Defaults to basic CRM contact scopes',
-        },
-        optionalScopes: {
-            type: z.array(z.string()).optional(),
-            description: 'Optional OAuth scopes. Defaults to empty array',
-        },
-        permittedFetchUrls: {
-            type: z.array(z.string()).optional(),
-            description: "URLs permitted for fetch requests. Defaults to ['https://api.example.com']",
-        },
-        plannedFeatures: {
-            type: z.array(z.string()).optional(),
-            description: "List of planned sub-components/features (e.g., 'cards', 'functions', 'webhooks'). Used to suggest appropriate OAuth scopes",
-        },
-    };
-    async execute(input) {
-        const { appName, uid, description = 'A public app', displayName = appName, distribution = 'marketplace', supportEmail = 'support@example.com', documentationUrl = 'https://example.com/docs', supportUrl = 'https://example.com/support', supportPhone = '+18005555555', redirectUrls = ['http://localhost:3000/oauth-callback'], requiredScopes = [
-            'crm.objects.contacts.read',
-            'crm.objects.contacts.write',
-        ], optionalScopes = [], permittedFetchUrls = ['https://api.example.com'], plannedFeatures = [], } = input;
-        // Generate the sanitized app name for file naming
-        const sanitizedAppName = appName.toLowerCase().replace(/\s+/g, '-');
-        const fileName = `${sanitizedAppName}-hsmeta.json`;
-        const folderPath = 'src/app';
-        const appConfig = {
-            uid: uid,
-            type: 'app',
-            config: {
-                description: description,
-                name: displayName,
-                distribution: distribution,
-                auth: {
-                    type: 'oauth',
-                    redirectUrls: redirectUrls,
-                    requiredScopes: requiredScopes,
-                    optionalScopes: optionalScopes,
-                    conditionallyRequiredScopes: [],
-                },
-                permittedUrls: {
-                    fetch: permittedFetchUrls,
-                    iframe: [],
-                    img: [],
-                },
-                support: {
-                    supportEmail: supportEmail,
-                    documentationUrl: documentationUrl,
-                    supportUrl: supportUrl,
-                    supportPhone: supportPhone,
-                },
-            },
-        };
-        // Generate scope recommendations based on planned features
-        const scopeRecommendations = this.generateScopeRecommendations(plannedFeatures);
-        // Generate next steps guidance
-        const nextSteps = this.generateNextSteps(plannedFeatures, folderPath);
-        return {
-            message: `Generated app component configuration for "${displayName}"`,
-            config: JSON.stringify(appConfig, null, 2),
-            folderPath: folderPath,
-            fileName: fileName,
-            fullPath: `${folderPath}/${fileName}`,
-            architecture: {
-                componentType: 'top-level',
-                role: 'authentication-provider',
-                singularComponent: true,
-                dependents: "All sub-components (cards, functions, settings, etc.) will depend on this app's authentication",
-            },
-            scopeRecommendations: scopeRecommendations,
-            nextSteps: nextSteps,
-            instructions: [
-                `Create the directory structure: ${folderPath}/`,
-                `Place the configuration file at: ${folderPath}/${fileName}`,
-                `This is a TOP-LEVEL component that provides OAuth authentication`,
-                `Sub-components (features) will live within ${folderPath}/ and depend on this app's authentication`,
-                `The app component uid: ${uid} must be unique within your project`,
-                'Consider what sub-components you plan to add and ensure sufficient OAuth scopes',
-                'Typically there is one app component per project (singular component)',
-            ],
-        };
-    }
-    generateScopeRecommendations(plannedFeatures) {
-        const recommendations = [];
-        if (plannedFeatures.length === 0) {
-            return [
-                'Consider what sub-components you plan to add to determine required OAuth scopes',
-                'Cards typically need CRM object read access',
-                'Functions may need broader API access depending on functionality',
-                'Webhooks may need specific event subscription scopes',
-            ];
-        }
-        const scopeMap = {
-            cards: [
-                'Cards typically need: crm.objects.contacts.read, crm.objects.companies.read, crm.objects.deals.read',
-            ],
-            functions: [
-                'Functions may need: broader API access depending on functionality',
-                'Consider: crm.objects.*.read, crm.objects.*.write if manipulating CRM data',
-            ],
-            webhooks: [
-                'Webhooks may need: specific event subscription scopes',
-                'Consider: webhooks scope and relevant object scopes for events you want to receive',
-            ],
-            settings: [
-                'Settings typically need: minimal scopes, may inherit from other components',
-            ],
-            'marketing-events': [
-                'Marketing events may need: marketing event creation and management scopes',
-            ],
-            'timeline-events': [
-                'Timeline events may need: timeline read/write scopes for the relevant objects',
-            ],
-            'workflow-actions': [
-                'Workflow actions may need: workflow and automation related scopes',
-            ],
-        };
-        plannedFeatures.forEach(feature => {
-            if (scopeMap[feature]) {
-                recommendations.push(`For ${feature}: ${scopeMap[feature].join(', ')}`);
-            }
-        });
-        return recommendations;
-    }
-    generateNextSteps(plannedFeatures, appPath) {
-        const steps = [
-            '1. Create the app component configuration file and directory structure',
-            '2. Test OAuth flow and ensure authentication works correctly',
-            '3. Add sub-components within the app directory as needed:',
-        ];
-        if (plannedFeatures.length > 0) {
-            plannedFeatures.forEach(feature => {
-                steps.push(`   - ${appPath}/${feature}/`);
-            });
-        }
-        else {
-            steps.push(`   - ${appPath}/cards/ (for UI cards)`);
-            steps.push(`   - ${appPath}/functions/ (for serverless functions)`);
-            steps.push(`   - ${appPath}/settings/ (for configuration UI)`);
-            steps.push(`   - ${appPath}/webhooks/ (for event handling)`);
-        }
-        steps.push("4. Ensure all sub-components can access required APIs with the app's OAuth scopes");
-        steps.push('5. Test the complete application with all components integrated');
-        return steps;
-    }
-}
-export default GenerateAppComponentTool;

package/mcp-server/tools/GenerateCardComponentTool.d.ts

@@ -1,74 +0,0 @@
-import { MCPTool } from "mcp-framework";
-import { z } from "zod";
-interface GenerateCardComponentInput {
-    cardName: string;
-    uid: string;
-    displayName?: string;
-    location?: string;
-    objectTypes?: string[];
-    componentFileName?: string;
-}
-declare class GenerateCardComponentTool extends MCPTool<GenerateCardComponentInput> {
-    name: string;
-    description: string;
-    schema: {
-        cardName: {
-            type: z.ZodString;
-            description: string;
-        };
-        uid: {
-            type: z.ZodString;
-            description: string;
-        };
-        displayName: {
-            type: z.ZodOptional<z.ZodString>;
-            description: string;
-        };
-        location: {
-            type: z.ZodOptional<z.ZodString>;
-            description: string;
-        };
-        objectTypes: {
-            type: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            description: string;
-        };
-        componentFileName: {
-            type: z.ZodOptional<z.ZodString>;
-            description: string;
-        };
-    };
-    execute(input: GenerateCardComponentInput): Promise<{
-        message: string;
-        files: {
-            configuration: {
-                path: string;
-                content: string;
-                description: string;
-            };
-            packageJson: {
-                path: string;
-                content: string;
-                description: string;
-            };
-            reactComponent: {
-                path: string;
-                content: string;
-                description: string;
-            };
-        };
-        folderPath: string;
-        architecture: {
-            componentType: string;
-            parentComponent: string;
-            category: string;
-            authenticationDependency: string;
-            allowMultiple: boolean;
-            technology: string;
-        };
-        instructions: string[];
-        nextSteps: string[];
-        developmentNotes: string[];
-    }>;
-    private toPascalCase;
-}
-export default GenerateCardComponentTool;

package/mcp-server/tools/GenerateCardComponentTool.js

@@ -1,146 +0,0 @@
-import { MCPTool } from "mcp-framework";
-import { z } from "zod";
-class GenerateCardComponentTool extends MCPTool {
-    name = "generateCardComponent";
-    description = "Generates a complete card sub-component including configuration, package.json, and React JSX implementation. Cards live within apps and depend on app authentication.";
-    schema = {
-        cardName: {
-            type: z.string(),
-            description: "Name of the card (used for file naming and component names)",
-        },
-        uid: {
-            type: z.string(),
-            description: "Unique identifier for the card component (must be unique per-project)",
-        },
-        displayName: {
-            type: z.string().optional(),
-            description: "Display name of the card. Defaults to cardName",
-        },
-        location: {
-            type: z.string().optional(),
-            description: "Card location/placement. Defaults to 'crm.record.tab'",
-        },
-        objectTypes: {
-            type: z.array(z.string()).optional(),
-            description: "CRM object types this card should appear on (e.g., ['contacts', 'companies']). Defaults to ['contacts']",
-        },
-        componentFileName: {
-            type: z.string().optional(),
-            description: "Name for the React component file (without extension). Defaults to PascalCase of cardName",
-        },
-    };
-    async execute(input) {
-        const { cardName, uid, displayName = cardName, location = "crm.record.tab", objectTypes = ["contacts"], componentFileName = this.toPascalCase(cardName), } = input;
-        // Generate the sanitized card name for file naming
-        const sanitizedCardName = cardName.toLowerCase().replace(/\s+/g, "-");
-        const configFileName = `${sanitizedCardName}-hsmeta.json`;
-        const folderPath = "src/app/cards";
-        const reactFileName = `${componentFileName}.jsx`;
-        const entrypoint = `/app/cards/${reactFileName}`;
-        // Card configuration
-        const cardConfig = {
-            uid: uid,
-            type: "card",
-            config: {
-                name: displayName,
-                location: location,
-                entrypoint: entrypoint,
-                objectTypes: objectTypes,
-            },
-        };
-        // Package.json configuration
-        const packageJson = {
-            name: "hubspot-example-extension",
-            version: "0.1.0",
-            license: "MIT",
-            dependencies: {
-                "@hubspot/ui-extensions": "latest",
-                react: "^18.2.0",
-            },
-            devDependencies: {
-                typescript: "^5.3.3",
-            },
-        };
-        // React component implementation
-        const reactComponent = `import React from "react";
-import { Text } from "@hubspot/ui-extensions";
-import { hubspot } from "@hubspot/ui-extensions";
-
-hubspot.extend(() => <Extension />);
-
-const Extension = () => {
-  return (
-    <>
-      <Text>
-        ${displayName} - Displaying information for {objectTypes.join(', ')} records.
-      </Text>
-    </>
-  );
-};
-
-export default Extension;`;
-        return {
-            message: `Generated complete card component "${displayName}" with React implementation`,
-            files: {
-                configuration: {
-                    path: `${folderPath}/${configFileName}`,
-                    content: JSON.stringify(cardConfig, null, 2),
-                    description: "Card component configuration",
-                },
-                packageJson: {
-                    path: `${folderPath}/package.json`,
-                    content: JSON.stringify(packageJson, null, 2),
-                    description: "NPM package dependencies",
-                },
-                reactComponent: {
-                    path: `${folderPath}/${reactFileName}`,
-                    content: reactComponent,
-                    description: "React JSX component implementation",
-                },
-            },
-            folderPath: folderPath,
-            architecture: {
-                componentType: "sub-component",
-                parentComponent: "app",
-                category: "feature",
-                authenticationDependency: "Inherits authentication from parent app - no additional scopes required",
-                allowMultiple: true,
-                technology: "React JSX with @hubspot/ui-extensions",
-            },
-            instructions: [
-                `Create the directory structure: ${folderPath}/`,
-                `Create configuration file: ${folderPath}/${configFileName}`,
-                `Create package.json: ${folderPath}/package.json`,
-                `Create React component: ${folderPath}/${reactFileName}`,
-                `This is a SUB-COMPONENT that depends on the parent app's authentication`,
-                `Card will appear on: ${objectTypes.join(", ")} records at location: ${location}`,
-                `Card uid: ${uid} must be unique within your project`,
-                "You can have multiple card components within the same app",
-                "Cards inherit all authentication and permissions from their parent app",
-            ],
-            nextSteps: [
-                "1. Ensure parent app component exists with appropriate OAuth scopes for your use case",
-                "2. Create the card directory and all generated files",
-                "3. Install dependencies by running npm install in the card directory",
-                "4. Customize the React component implementation",
-                "5. Test the card appears correctly on target object types",
-                "6. Verify card can access needed HubSpot data through inherited app authentication",
-            ],
-            developmentNotes: [
-                "Cards are React-based components using @hubspot/ui-extensions",
-                "Use HubSpot UI components for consistent styling",
-                "Cards can access HubSpot context and APIs through the UI extensions framework",
-                "Entrypoint path is relative to the app directory",
-                "Package.json defines React and HubSpot UI extension dependencies",
-                "Cards inherit authentication from parent app - no separate OAuth configuration needed",
-            ],
-        };
-    }
-    toPascalCase(str) {
-        return str
-            .split(/[\s-_]+/)
-            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-            .join("");
-    }
-}
-export default GenerateCardComponentTool;

package/mcp-server/tools/GenerateProjectConfigTool.d.ts

@@ -1,32 +0,0 @@
-import { MCPTool } from "mcp-framework";
-import { z } from "zod";
-interface GenerateProjectConfigInput {
-    projectName: string;
-    srcDir?: string;
-    platformVersion?: string;
-}
-declare class GenerateProjectConfigTool extends MCPTool<GenerateProjectConfigInput> {
-    name: string;
-    description: string;
-    schema: {
-        projectName: {
-            type: z.ZodString;
-            description: string;
-        };
-        srcDir: {
-            type: z.ZodOptional<z.ZodString>;
-            description: string;
-        };
-        platformVersion: {
-            type: z.ZodOptional<z.ZodString>;
-            description: string;
-        };
-    };
-    execute(input: GenerateProjectConfigInput): Promise<{
-        message: string;
-        config: string;
-        filename: string;
-        instructions: string[];
-    }>;
-}
-export default GenerateProjectConfigTool;

package/mcp-server/tools/GenerateProjectConfigTool.js

@@ -1,40 +0,0 @@
-import { MCPTool } from "mcp-framework";
-import { z } from "zod";
-class GenerateProjectConfigTool extends MCPTool {
-    name = "generateProjectConfig";
-    description = "Generates an hsproject.json configuration file for a developer project on the platform";
-    schema = {
-        projectName: {
-            type: z.string(),
-            description: "Name of the developer project",
-        },
-        srcDir: {
-            type: z.string().optional(),
-            description: "Directory that contains all project source code. Defaults to 'src'",
-        },
-        platformVersion: {
-            type: z.string().optional(),
-            description: "Version of the platform to use. Defaults to '2025.2'",
-        },
-    };
-    async execute(input) {
-        const { projectName, srcDir = "src", platformVersion = "2025.2" } = input;
-        const hsprojectConfig = {
-            name: projectName,
-            srcDir: srcDir,
-            platformVersion: platformVersion,
-        };
-        return {
-            message: `Generated hsproject.json configuration for project "${projectName}"`,
-            config: JSON.stringify(hsprojectConfig, null, 2),
-            filename: "hsproject.json",
-            instructions: [
-                "Place this hsproject.json file in your project's root directory",
-                "This file designates the folder as a developer project",
-                `Source code should be placed in the '${srcDir}' directory`,
-                `Project will use platform version ${platformVersion}`,
-            ],
-        };
-    }
-}
-export default GenerateProjectConfigTool;

package/mcp-server/tools/HubSpotCLIHelper.d.ts

@@ -1,24 +0,0 @@
-interface CLICheckResult {
-    isInstalled: boolean;
-    version?: string;
-    debugInfo?: {
-        command: string;
-        success: boolean;
-        output: string;
-        error?: string;
-        env?: Record<string, string | undefined>;
-    };
-}
-interface CommandResult {
-    success: boolean;
-    output: string;
-    error?: string;
-}
-export declare class HubSpotCLIHelper {
-    private execAsync;
-    checkCLIInstallation(): Promise<CLICheckResult>;
-    installCLI(): Promise<CommandResult>;
-    runCommand(command: string): Promise<CommandResult>;
-    runProjectCommand(command: string, projectPath?: string): Promise<CommandResult>;
-}
-export default HubSpotCLIHelper;

package/mcp-server/tools/HubSpotCLIHelper.js

@@ -1,110 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-export class HubSpotCLIHelper {
-    execAsync = promisify(exec);
-    async checkCLIInstallation() {
-        try {
-            // Run hs --version to check if CLI is installed
-            const result = await this.runCommand('hs --version');
-            const debugInfo = {
-                command: 'hs --version',
-                success: result.success,
-                output: result.output,
-                error: result.error,
-                env: {
-                    PATH: process.env.PATH,
-                    NODE_PATH: process.env.NODE_PATH,
-                    npm_config_prefix: process.env.npm_config_prefix,
-                },
-            };
-            if (result.success) {
-                // Parse version from output (typically like "@hubspot/cli/4.0.0 darwin-x64 node-v18.17.0")
-                const versionMatch = result.output.match(/@hubspot\/cli\/(\d+\.\d+\.\d+)/);
-                const version = versionMatch ? versionMatch[1] : result.output.trim();
-                return {
-                    isInstalled: true,
-                    version: version,
-                    debugInfo,
-                };
-            }
-            else {
-                return {
-                    isInstalled: false,
-                    debugInfo,
-                };
-            }
-        }
-        catch (error) {
-            return {
-                isInstalled: false,
-                debugInfo: {
-                    command: 'hs --version',
-                    success: false,
-                    output: '',
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                    env: {
-                        PATH: process.env.PATH,
-                        NODE_PATH: process.env.NODE_PATH,
-                        npm_config_prefix: process.env.npm_config_prefix,
-                    },
-                },
-            };
-        }
-    }
-    async installCLI() {
-        try {
-            return await this.runCommand('npm install -g @hubspot/cli');
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                success: false,
-                output: '',
-                error: errorMessage,
-            };
-        }
-    }
-    async runCommand(command) {
-        try {
-            // Use the same environment as the current process, including PATH
-            const result = await this.execAsync(command, {
-                env: process.env,
-                shell: '/bin/bash',
-            });
-            return {
-                success: true,
-                output: result.stdout || result.stderr || '',
-            };
-        }
-        catch (error) {
-            // Command failed (e.g., command not found, non-zero exit code)
-            const err = error;
-            return {
-                success: false,
-                output: err.stdout || '',
-                error: err.stderr || err.message || 'Command execution failed',
-            };
-        }
-    }
-    async runProjectCommand(command, projectPath = '.') {
-        try {
-            // Get absolute path to avoid any relative path issues
-            const path = await import('path');
-            const absoluteProjectPath = path.resolve(projectPath);
-            // Add debugging information about directories
-            const debugCommand = `echo "MCP Server CWD: $(pwd)" && echo "Project Path: ${absoluteProjectPath}" && ls -la "${absoluteProjectPath}" | head -5`;
-            // Change to the project directory and run command
-            const fullCommand = `cd "${absoluteProjectPath}" && ${debugCommand} && ${command}`;
-            return await this.runCommand(fullCommand);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                success: false,
-                output: '',
-                error: errorMessage,
-            };
-        }
-    }
-}
-export default HubSpotCLIHelper;

package/mcp-server/tools/UploadProjectTool.d.ts

@@ -1,44 +0,0 @@
-import { MCPTool } from 'mcp-framework';
-import { z } from 'zod';
-interface UploadProjectInput {
-    projectPath?: string;
-    accountId?: string;
-    autoInstallCLI?: boolean;
-}
-interface UploadResponse {
-    status: string;
-    message: string;
-    cliVersion?: string;
-    uploadOutput?: string;
-    accountId?: string;
-    projectPath?: string;
-    error?: string;
-    troubleshooting?: string[];
-    actions?: Array<{
-        action: string;
-        command: string;
-        description: string;
-    }>;
-    nextSteps?: string[];
-}
-declare class UploadProjectTool extends MCPTool<UploadProjectInput> {
-    name: string;
-    description: string;
-    private cliHelper;
-    schema: {
-        projectPath: {
-            type: z.ZodOptional<z.ZodString>;
-            description: string;
-        };
-        accountId: {
-            type: z.ZodOptional<z.ZodString>;
-            description: string;
-        };
-        autoInstallCLI: {
-            type: z.ZodOptional<z.ZodBoolean>;
-            description: string;
-        };
-    };
-    execute(input: UploadProjectInput): Promise<UploadResponse>;
-}
-export default UploadProjectTool;