@hubspot/cli 8.0.11-experimental.1 → 8.0.12-experimental.0

package/lib/link/prompts.js

@@ -0,0 +1,126 @@
+import { promptUser } from '../prompts/promptUtils.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { buildAccountRow, getNameColumnWidth, buildAccountHeader, sortDefaultFirst, } from './accountTableUtils.js';
+import { Separator } from '@inquirer/prompts';
+function buildColumnarChoices(accounts, localDefaultAccount) {
+    const rows = accounts.map(a => ({
+        ...buildAccountRow(a.accountId, a.accountId === localDefaultAccount),
+        disabled: a.disabled,
+        checked: a.checked,
+        hint: a.hint,
+    }));
+    const nameWidth = getNameColumnWidth(rows);
+    const header = buildAccountHeader(nameWidth);
+    return [
+        new Separator(header),
+        ...rows.map(row => {
+            const label = `${row.name.padEnd(nameWidth)}  ${row.accountId}`;
+            return {
+                name: row.hint ? `${label}  ${row.hint}` : label,
+                short: uiAccountDescription(Number(row.accountId), false),
+                value: Number(row.accountId),
+                disabled: row.disabled,
+                checked: row.checked,
+            };
+        }),
+    ];
+}
+function mapLinkAccountChoices(eligibleAccounts, inEligibleAccounts, accountOverrideId, localDefaultAccount, preselectedAccountId) {
+    const sortedIneligible = sortDefaultFirst(inEligibleAccounts, localDefaultAccount);
+    const accounts = [
+        ...eligibleAccounts.map(a => ({
+            accountId: a.accountId,
+            disabled: false,
+            checked: a.accountId === accountOverrideId ||
+                a.accountId === preselectedAccountId,
+            hint: a.accountId === accountOverrideId
+                ? commands.account.subcommands.link.prompts.fromHsAccount
+                : a.accountId === preselectedAccountId
+                    ? commands.account.subcommands.link.prompts.newlyAuthenticated
+                    : undefined,
+        })),
+        ...sortedIneligible.map(a => ({
+            accountId: a.accountId,
+            disabled: commands.account.subcommands.link.prompts.alreadyLinked,
+            checked: false,
+        })),
+    ];
+    return buildColumnarChoices(accounts, localDefaultAccount);
+}
+export async function promptForAction(state) {
+    const isSettingsEmpty = state.accounts.length === 0 && state.localDefaultAccount === undefined;
+    const { accountEditOption } = await promptUser({
+        type: 'list',
+        name: 'accountEditOption',
+        message: isSettingsEmpty
+            ? commands.account.subcommands.link.prompts.howToProceed
+            : commands.account.subcommands.link.prompts.whatToDo,
+        choices: [
+            {
+                name: commands.account.subcommands.link.prompts.linkExisting,
+                value: 'link',
+            },
+            {
+                name: commands.account.subcommands.link.prompts.authenticateNew,
+                value: 'authenticate',
+            },
+            {
+                name: commands.account.subcommands.link.prompts.cancel,
+                value: 'cancel',
+            },
+        ],
+    });
+    uiLogger.log('');
+    return accountEditOption;
+}
+export async function promptForDefaultAccount(accounts, currentDefaultAccount, prompt = '') {
+    const choiceAccounts = accounts.map(accountId => ({
+        accountId,
+    }));
+    const choices = buildColumnarChoices(choiceAccounts, currentDefaultAccount);
+    const { defaultAccount } = await promptUser({
+        type: 'list',
+        name: 'defaultAccount',
+        pageSize: 20,
+        message: prompt || commands.account.subcommands.link.prompts.selectDefault,
+        choices,
+        default: currentDefaultAccount ?? undefined,
+    });
+    uiLogger.log('');
+    return defaultAccount;
+}
+export async function promptForAccountsToLink(context, eligibleAccounts, inEligibleAccounts, localDefaultAccount) {
+    const { accountsToAdd } = await promptUser({
+        type: 'checkbox',
+        name: 'accountsToAdd',
+        pageSize: 20,
+        message: commands.account.subcommands.link.prompts.selectToLink,
+        choices: mapLinkAccountChoices(eligibleAccounts, inEligibleAccounts, context.accountOverrideId, localDefaultAccount, context.preselectedAccountId),
+        validate: (answer) => {
+            if (answer.length === 0) {
+                return commands.account.subcommands.link.prompts.mustSelectOne;
+            }
+            return true;
+        },
+    });
+    uiLogger.log('');
+    return accountsToAdd;
+}
+export async function promptForAccountsToUnlink(accounts, localDefaultAccount) {
+    const sortedAccounts = sortDefaultFirst(accounts, localDefaultAccount);
+    const choiceAccounts = sortedAccounts.map(accountId => ({
+        accountId,
+    }));
+    const choices = buildColumnarChoices(choiceAccounts, localDefaultAccount);
+    const { accountsToRemove } = await promptUser({
+        type: 'checkbox',
+        name: 'accountsToRemove',
+        pageSize: 20,
+        message: commands.account.subcommands.link.prompts.selectToUnlink,
+        choices,
+    });
+    uiLogger.log('');
+    return accountsToRemove;
+}

