@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

package/commands/project/profile/add.d.ts

@@ -0,0 +1,7 @@
+import { YargsCommandModule, CommonArgs } from '../../../types/Yargs.js';
+type ProjectProfileAddArgs = CommonArgs & {
+    name?: string;
+    targetAccount?: number;
+};
+declare const projectProfileAddCommand: YargsCommandModule<unknown, ProjectProfileAddArgs>;
+export default projectProfileAddCommand;

package/commands/project/profile/add.js

@@ -0,0 +1,203 @@
+import path from 'path';
+import fs from 'fs';
+import { getConfigAccountIfExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
+import { getAllHsProfiles, getHsProfileFilename, loadHsProfileFile, } from '@hubspot/project-parsing-lib/profiles';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { getProjectConfig } from '../../../lib/projects/config.js';
+import { uiAccountDescription } from '../../../lib/ui/index.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { commands } from '../../../lang/en.js';
+import { promptUser, listPrompt, confirmPrompt, } from '../../../lib/prompts/promptUtils.js';
+import { fileExists } from '../../../lib/validation.js';
+import { debugError } from '../../../lib/errorHandlers/index.js';
+const command = 'add [name]';
+const describe = commands.project.profile.add.describe;
+const verboseDescribe = commands.project.profile.add.verboseDescribe;
+async function selectProfileToCopyVariablesFrom(existingProfiles) {
+    let profileToCopyVariablesFrom;
+    if (existingProfiles.length == 1) {
+        uiLogger.log('');
+        uiLogger.log(commands.project.profile.add.logs.copyExistingProfile(getHsProfileFilename(existingProfiles[0])));
+        const shouldCopyVariables = await confirmPrompt('Copy profile variables?', {
+            defaultAnswer: true,
+        });
+        if (shouldCopyVariables) {
+            profileToCopyVariablesFrom = existingProfiles[0];
+        }
+    }
+    else if (existingProfiles.length > 1) {
+        uiLogger.log('');
+        uiLogger.log(commands.project.profile.add.logs.copyExistingProfiles);
+        const emptyChoice = {
+            name: commands.project.profile.add.prompts.copyExistingProfilePromptEmpty,
+            value: undefined,
+        };
+        const promptResponse = await listPrompt(commands.project.profile.add.prompts.copyExistingProfilePrompt, {
+            choices: [
+                ...existingProfiles.map(profile => ({
+                    name: getHsProfileFilename(profile),
+                    value: profile,
+                })),
+                emptyChoice,
+            ],
+        });
+        if (promptResponse) {
+            profileToCopyVariablesFrom = promptResponse;
+        }
+    }
+    return profileToCopyVariablesFrom;
+}
+async function handler(args) {
+    const { derivedAccountId } = args;
+    trackCommandUsage('project-profile-add', undefined, derivedAccountId);
+    const { projectConfig, projectDir } = await getProjectConfig();
+    if (!projectConfig || !projectDir) {
+        uiLogger.error(commands.project.profile.add.errors.noProjectConfig);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
+    let profileName = args.name;
+    let targetAccountId = args.targetAccount;
+    function checkIfProfileExists(profileName) {
+        return fileExists(path.join(projectSourceDir, getHsProfileFilename(profileName)));
+    }
+    function isValidProfileName(profileName) {
+        const trimmedProfileName = profileName.trim();
+        if (trimmedProfileName === '') {
+            return commands.project.profile.add.prompts.emptyName;
+        }
+        if (!/^[a-zA-Z0-9]+$/.test(trimmedProfileName)) {
+            return commands.project.profile.add.prompts.invalidProfileName;
+        }
+        if (checkIfProfileExists(trimmedProfileName)) {
+            return commands.project.profile.add.errors.profileExists(trimmedProfileName);
+        }
+        return true;
+    }
+    if (profileName) {
+        if (checkIfProfileExists(profileName)) {
+            uiLogger.error(commands.project.profile.add.errors.profileExists(getHsProfileFilename(profileName)));
+            uiLogger.log('');
+            profileName = undefined;
+        }
+        else {
+            const validationResult = isValidProfileName(profileName);
+            if (validationResult !== true) {
+                uiLogger.error(validationResult);
+                uiLogger.log('');
+                profileName = undefined;
+            }
+        }
+    }
+    if (!profileName) {
+        const promptResponse = await promptUser({
+            type: 'input',
+            name: 'name',
+            message: commands.project.profile.add.prompts.namePrompt,
+            validate: isValidProfileName,
+        });
+        profileName = promptResponse.name;
+    }
+    if (targetAccountId) {
+        const account = getConfigAccountIfExists(targetAccountId);
+        if (account) {
+            targetAccountId = account.accountId;
+        }
+        else {
+            uiLogger.error(commands.project.profile.add.errors.invalidTargetAccount);
+            uiLogger.log('');
+            targetAccountId = undefined;
+        }
+    }
+    if (!targetAccountId) {
+        const configuredAccounts = getAllConfigAccounts();
+        if (!configuredAccounts || !configuredAccounts.length) {
+            uiLogger.error(commands.project.profile.add.errors.noAccountsConfigured);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const promptResponse = await listPrompt(commands.project.profile.add.prompts.targetAccountPrompt, {
+            choices: configuredAccounts.map(account => {
+                const accountId = account.accountId;
+                return {
+                    name: uiAccountDescription(accountId),
+                    value: accountId,
+                };
+            }),
+        });
+        if (promptResponse) {
+            targetAccountId = promptResponse;
+        }
+    }
+    const existingProfiles = await getAllHsProfiles(projectSourceDir);
+    let existingTargetAccountIdSelected = false;
+    for (const profile of existingProfiles) {
+        try {
+            const loadedProfile = loadHsProfileFile(projectSourceDir, profile);
+            if (loadedProfile?.accountId === targetAccountId) {
+                existingTargetAccountIdSelected = true;
+                break;
+            }
+        }
+        catch (err) {
+            // Skip profiles that can't be loaded
+            debugError(err);
+        }
+    }
+    if (existingTargetAccountIdSelected) {
+        uiLogger.log('');
+        uiLogger.warn(commands.project.profile.add.warnings.duplicateTargetAccount(targetAccountId));
+    }
+    const profileFileContent = {
+        accountId: targetAccountId,
+        variables: {},
+    };
+    const profileToCopyVariablesFrom = await selectProfileToCopyVariablesFrom(existingProfiles);
+    if (profileToCopyVariablesFrom) {
+        try {
+            const profileToCopyFileContent = loadHsProfileFile(projectSourceDir, profileToCopyVariablesFrom);
+            if (profileToCopyFileContent?.variables) {
+                profileFileContent.variables = profileToCopyFileContent.variables;
+            }
+        }
+        catch (err) {
+            uiLogger.error(commands.project.profile.add.errors.failedToLoadProfile(profileToCopyVariablesFrom));
+        }
+    }
+    const profileFilename = getHsProfileFilename(profileName);
+    try {
+        fs.writeFileSync(path.join(projectSourceDir, profileFilename), JSON.stringify(profileFileContent, null, 2), 'utf8');
+    }
+    catch (err) {
+        uiLogger.error(commands.project.profile.add.errors.failedToCreateProfile);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    uiLogger.log('');
+    uiLogger.log(commands.project.profile.add.logs.profileAdded(profileFilename));
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function projectProfileAddBuilder(yargs) {
+    yargs.positional('name', {
+        describe: commands.project.profile.add.positionals.name,
+        type: 'string',
+    });
+    yargs.option('target-account', {
+        describe: commands.project.profile.add.options.targetAccount,
+        type: 'number',
+    });
+    yargs.example([
+        ['$0 project profile add qa', commands.project.profile.add.example],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectProfileAddBuilder, command, verboseDescribe, {
+    useGlobalOptions: true,
+});
+const projectProfileAddCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default projectProfileAddCommand;

package/commands/project/profile/delete.d.ts

@@ -0,0 +1,6 @@
+import { YargsCommandModule, CommonArgs } from '../../../types/Yargs.js';
+type ProjectProfileDeleteArgs = CommonArgs & {
+    name?: string;
+};
+declare const projectProfileDeleteCommand: YargsCommandModule<unknown, ProjectProfileDeleteArgs>;
+export default projectProfileDeleteCommand;

package/commands/project/profile/delete.js

@@ -0,0 +1,129 @@
+import fs from 'fs';
+import path from 'path';
+import { getAllHsProfiles, getHsProfileFilename, loadHsProfileFile, } from '@hubspot/project-parsing-lib/profiles';
+import { fetchProject, deleteProject, } from '@hubspot/local-dev-lib/api/projects';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { getProjectConfig } from '../../../lib/projects/config.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { commands } from '../../../lang/en.js';
+import { confirmPrompt, listPrompt } from '../../../lib/prompts/promptUtils.js';
+import { fileExists } from '../../../lib/validation.js';
+import { debugError } from '../../../lib/errorHandlers/index.js';
+import { isDeveloperTestAccount, isSandbox, } from '../../../lib/accountTypes.js';
+const command = 'delete [name]';
+const describe = commands.project.profile.delete.describe;
+async function handler(args) {
+    const { derivedAccountId } = args;
+    trackCommandUsage('project-profile-delete', undefined, derivedAccountId);
+    const { projectConfig, projectDir } = await getProjectConfig();
+    if (!projectConfig || !projectDir) {
+        uiLogger.error(commands.project.profile.delete.errors.noProjectConfig);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
+    let profileName = undefined;
+    if (args.name) {
+        profileName = args.name;
+        const profileFilename = getHsProfileFilename(profileName);
+        if (!fileExists(path.join(projectSourceDir, profileFilename))) {
+            uiLogger.error(commands.project.profile.delete.errors.noProfileFound(profileFilename));
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    else {
+        const existingProfiles = await getAllHsProfiles(projectSourceDir);
+        if (existingProfiles.length === 0) {
+            uiLogger.error(commands.project.profile.delete.errors.noProfilesFound);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const promptResponse = await listPrompt(commands.project.profile.delete.prompts.deleteProfilePrompt, {
+            choices: existingProfiles.map(profile => ({
+                name: getHsProfileFilename(profile),
+                value: profile,
+            })),
+        });
+        if (promptResponse) {
+            profileName = promptResponse;
+        }
+        uiLogger.log('');
+    }
+    // This should never happen
+    if (!profileName) {
+        process.exit(EXIT_CODES.ERROR);
+    }
+    let targetAccountId;
+    try {
+        const profileToDelete = loadHsProfileFile(projectSourceDir, profileName);
+        targetAccountId = profileToDelete?.accountId;
+    }
+    catch (err) {
+        uiLogger.debug(commands.project.profile.delete.debug.failedToLoadProfile(profileName));
+    }
+    const profileFilename = getHsProfileFilename(profileName);
+    try {
+        fs.unlinkSync(path.join(projectSourceDir, profileFilename));
+    }
+    catch (err) {
+        uiLogger.error(commands.project.profile.delete.errors.failedToDeleteProfile(profileFilename));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    uiLogger.log(commands.project.profile.delete.logs.profileDeleted(profileFilename));
+    if (targetAccountId) {
+        let projectExists = false;
+        try {
+            const fetchProjectResponse = await fetchProject(targetAccountId, projectConfig.name);
+            projectExists = !!fetchProjectResponse.data;
+        }
+        catch (err) {
+            debugError(err);
+        }
+        const targetAccountConfig = getConfigAccountById(targetAccountId);
+        if (projectExists &&
+            targetAccountConfig &&
+            (isDeveloperTestAccount(targetAccountConfig) ||
+                isSandbox(targetAccountConfig))) {
+            uiLogger.log('');
+            const confirmResponse = await confirmPrompt(commands.project.profile.delete.prompts.deleteProjectPrompt(targetAccountId), {
+                defaultAnswer: false,
+            });
+            if (confirmResponse) {
+                try {
+                    await deleteProject(targetAccountId, projectConfig.name);
+                }
+                catch (err) {
+                    debugError(err);
+                    uiLogger.error(commands.project.profile.delete.errors.failedToDeleteProject(targetAccountId));
+                    process.exit(EXIT_CODES.ERROR);
+                }
+                uiLogger.log(commands.project.profile.delete.logs.deletedProject(targetAccountId));
+            }
+            else {
+                uiLogger.log(commands.project.profile.delete.logs.didNotDeleteProject(targetAccountId));
+            }
+        }
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function projectProfileDeleteBuilder(yargs) {
+    yargs.positional('name', {
+        describe: commands.project.profile.delete.positionals.name,
+        type: 'string',
+    });
+    yargs.example([
+        ['$0 project profile delete qa', commands.project.profile.delete.example],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectProfileDeleteBuilder, command, describe, {
+    useGlobalOptions: true,
+});
+const projectProfileDeleteCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default projectProfileDeleteCommand;

package/commands/project/profile.d.ts

@@ -0,0 +1,3 @@
+import { YargsCommandModuleBucket } from '../../types/Yargs.js';
+declare const projectProfileCommand: YargsCommandModuleBucket;
+export default projectProfileCommand;

package/commands/project/profile.js

@@ -0,0 +1,19 @@
+import add from './profile/add.js';
+import deleteProfile from './profile/delete.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { commands } from '../../lang/en.js';
+const command = ['profile', 'profiles'];
+const describe = commands.project.profile.describe;
+const verboseDescribe = commands.project.profile.verboseDescribe;
+function projectProfileBuilder(yargs) {
+    yargs.command(add).command(deleteProfile).demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(projectProfileBuilder, command, verboseDescribe);
+const projectProfileCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default projectProfileCommand;

package/commands/project/updateDeps.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type ProjectUpdateDepsArgs = CommonArgs & ConfigArgs & {
+    packages?: string[];
+};
+declare const projectUpdateDepsCommand: YargsCommandModule<unknown, ProjectUpdateDepsArgs>;
+export default projectUpdateDepsCommand;

package/commands/project/updateDeps.js

@@ -0,0 +1,80 @@
+import { updatePackages, getProjectPackageJsonLocations, } from '../../lib/dependencyManagement.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { getProjectConfig } from '../../lib/projects/config.js';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import path from 'path';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'update-deps [packages..]';
+const describe = commands.project.updateDeps.help.describe;
+async function handler(args) {
+    const { derivedAccountId, packages } = args;
+    try {
+        trackCommandUsage('project-update-deps', undefined, derivedAccountId);
+        const projectConfig = await getProjectConfig();
+        if (!projectConfig || !projectConfig.projectDir) {
+            uiLogger.error(commands.project.updateDeps.noProjectConfig);
+            return process.exit(EXIT_CODES.ERROR);
+        }
+        const { projectDir } = projectConfig;
+        let installLocations = await getProjectPackageJsonLocations();
+        if (packages) {
+            const { selectedInstallLocations } = await promptUser([
+                {
+                    name: 'selectedInstallLocations',
+                    type: 'checkbox',
+                    when: () => packages && packages.length > 0,
+                    message: commands.project.updateDeps.installLocationPrompt,
+                    choices: installLocations.map(dir => ({
+                        name: path.relative(projectDir, dir),
+                        value: dir,
+                    })),
+                    validate: (choices) => {
+                        if (choices === undefined || choices.length === 0) {
+                            return commands.project.updateDeps.installLocationPromptRequired;
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            if (selectedInstallLocations) {
+                installLocations = selectedInstallLocations;
+            }
+        }
+        await updatePackages({
+            packages,
+            installLocations,
+        });
+    }
+    catch (e) {
+        logError(e);
+        return process.exit(EXIT_CODES.ERROR);
+    }
+}
+function projectUpdateDepsBuilder(yargs) {
+    yargs.example([
+        [
+            '$0 project update-deps',
+            commands.project.updateDeps.help.updateAppDepsExample,
+        ],
+        [
+            '$0 project update-deps dependency1 dependency2',
+            commands.project.updateDeps.help.updateDepToSubComponentExample,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectUpdateDepsBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const projectUpdateDepsCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default projectUpdateDepsCommand;

package/commands/project/upload.d.ts

@@ -0,0 +1,10 @@
+import { CommonArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type ProjectUploadArgs = CommonArgs & JSONOutputArgs & {
+    forceCreate: boolean;
+    message: string;
+    m: string;
+    skipValidation: boolean;
+    profile?: string;
+};
+declare const projectUploadCommand: YargsCommandModule<unknown, ProjectUploadArgs>;
+export default projectUploadCommand;

package/commands/project/upload.js

@@ -0,0 +1,145 @@
+import chalk from 'chalk';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
+import { isV2Project } from '../../lib/projects/platformVersion.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { getProjectConfig, validateProjectConfig, } from '../../lib/projects/config.js';
+import { logFeedbackMessage } from '../../lib/projects/ui.js';
+import { handleProjectUpload } from '../../lib/projects/upload.js';
+import { loadAndValidateProfile } from '../../lib/projects/projectProfiles.js';
+import { displayWarnLogs, pollProjectBuildAndDeploy, } from '../../lib/projects/pollProjectBuildAndDeploy.js';
+import { commands } from '../../lang/en.js';
+import { PROJECT_ERROR_TYPES } from '../../lib/constants.js';
+import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'upload';
+const describe = commands.project.upload.describe;
+async function handler(args) {
+    const { forceCreate, message, derivedAccountId, skipValidation, formatOutputAsJson, profile, } = args;
+    const jsonOutput = {};
+    const { projectConfig, projectDir } = await getProjectConfig();
+    try {
+        validateProjectConfig(projectConfig, projectDir);
+    }
+    catch (error) {
+        logError(error);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    let targetAccountId;
+    try {
+        if (isV2Project(projectConfig.platformVersion)) {
+            targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
+        }
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    targetAccountId = targetAccountId || derivedAccountId;
+    const accountConfig = getConfigAccountById(targetAccountId);
+    const accountType = accountConfig && accountConfig.accountType;
+    trackCommandUsage('project-upload', { type: accountType, assetType: projectConfig.platformVersion }, targetAccountId);
+    try {
+        const { result, uploadError } = await handleProjectUpload({
+            accountId: targetAccountId,
+            projectConfig,
+            projectDir: projectDir,
+            callbackFunc: pollProjectBuildAndDeploy,
+            uploadMessage: message,
+            forceCreate,
+            isUploadCommand: true,
+            sendIR: isV2Project(projectConfig.platformVersion),
+            skipValidation,
+            profile: args.profile,
+        });
+        if (uploadError) {
+            if (isSpecifiedError(uploadError, {
+                subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
+            })) {
+                uiLogger.log('');
+                uiLogger.error(commands.project.upload.errors.projectLockedError);
+                uiLogger.log('');
+            }
+            else {
+                logError(uploadError, new ApiErrorContext({
+                    accountId: targetAccountId,
+                    request: 'project upload',
+                }));
+            }
+            process.exit(EXIT_CODES.ERROR);
+        }
+        if (result && result.succeeded && !result.buildResult.isAutoDeployEnabled) {
+            uiLogger.log(chalk.bold(commands.project.upload.logs.buildSucceeded(result.buildId)));
+            uiLogger.log(commands.project.upload.logs.autoDeployDisabled(`hs project deploy --build=${result.buildId}`));
+            logFeedbackMessage(result.buildId);
+            await displayWarnLogs(targetAccountId, projectConfig.name, result.buildId);
+        }
+        if (result && result.succeeded && formatOutputAsJson) {
+            jsonOutput.buildId = result.buildId;
+            if (result.deployResult) {
+                jsonOutput.deployId = result.deployResult.deployId;
+            }
+        }
+    }
+    catch (e) {
+        logError(e, new ApiErrorContext({
+            accountId: targetAccountId,
+            request: 'project upload',
+        }));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (formatOutputAsJson) {
+        uiLogger.json(jsonOutput);
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function projectUploadBuilder(yargs) {
+    yargs.options({
+        'force-create': {
+            describe: commands.project.upload.options.forceCreate.describe,
+            type: 'boolean',
+            default: false,
+        },
+        message: {
+            alias: 'm',
+            describe: commands.project.upload.options.message.describe,
+            type: 'string',
+            default: '',
+        },
+        'skip-validation': {
+            type: 'boolean',
+            hidden: true,
+            default: false,
+        },
+        profile: {
+            type: 'string',
+            alias: 'p',
+            describe: commands.project.upload.options.profile.describe,
+        },
+    });
+    yargs.conflicts('profile', 'account');
+    yargs.example([
+        ['$0 project upload', commands.project.upload.examples.default],
+        [
+            '$0 project upload --profile=profileName',
+            commands.project.upload.examples.withProfile,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectUploadBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+    useJSONOutputOptions: true,
+});
+const projectUploadCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default projectUploadCommand;

package/commands/project/validate.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ProjectValidateArgs = CommonArgs & {
+    profile?: string;
+};
+declare const projectValidateCommand: YargsCommandModule<unknown, ProjectValidateArgs>;
+export default projectValidateCommand;