@servicetitan/startup 34.3.0 → 35.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/startup",
-    "version": "34.3.0",
+    "version": "35.1.0",
     "description": "CLI to create multi-package Lerna projects with TypeScript and React",
     "homepage": "https://docs.st.dev/docs/frontend/uikit/startup",
     "repository": {
@@ -9,8 +9,8 @@
         "directory": "packages/startup"
     },
     "engines": {
-        "node": ">=20.19 <21 || >=22.17",
-        "npm": ">=9"
+        "node": ">=22.17",
+        "npm": ">=10"
     },
     "sideEffects": false,
     "main": "./dist/index.js",
@@ -20,6 +20,7 @@
             "default": "./dist/index.js",
             "types": "./dist/index.d.ts"
         },
+        "./cypress-config": "./dist/cypress-config/index.js",
         "./jest-preset": "./jest/jest-preset.js",
         "./jest-resolver": "./dist/jest/resolver.js",
         "./jest-svg-transformer": "./dist/jest/svg-transformer.js",
@@ -53,19 +54,19 @@
     },
     "dependencies": {
         "@babel/preset-env": "~7.29.0",
-        "@jest/core": "~30.2.0",
-        "@jest/types": "~30.2.0",
+        "@jest/core": "~30.3.0",
+        "@jest/types": "~30.3.0",
         "@jsdevtools/coverage-istanbul-loader": "^3.0.5",
-        "@servicetitan/eslint-config": "34.3.0",
-        "@servicetitan/install": "34.3.0",
-        "@servicetitan/startup-utils": "34.3.0",
-        "@servicetitan/stylelint-config": "34.3.0",
+        "@servicetitan/eslint-config": "35.1.0",
+        "@servicetitan/install": "35.1.0",
+        "@servicetitan/startup-utils": "35.1.0",
+        "@servicetitan/stylelint-config": "35.1.0",
         "@svgr/webpack": "^8.1.0",
         "@swc/cli": "^0.5.0",
         "@swc/core": "1.15.18",
         "@types/debug": "^4.1.12",
         "@types/jest": "~30.0.0",
-        "@vitest/coverage-v8": "^4.0.18",
+        "@vitest/coverage-v8": "^4.1.0",
         "chalk": "~4.1.2",
         "cli-table3": "^0.6.5",
         "cpx2": "8.0.0",
@@ -80,40 +81,41 @@
         "html-webpack-plugin": "~5.6.6",
         "html-webpack-tags-plugin": "^3.0.2",
         "identity-obj-proxy": "~3.0.0",
-        "jest": "~30.2.0",
-        "jest-circus": "~30.2.0",
-        "jest-environment-jsdom": "^30.2.0",
+        "jest": "~30.3.0",
+        "jest-circus": "~30.3.0",
+        "jest-environment-jsdom": "^30.3.0",
         "jest-fetch-mock": "~3.0.3",
         "json5": "^2.2.3",
         "lerna": "~9.0.5",
         "less": "~4.5.1",
-        "less-loader": "~12.3.1",
+        "less-loader": "~12.3.2",
         "less-plugin-npm-import": "~2.1.0",
         "lodash.kebabcase": "^4.1.1",
         "lodash.memoize": "^4.1.2",
-        "memfs": "~4.56.10",
-        "mini-css-extract-plugin": "~2.10.0",
+        "memfs": "~4.56.11",
+        "mini-css-extract-plugin": "~2.10.1",
         "moment-locales-webpack-plugin": "~1.2.0",
         "multimatch": "~8.0.0",
         "patch-package": "^8.0.1",
         "portfinder": "~1.0.38",
         "postcss": "~8.5.8",
         "prettier": "~3.8.1",
-        "sass": "~1.97.3",
+        "sass": "~1.98.0",
         "sass-loader": "~16.0.7",
         "semver": "~7.7.4",
         "source-map-loader": "~5.0.0",
         "style-loader": "~4.0.0",
         "stylelint": "~16.26.1",
+        "swc-loader": "^0.2.7",
         "terminal-link": "^5.0.0",
-        "terser-webpack-plugin": "^5.3.16",
+        "terser-webpack-plugin": "^5.4.0",
         "ts-jest": "29.4.6",
         "ts-node": "~10.9.2",
         "typed-css-modules": "~0.9.1",
         "typescript": "5.9.3",
-        "vitest": "^4.0.18",
+        "vitest": "^4.1.0",
         "webpack": "~5.105.4",
-        "webpack-assets-manifest": "~6.5.0",
+        "webpack-assets-manifest": "~6.5.1",
         "webpack-bundle-analyzer": "^5.2.0",
         "webpack-dev-server": "~5.2.3",
         "webpack-filter-warnings-plugin": "~1.2.1",
@@ -144,5 +146,5 @@
     "cli": {
         "webpack": false
     },
-    "gitHead": "0ca13bccd0abdbcbda28f08829ef38bde4caa927"
+    "gitHead": "f1d49b43f27789cf5cd4bea3e065cd9e33bf5876"
 }