package/lib/link/renderLinkedAccountsTable.d.ts

@@ -0,0 +1,2 @@
+import { HsSettingsFile } from '@hubspot/local-dev-lib/types/HsSettings';
+export declare function renderLinkedAccountsTable(settings: HsSettingsFile): Promise<void>;

package/lib/link/renderLinkedAccountsTable.js

@@ -0,0 +1,14 @@
+import { commands } from '../../lang/en.js';
+import { renderTable } from '../../ui/render.js';
+import { buildAccountRow, sortDefaultFirst } from './accountTableUtils.js';
+export async function renderLinkedAccountsTable(settings) {
+    const labels = commands.account.subcommands.list.labels;
+    const tableHeader = [labels.name, labels.accountId];
+    const sortedAccounts = sortDefaultFirst(settings.accounts, settings.localDefaultAccount);
+    const tableData = sortedAccounts.map(accountId => {
+        const isDefault = accountId === settings.localDefaultAccount;
+        const row = buildAccountRow(accountId, isDefault);
+        return [row.name, row.accountId];
+    });
+    await renderTable(tableHeader, tableData, true);
+}

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/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

@@ -2,7 +2,7 @@ import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_
 import { commands, lib } from '../../../lang/en.js';
 import { listPrompt } from '../../prompts/promptUtils.js';
 import { APP_EVENTS_KEY as AppEventsKey } from '@hubspot/project-parsing-lib/constants';
-import { isV2Project } from '../platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import path from 'path';
 import { getConfigForPlatformVersion } from './legacy.js';
 import { hasFeature } from '../../hasFeature.js';
@@ -134,7 +134,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.js

@@ -10,7 +10,7 @@ import { PromptExitError } from '../errors/PromptExitError.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import { AUTO_GENERATED_COMPONENT_TYPES } from '@hubspot/project-parsing-lib/constants';
 import { mapToUserFacingType } from '@hubspot/project-parsing-lib/transform';
