@hubspot/cli 8.2.0 → 8.2.1-experimental.0

package/lib/mcp/promotion.js

@@ -0,0 +1,109 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { getStateValue, setStateValue, } from '@hubspot/local-dev-lib/config/state';
+import { STATE_FLAGS } from '@hubspot/local-dev-lib/constants/config';
+import { commands } from '../../lang/en.js';
+import { debugError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { trackMcpPromotionShown } from '../usageTracking.js';
+import { MCP_CLIENTS, MCP_SERVER_NAME } from './clients.js';
+const ONE_WEEK_IN_MS = 7 * 24 * 60 * 60 * 1000;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function configContainsMcpServer(value) {
+    if (typeof value === 'string') {
+        return value === MCP_SERVER_NAME;
+    }
+    if (Array.isArray(value)) {
+        return value.some(configContainsMcpServer);
+    }
+    if (!isRecord(value)) {
+        return false;
+    }
+    return Object.entries(value).some(([key, childValue]) => {
+        return key === MCP_SERVER_NAME || configContainsMcpServer(childValue);
+    });
+}
+function textConfigContainsMcpServer(configContent) {
+    return configContent.includes(MCP_SERVER_NAME);
+}
+function jsonConfigContainsMcpServer(configContent) {
+    const parsedConfig = JSON.parse(configContent);
+    return configContainsMcpServer(parsedConfig);
+}
+export function detectConfiguredMcpClients() {
+    const homeDirectory = os.homedir();
+    return MCP_CLIENTS.reduce((clients, client) => {
+        try {
+            const configPath = path.join(homeDirectory, ...client.detection.pathSegments);
+            if (!fs.existsSync(configPath)) {
+                return clients;
+            }
+            const configContent = fs.readFileSync(configPath, 'utf8');
+            const hasMcpServer = client.detection.type === 'json'
+                ? jsonConfigContainsMcpServer(configContent)
+                : textConfigContainsMcpServer(configContent);
+            if (hasMcpServer) {
+                clients.push(client.id);
+            }
+        }
+        catch (e) {
+            debugError(e);
+            return clients;
+        }
+        return clients;
+    }, []);
+}
+function isScriptSafeSuppressed() {
+    return Boolean(process.env.CI || process.env.HUBSPOT_MCP_AI_AGENT || !process.stdout.isTTY);
+}
+function hasRecentPromotion(lastShownAt, now, cooldownMs) {
+    if (!lastShownAt) {
+        return false;
+    }
+    const lastShownTime = new Date(lastShownAt).getTime();
+    if (Number.isNaN(lastShownTime)) {
+        return false;
+    }
+    return now.getTime() - lastShownTime < cooldownMs;
+}
+function getMcpPromotionLastShownAt() {
+    return getStateValue(STATE_FLAGS.MCP_PROMOTION_LAST_SHOWN_AT);
+}
+export async function shouldShowMcpPromotion() {
+    if (isScriptSafeSuppressed()) {
+        return false;
+    }
+    try {
+        const mcpTotalToolCalls = getStateValue(STATE_FLAGS.MCP_TOTAL_TOOL_CALLS);
+        if (typeof mcpTotalToolCalls === 'number' && mcpTotalToolCalls > 0) {
+            return false;
+        }
+        if (detectConfiguredMcpClients().length > 0) {
+            return false;
+        }
+        return !hasRecentPromotion(getMcpPromotionLastShownAt(), new Date(), ONE_WEEK_IN_MS);
+    }
+    catch (e) {
+        debugError(e);
+        return false;
+    }
+}
+function setMcpPromotionShownAt() {
+    setStateValue(STATE_FLAGS.MCP_PROMOTION_LAST_SHOWN_AT, new Date().toISOString());
+}
+export async function showMcpPromotionNudge(commandName) {
+    try {
+        if (!(await shouldShowMcpPromotion())) {
+            return;
+        }
+        setMcpPromotionShownAt();
+        uiLogger.info(commands.mcp.promotion.activeNudge);
+        await trackMcpPromotionShown(commandName || undefined);
+    }
+    catch (e) {
+        debugError(e);
+    }
+}

package/lib/mcp/setup.d.ts

@@ -7,11 +7,17 @@ interface McpCommand {
     args: string[];
     env?: Record<string, string>;
 }
-export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
+interface ConfigureMcpServerOptions {
+    targets?: string[];
+    standalone?: boolean;
+    cliVersion?: string;
+}
+export declare function configureMcpServer(options: ConfigureMcpServerOptions): Promise<string[]>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupCursor(mcpCommand?: McpCommand): boolean;
-export declare function setupWindsurf(mcpCommand?: McpCommand): boolean;
+export declare function setupDevin(mcpCommand?: McpCommand): boolean;
 export declare function setupCodex(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupGemini(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupOpenCode(mcpCommand?: McpCommand): Promise<boolean>;
 export {};

package/lib/mcp/setup.js

@@ -4,31 +4,43 @@ import { promptUser } from '../prompts/promptUtils.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { logError, getErrorMessage } from '../errorHandlers/index.js';
 import { execAsync } from '../../mcp-server/utils/command.js';
+import { MCP_CLIENTS, MCP_SERVER_NAME, getMcpClientPathSegments, } from './clients.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import { existsSync } from 'fs';
-const mcpServerName = 'HubSpotDev';
+const mcpServerName = MCP_SERVER_NAME;
 const claudeCode = 'claude';
-const windsurf = 'windsurf';
 const cursor = 'cursor';
+const devin = 'devin';
 const vscode = 'vscode';
 const codex = 'codex';
 const gemini = 'gemini';
+const opencode = 'opencode';
+const OTHER_TOOL = 'other';
+const clientLabels = {
+    codex: commands.mcp.setup.codex,
+    claude: commands.mcp.setup.claudeCode,
+    cursor: commands.mcp.setup.cursor,
+    devin: commands.mcp.setup.devin,
+    gemini: commands.mcp.setup.gemini,
+    opencode: commands.mcp.setup.opencode,
+    vscode: commands.mcp.setup.vsCode,
+};
 export const supportedTools = [
-    { name: commands.mcp.setup.codex, value: codex },
-    { name: commands.mcp.setup.claudeCode, value: claudeCode },
-    { name: commands.mcp.setup.cursor, value: cursor },
-    { name: commands.mcp.setup.gemini, value: gemini },
-    { name: commands.mcp.setup.vsCode, value: vscode },
-    { name: commands.mcp.setup.windsurf, value: windsurf },
+    ...MCP_CLIENTS.map(client => ({
+        name: clientLabels[client.id],
+        value: client.id,
+    })),
+    { name: commands.mcp.setup.other, value: OTHER_TOOL },
 ];
 const defaultMcpCommand = {
     command: 'hs',
     args: ['mcp', 'start'],
 };
-export async function addMcpServerToConfig(targets) {
+export async function configureMcpServer(options) {
     try {
+        const { targets, standalone, cliVersion: cliVersionFlag } = options;
         let derivedTargets = [];
         if (!targets || targets.length === 0) {
             const { selectedTargets } = await promptUser({
@@ -36,6 +48,7 @@ export async function addMcpServerToConfig(targets) {
                 type: 'checkbox',
                 message: commands.mcp.setup.prompts.targets,
                 choices: supportedTools,
+                pageSize: supportedTools.length,
                 validate: (choices) => {
                     return choices.length === 0
                         ? commands.mcp.setup.prompts.targetsRequired
@@ -47,23 +60,34 @@ 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 onlyOther = derivedTargets.length === 1 && derivedTargets[0] === OTHER_TOOL;
+        let useStandaloneMode = onlyOther ? false : standalone;
+        if (useStandaloneMode === undefined) {
+            const response = await promptUser({
+                name: 'useStandaloneMode',
+                type: 'confirm',
+                message: commands.mcp.setup.prompts.standaloneMode,
+                default: false,
+            });
+            useStandaloneMode = response.useStandaloneMode;
+        }
+        let cliVersion = '';
+        if (useStandaloneMode) {
+            if (cliVersionFlag !== undefined) {
+                cliVersion = cliVersionFlag;
+            }
+            else {
+                const response = 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 = response.cliVersion;
+            }
+        }
         const cliPackage = cliVersion
             ? `@hubspot/cli@${cliVersion}`
             : '@hubspot/cli';
@@ -86,8 +110,8 @@ export async function addMcpServerToConfig(targets) {
         if (derivedTargets.includes(cursor)) {
             await runSetupFunction(() => setupCursor(mcpCommand));
         }
-        if (derivedTargets.includes(windsurf)) {
-            await runSetupFunction(() => setupWindsurf(mcpCommand));
+        if (derivedTargets.includes(devin)) {
+            await runSetupFunction(() => setupDevin(mcpCommand));
         }
         if (derivedTargets.includes(vscode)) {
             await runSetupFunction(() => setupVsCode(mcpCommand));
@@ -98,8 +122,17 @@ export async function addMcpServerToConfig(targets) {
         if (derivedTargets.includes(gemini)) {
             await runSetupFunction(() => setupGemini(mcpCommand));
         }
-        uiLogger.info(commands.mcp.setup.success(derivedTargets));
-        return derivedTargets;
+        if (derivedTargets.includes(opencode)) {
+            await runSetupFunction(() => setupOpenCode(mcpCommand));
+        }
+        if (derivedTargets.includes(OTHER_TOOL)) {
+            logOtherToolInstructions(mcpCommand);
+        }
+        const configuredTargets = derivedTargets.filter(t => t !== OTHER_TOOL);
+        if (configuredTargets.length > 0) {
+            uiLogger.info(commands.mcp.setup.success(configuredTargets));
+        }
+        return configuredTargets;
     }
     catch (error) {
         SpinniesManager.fail('mcpSetup', {
@@ -247,7 +280,7 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
     }
 }
 export function setupCursor(mcpCommand = defaultMcpCommand) {
-    const cursorConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    const cursorConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(cursor));
     return setupMcpConfigFile({
         configPath: cursorConfigPath,
         configuringMessage: commands.mcp.setup.spinners.configuringCursor,
@@ -256,14 +289,14 @@ export function setupCursor(mcpCommand = defaultMcpCommand) {
         mcpCommand: buildCommandWithAgentString(mcpCommand, cursor),
     });
 }
-export function setupWindsurf(mcpCommand = defaultMcpCommand) {
-    const windsurfConfigPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+export function setupDevin(mcpCommand = defaultMcpCommand) {
+    const devinConfigPath = path.join(os.homedir(), ...getMcpClientPathSegments(devin));
     return setupMcpConfigFile({
-        configPath: windsurfConfigPath,
-        configuringMessage: commands.mcp.setup.spinners.configuringWindsurf,
-        configuredMessage: commands.mcp.setup.spinners.configuredWindsurf,
-        failedMessage: commands.mcp.setup.spinners.failedToConfigureWindsurf,
-        mcpCommand: buildCommandWithAgentString(mcpCommand, windsurf),
+        configPath: devinConfigPath,
+        configuringMessage: commands.mcp.setup.spinners.configuringDevin,
+        configuredMessage: commands.mcp.setup.spinners.configuredDevin,
+        failedMessage: commands.mcp.setup.spinners.failedToConfigureDevin,
+        mcpCommand: buildCommandWithAgentString(mcpCommand, devin),
     });
 }
 export async function setupCodex(mcpCommand = defaultMcpCommand) {
@@ -325,6 +358,58 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
         return false;
     }
 }
+export async function setupOpenCode(mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add('openCodeSpinner', {
+            text: commands.mcp.setup.spinners.configuringOpenCode,
+        });
+        try {
+            await execAsync('opencode --version');
+        }
+        catch (error) {
+            SpinniesManager.fail('openCodeSpinner', {
+                text: commands.mcp.setup.spinners.openCodeNotFound,
+            });
+            return false;
+        }
+        const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, opencode);
+        await execAsync(`opencode mcp add "${mcpServerName}"${buildEnvFlagString(mcpCommand)} -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
+        SpinniesManager.succeed('openCodeSpinner', {
+            text: commands.mcp.setup.spinners.configuredOpenCode,
+        });
+        return true;
+    }
+    catch (error) {
+        SpinniesManager.fail('openCodeSpinner', {
+            text: commands.mcp.setup.spinners.openCodeInstallFailed,
+        });
+        logError(error);
+        return false;
+    }
+}
+function logOtherToolInstructions(mcpCommand) {
+    const { otherInstructions } = commands.mcp.setup;
+    uiLogger.log('');
+    uiLogger.log(otherInstructions.header);
+    uiLogger.log(otherInstructions.docsNote);
+    uiLogger.log('');
+    uiLogger.log(`  ${otherInstructions.commandLabel}`);
+    uiLogger.log(`    ${mcpCommand.command} ${mcpCommand.args.join(' ')}`);
+    uiLogger.log('');
+    uiLogger.log(`  ${otherInstructions.jsonLabel}`);
+    uiLogger.log('');
+    const jsonConfig = {
+        mcpServers: {
+            [mcpServerName]: mcpCommand,
+        },
+    };
+    const indented = JSON.stringify(jsonConfig, null, 2)
+        .split('\n')
+        .map(line => `    ${line}`)
+        .join('\n');
+    uiLogger.log(indented);
+    uiLogger.log('');
+}
 function buildCommandWithAgentString(mcpCommand, agent) {
     const mcpCommandCopy = structuredClone(mcpCommand);
     mcpCommandCopy.args.push('--ai-agent', agent);

package/lib/middleware/autoUpdateMiddleware.js

@@ -42,6 +42,10 @@ export async function autoUpdateCLI(argv) {
         debugError(e);
     }
     const cliUpgradeInfo = getCliUpgradeInfo();
+    // Ignore all update notifications if the current version is a pre-release (contains a hyphen)
+    if (cliUpgradeInfo.current && cliUpgradeInfo.current.includes('-')) {
+        showManualInstallHelp = false;
+    }
     if (isAllowAutoUpdatesEnabled &&
         cliUpgradeInfo.current &&
         cliUpgradeInfo.latest &&
@@ -49,9 +53,8 @@ export async function autoUpdateCLI(argv) {
         !argv.useEnv &&
         !process.env.SKIP_HUBSPOT_CLI_AUTO_UPDATES &&
         !preventAutoUpdateForCommand(argv._)) {
-        // Ignore all update notifications if the current version is a pre-release (contains a hyphen)
-        if (cliUpgradeInfo.current.includes('-')) {
-            showManualInstallHelp = false;
+        if (!showManualInstallHelp) {
+            // Pre-release version detected, skip auto-update
         }
         else if (!['major', 'latest'].includes(cliUpgradeInfo.type)) {
             // type "latest" => current installed version is latest

package/lib/middleware/commandTargetingUtils.js

@@ -21,6 +21,7 @@ const SKIP_CONFIG_LOADING_COMMANDS = {
     init: true,
     feedback: true,
     mcp: { start: true },
+    project: { lint: true },
 };
 // Returns true if the command requires a config file to be present
 export function shouldLoadConfigForCommand(commandParts) {

package/lib/npm/npmCli.d.ts

@@ -4,6 +4,7 @@ export declare function getLatestPackageVersion(packageName: string): Promise<{
     latest: string | null;
     next: string | null;
 }>;
+export declare function getNpmExecErrorOutput(error: unknown): string | null;
 export declare function executeInstall(packages?: string[], flags?: string | null, options?: {
     cwd?: string;
 }): Promise<void>;

package/lib/npm/npmCli.js

@@ -23,6 +23,19 @@ export async function getLatestPackageVersion(packageName) {
         return { latest: null, next: null };
     }
 }
+function isNpmExecError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        ('stderr' in error || 'stdout' in error));
+}
+export function getNpmExecErrorOutput(error) {
+    if (!isNpmExecError(error)) {
+        return null;
+    }
+    const stderr = error.stderr?.trim();
+    const stdout = error.stdout?.trim();
+    return stderr || stdout || null;
+}
 export async function executeInstall(packages = [], flags, options) {
     const installCommand = `${DEFAULT_PACKAGE_MANAGER} install${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
     uiLogger.debug('Running', installCommand);

package/lib/process.d.ts

@@ -8,6 +8,6 @@ interface KeyPress {
 export declare const TERMINATION_SIGNALS: string[];
 export declare function handleExit(callback: (onTerminate: {
     isSIGHUP: boolean;
-}) => void): void;
+}) => void): () => void;
 export declare function handleKeypress(callback: (onKeyPress: KeyPress) => void): void;
 export {};

package/lib/process.js

@@ -16,9 +16,9 @@ export const TERMINATION_SIGNALS = [
 ];
 export function handleExit(callback) {
     let exitInProgress = false;
+    const listeners = [];
     TERMINATION_SIGNALS.forEach(signal => {
-        process.removeAllListeners(signal);
-        process.on(signal, async (...args) => {
+        const handler = async (...args) => {
             // Prevent duplicate exit handling
             if (!exitInProgress) {
                 exitInProgress = true;
@@ -38,8 +38,15 @@ export function handleExit(callback) {
                 }
                 await callback({ isSIGHUP });
             }
-        });
+        };
+        listeners.push({ signal, handler });
+        process.on(signal, handler);
     });
+    return () => {
+        for (const { signal, handler } of listeners) {
+            process.removeListener(signal, handler);
+        }
+    };
 }
 export function handleKeypress(callback) {
     readline.createInterface(process.stdin, process.stdout);

package/lib/projects/ProjectLogsManager.js

@@ -4,7 +4,7 @@ import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/proje
 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 { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { getDeployedProjectNodes } from './localDev/helpers/project.js';
 import { debugError } from '../errorHandlers/index.js';
 class _ProjectLogsManager {
@@ -51,7 +51,7 @@ class _ProjectLogsManager {
             throw new Error(commands.project.logs.errors.failedToFetchProjectDetails);
         }
         this.projectId = project.id;
-        if (isV2Project(projectConfig.platformVersion)) {
+        if (!isLegacyProject(projectConfig.platformVersion)) {
             const deployedBuildId = project.deployedBuild.buildId;
             if (!deployedBuildId) {
                 throw new Error(commands.project.logs.errors.noDeployedBuild);
@@ -134,9 +134,12 @@ class _ProjectLogsManager {
         return this.functions.map(serverlessFunction => serverlessFunction.componentName);
     }
     setFunction(functionName) {
-        if (!functionName || this.functions.length === 0) {
+        if (this.functions.length === 0) {
             throw new Error(commands.project.logs.errors.noFunctionsInProject);
         }
+        if (!functionName) {
+            throw new Error(commands.project.logs.errors.functionNameRequired);
+        }
         this.selectedFunction = this.functions.find(serverlessFunction => serverlessFunction.componentName === functionName);
         if (!this.selectedFunction) {
             throw new Error(commands.project.logs.errors.noFunctionWithName(functionName));

package/lib/projects/builds.d.ts

@@ -0,0 +1,2 @@
+import { type Build } from '@hubspot/local-dev-lib/types/Build';
+export declare function getLastSuccessfulBuild(accountId: number, projectName: string, latestBuild?: Build): Promise<Build | undefined>;

package/lib/projects/builds.js

@@ -0,0 +1,22 @@
+import { fetchProjectBuilds } from '@hubspot/local-dev-lib/api/projects';
+import { BUILD_STATUS } from '@hubspot/local-dev-lib/enums/build';
+export async function getLastSuccessfulBuild(accountId, projectName, latestBuild) {
+    if (latestBuild?.status === BUILD_STATUS.SUCCESS) {
+        return latestBuild;
+    }
+    let after;
+    let hasMore = true;
+    while (hasMore) {
+        const { data: { results, paging }, } = await fetchProjectBuilds(accountId, projectName, {
+            limit: 100,
+            ...(after ? { after } : {}),
+        });
+        const successfulBuild = results.find(build => build.status === BUILD_STATUS.SUCCESS);
+        if (successfulBuild) {
+            return successfulBuild;
+        }
+        after = paging?.next?.after;
+        hasMore = !!after;
+    }
+    return undefined;
+}

package/lib/projects/components.js

@@ -114,9 +114,19 @@ export function handleComponentCollision({ dest, src, collisions }) {
         }
     });
     const filenameDifferentiator = generateSafeFilenameDifferentiator(sourceFiles, hsMetaFiles);
-    // Exclude markdown files fromthe rename process because they should not be duplicated
     const sourceFilenameMapping = sourceFiles
-        .filter(filename => !filename.endsWith('.md'))
+        .filter(filename => {
+        // Exclude markdown files from the rename process because they should not be duplicated
+        if (filename.endsWith('.md')) {
+            return false;
+        }
+        // Also exclude the tooling config we add to new projects
+        const base = path.parse(filename).base;
+        if (base === '.prettierrc.json' || base === 'eslint.config.js') {
+            return false;
+        }
+        return true;
+    })
         .reduce((acc, filename) => {
         return {
             ...acc,
@@ -183,12 +193,13 @@ export async function updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMe
                 return component.uid;
             };
             let uid = getBaseUid();
-            let differentiator = 1;
+            let differentiator = 2;
             while (existingUids.includes(uid)) {
-                differentiator++;
                 uid = `${getBaseUid()}_${differentiator}`;
+                differentiator++;
             }
             component.uid = uid;
+            existingUids.push(uid);
             if (component.type === AppKey && component.config) {
                 component.config.name = `${projectName}-App`;
             }

package/lib/projects/create/index.js

@@ -1,7 +1,7 @@
 import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplatePrompt.js';
 import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
 import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, EMPTY_PROJECT, } from '../../constants.js';
-import { isV2Project } from '../platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { v2ComponentFlow } from './v2.js';
 import { getProjectTemplateListFromRepo } from './legacy.js';
 import { commands } from '../../../lang/en.js';
@@ -9,7 +9,7 @@ export async function handleProjectCreationFlow(args) {
     const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
     const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
     const projectNameAndDestPromptResponse = await projectNameAndDestPrompt(args);
-    if (isV2Project(platformVersion)) {
+    if (!isLegacyProject(platformVersion)) {
         const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v2ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, args.derivedAccountId);
         const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, undefined, projectContents !== EMPTY_PROJECT ? componentTemplateChoices : undefined);
         return {

package/lib/projects/create/legacy.js

@@ -1,13 +1,13 @@
 import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
 import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_COMPONENT_TYPES, } from '../../constants.js';
 import { debugError } from '../../errorHandlers/index.js';
-import { isV2Project } from '../platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { lib } from '../../../lang/en.js';
 const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
 export const EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
 export async function getConfigForPlatformVersion(platformVersion) {
     let path = '';
-    if (isV2Project(platformVersion)) {
+    if (!isLegacyProject(platformVersion)) {
         path = `${platformVersion}/`;
     }
     const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, DEFAULT_PROJECT_TEMPLATE_BRANCH);

package/lib/projects/create/v2.js

@@ -1,8 +1,8 @@
 import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_PROJECT, PROJECT_WITH_APP, FEATURES, } from '../../constants.js';
 import { commands, lib } from '../../../lang/en.js';
 import { listPrompt } from '../../prompts/promptUtils.js';
-import { APP_EVENTS_KEY as AppEventsKey, PAGES_KEY as PagesKey, } from '@hubspot/project-parsing-lib/constants';
-import { isV2Project } from '../platformVersion.js';
+import { APP_EVENTS_KEY as AppEventsKey } from '@hubspot/project-parsing-lib/constants';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import path from 'path';
 import { getConfigForPlatformVersion } from './legacy.js';
 import { hasFeature } from '../../hasFeature.js';
@@ -47,8 +47,8 @@ export async function createV2App(providedAuth, providedDistribution) {
 }
 const componentTypeToGateMap = {
     [AppEventsKey]: FEATURES.APP_EVENTS,
-    [PagesKey]: FEATURES.APPS_HOME,
     'workflow-action-tool': FEATURES.AGENT_TOOLS,
+    'crm-bulk-action': FEATURES.APP_ACTIONS,
 };
 export async function calculateComponentTemplateChoices(components, authType, distribution, accountId, projectMetadata) {
     const enabledComponents = [];
@@ -113,11 +113,11 @@ export async function v2ComponentFlow(platformVersion, projectBase, providedAuth
     const projectContentsChoice = projectBase ||
         (await listPrompt(commands.project.create.prompts.parentComponents, {
             choices: [
+                { name: commands.project.create.prompts.app, value: PROJECT_WITH_APP },
                 {
                     name: commands.project.create.prompts.emptyProject,
                     value: EMPTY_PROJECT,
                 },
-                { name: commands.project.create.prompts.app, value: PROJECT_WITH_APP },
             ],
         }));
     if (projectContentsChoice === PROJECT_WITH_APP) {
@@ -135,7 +135,7 @@ export async function v2ComponentFlow(platformVersion, projectBase, providedAuth
     };
 }
 export function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
-    if (!isV2Project(platformVersion)) {
+    if (isLegacyProject(platformVersion)) {
         return [];
     }
     const components = selectProjectTemplatePromptResponse.componentTemplates?.map((componentTemplate) => {

package/lib/projects/delete.d.ts

@@ -0,0 +1,13 @@
+export declare const DELETION_POLL_TIMEOUT_MS: number;
+export declare const DELETION_DEPLOY_SUCCESS_STATES: string[];
+export declare const DELETION_DEPLOY_ERROR_STATES: ("FAILURE" | "ERROR" | "REVERTED")[];
+export declare function resolveProjectName(accountId: number, projectArg: string | undefined): Promise<string>;
+export declare function fetchProjectInstallCount(accountId: number, projectId: number): Promise<number>;
+export declare function checkDeployedComponents(accountId: number, projectName: string): Promise<{
+    platformVersion: string;
+    hasUnifiedComponents: boolean;
+    projectId: number;
+}>;
+export declare function deleteDeployedComponents(accountId: number, projectName: string): Promise<void>;
+export declare function handleProjectDeletion(accountId: number, projectName: string): Promise<void>;
+export declare function confirmDeletion(projectName: string, accountId: number, projectId: number): Promise<void>;