package/src/cli/commands/__tests__/mfe-package-publish.test.ts

@@ -12,7 +12,7 @@ import {
     runCommand,
 } from '../../utils';
 import { MFEPackagePublish } from '../mfe-package-publish';
-import { ROLLBACK_TAG_SUFFIX } from '../utils';
+import { purgeCache, ROLLBACK_TAG_SUFFIX } from '../utils';
 
 jest.mock('fs', () => fs);
 
@@ -32,6 +32,10 @@ jest.mock('../../utils', () => ({
     npmView: jest.fn(),
     runCommand: jest.fn(),
 }));
+jest.mock('../utils', () => ({
+    ...jest.requireActual('../utils'),
+    purgeCache: jest.fn(),
+}));
 
 describe(`[startup] ${MFEPackagePublish.name}`, () => {
     const defaultRegistry = 'https://verdaccio.servicetitan.com';
@@ -127,6 +131,12 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         );
     });
 
+    test('purges cache after publishing', async () => {
+        await subject();
+
+        expect(purgeCache).toHaveBeenCalledWith({ packageName, tag });
+    });
+
     test('gets current tagged versions before publishing', async () => {
         await subject();
 
@@ -196,6 +206,14 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         });
     });
 
+    function itDoesNotPurgeCache() {
+        test('does not purge cache', async () => {
+            await subject();
+
+            expect(purgeCache).not.toHaveBeenCalled();
+        });
+    }
+
     describe('with "dry" argument', () => {
         beforeEach(() => (args.dry = true));
 
@@ -239,6 +257,8 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
                 `npx startup upload-sourcemaps --dry --releaseVersion=${buildPackageVersion()}`
             );
         });
+
+        itDoesNotPurgeCache();
     });
 
     function itDoesNotUploadSourcemaps() {
@@ -257,6 +277,12 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         itDoesNotUploadSourcemaps();
     });
 