-import { isV2Project } from './platformVersion.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 import { COMPONENT_TYPES, SUBCOMPONENT_TYPES, } from '@hubspot/local-dev-lib/enums/build';
 export const DELETION_POLL_TIMEOUT_MS = 5 * 60 * 1000;
 export const DELETION_DEPLOY_SUCCESS_STATES = [
@@ -81,7 +81,7 @@ export async function checkDeployedComponents(accountId, projectName) {
     if (!platformVersion) {
         throw new Error(commands.project.delete.errors.noPlatformVersion);
     }
-    if (!isV2Project(platformVersion)) {
+    if (isLegacyProject(platformVersion)) {
         const userVisibleComponents = [];
         projectData.deployedBuild?.subbuildStatuses?.forEach(item => {
             if (LEGACY_COMPONENTS_TO_FILTER.includes(item.buildType)) {

package/lib/projects/deploy.d.ts

@@ -10,4 +10,4 @@ export declare function logDeployErrors(errorData: {
         };
     }>;
 }): void;
-export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isV2Project: boolean, force: boolean): Promise<Deploy | undefined>;
+export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isLegacyProject: boolean, force: boolean): Promise<Deploy | undefined>;

package/lib/projects/deploy.js

@@ -47,9 +47,9 @@ function handleBlockedDeploy(deployResp) {
         uiLogger.log('');
     });
 }
-export async function handleProjectDeploy(targetAccountId, projectName, buildId, isV2Project, force) {
+export async function handleProjectDeploy(targetAccountId, projectName, buildId, isLegacyProject, force) {
     let deployId;
-    if (isV2Project) {
+    if (!isLegacyProject) {
         const { data: deployResp } = await deployProjectV2(targetAccountId, projectName, buildId, force);
         if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
             if (deployResp?.buildResultType === 'DEPLOY_BLOCKED') {

package/lib/projects/preview.d.ts

@@ -0,0 +1,7 @@
+type PreviewResult = {
+    succeeded: boolean;
+    releaseTag?: string;
+    appId?: number;
+};
+export declare function triggerAndPollPreview(accountId: number, projectId: number, buildId: number, targetPortalId: number): Promise<PreviewResult>;
+export {};

package/lib/projects/preview.js

@@ -0,0 +1,71 @@
+import { triggerAutoRelease, getAutoReleaseStatus, } from '@hubspot/local-dev-lib/api/projects';
+import { DEFAULT_POLLING_DELAY } from '../constants.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { lib } from '../../lang/en.js';
+const PREVIEW_POLL_TIMEOUT = 5 * 60 * 1000;
+export async function triggerAndPollPreview(accountId, projectId, buildId, targetPortalId) {
+    let triggerResponse;
+    SpinniesManager.add('preview', {
+        text: lib.projectPreview.triggeringPreview(buildId, targetPortalId),
+        succeedColor: 'white',
+    });
+    try {
+        const { data } = await triggerAutoRelease(accountId, projectId, buildId, targetPortalId);
+        triggerResponse = data;
+    }
+    catch (e) {
+        SpinniesManager.fail('preview', {
+            text: lib.projectPreview.triggerFailed,
+        });
+        logError(e, new ApiErrorContext({
+            accountId,
+            request: 'preview trigger',
+        }));
+        return { succeeded: false };
+    }
+    const { releaseTag, appId } = triggerResponse;
+    SpinniesManager.update('preview', {
+        text: lib.projectPreview.pollingStatus(releaseTag, targetPortalId),
+    });
+    try {
+        await pollPreviewStatus(accountId, projectId, targetPortalId, releaseTag, appId);
+    }
+    catch (e) {
+        SpinniesManager.fail('preview', {
+            text: lib.projectPreview.pollFailed,
+        });
+        logError(e, new ApiErrorContext({
+            accountId,
+            request: 'preview status',
+        }));
+        return { succeeded: false, releaseTag, appId };
+    }
+    SpinniesManager.succeed('preview', {
+        text: lib.projectPreview.succeeded(releaseTag, targetPortalId),
+    });
+    return { succeeded: true, releaseTag, appId };
+}
+function pollPreviewStatus(accountId, projectId, targetPortalId, expectedReleaseTag, appId) {
+    return new Promise((resolve, reject) => {
+        const startTime = Date.now();
+        const pollInterval = setInterval(async () => {
+            try {
+                const { data } = await getAutoReleaseStatus(accountId, projectId, targetPortalId, expectedReleaseTag, appId);
+                if (data.status === 'COMPLETE') {
+                    clearInterval(pollInterval);
+                    resolve();
+                    return;
+                }
+                if (Date.now() - startTime >= PREVIEW_POLL_TIMEOUT) {
+                    clearInterval(pollInterval);
+                    reject(new Error(lib.projectPreview.timeout));
+                }
+            }
+            catch (e) {
+                clearInterval(pollInterval);
+                reject(e);
+            }
+        }, DEFAULT_POLLING_DELAY);
+    });
+}

package/lib/projects/uieLinting.d.ts

@@ -1,8 +1,13 @@
 export declare const REQUIRED_PACKAGES_AND_MIN_VERSIONS: {
     readonly eslint: "9.0.0";
-    readonly '@typescript-eslint/eslint-plugin': "8.46.4";
-    readonly '@typescript-eslint/parser': "8.46.4";
+    readonly '@eslint/js': "9.0.0";
     readonly 'typescript-eslint': "8.46.4";
+    readonly '@hubspot/eslint-config-ui-extensions': "1.0.0";
+    readonly 'eslint-config-prettier': "10.0.0";
+    readonly 'eslint-plugin-react': "7.0.0";
+    readonly 'eslint-plugin-react-hooks': "7.0.0";
+    readonly 'eslint-plugin-unused-imports': "4.0.0";
+    readonly prettier: "3.0.0";
     readonly jiti: "2.6.1";
 };
 export declare function isEslintInstalled(directory: string): boolean;
@@ -13,7 +18,7 @@ export declare function getMissingLintPackages(directory: string): {
 export declare function hasEslintConfig(directory: string): boolean;
 export declare function hasDeprecatedEslintConfig(directory: string): boolean;
 export declare function getDeprecatedEslintConfigFiles(directory: string): string[];
-export declare function createEslintConfig(directory: string): string;
+export declare function createEslintConfig(directory: string, platformVersion?: string | null): Promise<string>;
 export declare function lintPackagesInDirectory(directory: string, projectDir?: string): Promise<{
     success: boolean;
     output: string;

package/lib/projects/uieLinting.js

@@ -3,17 +3,27 @@ import path from 'path';
 import util from 'util';
 import semver from 'semver';
 import { exec as execAsync } from 'node:child_process';
+import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
 import { getProjectPackageJsonLocations, isPackageInstalled, } from '../dependencyManagement.js';
 import { commands } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
 import { safeGetPackageJsonCached } from '../npm/packageJson.js';
+import { debugError } from '../errorHandlers/index.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../constants.js';
 export const REQUIRED_PACKAGES_AND_MIN_VERSIONS = {
     eslint: '9.0.0',
-    '@typescript-eslint/eslint-plugin': '8.46.4',
-    '@typescript-eslint/parser': '8.46.4',
+    '@eslint/js': '9.0.0',
     'typescript-eslint': '8.46.4',
+    '@hubspot/eslint-config-ui-extensions': '1.0.0',
+    'eslint-config-prettier': '10.0.0',
+    'eslint-plugin-react': '7.0.0',
+    'eslint-plugin-react-hooks': '7.0.0',
+    'eslint-plugin-unused-imports': '4.0.0',
+    prettier: '3.0.0',
     jiti: '2.6.1',
 };
+const UIE_ESLINT_CONFIG_PATH_IN_REPO = 'components/cards/src/app/cards/eslint.config.js';
 const ESLINT_CONFIG_FILES = [
     'eslint.config.mts',
     'eslint.config.ts',
@@ -30,28 +40,6 @@ const DEPRECATED_ESLINT_CONFIG_FILES = [
     '.eslintrc.json',
     '.eslintrc',
 ];
-const ESLINT_CONFIG_TEMPLATE = `import { defineConfig } from "eslint/config";
-import tsParser from "@typescript-eslint/parser";
-
-export default defineConfig([
-  {
-    files: ["**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        ecmaVersion: "latest",
-        sourceType: "module",
-        ecmaFeatures: {
-          jsx: true
-        }
-      }
-    },
-    rules: {
-      "no-console": ["warn", { allow: ["warn", "error"] }]
-    }
-  },
-]);
-`;
 function getPackageVersionFromPackageJson(directory, packageName) {
     const packageJsonPath = path.join(directory, 'package.json');
     const packageJson = safeGetPackageJsonCached(packageJsonPath);
@@ -127,10 +115,43 @@ export function getDeprecatedEslintConfigFiles(directory) {
         return fs.existsSync(configPath);
     });
 }
-export function createEslintConfig(directory) {
-    const configPath = path.join(directory, 'eslint.config.mts');
+function repoFileDataToString(data) {
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (Buffer.isBuffer(data)) {
+        return data.toString('utf-8');
+    }
+    return String(data);
+}
+export async function createEslintConfig(directory, platformVersion) {
+    const versionForRemote = platformVersion && !isLegacyProject(platformVersion)
+        ? platformVersion
+        : null;
+    if (versionForRemote === null) {
+        const message = commands.project.lint.createEslintConfigRequiresV2Platform(platformVersion);
+        uiLogger.error(message);
+        throw new Error(message);
+    }
+    let fetchedContent = null;
+    try {
+        const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${versionForRemote}/${UIE_ESLINT_CONFIG_PATH_IN_REPO}`, DEFAULT_PROJECT_TEMPLATE_BRANCH);
+        const content = repoFileDataToString(data);
+        if (content.trim().length > 0) {
+            fetchedContent = content;
+        }
+    }
+    catch (error) {
+        debugError(error);
+    }
+    if (fetchedContent === null) {
+        const message = commands.project.lint.failedToFetchRemoteEslintConfig(versionForRemote);
+        uiLogger.error(message);
+        throw new Error(message);
+    }
+    const configPath = path.join(directory, 'eslint.config.js');
     try {
-        fs.writeFileSync(configPath, ESLINT_CONFIG_TEMPLATE, 'utf-8');
+        fs.writeFileSync(configPath, fetchedContent, 'utf-8');
         return path.relative(process.cwd(), configPath);
     }
     catch (error) {

package/lib/projects/upload.d.ts

@@ -5,6 +5,7 @@ type ProjectUploadResult<T> = {
     result?: T;
     uploadError?: unknown;
     projectNotFound?: boolean;
+    projectId?: number;
 };
 type HandleProjectUploadArg<T> = {
     accountId: number;

package/lib/projects/upload.js

@@ -13,11 +13,11 @@ import util from 'node:util';
 import { lib } from '../../lang/en.js';
 import { ensureProjectExists } from './ensureProjectExists.js';
 import { uiLogger } from '../ui/logger.js';
-import { isV2Project } from './platformVersion.js';
 import ProjectValidationError from '../errors/ProjectValidationError.js';
 import { walk } from '@hubspot/local-dev-lib/fs';
 import { LEGACY_CONFIG_FILES } from '../constants.js';
 import { archiveWorkspacesAndDependencies, getPackageJsonPathsToUpdate, getLockfilePathsToUpdate, } from './workspaces.js';
+import { isLegacyProject } from '@hubspot/project-parsing-lib/projects';
 async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
     const accountIdentifier = uiAccountDescription(accountId) || `${accountId}`;
     SpinniesManager.add('upload', {
@@ -54,7 +54,7 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
     // Versions <= 2025.1 do not support the new npm workspaces bundling behavior.
     let workspaceMappings = [];
     let fileDependencyMappings = [];
-    if (isV2Project(projectConfig.platformVersion)) {
+    if (!isLegacyProject(projectConfig.platformVersion)) {
         const parsedPackageJsons = await findAndParsePackageJsonFiles(srcDir);
         workspaceMappings = await collectWorkspaceDirectories(parsedPackageJsons);
         fileDependencyMappings = await collectFileDependencies(parsedPackageJsons);
@@ -79,7 +79,7 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
                     return resolve({ uploadError: e });
                 }
             }
-            const { projectExists } = await ensureProjectExists(accountId, projectConfig.name, {
+            const { projectExists, project } = await ensureProjectExists(accountId, projectConfig.name, {
                 forceCreate,
                 uploadCommand: isUploadCommand,
                 noLogs: true,
@@ -88,13 +88,14 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
                 uiLogger.log(lib.projectUpload.handleProjectUpload.projectDoesNotExist(accountId));
                 return resolve({ projectNotFound: true });
             }
+            const projectId = project?.id;
             const { buildId, error } = await uploadProjectFiles(accountId, projectConfig.name, tempFile.name, uploadMessage, projectConfig.platformVersion, intermediateRepresentation);
             if (error) {
-                resolve({ uploadError: error });
+                resolve({ uploadError: error, projectId });
             }
             else if (callbackFunc) {
                 const uploadResult = await callbackFunc(accountId, projectConfig, tempFile, buildId);
-                resolve({ result: uploadResult });
+                resolve({ result: uploadResult, projectId });
             }
         }
         catch (e) {
@@ -132,7 +133,7 @@ export async function validateSourceDirectory(srcDir, projectConfig, projectDir)
     if (!projectFilePaths || projectFilePaths.length === 0) {
         throw new ProjectValidationError(lib.projectUpload.handleProjectUpload.emptySource(projectConfig.srcDir));
     }
-    if (isV2Project(projectConfig.platformVersion)) {
+    if (!isLegacyProject(projectConfig.platformVersion)) {
         projectFilePaths.forEach(filePath => {
             const filename = path.basename(filePath);
             if (LEGACY_CONFIG_FILES.includes(filename)) {
@@ -143,7 +144,7 @@ export async function validateSourceDirectory(srcDir, projectConfig, projectDir)
 }
 export async function validateNoHSMetaMismatch(srcDir, projectConfig) {
     const hasHsMetaFiles = await projectContainsHsMetaFiles(srcDir);
-    if (!isV2Project(projectConfig.platformVersion) && hasHsMetaFiles) {
+    if (isLegacyProject(projectConfig.platformVersion) && hasHsMetaFiles) {
         throw new ProjectValidationError(lib.projectUpload.wrongPlatformVersionMetaFiles);
     }
 }

package/lib/prompts/projectsLogsPrompt.js

@@ -4,6 +4,9 @@ export async function projectLogsPrompt({ functionChoices, promptOptions, projec
     if (!functionChoices) {
         return {};
     }
+    if (promptOptions?.function) {
+        return { functionName: promptOptions.function };
+    }
     if (functionChoices.length === 1) {
         return { functionName: functionChoices[0] };
     }

package/lib/prompts/promptUtils.js

@@ -42,6 +42,7 @@ function mapPromptChoicesToChoices(choices) {
         return {
             value: choice.value,
             name: choice.name,
+            short: choice.short,
             disabled: choice.disabled,
             checked: choice.checked,
         };

package/lib/theme/cmsDevServerProcess.js

@@ -10,7 +10,7 @@ import { EXIT_CODES } from '../enums/exitCodes.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // cms-dev-server version to install to isolated cache
-const TARGET_CMS_DEV_SERVER_VERSION = '1.2.16';
+const TARGET_CMS_DEV_SERVER_VERSION = '1.2.26';
 /**
  * Ensures cms-dev-server is installed in an isolated cache directory.
  * This prevents React version conflicts with the CLI.

package/mcp-server/Tool.d.ts

@@ -0,0 +1,15 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from './utils/logger.js';
+import { TextContentResponse } from './types.js';
+export declare class Tool<InputSchema> {
+    protected mcpServer: McpServer;
+    protected logger: McpLogger;
+    protected toolName: string;
+    constructor(mcpServer: McpServer, logger: McpLogger, toolName: string);
+    register(): RegisteredTool;
+    handler(input: InputSchema): TextContentResponse | Promise<TextContentResponse>;
+    protected getTrackingMeta(input: InputSchema): {
+        [key: string]: string;
+    } | undefined;
+    protected wrappedHandler(input: InputSchema): Promise<TextContentResponse>;
+}

package/mcp-server/Tool.js

@@ -0,0 +1,53 @@
+import { formatTextContents } from './utils/content.js';
+import { getErrorMessage } from '../lib/errorHandlers/index.js';
+import { trackToolUsage } from './utils/toolUsageTracking.js';
+export class Tool {
+    mcpServer;
+    logger;
+    toolName;
+    constructor(mcpServer, logger, toolName) {
+        this.mcpServer = mcpServer;
+        this.logger = logger;
+        this.toolName = toolName;
+    }
+    register() {
+        throw new Error('Must implement register');
+    }
+    handler(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    input) {
+        throw new Error('Must implement handler');
+    }
+    getTrackingMeta(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    input) {
+        return undefined;
+    }
+    async wrappedHandler(input) {
+        const startTime = Date.now();
+        try {
+            // `input` is logged unredacted. Tool input schemas MUST NOT include
+            // credentials or other sensitive values, since MCP clients (Claude
+            // Desktop, Inspector, etc.) will display these logs.
+            this.logger.debug(this.toolName, {
+                message: 'Tool invoked',
+                args: input,
+            });
+            await trackToolUsage(this.toolName, this.getTrackingMeta(input));
+            const result = await this.handler(input);
+            this.logger.debug(this.toolName, {
+                message: 'Tool completed',
+                durationMs: Date.now() - startTime,
+            });
+            return result;
+        }
+        catch (error) {
+            this.logger.error(this.toolName, {
+                message: 'Tool failed',
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - startTime,
+            });
+            return formatTextContents(getErrorMessage(error));
+        }
+    }
+}