@hubspot/cli 8.1.2-experimental.2 → 8.1.3-experimental.0

package/commands/account/link.js

@@ -15,9 +15,7 @@ import { commands } from '../../lang/en.js';
 import { debugError } from '../../lib/errorHandlers/index.js';
 import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
 const command = 'link';
-// Hide the command until we're done testing and ready to make linking GA
-// const describe = commands.account.subcommands.link.describe;
-const describe = undefined;
+const describe = commands.account.subcommands.link.describe;
 async function handler(args) {
     const { exit } = args;
     if (hasDeprecatedConfigConflict(args._)) {

package/commands/account/unlink.js

@@ -11,9 +11,7 @@ import { commands } from '../../lang/en.js';
 import { DEFAULT_HS_SETTINGS_PATH } from '@hubspot/local-dev-lib/constants/config';
 import { makeWrappedYargsHandler } from '../../lib/yargs/makeWrappedYargsHandler.js';
 const command = 'unlink';
-// Hide the command until we're done testing and ready to make linking GA
-// const describe = commands.account.subcommands.link.describe;
-const describe = undefined;
+const describe = commands.account.subcommands.unlink.describe;
 async function handler(args) {
     const { exit } = args;
     if (hasDeprecatedConfigConflict(args._)) {

package/commands/project/appInstallStatus.d.ts

@@ -1,4 +1,4 @@
-import { AccountArgs, CommonArgs, ConfigArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectInstallStatusArgs = CommonArgs & ConfigArgs & AccountArgs & JSONOutputArgs;
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ProjectInstallStatusArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & JSONOutputArgs;
 declare const projectInstallStatusCommand: YargsCommandModule<unknown, ProjectInstallStatusArgs>;
 export default projectInstallStatusCommand;

package/commands/project/appInstallStatus.js

@@ -121,6 +121,7 @@ const builder = makeYargsBuilder(projectInstallStatusBuilder, command, describe,
     useGlobalOptions: true,
     useConfigOptions: true,
     useAccountOptions: true,
+    useEnvironmentOptions: true,
     useJSONOutputOptions: true,
 });
 const projectInstallStatusCommand = {

package/commands/project/info.d.ts

@@ -1,4 +1,4 @@
-import { AccountArgs, CommonArgs, ConfigArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectInfoArgs = CommonArgs & ConfigArgs & AccountArgs & JSONOutputArgs;
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ProjectInfoArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & JSONOutputArgs;
 declare const projectInfoCommand: YargsCommandModule<unknown, ProjectInfoArgs>;
 export default projectInfoCommand;

package/commands/project/info.js

@@ -56,6 +56,7 @@ const builder = makeYargsBuilder(projectInfoBuilder, command, verboseDescribe, {
     useGlobalOptions: true,
     useConfigOptions: true,
     useAccountOptions: true,
+    useEnvironmentOptions: true,
     useJSONOutputOptions: true,
 });
 const projectInfoCommand = {

package/commands/project/lint.js

@@ -1,5 +1,5 @@
 import path from 'path';
-import { getProjectPackageJsonLocations, installPackages, } from '../../lib/dependencyManagement.js';
+import { installPackages } from '../../lib/dependencyManagement.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { isPromptExitError } from '../../lib/errors/PromptExitError.js';
 import { getProjectConfig } from '../../lib/projects/config.js';
@@ -10,7 +10,7 @@ import { logError } from '../../lib/errorHandlers/index.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
 import SpinniesManager from '../../lib/ui/SpinniesManager.js';
-import { areAllLintPackagesInstalled, getMissingLintPackages, getMissingLintScripts, addLintScriptsToPackageJson, lintPackages, displayLintResults, hasEslintConfig, hasDeprecatedEslintConfig, getDeprecatedEslintConfigFiles, createEslintConfig, REQUIRED_PACKAGES_AND_MIN_VERSIONS, } from '../../lib/projects/uieLinting.js';
+import { addLintScriptsToPackageJson, areAllLintPackagesInstalled, createEslintConfig, displayLintResults, getDeprecatedEslintConfigFiles, getMissingLintPackages, getMissingLintScripts, getUieLintablePackageJsonLocations, hasDeprecatedEslintConfig, hasEslintConfig, lintPackages, REQUIRED_PACKAGES_AND_MIN_VERSIONS, } from '../../lib/projects/uieLinting.js';
 import { clearPackageJsonCache } from '../../lib/npm/packageJson.js';
 const command = 'lint';
 const describe = commands.project.lint.help.describe;
@@ -26,7 +26,7 @@ async function handler(args) {
         SpinniesManager.add('lintCheck', {
             text: commands.project.lint.loading.checking,
         });
-        const lintLocations = await getProjectPackageJsonLocations();
+        const lintLocations = await getUieLintablePackageJsonLocations(projectConfig);
         const locationsReadyToLint = [];
         const locationsNeedingPackages = new Map();
         for (const lintLocation of lintLocations) {

package/commands/project/release/create.d.ts

@@ -0,0 +1,7 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../../types/Yargs.js';
+export type ProjectReleaseCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & JSONOutputArgs & {
+    build?: number;
+    force: boolean;
+};
+declare const projectReleaseCreateCommand: YargsCommandModule<unknown, ProjectReleaseCreateArgs>;
+export default projectReleaseCreateCommand;

package/commands/project/release/create.js

@@ -0,0 +1,159 @@
+import { fetchProject, getBuildStatus, } from '@hubspot/local-dev-lib/api/projects';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { logError, ApiErrorContext } from '../../../lib/errorHandlers/index.js';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import { confirmPrompt } from '../../../lib/prompts/promptUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { commands } from '../../../lang/en.js';
+import { makeWrappedYargsHandler } from '../../../lib/yargs/makeWrappedYargsHandler.js';
+import { createRelease } from '../../../api/releases.js';
+const command = 'create';
+// const describe = commands.project.release.create.describe;
+const describe = undefined;
+// const verboseDescribe = commands.project.release.create.verboseDescribe;
+const verboseDescribe = undefined;
+async function resolveBuildId(accountId, projectName, buildOption) {
+    const { data: { deployedBuildId }, } = await fetchProject(accountId, projectName);
+    if (buildOption) {
+        return buildOption;
+    }
+    if (!deployedBuildId) {
+        throw new Error(commands.project.release.create.errors.noDeployedBuild);
+    }
+    return deployedBuildId;
+}
+async function validateBuild(accountId, projectName, buildId) {
+    try {
+        await getBuildStatus(accountId, projectName, buildId);
+    }
+    catch (e) {
+        if (isHubSpotHttpError(e) && e.status === 404) {
+            uiLogger.error(commands.project.release.create.errors.buildNotFound(buildId, projectName));
+        }
+        else {
+            logError(e, new ApiErrorContext({
+                accountId,
+                request: 'project release create',
+            }));
+        }
+        throw e;
+    }
+}
+async function executeRelease(accountId, projectName, buildId, formatOutputAsJson) {
+    try {
+        const { data: release } = await createRelease(accountId, projectName, buildId);
+        if (formatOutputAsJson) {
+            uiLogger.json(release);
+        }
+        else {
+            uiLogger.success(commands.project.release.create.success(release.releaseTag, release.buildId));
+        }
+    }
+    catch (e) {
+        if (isHubSpotHttpError(e) && e.status === 422) {
+            uiLogger.error(commands.project.release.create.errors.buildNotDeployed(buildId));
+        }
+        else {
+            logError(e, new ApiErrorContext({
+                accountId,
+                request: 'project release create',
+            }));
+        }
+        throw e;
+    }
+}
+async function handler(args) {
+    const { exit, derivedAccountId, build: buildOption, json: formatOutputAsJson, force, } = args;
+    const { projectConfig, projectDir } = await getProjectConfig();
+    try {
+        validateProjectConfig(projectConfig, projectDir);
+    }
+    catch (error) {
+        logError(error);
+        return exit(EXIT_CODES.ERROR);
+    }
+    const projectName = projectConfig.name;
+    let buildId;
+    try {
+        buildId = await resolveBuildId(derivedAccountId, projectName, buildOption);
+    }
+    catch (e) {
+        if (isHubSpotHttpError(e) && e.status === 404) {
+            uiLogger.error(commands.project.release.create.errors.projectNotFound(derivedAccountId, projectName));
+        }
+        else if (!(e instanceof Error) || !e.message) {
+            logError(e, new ApiErrorContext({
+                accountId: derivedAccountId,
+                request: 'project release create',
+            }));
+        }
+        else {
+            uiLogger.error(e.message);
+        }
+        return exit(EXIT_CODES.ERROR);
+    }
+    if (buildOption) {
+        try {
+            await validateBuild(derivedAccountId, projectName, buildId);
+        }
+        catch {
+            return exit(EXIT_CODES.ERROR);
+        }
+    }
+    if (!formatOutputAsJson && !force) {
+        const confirmed = await confirmPrompt(commands.project.release.create.confirmPrompt(projectName, buildId));
+        if (!confirmed) {
+            uiLogger.log(commands.project.release.create.cancelled);
+            return exit(EXIT_CODES.SUCCESS);
+        }
+    }
+    try {
+        await executeRelease(derivedAccountId, projectName, buildId, !!formatOutputAsJson);
+    }
+    catch {
+        return exit(EXIT_CODES.ERROR);
+    }
+    return exit(EXIT_CODES.SUCCESS);
+}
+function projectReleaseCreateBuilder(yargs) {
+    yargs.options({
+        build: {
+            alias: ['build-id'],
+            describe: commands.project.release.create.options.build,
+            type: 'number',
+        },
+        force: {
+            alias: ['f'],
+            describe: commands.project.release.create.options.force,
+            default: false,
+            type: 'boolean',
+        },
+    });
+    yargs.example([
+        [
+            '$0 project release create',
+            commands.project.release.create.examples.default,
+        ],
+        [
+            '$0 project release create --build=5',
+            commands.project.release.create.examples.withBuild,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectReleaseCreateBuilder, command, verboseDescribe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+    useJSONOutputOptions: true,
+});
+const projectReleaseCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler: makeWrappedYargsHandler('project-release-create', handler),
+};
+export default projectReleaseCreateCommand;

package/commands/project/release/info.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../../types/Yargs.js';
+export type ProjectReleaseInfoArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & JSONOutputArgs & {
+    tag?: string;
+};
+declare const projectReleaseInfoCommand: YargsCommandModule<unknown, ProjectReleaseInfoArgs>;
+export default projectReleaseInfoCommand;

package/commands/project/release/info.js

@@ -0,0 +1,147 @@
+import { getReleaseInfo, listReleases } from '../../../api/releases.js';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { logError, ApiErrorContext } from '../../../lib/errorHandlers/index.js';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import { listPrompt } from '../../../lib/prompts/promptUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { commands } from '../../../lang/en.js';
+import { renderTable } from '../../../ui/render.js';
+import { makeWrappedYargsHandler } from '../../../lib/yargs/makeWrappedYargsHandler.js';
+import { isPromptExitError } from '../../../lib/errors/PromptExitError.js';
+import { mapToUserFacingType } from '@hubspot/project-parsing-lib/transform';
+import { AUTO_GENERATED_COMPONENT_TYPES } from '@hubspot/project-parsing-lib/constants';
+const command = 'info';
+// const describe = commands.project.release.info.describe;
+const describe = undefined;
+// const verboseDescribe = commands.project.release.info.verboseDescribe;
+const verboseDescribe = undefined;
+function normalizeTag(rawTag) {
+    return rawTag.startsWith('v') ? rawTag : `v${rawTag}`;
+}
+async function selectReleasePrompt(accountId, projectName) {
+    const { data: { results, paging }, } = await listReleases(accountId, projectName);
+    if (results.length === 0) {
+        return null;
+    }
+    if (paging?.next?.after) {
+        uiLogger.info(commands.project.release.info.moreReleasesHint);
+    }
+    return listPrompt(commands.project.release.info.selectRelease(projectName), {
+        choices: results.map(release => ({
+            name: `${release.releaseTag} (build #${release.buildId}, ${new Date(release.createdAt).toLocaleString()})`,
+            value: release.releaseTag,
+        })),
+    });
+}
+async function handler(args) {
+    const { derivedAccountId, tag: rawTag, json: formatOutputAsJson, exit, } = args;
+    const { projectConfig, projectDir } = await getProjectConfig();
+    try {
+        validateProjectConfig(projectConfig, projectDir);
+    }
+    catch (error) {
+        logError(error);
+        return exit(EXIT_CODES.ERROR);
+    }
+    const projectName = projectConfig.name;
+    let tag;
+    if (rawTag) {
+        tag = normalizeTag(rawTag);
+    }
+    else {
+        try {
+            const selected = await selectReleasePrompt(derivedAccountId, projectName);
+            if (!selected) {
+                uiLogger.error(commands.project.release.info.errors.noReleases);
+                return exit(EXIT_CODES.ERROR);
+            }
+            tag = selected;
+        }
+        catch (e) {
+            if (isPromptExitError(e)) {
+                throw e;
+            }
+            logError(e);
+            return exit(EXIT_CODES.ERROR);
+        }
+    }
+    try {
+        const { data: release } = await getReleaseInfo(derivedAccountId, projectName, tag);
+        if (formatOutputAsJson) {
+            uiLogger.json(release);
+        }
+        else {
+            uiLogger.log(commands.project.release.info.releaseDetails(release.releaseTag, projectName));
+            renderTable(['Release', 'Build', 'Created'], [
+                [
+                    release.releaseTag,
+                    `#${release.buildId}`,
+                    new Date(release.createdAt).toLocaleString(),
+                ],
+            ]);
+            const visibleComponents = (release.components ?? []).filter(component => !AUTO_GENERATED_COMPONENT_TYPES.includes(component.buildType));
+            if (visibleComponents.length > 0) {
+                uiLogger.log('');
+                uiLogger.log(commands.project.release.info.components);
+                const componentRows = visibleComponents.map(component => [
+                    mapToUserFacingType(component.buildType),
+                    component.buildName ?? '',
+                    component.rootPath ?? '',
+                ]);
+                renderTable(['Type', 'Name', 'Path'], componentRows);
+            }
+            else {
+                uiLogger.log('');
+                uiLogger.log(commands.project.release.info.noComponents);
+            }
+        }
+    }
+    catch (e) {
+        if (isHubSpotHttpError(e) && e.status === 404) {
+            uiLogger.error(commands.project.release.info.errors.releaseNotFound(tag, projectName));
+        }
+        else {
+            logError(e, new ApiErrorContext({
+                accountId: derivedAccountId,
+                request: 'project release info',
+            }));
+        }
+        return exit(EXIT_CODES.ERROR);
+    }
+    return exit(EXIT_CODES.SUCCESS);
+}
+function projectReleaseInfoBuilder(yargs) {
+    yargs.options({
+        tag: {
+            describe: commands.project.release.info.options.tag,
+            type: 'string',
+        },
+    });
+    yargs.example([
+        [
+            '$0 project release info --tag=v1.0.0',
+            commands.project.release.info.examples.default,
+        ],
+        [
+            '$0 project release info --tag=v1.0.0 --json',
+            commands.project.release.info.examples.json,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectReleaseInfoBuilder, command, verboseDescribe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+    useJSONOutputOptions: true,
+});
+const projectReleaseInfoCommand = {
+    command,
+    describe,
+    builder,
+    handler: makeWrappedYargsHandler('project-release-info', handler),
+};
+export default projectReleaseInfoCommand;

package/commands/project/release/list.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../../types/Yargs.js';
+export type ProjectReleaseListArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & JSONOutputArgs & {
+    limit?: number;
+};
+declare const projectReleaseListCommand: YargsCommandModule<unknown, ProjectReleaseListArgs>;
+export default projectReleaseListCommand;

package/commands/project/release/list.js

@@ -0,0 +1,111 @@
+import { listReleases } from '../../../api/releases.js';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { isPromptExitError } from '../../../lib/errors/PromptExitError.js';
+import { logError, ApiErrorContext } from '../../../lib/errorHandlers/index.js';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import { promptUser } from '../../../lib/prompts/promptUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { commands } from '../../../lang/en.js';
+import { renderTable } from '../../../ui/render.js';
+import { makeWrappedYargsHandler } from '../../../lib/yargs/makeWrappedYargsHandler.js';
+const command = 'list';
+// const describe = commands.project.release.list.describe;
+const describe = undefined;
+// const verboseDescribe = commands.project.release.list.verboseDescribe;
+const verboseDescribe = undefined;
+async function fetchAndDisplayReleases(accountId, projectName, options) {
+    const { data: { results, paging }, } = await listReleases(accountId, projectName, options);
+    uiLogger.log(commands.project.release.list.showingReleases(results.length, projectName));
+    if (results.length === 0) {
+        uiLogger.log(commands.project.release.list.noReleases);
+    }
+    else {
+        const rows = results.map(release => [
+            release.releaseTag,
+            `#${release.buildId}`,
+            new Date(release.createdAt).toLocaleString(),
+        ]);
+        renderTable(['Release', 'Build', 'Created'], rows);
+    }
+    if (paging?.next?.after) {
+        await promptUser({
+            name: 'more',
+            message: commands.project.release.list.continueOrExitPrompt,
+        });
+        await fetchAndDisplayReleases(accountId, projectName, {
+            limit: options.limit,
+            after: paging.next.after,
+        });
+    }
+}
+async function handler(args) {
+    const { derivedAccountId, limit, json: formatOutputAsJson } = args;
+    const { projectConfig, projectDir } = await getProjectConfig();
+    try {
+        validateProjectConfig(projectConfig, projectDir);
+    }
+    catch (error) {
+        logError(error);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const projectName = projectConfig.name;
+    try {
+        if (formatOutputAsJson) {
+            const { data } = await listReleases(derivedAccountId, projectName, {
+                limit,
+            });
+            uiLogger.json(data);
+        }
+        else {
+            await fetchAndDisplayReleases(derivedAccountId, projectName, { limit });
+        }
+    }
+    catch (e) {
+        if (isPromptExitError(e)) {
+            throw e;
+        }
+        if (isHubSpotHttpError(e) && e.status === 404) {
+            uiLogger.error(commands.project.release.list.errors.projectNotFound(derivedAccountId, projectName));
+        }
+        else {
+            logError(e, new ApiErrorContext({
+                accountId: derivedAccountId,
+                request: 'project release list',
+            }));
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+    process.exit(EXIT_CODES.SUCCESS);
+}
+function projectReleaseListBuilder(yargs) {
+    yargs.options({
+        limit: {
+            describe: commands.project.release.list.options.limit,
+            type: 'number',
+        },
+    });
+    yargs.example([
+        ['$0 project release list', commands.project.release.list.examples.default],
+        [
+            '$0 project release list --limit=5',
+            commands.project.release.list.examples.withLimit,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectReleaseListBuilder, command, verboseDescribe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+    useJSONOutputOptions: true,
+});
+const projectReleaseListCommand = {
+    command,
+    describe,
+    builder,
+    handler: makeWrappedYargsHandler('project-release-list', handler),
+};
+export default projectReleaseListCommand;

package/commands/project/release.d.ts

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

package/commands/project/release.js

@@ -0,0 +1,20 @@
+import create from './release/create.js';
+import info from './release/info.js';
+import list from './release/list.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+// import { commands } from '../../lang/en.js';
+const command = 'release';
+// const describe = commands.project.release.describe;
+const describe = undefined;
+function projectReleaseBuilder(yargs) {
+    yargs.command(create).command(info).command(list).demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(projectReleaseBuilder, command, describe);
+const projectReleaseCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default projectReleaseCommand;

package/commands/project/upload.js

@@ -124,6 +124,15 @@ async function handler(args) {
                 jsonOutput.deployId = result.deployResult.deployId;
             }
         }
+        if (result && !result.succeeded) {
+            if (formatOutputAsJson) {
+                uiLogger.json(jsonOutput);
+            }
+            return exit(EXIT_CODES.ERROR);
+        }
+        if (!result && !uploadError) {
+            return exit(EXIT_CODES.ERROR);
+        }
     }
     catch (e) {
         logError(e, new ApiErrorContext({

package/commands/project.js

@@ -15,6 +15,7 @@ import installDeps from './project/installDeps.js';
 import lint from './project/lint.js';
 import updateDeps from './project/updateDeps.js';
 import profile from './project/profile.js';
+import release from './project/release.js';
 import projectValidate from './project/validate.js';
 import list from './project/list.js';
 import info from './project/info.js';
@@ -66,6 +67,7 @@ function projectBuilder(yargs) {
         .command(lint)
         .command(updateDeps)
         .command(profile)
+        .command(release)
         .command(projectValidate)
         .command(appInstallStatus)
         .demandCommand(1, '');

package/lang/en.d.ts

@@ -1729,6 +1729,67 @@ export declare const commands: {
                 deployLatestBuild: string;
             };
         };
+        release: {
+            describe: string;
+            create: {
+                describe: string;
+                verboseDescribe: string;
+                confirmPrompt: (projectName: string, buildId: number) => string;
+                success: (releaseTag: string, buildId: number) => string;
+                cancelled: string;
+                errors: {
+                    projectNotFound: (accountId: number, projectName: string) => string;
+                    noDeployedBuild: string;
+                    buildNotFound: (buildId: number, projectName: string) => string;
+                    buildNotDeployed: (buildId: number) => string;
+                };
+                options: {
+                    build: string;
+                    force: string;
+                };
+                examples: {
+                    default: string;
+                    withBuild: string;
+                };
+            };
+            list: {
+                describe: string;
+                verboseDescribe: string;
+                noReleases: string;
+                showingReleases: (count: number, projectName: string) => string;
+                continueOrExitPrompt: string;
+                errors: {
+                    projectNotFound: (accountId: number, projectName: string) => string;
+                };
+                options: {
+                    limit: string;
+                };
+                examples: {
+                    default: string;
+                    withLimit: string;
+                };
+            };
+            info: {
+                describe: string;
+                verboseDescribe: string;
+                releaseDetails: (releaseTag: string, projectName: string) => string;
+                components: string;
+                noComponents: string;
+                moreReleasesHint: string;
+                selectRelease: (projectName: string) => string;
+                errors: {
+                    releaseNotFound: (releaseTag: string, projectName: string) => string;
+                    noReleases: string;
+                };
+                options: {
+                    tag: string;
+                };
+                examples: {
+                    default: string;
+                    json: string;
+                };
+            };
+        };
         listBuilds: {
             describe: string;
             continueOrExitPrompt: string;
@@ -3406,6 +3467,9 @@ export declare const lib: {
             updatingPackageJsonWorkspaces: (packageJsonPath: string) => string;
             updatedWorkspaces: (workspaces: string) => string;
             updatedFileDependency: (packageName: string, relativePath: string) => string;
+            lintPackagesNotConfigured: (packageRoot: string) => string;
+            lintConfigNotFound: (packageRoot: string) => string;
+            lintHubSpotRulesNotActive: (packageRoot: string) => string;
             npmAuditClean: (packageRoot: string) => string;
             npmAuditIssues: (packageRoot: string, details: string) => string;
             npmAuditNpmUnavailable: (packageRoot: string) => string;

package/lang/en.js

@@ -1746,6 +1746,67 @@ export const commands = {
                 deployLatestBuild: 'Deploy the latest build of the current project',
             },
         },
+        release: {
+            describe: 'Manage project releases.',
+            create: {
+                describe: 'Create a release for a project build.',
+                verboseDescribe: `Create a release for a project build\n\nReleases mark a deployed build with an auto-generated semantic version tag (e.g. v1.0.0). The build must have been successfully deployed before it can be released.\n\nBy default, the latest deployed build is used. Use ${uiCommandReference('--build')} to specify a different build ID.`,
+                confirmPrompt: (projectName, buildId) => `Create a release for project ${chalk.bold(projectName)} using build ${chalk.bold(String(buildId))}?`,
+                success: (releaseTag, buildId) => `Release ${chalk.bold(releaseTag)} created for build ${chalk.bold(String(buildId))}.`,
+                cancelled: 'Release creation cancelled.',
+                errors: {
+                    projectNotFound: (accountId, projectName) => `The project ${chalk.bold(projectName)} does not exist in account ${uiAccountDescription(accountId)}. Run ${uiCommandReference('hs project upload')} to upload your project files to HubSpot.`,
+                    noDeployedBuild: `No deployed build found for this project. Run ${uiCommandReference('hs project deploy')} first.`,
+                    buildNotFound: (buildId, projectName) => `Build ${chalk.bold(String(buildId))} was not found for project ${chalk.bold(projectName)}. Run ${uiCommandReference('hs project list-builds')} to view existing builds or ${uiCommandReference('hs project deploy')} to deploy a build first.`,
+                    buildNotDeployed: (buildId) => `Build ${chalk.bold(String(buildId))} has not been deployed. Run ${uiCommandReference('hs project deploy')} first.`,
+                },
+                options: {
+                    build: 'Build ID to release. Defaults to the latest deployed build.',
+                    force: 'Skip confirmation prompt.',
+                },
+                examples: {
+                    default: 'Create a release for the latest deployed build',
+                    withBuild: 'Create a release for a specific build',
+                },
+            },
+            list: {
+                describe: 'List releases for the current project.',
+                verboseDescribe: `List releases for the current project\n\nDisplays all releases in sorted order, newest first. Includes the version tag, build ID, and creation date. Use ${uiCommandReference('--limit')} to control how many results are shown.`,
+                noReleases: 'No releases found for this project.',
+                showingReleases: (count, projectName) => `Showing ${count} release${count === 1 ? '' : 's'} for ${chalk.bold(projectName)}:`,
+                continueOrExitPrompt: 'Press <enter> to load more, or ctrl+c to exit',
+                errors: {
+                    projectNotFound: (accountId, projectName) => `The project ${chalk.bold(projectName)} does not exist in account ${uiAccountDescription(accountId)}. Run ${uiCommandReference('hs project upload')} to upload your project files to HubSpot.`,
+                },
+                options: {
+                    limit: 'Number of releases to show',
+                },
+                examples: {
+                    default: 'List releases for the current project',
+                    withLimit: 'Show only the 5 most recent releases',
+                },
+            },
+            info: {
+                describe: 'Show details about a specific release.',
+                verboseDescribe: `Show details about a specific release\n\nDisplays the release tag, build ID, creation date, and list of components included in the release. Use ${uiCommandReference('--json')} for machine-readable output.`,
+                releaseDetails: (releaseTag, projectName) => `Release ${chalk.bold(releaseTag)} for ${chalk.bold(projectName)}:`,
+                components: 'Components:',
+                noComponents: 'No components found for this release.',
+                moreReleasesHint: `Not all releases are shown. Use ${uiCommandReference('--tag')} to look up an older release directly.`,
+                selectRelease: (projectName) => `Select a release for ${chalk.bold(projectName)}`,
+                errors: {
+                    releaseNotFound: (releaseTag, projectName) => `Release ${chalk.bold(releaseTag)} was not found for project ${chalk.bold(projectName)}. Verify the project has been uploaded and the release tag exists. Run ${uiCommandReference('hs project release list')} to view existing releases.`,
+                    noReleases: 'No releases found for this project.',
+                },
+                options: {
+                    tag: 'Release tag to look up (e.g. v1.0.0)',
+                },
+                examples: {
+                    default: 'Show details about a specific release',
+                    json: 'Output release details as JSON',
+                },
+            },
+        },
         listBuilds: {
             describe: "List the project's builds.",
             continueOrExitPrompt: 'Press <enter> to load more, or ctrl+c to exit',
@@ -3432,6 +3493,9 @@ export const lib = {
             updatingPackageJsonWorkspaces: (packageJsonPath) => `Updating package.json workspaces in archive: ${packageJsonPath}`,
             updatedWorkspaces: (workspaces) => `  Updated workspaces: ${workspaces}`,
             updatedFileDependency: (packageName, relativePath) => `  Updated dependencies.${packageName}: file:${relativePath}`,
+            lintPackagesNotConfigured: (packageRoot) => `Project lint: lint packages not installed for ${chalk.bold(packageRoot)}. Run ${uiCommandReference('hs project lint')} to install them.`,
+            lintConfigNotFound: (packageRoot) => `Project lint: ESLint configuration not found for ${chalk.bold(packageRoot)}. Run ${uiCommandReference('hs project lint')} to create an ESLint config.`,
+            lintHubSpotRulesNotActive: (packageRoot) => `Project lint: HubSpot ESLint rules not active for ${chalk.bold(packageRoot)}. Configure ${chalk.bold('@hubspot/eslint-config-ui-extensions')} — see ${uiLink('setup instructions', 'https://www.npmjs.com/package/@hubspot/eslint-config-ui-extensions')}.`,
             npmAuditClean: (packageRoot) => `npm audit: No npm dependency issues found for ${chalk.bold(packageRoot)}`,
             npmAuditIssues: (packageRoot, details) => `npm audit: security issues found for ${chalk.bold(packageRoot)}: ${details}`,
             npmAuditNpmUnavailable: (packageRoot) => `npm audit: skipped for ${chalk.bold(packageRoot)} (npm not available in PATH)`,

package/lib/commonOpts.js

@@ -76,7 +76,6 @@ export function addJSONOutputOptions(yargs) {
         alias: 'format-output-as-json',
         describe: lib.commonOpts.options.jsonOutput,
         type: 'boolean',
-        hidden: true,
     });
 }
 // Remove this once we've upgraded to yargs 18.0.0

package/lib/projects/uieLinting.d.ts

@@ -1,3 +1,4 @@
+import { LoadedProjectConfig } from './config.js';
 export declare const REQUIRED_PACKAGES_AND_MIN_VERSIONS: {
     readonly eslint: "9.0.0";
     readonly '@eslint/js': "9.0.0";
@@ -23,6 +24,9 @@ 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, platformVersion?: string | null): Promise<string>;
+export declare function getUieLintablePackageJsonLocations(projectConfig: LoadedProjectConfig): Promise<string[]>;
+export declare const HUBSPOT_UI_EXTENSIONS_RULE_PREFIX = "@hubspot/ui-extensions/";
+export declare function isHubSpotEslintConfigActive(directory: string): Promise<boolean>;
 export declare function lintPackagesInDirectory(directory: string, projectDir?: string): Promise<{
     success: boolean;
     output: string;

package/lib/projects/uieLinting.js

@@ -10,7 +10,8 @@ import { uiLogger } from '../ui/logger.js';
 import { clearPackageJsonCache, 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';
+import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } from '../constants.js';
+import { CARDS_KEY, Components, PAGES_KEY, SETTINGS_KEY, } from '@hubspot/project-parsing-lib/constants';
 export const REQUIRED_PACKAGES_AND_MIN_VERSIONS = {
     eslint: '9.0.0',
     '@eslint/js': '9.0.0',
@@ -40,6 +41,11 @@ const DEPRECATED_ESLINT_CONFIG_FILES = [
     '.eslintrc.json',
     '.eslintrc',
 ];
+const UIE_COMPONENTS = [
+    Components[CARDS_KEY],
+    Components[SETTINGS_KEY],
+    Components[PAGES_KEY],
+];
 export const LINT_SCRIPTS = {
     lint: 'eslint .',
     'lint:fix': 'eslint . --fix',
@@ -163,6 +169,38 @@ export async function createEslintConfig(directory, platformVersion) {
         throw error;
     }
 }
+export async function getUieLintablePackageJsonLocations(projectConfig) {
+    if (!projectConfig.projectDir || !projectConfig.projectConfig?.srcDir) {
+        return [];
+    }
+    const srcDirAbsolute = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
+    const uiePackageDirPrefixes = UIE_COMPONENTS.map(component => path.join(srcDirAbsolute, component.parentComponent
+        ? Components[component.parentComponent].dir
+        : '', component.dir));
+    const allLocations = await getProjectPackageJsonLocations(projectConfig.projectDir);
+    return allLocations.filter(location => {
+        const resolvedLocation = path.resolve(location);
+        return uiePackageDirPrefixes.some(prefix => resolvedLocation.startsWith(prefix));
+    });
+}
+export const HUBSPOT_UI_EXTENSIONS_RULE_PREFIX = '@hubspot/ui-extensions/';
+function getEnvironmentWithoutNpmConfig() {
+    return Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.toLowerCase().startsWith('npm_config_')));
+}
+export async function isHubSpotEslintConfigActive(directory) {
+    const exec = util.promisify(execAsync);
+    try {
+        const { stdout } = await exec('npx eslint --print-config ./Component.tsx', {
+            cwd: directory,
+        });
+        const config = JSON.parse(stdout);
+        const rules = config.rules ?? {};
+        return Object.keys(rules).some(rule => rule.startsWith(HUBSPOT_UI_EXTENSIONS_RULE_PREFIX));
+    }
+    catch {
+        return false;
+    }
+}
 export async function lintPackagesInDirectory(directory, projectDir) {
     const displayPath = projectDir
         ? path.relative(projectDir, directory)
@@ -173,6 +211,7 @@ export async function lintPackagesInDirectory(directory, projectDir) {
         const { stdout, stderr } = await exec(lintCommand, {
             cwd: directory,
             maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large outputs
+            env: getEnvironmentWithoutNpmConfig(),
         });
         let output = `\n${displayPath}:\n`;
         if (stdout && stdout.trim()) {

package/lib/projects/upload.js

@@ -18,6 +18,7 @@ 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';
+import { validateLintConfigOnUpload } from './validateLintConfigOnUpload.js';
 import { runNpmAuditsBeforeProjectUpload } from './npmAuditOnUpload.js';
 async function uploadProjectFiles(accountId, projectName, filePath, uploadMessage, platformVersion, intermediateRepresentation) {
     const accountIdentifier = uiAccountDescription(accountId) || `${accountId}`;
@@ -61,6 +62,14 @@ export async function handleProjectUpload({ accountId, projectConfig, projectDir
         workspaceMappings = await collectWorkspaceDirectories(parsedPackageJsons);
         fileDependencyMappings = await collectFileDependencies(parsedPackageJsons);
     }
+    if (isUploadCommand && !skipValidation) {
+        await validateLintConfigOnUpload({
+            srcDir,
+            projectDir,
+            parsedPackageJsons,
+            isLegacyPlatform: isLegacyProject(projectConfig.platformVersion),
+        });
+    }
     if (isUploadCommand && !skipNpmAudit) {
         await runNpmAuditsBeforeProjectUpload({
             srcDir,

package/lib/projects/validateLintConfigOnUpload.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedPackageJson } from '@hubspot/project-parsing-lib/workspaces';
+type ValidateLintConfigOnUploadArgs = {
+    srcDir: string;
+    projectDir: string;
+    parsedPackageJsons: ParsedPackageJson[];
+    isLegacyPlatform: boolean;
+};
+export declare function validateLintConfigOnUpload({ srcDir, projectDir, parsedPackageJsons, isLegacyPlatform, }: ValidateLintConfigOnUploadArgs): Promise<void>;
+export {};

package/lib/projects/validateLintConfigOnUpload.js

@@ -0,0 +1,45 @@
+import path from 'path';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+import { areAllLintPackagesInstalled, hasEslintConfig, isHubSpotEslintConfigActive, } from './uieLinting.js';
+export async function validateLintConfigOnUpload({ srcDir, projectDir, parsedPackageJsons, isLegacyPlatform, }) {
+    const lintRoots = new Set();
+    if (isLegacyPlatform) {
+        lintRoots.add(srcDir);
+    }
+    else {
+        for (const { dir } of parsedPackageJsons) {
+            lintRoots.add(dir);
+        }
+        if (lintRoots.size === 0) {
+            lintRoots.add(srcDir);
+        }
+    }
+    let hasAnyOutput = false;
+    for (const lintRoot of lintRoots) {
+        const relativeRoot = path.relative(projectDir, lintRoot) || '.';
+        let warnMessage;
+        if (!areAllLintPackagesInstalled(lintRoot)) {
+            warnMessage =
+                lib.projectUpload.handleProjectUpload.lintPackagesNotConfigured(relativeRoot);
+        }
+        else if (!hasEslintConfig(lintRoot)) {
+            warnMessage =
+                lib.projectUpload.handleProjectUpload.lintConfigNotFound(relativeRoot);
+        }
+        else if (!(await isHubSpotEslintConfigActive(lintRoot))) {
+            warnMessage =
+                lib.projectUpload.handleProjectUpload.lintHubSpotRulesNotActive(relativeRoot);
+        }
+        if (warnMessage) {
+            if (!hasAnyOutput) {
+                uiLogger.log('');
+                hasAnyOutput = true;
+            }
+            uiLogger.warn(warnMessage);
+        }
+    }
+    if (hasAnyOutput) {
+        uiLogger.log('');
+    }
+}

package/lib/projects/workspaces.d.ts

@@ -1,11 +1,15 @@
 import archiver from 'archiver';
-import { WorkspaceMapping, FileDependencyMapping } from '@hubspot/project-parsing-lib/workspaces';
+import { WorkspaceMapping, FileDependencyMapping, FileDependencyKind, LocalDependencyProtocol } from '@hubspot/project-parsing-lib/workspaces';
+export type FileDepArchiveEntry = {
+    archivePath: string;
+    protocol: LocalDependencyProtocol;
+};
 /**
  * Result of archiving workspaces and file dependencies
  */
 export type WorkspaceArchiveResult = {
     packageWorkspaces: Map<string, string[]>;
-    packageFileDeps: Map<string, Map<string, string>>;
+    packageFileDeps: Map<string, Map<string, FileDepArchiveEntry>>;
 };
 /**
  * Generates a short hash of the input string for use in workspace paths.
@@ -24,10 +28,14 @@ export declare function shortHash(input: string): string;
 export declare function toPosixPath(p: string): string;
 /**
  * Determines the archive path for an external workspace or file: dependency.
- * Produces `_workspaces/<basename>-<hash>` with no subdirectory.
- * The hash prevents collisions between different directories with the same basename.
+ *
+ * For directories, produces `_workspaces/<basename>-<hash>`.
+ * For tarballs, produces `_workspaces/<basename-no-ext>-<hash>/<original-basename>`,
+ * so the rewritten package.json reference still ends in the original filename.
+ *
+ * The hash prevents collisions between different paths with the same basename.
  */
-export declare function computeExternalArchivePath(absolutePath: string): string;
+export declare function computeExternalArchivePath(absolutePath: string, kind?: FileDependencyKind): string;
 /**
  * Updates package.json files in the archive to reflect new workspace and file: dependency paths.
  *
@@ -38,7 +46,7 @@ export declare function computeExternalArchivePath(absolutePath: string): string
  * Only external file: dependencies appear in packageFileDeps; internal ones
  * keep their original file: references and are left untouched.
  */
-export declare function updatePackageJsonInArchive(archive: archiver.Archiver, srcDir: string, packageWorkspaces: Map<string, string[]>, packageFileDeps: Map<string, Map<string, string>>): Promise<void>;
+export declare function updatePackageJsonInArchive(archive: archiver.Archiver, srcDir: string, packageWorkspaces: Map<string, string[]>, packageFileDeps: Map<string, Map<string, FileDepArchiveEntry>>): Promise<void>;
 export declare function rewriteLockfileForExternalDeps(lockfileContent: Record<string, unknown>, pathMappings: Array<{
     oldPath: string;
     newPath: string;

package/lib/projects/workspaces.js

@@ -27,14 +27,35 @@ export function toPosixPath(p) {
     }
     return p.replaceAll(path.sep, path.posix.sep);
 }
+/**
+ * Strips the longest matching tarball extension (.tar.gz, .tgz, .tar)
+ * from a file basename. Returns the input unchanged if no extension matches.
+ */
+function stripTarballExtension(basename) {
+    const lower = basename.toLowerCase();
+    for (const ext of ['.tar.gz', '.tgz', '.tar']) {
+        if (lower.endsWith(ext)) {
+            return basename.slice(0, basename.length - ext.length);
+        }
+    }
+    return basename;
+}
 /**
  * Determines the archive path for an external workspace or file: dependency.
- * Produces `_workspaces/<basename>-<hash>` with no subdirectory.
- * The hash prevents collisions between different directories with the same basename.
+ *
+ * For directories, produces `_workspaces/<basename>-<hash>`.
+ * For tarballs, produces `_workspaces/<basename-no-ext>-<hash>/<original-basename>`,
+ * so the rewritten package.json reference still ends in the original filename.
+ *
+ * The hash prevents collisions between different paths with the same basename.
  */
-export function computeExternalArchivePath(absolutePath) {
+export function computeExternalArchivePath(absolutePath, kind = 'directory') {
     const resolved = path.resolve(absolutePath);
     const name = path.basename(resolved);
+    if (kind === 'tarball') {
+        const nameNoExt = stripTarballExtension(name);
+        return path.posix.join('_workspaces', `${nameNoExt}-${shortHash(resolved)}`, name);
+    }
     return path.posix.join('_workspaces', `${name}-${shortHash(resolved)}`);
 }
 /**
@@ -121,25 +142,25 @@ async function archiveWorkspaceDirectories(archive, srcDir, workspaceMappings) {
     return { externalArchivePaths, packageWorkspaceEntries };
 }
 /**
- * Archives file: dependencies and returns mapping information.
+ * Archives file: and link: dependencies and returns mapping information.
  *
- * Internal file: dependencies (inside srcDir) are skipped — their original
- * `file:` references in package.json remain valid after upload.
+ * Internal dependencies (inside srcDir) are skipped — their original
+ * references in package.json remain valid after upload.
  *
- * External file: dependencies are archived to `_workspaces/<name>-<hash>`
- * and tracked in the returned map so package.json can be rewritten.
+ * External directory dependencies are archived to `_workspaces/<name>-<hash>`.
+ * External tarball dependencies are archived to
+ * `_workspaces/<name-no-ext>-<hash>/<original-basename>` so the rewritten
+ * reference still ends in the original filename.
  */
 async function archiveFileDependencies(archive, srcDir, fileDependencyMappings, externalArchivePaths) {
     const packageFileDeps = new Map();
     const toArchive = [];
     for (const mapping of fileDependencyMappings) {
-        const { packageName, localPath, sourcePackageJsonPath } = mapping;
+        const { packageName, localPath, sourcePackageJsonPath, kind, protocol } = mapping;
         if (isInsideSrcDir(localPath, srcDir)) {
-            // Internal: original file: reference stays unchanged, nothing to do
             continue;
         }
-        // External: archive to _workspaces/<name>-<hash>
-        const archivePath = computeExternalArchivePath(localPath);
+        const archivePath = computeExternalArchivePath(localPath, kind);
         const resolvedPath = path.resolve(localPath);
         if (!packageFileDeps.has(sourcePackageJsonPath)) {
             packageFileDeps.set(sourcePackageJsonPath, new Map());
@@ -148,23 +169,27 @@ async function archiveFileDependencies(archive, srcDir, fileDependencyMappings,
         const relativeArchivePath = toPosixPath(path.relative(relPkgJsonDir, archivePath));
         packageFileDeps
             .get(sourcePackageJsonPath)
-            .set(packageName, relativeArchivePath);
-        // Only archive each unique path once
+            .set(packageName, { archivePath: relativeArchivePath, protocol });
         if (!externalArchivePaths.has(resolvedPath)) {
             externalArchivePaths.set(resolvedPath, archivePath);
-            toArchive.push({ localPath, archivePath, packageName });
+            toArchive.push({ localPath, archivePath, packageName, kind });
         }
     }
-    // Fetch packable files in parallel (I/O optimization)
-    const withPackableFiles = await Promise.all(toArchive.map(async (item) => ({
+    const directoryItems = toArchive.filter(item => item.kind === 'directory');
+    const tarballItems = toArchive.filter(item => item.kind === 'tarball');
+    // getPackableFiles only applies to directory deps; tarballs are a single file.
+    const directoriesWithPackableFiles = await Promise.all(directoryItems.map(async (item) => ({
         ...item,
         packableFiles: await getPackableFiles(item.localPath),
     })));
-    // Archive directories sequentially (archiver requires sequential operations)
-    for (const { localPath, archivePath, packageName, packableFiles, } of withPackableFiles) {
+    for (const { localPath, archivePath, packageName, packableFiles, } of directoriesWithPackableFiles) {
         uiLogger.log(lib.projectUpload.handleProjectUpload.fileDependencyIncluded(packageName, localPath, archivePath));
         archive.directory(localPath, archivePath, createWorkspaceFileFilter(packableFiles));
     }
+    for (const { localPath, archivePath, packageName } of tarballItems) {
+        uiLogger.log(lib.projectUpload.handleProjectUpload.fileDependencyIncluded(packageName, localPath, archivePath));
+        archive.file(localPath, { name: archivePath });
+    }
     return packageFileDeps;
 }
 /**
@@ -213,14 +238,18 @@ export async function updatePackageJsonInArchive(archive, srcDir, packageWorkspa
             uiLogger.debug(lib.projectUpload.handleProjectUpload.updatingPackageJsonWorkspaces(relativePackageJsonPath));
             uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedWorkspaces(workspaceEntries.join(', ')));
         }
-        // Update external file: dependencies; internal ones are left untouched
+        // Update external file: and link: dependencies; internal ones are left untouched.
+        // The protocol prefix (file: vs link:) is preserved from the original spec.
         const fileDeps = packageFileDeps.get(packageJsonPath);
         if (fileDeps && fileDeps.size > 0 && packageJson.dependencies) {
-            for (const [packageName, archivePath] of fileDeps.entries()) {
-                if (packageJson.dependencies[packageName]?.startsWith('file:')) {
-                    packageJson.dependencies[packageName] = `file:${archivePath}`;
+            for (const [packageName, { archivePath, protocol },] of fileDeps.entries()) {
+                const current = packageJson.dependencies[packageName];
+                if (typeof current === 'string' &&
+                    (current.startsWith('file:') || current.startsWith('link:'))) {
+                    const newValue = `${protocol}:${archivePath}`;
+                    packageJson.dependencies[packageName] = newValue;
                     modified = true;
-                    uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedFileDependency(packageName, archivePath));
+                    uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedFileDependency(packageName, newValue));
                 }
             }
         }
@@ -248,11 +277,24 @@ export function rewriteLockfileForExternalDeps(lockfileContent, pathMappings) {
             typeof value === 'object' &&
             value !== null) {
             const entry = value;
-            if (entry.link === true && typeof entry.resolved === 'string') {
-                const mapping = pathMappings.find(m => m.oldPath === entry.resolved);
-                if (mapping) {
-                    newPackages[key] = { ...entry, resolved: mapping.newPath };
-                }
+            if (typeof entry.resolved !== 'string')
+                continue;
+            // Symlink entries (directory deps with link:true) store resolved as a
+            // bare relative path. Tarball entries store resolved as a "file:" URL.
+            const resolved = entry.resolved;
+            const filePrefix = 'file:';
+            const isFileUrl = resolved.startsWith(filePrefix);
+            const resolvedPath = isFileUrl
+                ? resolved.slice(filePrefix.length)
+                : resolved;
+            const mapping = pathMappings.find(m => m.oldPath === resolvedPath);
+            if (mapping) {
+                newPackages[key] = {
+                    ...entry,
+                    resolved: isFileUrl
+                        ? `${filePrefix}${mapping.newPath}`
+                        : mapping.newPath,
+                };
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.1.2-experimental.2",
+    "version": "8.1.3-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
@@ -10,8 +10,8 @@
         "!**/__tests__/**"
     ],
     "dependencies": {
-        "@hubspot/local-dev-lib": "5.7.0",
-        "@hubspot/project-parsing-lib": "0.16.0",
+        "@hubspot/local-dev-lib": "5.7.1",
+        "@hubspot/project-parsing-lib": "0.2.2-experimental.0",
         "@hubspot/serverless-dev-runtime": "7.0.7",
         "@hubspot/ui-extensions-dev-server": "2.0.7",
         "@inquirer/prompts": "7.1.0",
@@ -37,7 +37,7 @@
         "table": "6.9.0",
         "tmp": "0.2.4",
         "update-notifier": "7.3.1",
-        "ws": "^8.18.2",
+        "ws": "8.20.0",
         "yargs": "17.7.2",
         "yargs-parser": "21.1.1"
     },