+    describe('with "purgeCache: false"', () => {
+        beforeEach(() => (args.purgeCache = false));
+
+        itDoesNotPurgeCache();
+    });
+
     describe('when branch configuration includes "uploadSourcemaps: false"', () => {
         beforeEach(() =>
             vol.fromJSON({

package/src/cli/commands/__tests__/mfe-package-rollback.test.ts

@@ -1,6 +1,7 @@
 import { log, readJson } from '../../../utils';
 import { npmTagVersion, npmView } from '../../utils';
 import { MFEPackageRollback } from '../mfe-package-rollback';
+import { purgeCache } from '../utils';
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
@@ -16,6 +17,10 @@ jest.mock('../../utils', () => ({
     npmTagVersion: jest.fn(),
     npmView: jest.fn(),
 }));
+jest.mock('../utils', () => ({
+    ...jest.requireActual('../utils'),
+    purgeCache: jest.fn(),
+}));
 
 describe(`[startup] ${MFEPackageRollback.name}`, () => {
     const registry = 'https://verdaccio.servicetitan.com';
@@ -98,6 +103,12 @@ describe(`[startup] ${MFEPackageRollback.name}`, () => {
         });
     });
 
+    test('purges cache after rollback', async () => {
+        await subject();
+
+        expect(purgeCache).toHaveBeenCalledWith({ packageName, tag });
+    });
+
     describe('when package is not found in registry', () => {
         beforeEach(() => {
             jest.mocked(npmView).mockReturnValue(undefined);
@@ -114,6 +125,14 @@ describe(`[startup] ${MFEPackageRollback.name}`, () => {
         itReportsError(`No rollback version found for tag "${tag}" (looking for "${rollbackTag}")`);
     });
 
+    function itDoesNotPurgeCache() {
+        test('does not purge cache', async () => {
+            await subject();
+
+            expect(purgeCache).not.toHaveBeenCalled();
+        });
+    }
+
     describe('when tag and rollback tag both point to the same version', () => {
         beforeEach(() => {
             packageInfo['dist-tags'] = {
@@ -130,6 +149,8 @@ describe(`[startup] ${MFEPackageRollback.name}`, () => {
             );
             expect(npmTagVersion).not.toHaveBeenCalled();
         });
+
+        itDoesNotPurgeCache();
     });
 
     describe('when tag does not exist', () => {
@@ -190,5 +211,15 @@ describe(`[startup] ${MFEPackageRollback.name}`, () => {
                 )
             );
         });
+
+        itDoesNotPurgeCache();
+    });
+
+    describe('with purgeCache: false', () => {
+        beforeEach(() => {
+            args.purgeCache = false;
+        });
+
+        itDoesNotPurgeCache();
     });
 });

package/src/cli/commands/__tests__/mfe-publish.test.ts

@@ -139,11 +139,13 @@ describe(`[startup] ${MFEPublish.name}`, () => {
         const testArgs: { name: ArgumentName; value: any; expected?: string | string[] }[] = [
             { name: 'build', value: true },
             { name: 'branch', value: 'foo-123' },
-            { name: 'tag', value: 'foo' },
-            { name: 'tag', value: true, expected: [] }, // check ignores obsolete --tag with no name
             { name: 'dry', value: true, expected: '--dry' },
             { name: 'force', value: true, expected: '--force' },
+            { name: 'purgeCache', value: true, expected: '--purge-cache' },
+            { name: 'purgeCache', value: false, expected: '--no-purge-cache' },
             { name: 'registry', value: 'https://foo' },
+            { name: 'tag', value: 'foo' },
+            { name: 'tag', value: true, expected: [] }, // check ignores obsolete --tag with no name
             { name: 'trackHistory', value: true, expected: '--track-history' },
             { name: 'trackHistory', value: false, expected: '--no-track-history' },
             { name: 'uploadSourcemaps', value: true, expected: '--upload-sourcemaps' },

package/src/cli/commands/__tests__/mfe-purge-cache.test.ts

@@ -0,0 +1,141 @@
+import { log } from '../../../utils';
+import { MFEPurgeCache, PurgeResponse } from '../mfe-purge-cache';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    log: { debug: jest.fn(), info: jest.fn(), warning: jest.fn() },
+}));
+
+describe(`[startup] ${MFEPurgeCache.name}`, () => {
+    const host = 'https://unpkg.example.com';
+    const token = 'purge-token';
+    const tag = 'prod';
+    const packageName = '@servicetitan/foo';
+    const version = '0.0.0-master.abc1223';
+    const location = `/${packageName}@${version}/dist/metadata.json`;
+
+    let args: ConstructorParameters<typeof MFEPurgeCache>[0];
+    let fetchSpy: jest.SpyInstance;
+    let fetchResponse: any;
+    let responseJson: PurgeResponse;
+
+    beforeEach(() => {
+        process.env.UNPKG_PURGE_TOKEN = token;
+        args = { host, packageName, tag };
+        fetchResponse = {
+            ok: true,
+            json: jest.fn().mockImplementation(() => Promise.resolve(responseJson)),
+        };
+        responseJson = [{ pod: '10.36.110.200', status: 302, cache: 'BYPASS', location }];
+
+        jest.clearAllMocks();
+        jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+        fetchSpy = jest.spyOn(global, 'fetch').mockImplementation(() => fetchResponse);
+    });
+
+    afterEach(() => delete process.env.UNPKG_PURGE_TOKEN);
+
+    const subject = () => new MFEPurgeCache(args).execute();
+
+    test('sends POST request with X-Purge-Token header', async () => {
+        await subject();
+
+        expect(fetchSpy).toHaveBeenCalledWith(
+            `${host}/_purge/${packageName}@${tag}/dist/metadata.json`,
+            { method: 'POST', headers: { 'X-Purge-Token': token } }
+        );
+    });
+
+    test('logs progress', async () => {
+        await subject();
+
+        expect(log.info).toHaveBeenCalledWith(`Purging cache for ${packageName}@${tag}`);
+    });
+
+    test('logs the redirect location from the response', async () => {
+        await subject();
+
+        expect(log.info).toHaveBeenCalledWith(
+            `Cache purged: ${packageName}@${tag}/dist/metadata.json -> ${location.replace(/^\//, '')}`
+        );
+    });
+
+    describe('when request fails', () => {
+        beforeEach(() => {
+            fetchResponse = { ok: false, status: 403, statusText: 'Forbidden' };
+        });
+
+        test('throws error', () => {
+            expect(subject).rejects.toThrow(
+                `Purge request failed: ${fetchResponse.status} ${fetchResponse.statusText}`
+            );
+        });
+    });
+
+    function itLogsNullLocation() {
+        test('logs null location', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(expect.stringMatching(/-> null$/));
+        });
+    }
+
+    describe('when response location is null', () => {
+        beforeEach(() => (responseJson[0].location = null));
+
+        itLogsNullLocation();
+    });
+
+    describe('when response is empty', () => {
+        beforeEach(() => (responseJson = []));
+
+        itLogsNullLocation();
+    });
+
+    describe('when response is unexpected', () => {
+        beforeEach(() => (responseJson = {} as any));
+
+        itLogsNullLocation();
+    });
+
+    describe('when host has trailing slash', () => {
+        beforeEach(() => {
+            args.host = `${host}/`;
+        });
+
+        test('strips trailing slash from host', async () => {
+            await subject();
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                `${host}/_purge/${packageName}@${tag}/dist/metadata.json`,
+                expect.anything()
+            );
+        });
+    });
+
+    describe('with --token', () => {
+        const cliToken = 'cli-purge-token';
+
+        beforeEach(() => (args.token = cliToken));
+
+        test('uses specified token', async () => {
+            await subject();
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.objectContaining({ headers: { 'X-Purge-Token': cliToken } })
+            );
+        });
+    });
+
+    describe('with no token', () => {
+        beforeEach(() => delete process.env.UNPKG_PURGE_TOKEN);
+
+        test('logs warning and does nothing', async () => {
+            await subject();
+
+            expect(log.warning).toHaveBeenCalledWith('Token is not defined, skipping purge');
+            expect(fetchSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/src/cli/commands/get-command.ts

@@ -15,6 +15,7 @@ import { MFEPackageClean } from './mfe-package-clean';
 import { MFEPackagePublish } from './mfe-package-publish';
 import { MFEPackageRollback } from './mfe-package-rollback';
 import { MFEPublish } from './mfe-publish';
+import { MFEPurgeCache } from './mfe-purge-cache';
 import { PreparePackage } from './prepare-package';
 import { Review } from './review';
 import { RunTask } from './run-task';
@@ -42,6 +43,7 @@ const commands: Record<CommandName, Newable<Command>> = {
     [CommandName['mfe-package-publish']]: MFEPackagePublish,
     [CommandName['mfe-package-rollback']]: MFEPackageRollback,
     [CommandName['mfe-publish']]: MFEPublish,
+    [CommandName['mfe-purge-cache']]: MFEPurgeCache,
     [CommandName['prepare-package']]: PreparePackage,
     [CommandName.review]: Review,
     [CommandName.start]: Start,

package/src/cli/commands/mfe-package-publish.ts

@@ -22,7 +22,7 @@ import {
     runCommand,
 } from '../utils';
 import { Command, CommandOptions } from './types';
-import { buildRollbackTag, DEFAULT_MFE_REGISTRY } from './utils';
+import { DEFAULT_MFE_REGISTRY, buildRollbackTag, purgeCache } from './utils';
 
 export const mfePackagePublishOptions = {
     branch: {
@@ -59,6 +59,11 @@ export const mfePackagePublishOptions = {
         description: 'Upload source maps to Datadog?',
         defaultDescription: 'true',
     },
+    purgeCache: {
+        boolean: true,
+        description: 'Purge unpkg cache after publishing?',
+        defaultDescription: 'true',
+    },
 } satisfies CommandOptions;
 
 interface PublishData {
@@ -100,6 +105,11 @@ export class MFEPackagePublish extends Command<typeof mfePackagePublishOptions>
 
         await this.maybePublishPackage(packageJson, data);
 
+        const { dry, tag } = data;
+        if (this.args.purgeCache !== false && !dry) {
+            purgeCache({ packageName: packageJson.name, tag });
+        }
+
         if (data.uploadSourcemaps) {
             this.uploadSourcemaps(data);
         }

package/src/cli/commands/mfe-package-rollback.ts

@@ -1,7 +1,7 @@
 import { log, logErrors, readJson } from '../../utils';
 import { DRY_RUN_PREFIX, npmTagVersion, npmView } from '../utils';
 import { Command, CommandOptions } from './types';
-import { buildRollbackTag, DEFAULT_MFE_REGISTRY } from './utils';
+import { DEFAULT_MFE_REGISTRY, buildRollbackTag, purgeCache } from './utils';
 
 export const mfePackageRollbackOptions = {
     dry: {
@@ -18,6 +18,11 @@ export const mfePackageRollbackOptions = {
         description: 'The tag to rollback to its previous version',
         required: true,
     },
+    purgeCache: {
+        boolean: true,
+        description: 'Purge unpkg cache after rolling back?',
+        defaultDescription: 'true',
+    },
 } satisfies CommandOptions;
 
 interface PackageJson {
@@ -25,8 +30,6 @@ interface PackageJson {
 }
 
 export class MFEPackageRollback extends Command<typeof mfePackageRollbackOptions> {
-    static readonly description = 'Rollback a package to a previous tagged version';
-
     static readonly options = mfePackageRollbackOptions;
 
     private get dryRunPrefix() {
@@ -35,11 +38,16 @@ export class MFEPackageRollback extends Command<typeof mfePackageRollbackOptions
 
     @logErrors
     async execute() {
-        if (this.args.dry) {
+        const { dry, tag } = this.args;
+        if (dry) {
             log.warning('DRY-RUN MODE ENABLED, WILL NOT PERFORM ROLLBACK');
         }
 
-        await this.handleRollback();
+        const packageName = await this.handleRollback();
+
+        if (packageName && this.args.purgeCache !== false && !dry) {
+            purgeCache({ packageName, tag });
+        }
     }
 
     private async handleRollback() {
@@ -96,5 +104,7 @@ export class MFEPackageRollback extends Command<typeof mfePackageRollbackOptions
                 tag,
             });
         }
+
+        return packageName;
     }
 }

package/src/cli/commands/mfe-publish.ts

@@ -111,17 +111,28 @@ export class MFEPublish extends Command<MFEPublishOptions> {
     }
 
     getPublishOptions() {
-        const { build, branch, dry, force, registry, tag, uploadSourcemaps, trackHistory } =
-            this.args;
+        const {
+            build,
+            branch,
+            dry,
+            force,
+            purgeCache,
+            registry,
+            tag,
+            uploadSourcemaps,
+            trackHistory,
+        } = this.args;
         return [
             ...[branch && `--branch ${branch}`],
             ...[build && `--build ${build}`],
             ...[dry && '--dry'],
             ...[force && '--force'],
+            ...[purgeCache === true && '--purge-cache'],
+            ...[purgeCache === false && '--no-purge-cache'],
             ...[registry && `--registry ${registry}`],
+            ...[typeof tag === 'string' && `--tag ${tag}`],
             ...[trackHistory === true && '--track-history'],
             ...[trackHistory === false && '--no-track-history'],
-            ...[typeof tag === 'string' && `--tag ${tag}`],
             ...[uploadSourcemaps === true && `--upload-sourcemaps`],
             ...[uploadSourcemaps === false && `--no-upload-sourcemaps`],
         ].filter(item => !!item) as string[];

package/src/cli/commands/mfe-purge-cache.ts

@@ -0,0 +1,75 @@
+import { log, logErrors } from '../../utils';
+import { Command, CommandOptions } from './types';
+
+const mfePurgeCacheOptions = {
+    host: {
+        string: true,
+        description: 'Host URL to send purge requests to',
+        demandOption: true,
+    },
+    packageName: {
+        string: true,
+        description: 'Package name to purge',
+        demandOption: true,
+    },
+    tag: {
+        string: true,
+        description: 'Package tag to purge',
+        demandOption: true,
+    },
+    token: {
+        string: true,
+        description: 'X-Purge-Token header value',
+        defaultDescription: 'process.env.UNPKG_PURGE_TOKEN',
+    },
+} satisfies CommandOptions;
+
+export type PurgeResponse = {
+    pod: string;
+    status: number;
+    cache: string | null;
+    location: string | null;
+}[];
+
+export class MFEPurgeCache extends Command<typeof mfePurgeCacheOptions> {
+    static readonly options = mfePurgeCacheOptions;
+
+    @logErrors
+    async execute() {
+        const { host: rawHost, packageName, tag } = this.args;
+        const host = rawHost.replace(/\/$/, '');
+        const token = this.args.token ?? process.env.UNPKG_PURGE_TOKEN;
+        const packageNameAndTag = `${packageName}@${tag}`;
+        const path = `${packageNameAndTag}/dist/metadata.json`;
+
+        log.info(`Purging cache for ${packageNameAndTag}`);
+
+        if (!token) {
+            log.warning('Token is not defined, skipping purge');
+            return;
+        }
+
+        const response = await fetch(`${host}/_purge/${path}`, {
+            method: 'POST',
+            headers: { 'X-Purge-Token': token },
+        });
+
+        if (!response.ok) {
+            throw new Error(`Purge request failed: ${response.status} ${response.statusText}`);
+        }
+
+        const responseJson = await response.json();
+        /* istanbul ignore next: debug only */
+        log.debug('mfe-purge-cache', () => JSON.stringify(responseJson, null, 2));
+
+        log.info(`Cache purged: ${path} -> ${this.getLocation(responseJson)}`);
+    }
+
+    private getLocation(responseJson: PurgeResponse) {
+        let location: string | null = null;
+        if (Array.isArray(responseJson)) {
+            location = responseJson[0]?.location?.replace(/^\//, '') ?? null;
+        }
+        return location;
+    }
+}

package/src/cli/commands/utils/__tests__/purge-cache.test.ts

@@ -0,0 +1,40 @@
+import { runCommandOutput } from '../../../utils';
+import { purgeCache } from '../purge-cache';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    runCommandOutput: jest.fn(),
+}));
+
+describe(purgeCache.name, () => {
+    let args: Parameters<typeof purgeCache>[0];
+    const packageName = '@servicetitan/foo';
+    const tag = 'prod';
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        args = { packageName, tag };
+    });
+
+    const subject = () => purgeCache(args);
+
+    test('runs mfe-purge-cache with host "https://unpkg.servicetitan.com", package name and tag', () => {
+        subject();
+
+        expect(runCommandOutput).toHaveBeenCalledWith(
+            `npx startup mfe-purge-cache --host https://unpkg.servicetitan.com --package-name ${packageName} --tag ${tag}`
+        );
+    });
+
+    describe('when registry is "https://verdaccio.st.dev"', () => {
+        beforeEach(() => (args.registry = 'https://verdaccio.st.dev'));
+
+        test('runs mfe-purge-cache with host "https://unpkg.st.dev"', () => {
+            subject();
+
+            expect(runCommandOutput).toHaveBeenCalledWith(
+                expect.stringContaining(`--host https://unpkg.st.dev`)
+            );
+        });
+    });
+});

package/src/cli/commands/{utils.ts → utils/build-rollback-tag.ts}

@@ -1,4 +1,3 @@
-export const DEFAULT_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';
 export const ROLLBACK_TAG_SUFFIX = '-rollback-1';
 
 export function buildRollbackTag(tag: string): string {

package/src/cli/commands/utils/constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';

package/src/cli/commands/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './build-rollback-tag';
+export * from './constants';
+export * from './purge-cache';