@servicetitan/startup 38.0.0 → 38.2.0

package/src/cli/commands/__tests__/start.test.ts

@@ -1,6 +1,8 @@
 import { createPackage } from '../../../__mocks__';
-import { Package, PackageType, getPackages, log } from '../../../utils';
-import { compile, lernaExec, typeCheck, watchStdout } from '../../utils';
+import { Attributes } from '../../../telemetry';
+import { getConfiguration, getPackages, log, Package, PackageType } from '../../../utils';
+import { compile, lernaExec, ProcessTree, typeCheck, watchStdout } from '../../utils';
+import { Command } from '../command';
 import { entry } from '../registry/start';
 import { Start } from '../start';
 
@@ -31,18 +33,29 @@ jest.mock('../../utils', () => ({
 }));
 
 describe(`[startup] ${Start.name}`, () => {
+    const commandProto = Command.prototype as unknown as {
+        recordStart: (command: string, attributes?: Attributes) => void;
+        recordEnd: (error?: unknown) => Promise<void>;
+    };
+
     let args: ConstructorParameters<typeof Start>[0];
     let packages: Package[];
+    let recordStart: jest.SpyInstance;
+    let recordEnd: jest.SpyInstance;
 
     beforeEach(() => {
         args = {};
         packages = [];
+        jest.restoreAllMocks();
         jest.clearAllMocks();
+        jest.mocked(getConfiguration).mockReturnValue({});
         jest.mocked(getPackages).mockImplementation(() => packages);
         jest.mocked(watchStdout).mockImplementation((_process, _indicator, handler) => {
             handler(packages.length);
             return jest.fn();
         });
+        recordStart = jest.spyOn(commandProto, 'recordStart').mockImplementation(() => {});
+        recordEnd = jest.spyOn(commandProto, 'recordEnd').mockResolvedValue(undefined);
     });
 
     const subject = () => new Start(args).execute();
@@ -106,6 +119,41 @@ describe(`[startup] ${Start.name}`, () => {
         expect(entry.greedy).toBe(true);
     });
 
+    test('sets process.env.STARTUP_PARENT_PID', async () => {
+        await subject();
+
+        expect(process.env.STARTUP_PARENT_PID).toBe(String(process.pid));
+    });
+
+    describe('telemetry', () => {
+        beforeEach(() => packages.push(createPackage({ type: PackageType.TSC })));
+
+        test('records the command start', async () => {
+            await subject();
+
+            expect(recordStart).toHaveBeenCalledWith('start', { bundler: expect.any(String) });
+        });
+
+        describe('when start fails', () => {
+            const error = new Error('watch failed');
+
+            beforeEach(() => {
+                jest.spyOn(log, 'error').mockImplementation(jest.fn());
+                jest.spyOn(ProcessTree.prototype, 'run').mockRejectedValue(error);
+            });
+
+            test('records the failure', async () => {
+                await subject().catch(() => {});
+
+                expect(recordEnd).toHaveBeenCalledWith(error);
+            });
+
+            test('propagates the error', async () => {
+                await expect(subject()).rejects.toBe(error);
+            });
+        });
+    });
+
     describe('with TSC package', () => {
         beforeEach(() => packages.push(createPackage({ type: PackageType.TSC })));
 
@@ -121,7 +169,7 @@ describe(`[startup] ${Start.name}`, () => {
         });
     });
 
-    describe('with Webpack package', () => {
+    describe('with bundle package', () => {
         beforeEach(() => packages.push(createPackage({ type: PackageType.Bundle })));
 
         itPreparesThePackages();
@@ -132,11 +180,11 @@ describe(`[startup] ${Start.name}`, () => {
             await subject();
 
             expect(lernaExec).toHaveBeenCalledWith({
-                'cmd': 'startup bundle-webpack',
+                'cmd': 'startup bundle-package',
                 'scope': packages.map(({ name }) => name),
                 'parallel': true,
                 'stream': true,
-                '--': ['--exposed-dependencies', '--use-watch-config'],
+                '--': ['--exposed-dependencies', '--use-watch-config', '--bundler webpack'],
             });
         });
 
@@ -144,24 +192,37 @@ describe(`[startup] ${Start.name}`, () => {
             await subject();
 
             expect(lernaExec).toHaveBeenCalledWith({
-                'cmd': 'startup bundle-webpack',
+                'cmd': 'startup bundle-package',
                 'scope': packages.map(({ name }) => name),
                 'parallel': true,
                 'stream': true,
-                '--': ['--watch'],
+                '--': ['--watch', '--bundler webpack'],
             });
         });
 
-        describe('with --bundler=vite', () => {
-            beforeEach(() => (args.bundler = 'vite'));
-
-            test('bundles with Vite in watch mode', async () => {
+        function itBundlesWithVite() {
+            test('bundles with vite', async () => {
                 await subject();
 
                 expect(lernaExec).toHaveBeenCalledWith(
-                    expect.objectContaining({ cmd: 'startup bundle-vite' })
+                    expect.objectContaining({
+                        'cmd': 'startup bundle-package',
+                        '--': ['--watch', '--bundler vite'],
+                    })
                 );
             });
+        }
+
+        describe('with --bundler=vite', () => {
+            beforeEach(() => (args.bundler = 'vite'));
+
+            itBundlesWithVite();
+        });
+
+        describe('with cli.bundler set to vite', () => {
+            beforeEach(() => jest.mocked(getConfiguration).mockReturnValue({ bundler: 'vite' }));
+
+            itBundlesWithVite();
         });
 
         describe('with "code-coverage"', () => {
@@ -172,8 +233,8 @@ describe(`[startup] ${Start.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        'cmd': 'startup bundle-webpack',
-                        '--': ['--watch', '--code-coverage'],
+                        'cmd': 'startup bundle-package',
+                        '--': ['--watch', '--code-coverage', '--bundler webpack'],
                     })
                 );
             });
@@ -187,8 +248,8 @@ describe(`[startup] ${Start.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        'cmd': 'startup bundle-webpack',
-                        '--': ['--watch', `--config "${args.config}"`],
+                        'cmd': 'startup bundle-package',
+                        '--': ['--watch', `--config "${args.config}"`, '--bundler webpack'],
                     })
                 );
             });

package/src/cli/commands/build.ts

@@ -1,5 +1,5 @@
 import { getPackages, logErrors, PackageType } from '../../utils';
-import { checkArgs, compile, getBundleCommand, lernaExec, ProcessTree, typeCheck } from '../utils';
+import { checkArgs, compile, lernaExec, ProcessTree, resolveBundler, typeCheck } from '../utils';
 import { kendoUILicense } from './kendo-ui-license';
 import type { entry } from './registry/build';
 import { Command } from './types';
@@ -30,6 +30,8 @@ export class Build extends Command<typeof entry> {
             return;
         }
 
+        this.recordStart('build', { bundler: resolveBundler(this.args) });
+
         if (this.args.cdnPath) {
             process.env.CLIENT_CDN_PATH = this.args.cdnPath;
         }
@@ -38,7 +40,7 @@ export class Build extends Command<typeof entry> {
         const bundleScope = packages
             .filter(({ type }) => type === PackageType.Bundle)
             .map(({ name }) => name);
-        const bundleCmd = getBundleCommand(this.args);
+        const bundlerArg = [`--bundler ${resolveBundler(this.args)}`];
         const precompileScope = packages
             .filter(({ scripts }) => !!scripts?.precompile)
             .map(({ name }) => name);
@@ -77,11 +79,11 @@ export class Build extends Command<typeof entry> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    'cmd': bundleCmd,
+                    'cmd': 'startup bundle-package',
                     'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
-                    '--': ['--exposed-dependencies'],
+                    '--': ['--exposed-dependencies', ...bundlerArg],
                 });
             },
             {
@@ -100,7 +102,7 @@ export class Build extends Command<typeof entry> {
                 }
 
                 return lernaExec({
-                    'cmd': bundleCmd,
+                    'cmd': 'startup bundle-package',
                     'scope': bundleScope,
                     'stream': true,
                     '--': [
@@ -108,12 +110,19 @@ export class Build extends Command<typeof entry> {
                         ...[this.args.codeCoverage ? '--code-coverage' : undefined],
                         ...[this.args.stat ? '--stat' : undefined],
                         ...[this.args.preview ? '--preview' : undefined],
+                        ...bundlerArg,
                     ].filter(item => !!item) as string[],
                 });
             },
             { dependsOn: [BuildProcesses.BundleExposedDependencies] }
         );
 
-        await processTree.run();
+        try {
+            await processTree.run();
+        } catch (error) {
+            await this.recordEnd(error);
+            throw error;
+        }
+        this.recordEnd();
     }
 }

package/src/cli/commands/bundle-package.ts

@@ -0,0 +1,20 @@
+import { bundleConstants } from '../../core';
+import { getConfiguration } from '../../utils';
+import { entry } from './registry/bundle-package';
+import { Command } from './types';
+
+export class BundlePackage extends Command<typeof entry> {
+    async execute() {
+        // Local cli.bundler overrides project-wide default in this.args.bundler
+        const bundler =
+            getConfiguration().bundler ?? this.args.bundler ?? bundleConstants.defaultBundler;
+
+        if (bundler === 'vite') {
+            const { BundleVite } = await import('./bundle-vite');
+            await new BundleVite(this.args).execute();
+        } else {
+            const { BundleWebpack } = await import('./bundle-webpack');
+            await new BundleWebpack(this.args).execute();
+        }
+    }
+}

package/src/cli/commands/command.ts

@@ -0,0 +1,64 @@
+import { randomUUID } from 'crypto';
+import { Attributes, telemetry } from '../../telemetry';
+import { CommandName, exitWhenParentExits } from '../../utils';
+import { CommandEntry, InferArgs } from './types';
+
+const NS_PER_MS = 1_000_000;
+
+interface CommandRun {
+    command: string;
+    runId: string;
+    startedAt: number;
+    attributes?: Attributes;
+}
+
+export abstract class Command<T extends CommandEntry = CommandEntry, U = unknown> {
+    private commandRun?: CommandRun;
+
+    constructor(protected readonly args: InferArgs<NonNullable<T['options']>, U>) {}
+
+    watchForParentExit(name: CommandName): void {
+        if ('watch' in this.args && this.args.watch === true) {
+            exitWhenParentExits(name);
+        }
+    }
+
+    protected recordStart(command: string, attributes?: Attributes): void {
+        if (this.commandRun) {
+            return;
+        }
+        this.commandRun = {
+            command,
+            runId: randomUUID(),
+            startedAt: globalThis.performance.now(),
+            attributes,
+        };
+        telemetry.info('command.started', {
+            ...attributes,
+            command,
+            runId: this.commandRun.runId,
+        });
+    }
+
+    protected recordEnd(error?: unknown): Promise<void> {
+        const run = this.commandRun;
+        if (!run) {
+            return Promise.resolve();
+        }
+        this.commandRun = undefined;
+        const attributes = {
+            ...run.attributes,
+            command: run.command,
+            runId: run.runId,
+            duration: Math.round((globalThis.performance.now() - run.startedAt) * NS_PER_MS),
+        };
+        if (error !== undefined) {
+            telemetry.error('command.finished', error, attributes);
+        } else {
+            telemetry.info('command.finished', attributes);
+        }
+        return telemetry.flush();
+    }
+
+    abstract execute(): Promise<void>;
+}

package/src/cli/commands/init.ts

@@ -39,7 +39,6 @@ export class Init extends Command<typeof entry> {
 
         fs.rmSync(path.join(destination, '.git'), { recursive: true, force: true });
         fs.rmSync(path.join(destination, '.github', 'CODEOWNERS'));
-        fs.rmSync(path.join(destination, 'package-lock.json'));
         return true;
     }
 }

package/src/cli/commands/install.ts

@@ -1,29 +1,13 @@
-import { execSync } from 'child_process';
-import { getStartupVersion } from '../../core';
-import { log, logErrors } from '../../utils';
+import { logErrors } from '../../utils';
 import type { entry } from './registry/install';
 import { Command } from './types';
 
 export class Install extends Command<typeof entry> {
     @logErrors
+    // eslint-disable-next-line @typescript-eslint/require-await
     async execute() {
-        if (!this.args.quiet) {
-            log.info(`startup cli v${getStartupVersion()}`);
-        }
-
-        const options = [
-            this.args.fix ? '--fix' : '',
-            this.args.quiet ? '--quiet' : '',
-            this.args.token === true ? '--token' : '',
-            this.args.token === false ? '--no-token' : '',
-        ].filter(option => !!option);
-
-        const command = `npx --yes @servicetitan/install ${options.join(' ')}`.trim();
-
-        log.debug('install', command);
-
-        execSync(command, { stdio: 'inherit' });
-
-        return Promise.resolve(); // stops "async method has no 'await' expression" lint error
+        throw new Error(
+            'The `startup install` command has been removed. Run `npx --yes @servicetitan/install` directly instead.'
+        );
     }
 }

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

@@ -2,7 +2,10 @@ import { getPackageManager } from '@servicetitan/install';
 import { getVersionMismatches } from '@servicetitan/startup-utils';
 import path from 'node:path';
 import { getExposedDependencies, Metadata } from '../../core';
+import type { Configuration } from '../../utils';
 import {
+    getSharedDependencies,
+    isExposeSharedDependencies,
     isWebComponent,
     loadSharedDependencies,
     log,
@@ -16,13 +19,7 @@ import { Command } from './types';
 interface HostPackageJSON {
     name: string;
     dependencies: Record<string, string>;
-    cli?: {
-        'web-component'?: boolean | string | object;
-        'webpack'?: {
-            'expose-shared-dependencies'?: boolean;
-            'shared-dependencies'?: Record<string, string>;
-        };
-    };
+    cli?: Configuration;
 }
 
 interface HostData extends HostPackageJSON {
@@ -82,7 +79,7 @@ export class MfeCheck extends Command<typeof entry> {
         const mfeSharedDependencies = mfeMetadata.sharedDependencies;
         const hostSharedDependencies = loadSharedDependencies(
             hostData.dependencies,
-            hostData.cli?.webpack?.['shared-dependencies']
+            getSharedDependencies(hostData)
         );
         const packageManager = getPackageManager();
         const workspacePackage = packageManager.getWorkspacePackage(hostData.location);
@@ -99,8 +96,7 @@ export class MfeCheck extends Command<typeof entry> {
         );
 
         const isHostMfe = isWebComponent(hostData);
-        const isSharedDependenciesEnabled =
-            hostData.cli?.webpack?.['expose-shared-dependencies'] === true;
+        const isSharedDependenciesEnabled = isExposeSharedDependencies(hostData);
         const compatible = !isHostMfe && !mismatchResult && isSharedDependenciesEnabled;
 
         return {

package/src/cli/commands/registry/build.ts

@@ -1,3 +1,4 @@
+import { bundleConstants } from '../../../core';
 import type { CommandEntry } from '../types';
 import { defineEntry } from './define-entry';
 
@@ -6,9 +7,9 @@ export const entry = defineEntry({
     greedy: true,
     options: {
         bundler: {
-            choices: ['vite', 'webpack'] as const,
+            choices: bundleConstants.bundlers,
             description: 'Bundler',
-            defaultDescription: 'webpack',
+            defaultDescription: bundleConstants.defaultBundler,
         },
         cdnPath: { string: true, description: 'Base url for application assets' },
         codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },

package/src/cli/commands/registry/bundle-package.ts

@@ -0,0 +1,22 @@
+import { bundleConstants } from '../../../core';
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+/*
+ * Internal dispatcher invoked by `start`/`build` per package. Its options are the union of
+ * bundle-vite and bundle-webpack so it can forward them to whichever bundler it delegates to,
+ * plus the run's --bundler default.
+ */
+export const entry = defineEntry({
+    options: {
+        bundler: { choices: bundleConstants.bundlers, hidden: true },
+        codeCoverage: { boolean: true, hidden: true },
+        config: { string: true, hidden: true },
+        exposedDependencies: { boolean: true, hidden: true },
+        preview: { boolean: true, hidden: true },
+        printConfig: { boolean: true, hidden: true },
+        stat: { boolean: true, hidden: true },
+        useWatchConfig: { boolean: true, hidden: true },
+        watch: { boolean: true, hidden: true },
+    },
+} satisfies CommandEntry);

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

@@ -1,6 +1,7 @@
 import { CommandName } from '../../../utils';
 import { Command, CommandEntry, Newable } from '../types';
 import { entry as build } from './build';
+import { entry as bundlePackage } from './bundle-package';
 import { entry as bundleVite } from './bundle-vite';
 import { entry as bundleWebpack } from './bundle-webpack';
 import { entry as clean } from './clean';
@@ -64,6 +65,7 @@ function makeEntry<K extends CommandName, T extends CommandEntry>(
  */
 export const commandRegistry = {
     ...makeEntry(CommandName.build, build),
+    ...makeEntry(CommandName['bundle-package'], bundlePackage),
     ...makeEntry(CommandName['bundle-vite'], bundleVite),
     ...makeEntry(CommandName['bundle-webpack'], bundleWebpack),
     ...makeEntry(CommandName.clean, clean),

package/src/cli/commands/registry/install.ts

@@ -3,10 +3,5 @@ import { defineEntry } from './define-entry';
 
 export const entry = defineEntry({
     allowRunFromGlobal: true,
-    description: 'Install project dependencies',
-    options: {
-        fix: { boolean: true, description: 'Update and dedupe package-lock.json', hidden: true },
-        quiet: { boolean: true, description: 'Suppress output', hidden: true },
-        token: { boolean: true, description: 'Configure npm token' },
-    },
+    description: 'Removed. Run `npx --yes @servicetitan/install` directly instead.',
 } satisfies CommandEntry);

package/src/cli/commands/registry/start.ts

@@ -1,3 +1,4 @@
+import { bundleConstants } from '../../../core';
 import type { CommandEntry } from '../types';
 import { defineEntry } from './define-entry';
 
@@ -6,9 +7,9 @@ export const entry = defineEntry({
     greedy: true,
     options: {
         bundler: {
-            choices: ['vite', 'webpack'] as const,
+            choices: bundleConstants.bundlers,
             description: 'Bundler',
-            defaultDescription: 'webpack',
+            defaultDescription: bundleConstants.defaultBundler,
         },
         codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },
         config: { string: true, hidden: true, description: 'Use specified configuration' },

package/src/cli/commands/run-task.ts

@@ -12,15 +12,21 @@ const tasks: Record<string, new (args: { [key: string]: unknown }) => Task> = {
 };
 
 export class RunTask extends Command<typeof entry> {
+    watchForParentExit(): void {
+        // No-op: the task being run handles its own parent-exit watch.
+    }
+
     @logErrors
     async execute() {
         const { _ = [], taskName = this.args._?.[0], taskArgs = [], ...restOptions } = this.args;
 
         if (taskName && taskName in tasks) {
-            await new tasks[taskName]({
+            const task = new tasks[taskName]({
                 _: [..._, ...taskArgs],
                 ...restOptions,
-            }).execute();
+            });
+            task.watchForParentExit();
+            await task.execute();
             return;
         }
 

package/src/cli/commands/start.ts

@@ -2,10 +2,10 @@ import { getPackages, logErrors, PackageType } from '../../utils';
 import {
     checkArgs,
     compile,
-    getBundleCommand,
     lernaExec,
     pipeStdout,
     ProcessTree,
+    resolveBundler,
     typeCheck,
     watchStdout,
 } from '../utils';
@@ -28,6 +28,9 @@ export class Start extends Command<typeof entry> {
     async execute() {
         checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });
 
+        // Used by sub-processes to detect this process dying
+        process.env.STARTUP_PARENT_PID = String(process.pid);
+
         const useTsc = this.args.useTsc;
 
         const packages = getPackages({
@@ -39,11 +42,13 @@ export class Start extends Command<typeof entry> {
             return;
         }
 
+        this.recordStart('start', { bundler: resolveBundler(this.args) });
+
         const scope = packages.map(({ name }) => name);
         const bundleScope = packages
             .filter(({ type }) => type === PackageType.Bundle)
             .map(({ name }) => name);
-        const bundleCmd = getBundleCommand(this.args);
+        const bundlerArg = [`--bundler ${resolveBundler(this.args)}`];
         const precompileScope = packages
             .filter(({ scripts }) => !!scripts?.precompile)
             .map(({ name }) => name);
@@ -126,11 +131,11 @@ export class Start extends Command<typeof entry> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    'cmd': bundleCmd,
+                    'cmd': 'startup bundle-package',
                     'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
-                    '--': ['--exposed-dependencies', '--use-watch-config'],
+                    '--': ['--exposed-dependencies', '--use-watch-config', ...bundlerArg],
                 });
             },
             { dependsOn: [StartProcesses.Compile, StartProcesses.PreparePackage] }
@@ -142,7 +147,7 @@ export class Start extends Command<typeof entry> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    'cmd': bundleCmd,
+                    'cmd': 'startup bundle-package',
                     'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
@@ -150,12 +155,18 @@ export class Start extends Command<typeof entry> {
                         '--watch',
                         this.args.config ? `--config "${this.args.config}"` : undefined,
                         this.args.codeCoverage ? '--code-coverage' : undefined,
+                        ...bundlerArg,
                     ].filter(item => !!item) as string[],
                 });
             },
             { dependsOn: [StartProcesses.BundleExposedDependencies] }
         );
 
-        await processTree.run();
+        try {
+            await processTree.run();
+        } catch (error) {
+            await this.recordEnd(error);
+            throw error;
+        }
     }
 }

package/src/cli/commands/types.ts

@@ -56,10 +56,6 @@ export interface CommandEntry {
     options?: CommandOptions;
 }
 
-export abstract class Command<T extends CommandEntry = CommandEntry, U = unknown> {
-    constructor(protected readonly args: InferArgs<NonNullable<T['options']>, U>) {}
-
-    abstract execute(): Promise<void>;
-}
-
 export type Newable<T> = new (...args: any[]) => T;
+
+export { Command } from './command';

package/src/cli/index.ts

@@ -69,6 +69,9 @@ async function handleCommand(name: CommandName, argv: any) {
     const CommandClass = await entry.load();
     // eslint-disable-next-line @typescript-eslint/naming-convention
     const command = new CommandClass({ ...argv, _: argv._.slice(1) });
+
+    command.watchForParentExit(name);
+
     command.execute().catch(() => {
         process.exit(1);
     });