@travetto/cli 8.0.0-alpha.1 → 8.0.0-alpha.10

package/README.md

@@ -59,7 +59,7 @@ This module also has a tight integration with the [VSCode plugin](https://market
 At it's heart, a cli command is the contract defined by what flags, and what arguments the command supports. Within the framework this requires three criteria to be met:
    *  The file must be located in the `support/` folder, and have a name that matches `cli.*.ts`
    *  The file must be a class that has a main method
-   *  The class must use the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L27) decorator
+   *  The class must use the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L20) decorator
 
 **Code: Basic Command**
 ```typescript
@@ -94,7 +94,7 @@ Examples of mappings:
 The pattern is that underscores(_) translate to colons (:), and the `cli.` prefix, and `.ts` suffix are dropped.
 
 ## Binding Flags
-[@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L27) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L27) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19) class. The fields of the class represent the flags that are available to the command.
+[@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L20) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L20) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19) class. The fields of the class represent the flags that are available to the command.
 
 **Code: Basic Command with Flag**
 ```typescript
@@ -131,7 +131,7 @@ $ trv basic:flag --loud
 HELLO
 ```
 
-The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L27) supports the following data types for flags:
+The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L20) supports the following data types for flags:
    *  Boolean values
    *  Number values. The [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L172), [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L179), [@Precision](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L165), [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L99) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L110) decorators help provide additional validation.
    *  String values. [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L99), [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L110), [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L90) and [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L64) provide additional constraints
@@ -390,7 +390,7 @@ npx trv call:db --host localhost --port 3306 --username app --password <custom>
 ```
 
 ## VSCode Integration
-By default, cli commands do not expose themselves to the VSCode extension, as the majority of them are not intended for that sort of operation.  [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") does expose a cli target `web:http` that will show up, to help run/debug a web application.  Any command can mark itself as being a run target, and will be eligible for running from within the [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=arcsine.travetto-plugin). This is achieved by setting the `runTarget` field on the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L27) decorator.  This means the target will be visible within the editor tooling.
+By default, cli commands do not expose themselves to the VSCode extension, as the majority of them are not intended for that sort of operation.  [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") does expose a cli target `web:http` that will show up, to help run/debug a web application.  Any command can mark itself as being a run target, and will be eligible for running from within the [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=arcsine.travetto-plugin). This is achieved by setting the `runTarget` field on the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L20) decorator.  This means the target will be visible within the editor tooling.
 
 **Code: Simple Run Target**
 ```typescript
@@ -460,7 +460,7 @@ export class WebHttpCommand implements CliCommandShape {
   profile: string[];
 
   @CliRestartOnChangeFlag()
-  restartOnChange: boolean = true;
+  restartOnChange: boolean = Runtime.localDevelopment;
 
   @CliDebugIpcFlag()
   debugIpc?: boolean;
@@ -542,7 +542,7 @@ A simple example of the validation can be found in the `doc` command:
 ```typescript
 @Validator(async (cmd) => {
   const docFile = path.resolve(cmd.input);
-  if (!(await fs.stat(docFile).catch(() => false))) {
+  if (!(await fs.stat(docFile, { throwIfNoEntry: false }))) {
     return { message: `input: ${cmd.input} does not exist`, path: 'input', source: 'flag', kind: 'invalid' };
   }
 })
@@ -558,7 +558,8 @@ $ trv service --help
 Usage: service [options] <action:restart|start|status|stop> [services...:string]
 
 Options:
-  -h, --help  display help for command
+  -q, --quiet   (default: false)
+  -h, --help   display help for command
 
 Available Services
 --------------------

package/__index__.ts

@@ -1,7 +1,6 @@
 import type { } from './src/trv.d.ts';
 export * from './src/types.ts';
 export * from './src/execute.ts';
-export * from './src/error.ts';
 export * from './src/schema.ts';
 export * from './src/schema-export.ts';
 export * from './src/registry/decorator.ts';

package/bin/trv.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 // @ts-check
+import '@travetto/runtime/support/patch.js';
 import '@travetto/compiler/bin/hook.js';
 const { invoke } = await import('@travetto/compiler/support/invoke.ts');
 await invoke('exec', ['@travetto/cli/support/entry.trv.ts', ...process.argv.slice(2)]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/cli",
-  "version": "8.0.0-alpha.1",
+  "version": "8.0.0-alpha.10",
   "type": "module",
   "description": "CLI infrastructure for Travetto framework",
   "keywords": [
@@ -29,8 +29,8 @@
     "directory": "module/cli"
   },
   "dependencies": {
-    "@travetto/schema": "^8.0.0-alpha.1",
-    "@travetto/terminal": "^8.0.0-alpha.1"
+    "@travetto/schema": "^8.0.0-alpha.5",
+    "@travetto/terminal": "^8.0.0-alpha.5"
   },
   "travetto": {
     "displayName": "Command Line Interface",

package/src/execute.ts

@@ -3,7 +3,6 @@ import { ConsoleManager, getClass, Runtime, ShutdownManager, Util } from '@trave
 import { HelpUtil } from './help.ts';
 import { CliCommandRegistryIndex } from './registry/registry-index.ts';
 import { CliCommandSchemaUtil } from './schema.ts';
-import { CliUnknownCommandError, CliValidationResultError } from './error.ts';
 import { CliParseUtil } from './parse.ts';
 import type { CliCommandShape } from './types.ts';
 
@@ -12,51 +11,52 @@ import type { CliCommandShape } from './types.ts';
  */
 export class ExecutionManager {
 
-  /** Error handler */
-  static async #onError(error: unknown): Promise<void> {
-    process.exitCode ??= 1;
-    if (error instanceof CliValidationResultError) {
-      console.error!(HelpUtil.renderValidationError(error));
-      console.error!(await HelpUtil.renderCommandHelp(error.command));
-    } else if (error instanceof CliUnknownCommandError) {
-      if (error.help) {
-        console.error!(error.help);
-      } else {
-        console.error!(error.defaultMessage, '\n');
-        console.error!(await HelpUtil.renderAllHelp(''));
-      }
-    } else {
-      console.error!(error);
+  /** Command Execution */
+  static async execute(instance: CliCommandShape, args: unknown[]): Promise<void> {
+    const config = CliCommandRegistryIndex.get(getClass(instance));
+
+    for (const item of config.preMain) {
+      await item.handler(instance);
     }
-    console.error!();
+
+    // Wait 50ms to allow stdout to flush on shutdown
+    ShutdownManager.signal.addEventListener('abort', () => Util.blockingTimeout(50));
+    ConsoleManager.debug(Runtime.debug);
+    await instance.main(...args);
   }
 
-  /** Bind command  */
-  static async #bindCommand(cmd: string, args: string[]): Promise<{ command: CliCommandShape, boundArgs: unknown[] }> {
-    const [{ instance: command, schema }] = await CliCommandRegistryIndex.load([cmd]);
-    const fullArgs = await CliParseUtil.expandArgs(schema, args);
+  /** Extract configuration and show help as needed */
+  static async getExecutionCommand(argv: string[]): Promise<(() => Promise<void>) | undefined> {
+    let command: CliCommandShape | undefined;
 
-    const state = await CliParseUtil.parse(schema, fullArgs);
-    CliParseUtil.setState(command, state);
+    const { cmd, args, help } = CliParseUtil.getArgs(argv);
+    if (!cmd) {
+      console.info!(await HelpUtil.renderAllHelp());
+      return;
+    }
 
-    const boundArgs = CliCommandSchemaUtil.bindInput(command, state);
-    return { command, boundArgs };
-  }
+    try {
+      const [{ instance, schema }] = await CliCommandRegistryIndex.load([cmd]);
+      command = instance;
+      const fullArgs = await CliParseUtil.expandArgs(schema, args);
 
-  /** Run command */
-  static async #runCommand(cmd: string, args: string[]): Promise<void> {
-    const { command, boundArgs } = await this.#bindCommand(cmd, args);
+      const state = await CliParseUtil.parse(schema, fullArgs);
+      CliParseUtil.setState(instance, state);
 
-    await CliCommandSchemaUtil.validate(command, boundArgs);
-    const config = CliCommandRegistryIndex.get(getClass(command));
+      const boundArgs = CliCommandSchemaUtil.bindInput(instance, state);
+      await instance.finalize?.(help);
 
-    for (const preMain of config.preMain ?? []) {
-      await preMain(command);
-    }
-    await command.finalize?.();
+      if (help) {
+        console.log!(await HelpUtil.renderCommandHelp(instance));
+        return;
+      }
 
-    ConsoleManager.debug(Runtime.debug);
-    await command.main(...boundArgs);
+      await CliCommandSchemaUtil.validate(command, boundArgs);
+
+      return this.execute.bind(this, instance, boundArgs);
+    } catch (error) {
+      await HelpUtil.renderError(error, cmd, command);
+    }
   }
 
   /**
@@ -65,20 +65,10 @@ export class ExecutionManager {
    */
   static async run(argv: string[]): Promise<void> {
     try {
-      // Wait 50ms to allow stdout to flush on shutdown
-      ShutdownManager.signal.addEventListener('abort', () => Util.blockingTimeout(50));
-
-      const { cmd, args, help } = CliParseUtil.getArgs(argv);
-      if (!cmd) {
-        console.info!(await HelpUtil.renderAllHelp());
-      } else if (help) {
-        const { command } = await this.#bindCommand(cmd, args);
-        console.log!(await HelpUtil.renderCommandHelp(command));
-      } else {
-        await this.#runCommand(cmd, args);
-      }
+      const execute = await this.getExecutionCommand(argv);
+      await execute?.();
     } catch (error) {
-      await this.#onError(error);
+      console.error!(error);
     } finally {
       await ShutdownManager.shutdown();
     }

package/src/help.ts

@@ -1,12 +1,11 @@
 import util from 'node:util';
 
-import { castKey, getClass, JSONUtil } from '@travetto/runtime';
-import { SchemaRegistryIndex } from '@travetto/schema';
+import { castKey, getClass, JSONUtil, Runtime } from '@travetto/runtime';
+import { SchemaRegistryIndex, ValidationResultError } from '@travetto/schema';
 
 import { cliTpl } from './color.ts';
 import type { CliCommandShape } from './types.ts';
-import { CliCommandRegistryIndex } from './registry/registry-index.ts';
-import type { CliValidationResultError } from './error.ts';
+import { CliCommandRegistryIndex, UNKNOWN_COMMAND } from './registry/registry-index.ts';
 import { CliSchemaExportUtil } from './schema-export.ts';
 
 const validationSourceMap: Record<string, string> = {
@@ -17,11 +16,39 @@ const validationSourceMap: Record<string, string> = {
 const ifDefined = <T>(value: T | null | '' | undefined): T | undefined =>
   (value === null || value === '' || value === undefined) ? undefined : value;
 
+const toItem = (name: string, pkg: string, prod?: boolean) => [name, Runtime.getInstallCommand(pkg, prod)] as const;
+
+const INSTALL_COMMANDS = new Map<string, string>([
+  ...['test', 'test:watch', 'test:direct'].map(item => toItem(item, '@travetto/test')),
+  ...['lint', 'lint:register', 'eslint', 'eslint:register'].map(item => toItem(item, '@travetto/eslint')),
+  ...['model:install', 'model:export'].map(item => toItem(item, '@travetto/model', true)),
+  ...['openapi:spec', 'openapi:client'].map(item => toItem(item, '@travetto/openapi', true)),
+  ...['email:compile', 'email:test', 'email:editor'].map(item => toItem(item, '@travetto/email-compiler')),
+  ...['pack', 'pack:zip', 'pack:docker'].map(item => toItem(item, '@travetto/pack')),
+  ...['repo:publish', 'repo:version', 'repo:exec', 'repo:list', 'repo:version-sync'].map(item => toItem(item, '@travetto/repo')),
+  toItem('web:http', '@travetto/web-http', true),
+  toItem('doc', '@travetto/doc'),
+  toItem('web:rpc-client', '@travetto/web-rpc', true),
+]);
+
 /**
  * Utilities for showing help
  */
 export class HelpUtil {
 
+  /** Render the unknown command message */
+  static renderUnknownCommandMessage(cmd: string): string {
+    const install = INSTALL_COMMANDS.get(cmd);
+    if (install) {
+      return cliTpl`
+${{ title: 'Missing Package' }}\n${'-'.repeat(20)}\nTo use ${{ input: cmd }} please run:\n
+${{ identifier: install }}
+`;
+    } else {
+      return cliTpl`${{ subtitle: 'Unknown command' }}: ${{ input: cmd }}`;
+    }
+  }
+
   /**
    * Render command-specific help
    * @param command
@@ -31,8 +58,6 @@ export class HelpUtil {
     const { name: commandName } = CliCommandRegistryIndex.get(getClass(command));
     const args = schema.methods.main?.parameters ?? [];
 
-    await command.finalize?.(true);
-
     // Ensure finalized
 
     const usage: string[] = [cliTpl`${{ title: 'Usage:' }} ${{ param: commandName }} ${{ input: '[options]' }}`,];
@@ -132,7 +157,7 @@ export class HelpUtil {
   /**
    * Render validation error to a string
    */
-  static renderValidationError(validationError: CliValidationResultError): string {
+  static renderValidationError(validationError: ValidationResultError): string {
     return [
       cliTpl`${{ failure: 'Execution failed' }}:`,
       ...validationError.details.errors.map(error => {
@@ -144,4 +169,20 @@ export class HelpUtil {
       '',
     ].join('\n');
   }
+
+  /** Error handler */
+  static async renderError(error: unknown, cmd: string, command?: CliCommandShape): Promise<void> {
+    process.exitCode ??= 1;
+    if (error instanceof ValidationResultError) {
+      console.error!(this.renderValidationError(error));
+    } else if (error instanceof Error) {
+      console.error!(cliTpl`${{ failure: error.stack }}\n`);
+    }
+    if (command) {
+      console.error!(await this.renderCommandHelp(command));
+    } else if (error === UNKNOWN_COMMAND) {
+      console.error!(this.renderUnknownCommandMessage(cmd));
+    }
+    console.error!();
+  }
 }

package/src/parse.ts

@@ -95,7 +95,7 @@ export class CliParseUtil {
 
     const file = path.resolve(relativePath);
 
-    if (!await fs.stat(file).catch(() => false)) {
+    if (!await fs.stat(file, { throwIfNoEntry: false })) {
       throw new Error(`Missing flag file: ${key}, unable to proceed`);
     }
 

package/src/registry/decorator.ts

@@ -10,13 +10,6 @@ import { CliUtil } from '../util.ts';
 type CliCommandConfigOptions = { runTarget?: boolean };
 type CliFlagOptions = { full?: string, short?: string, envVars?: string[] };
 
-function runBeforeMain<T>(cls: Class, handler: (item: T) => (unknown | Promise<unknown>), runTarget?: boolean): void {
-  CliCommandRegistryIndex.getForRegister(cls).register({
-    runTarget,
-    preMain: [async (cmd): Promise<void> => { await handler(castTo(cmd)); }]
-  });
-}
-
 /**
  * Decorator to register a CLI command
  *
@@ -72,9 +65,7 @@ export function CliProfilesFlag(config: CliFlagOptions = {}) {
       description: 'Application profiles'
     });
 
-    runBeforeMain(cls, (cmd: typeof instance) =>
-      Env.TRV_PROFILES.set([...cmd[property] ?? [], ...(Env.TRV_PROFILES.list ?? [])])
-    );
+    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 1, cmd => Env.TRV_PROFILES.add(...cmd[property] ?? []));
   };
 };
 
@@ -103,12 +94,8 @@ export function CliModuleFlag(config: CliFlagOptions & { scope?: 'current' | 'co
         const runModule = (config.scope === 'command' ? commandModule : providedModule) || Runtime.main.name;
 
         // If we need to run as a specific module
-        if (runModule !== Runtime.main.name) {
-          try {
-            RuntimeIndex.reinitForModule(runModule);
-          } catch {
-            return { source: 'flag', message: `${runModule} is an unknown module`, kind: 'custom', path: property };
-          }
+        if (runModule !== Runtime.main.name && RuntimeIndex.getModule(runModule) === undefined) {
+          return { source: 'flag', message: `${runModule} is an unknown module`, kind: 'custom', path: property };
         }
 
         if (!(await CliModuleUtil.moduleHasDependency(runModule, commandModule))) {
@@ -116,6 +103,15 @@ export function CliModuleFlag(config: CliFlagOptions & { scope?: 'current' | 'co
         }
       }],
     });
+
+    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 5, cmd => {
+      const typed: (typeof cmd) & { [property]?: string } = castTo(cmd);
+      const providedModule = typed[property];
+      const runModule = (config.scope === 'command' ? commandModule : providedModule) || Runtime.main.name;
+      if (runModule !== Runtime.main.name) {
+        RuntimeIndex.reinitForModule(runModule);
+      }
+    });
   };
 }
 
@@ -127,14 +123,15 @@ export function CliModuleFlag(config: CliFlagOptions & { scope?: 'current' | 'co
 export function CliRestartOnChangeFlag(config: CliFlagOptions = {}) {
   return function <K extends string, T extends Partial<Record<K, boolean>>>(instance: T, property: K): void {
     const cls = getClass(instance);
+    if (Runtime.production) { return; }
+
     SchemaRegistryIndex.getForRegister(cls).registerField(property, {
       ...CliParseUtil.buildAliases(config),
-      description: 'Should the invocation automatically restart on source changes',
-      default: Runtime.localDevelopment,
-      required: { active: false },
+      description: 'Should the invocation automatically restart on source changes'
     });
 
-    runBeforeMain(cls, (cmd: typeof instance) => CliUtil.runWithRestartOnChange(cmd[property]), true);
+    CliCommandRegistryIndex.getForRegister(cls).register({ runTarget: true });
+    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 20, cmd => CliUtil.runWithRestartOnChange(cmd[property]));
   };
 }
 
@@ -145,20 +142,18 @@ export function CliRestartOnChangeFlag(config: CliFlagOptions = {}) {
  */
 export function CliDebugIpcFlag(config: CliFlagOptions = {}) {
   return function <K extends string, T extends Partial<Record<K, boolean>>>(instance: T, property: K): void {
+    if (Runtime.production) { return; }
+
     const cls = getClass(instance);
     SchemaRegistryIndex.getForRegister(cls).registerField(property, {
       ...CliParseUtil.buildAliases(config, Env.TRV_DEBUG_IPC.key),
-      description: 'Should the invocation automatically restart on source changes',
-      default: Runtime.localDevelopment,
-      required: { active: false },
+      description: 'Should the invocation automatically restart on source changes'
     });
 
-    runBeforeMain(cls,
-      (cmd: typeof instance & CliCommandShape) => {
-        const cliConfig = CliCommandRegistryIndex.get(cls);
-        return cmd[property] && CliUtil.runWithDebugIpc(cliConfig.name);
-      },
-      true
-    );
+    CliCommandRegistryIndex.getForRegister(cls).register({ runTarget: true });
+    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 10, cmd => {
+      const cliConfig = CliCommandRegistryIndex.get(cls);
+      return cmd[property] && CliUtil.runWithDebugIpc(cliConfig.name);
+    });
   };
 }

package/src/registry/registry-adapter.ts

@@ -29,7 +29,7 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
     this.#cls = cls;
   }
 
-  finalize(): void {
+  finalize(parent?: CliCommandConfig): void {
     // Add help command
     const schema = SchemaRegistryIndex.getConfig(this.#cls);
 
@@ -75,6 +75,13 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
         aliases.push(`--no-${long}`);
       }
     }
+
+    if (parent) {
+      this.#config.preMain = [...this.#config.preMain, ...parent?.preMain ?? []];
+    }
+
+    // Sort
+    this.#config.preMain = this.#config.preMain.toSorted((left, right) => left.priority - right.priority);
   }
 
   get(): CliCommandConfig {
@@ -86,7 +93,7 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
    */
   register(...configs: Partial<CliCommandConfig>[]): CliCommandConfig {
     const metadata = describeFunction(this.#cls);
-    this.#config ??= { cls: this.#cls, name: getName(metadata.import), preMain: [], runTarget: true };
+    this.#config ??= { cls: this.#cls, name: getName(metadata.import), preMain: [], runTarget: false };
     return combineClasses(this.#config, ...configs);
   }
 

package/src/registry/registry-index.ts

@@ -1,9 +1,8 @@
-import { type Class, getClass, getParentClass, isClass, Runtime, RuntimeIndex } from '@travetto/runtime';
+import { type Any, type Class, getClass, getParentClass, isClass, Runtime, RuntimeIndex } from '@travetto/runtime';
 import { type RegistryAdapter, type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
 import { type SchemaClassConfig, SchemaRegistryIndex } from '@travetto/schema';
 
-import type { CliCommandConfig, CliCommandShape } from '../types.ts';
-import { CliUnknownCommandError } from '../error.ts';
+import type { CliCommandConfig, CliCommandShape, PreMainHandler } from '../types.ts';
 import { CliCommandRegistryAdapter } from './registry-adapter.ts';
 
 const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
@@ -11,6 +10,8 @@ const getName = (field: string): string => (field.match(CLI_FILE_REGEX)?.groups?
 
 type CliCommandLoadResult = { command: string, config: CliCommandConfig, instance: CliCommandShape, schema: SchemaClassConfig };
 
+export const UNKNOWN_COMMAND = Symbol();
+
 export class CliCommandRegistryIndex implements RegistryIndex {
 
   static #instance = Registry.registerIndex(this);
@@ -27,6 +28,10 @@ export class CliCommandRegistryIndex implements RegistryIndex {
     return this.#instance.load(names);
   }
 
+  static registerPreMain<T = Any>(cls: Class, priority: number, handler: PreMainHandler<T>['handler']): void {
+    CliCommandRegistryIndex.getForRegister(cls).register({ preMain: [{ handler, priority }] });
+  }
+
   #fileMapping: Map<string, string>;
   #instanceMapping: Map<string, CliCommandShape> = new Map();
 
@@ -57,7 +62,7 @@ export class CliCommandRegistryIndex implements RegistryIndex {
    */
   async #getInstance(name: string): Promise<CliCommandShape> {
     if (!this.hasCommand(name)) {
-      throw new CliUnknownCommandError(name);
+      throw UNKNOWN_COMMAND;
     }
 
     if (this.#instanceMapping.has(name)) {
@@ -95,7 +100,7 @@ export class CliCommandRegistryIndex implements RegistryIndex {
       this.#instanceMapping.set(name, result);
       return result;
     }
-    throw new CliUnknownCommandError(name);
+    throw UNKNOWN_COMMAND;
   }
 
   hasCommand(name: string): boolean {

package/src/schema-export.ts

@@ -1,4 +1,4 @@
-import { type Class, describeFunction } from '@travetto/runtime';
+import { castTo, type Class, describeFunction } from '@travetto/runtime';
 import { type SchemaInputConfig, SchemaRegistryIndex } from '@travetto/schema';
 
 import { CliCommandRegistryIndex } from '../src/registry/registry-index.ts';
@@ -9,7 +9,7 @@ import { CliCommandRegistryIndex } from '../src/registry/registry-index.ts';
 export type CliCommandInput<K extends string = string> = {
   name: string;
   description?: string;
-  type: 'string' | 'file' | 'number' | 'boolean' | 'date' | 'regex' | 'module';
+  type: 'string' | 'file' | 'number' | 'bigint' | 'boolean' | 'date' | 'regex' | 'module';
   fileExtensions?: string[];
   choices?: unknown[];
   required?: boolean;
@@ -37,11 +37,12 @@ export class CliSchemaExportUtil {
    * Get the base type for a CLI command input
    */
   static baseInputType(config: SchemaInputConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
-    switch (config.type) {
+    switch (castTo<Function>(config.type)) {
       case Date: return { type: 'date' };
       case Boolean: return { type: 'boolean' };
       case Number: return { type: 'number' };
       case RegExp: return { type: 'regex' };
+      case BigInt: return { type: 'bigint' };
       case String: {
         switch (true) {
           case config.specifiers?.includes('module'): return { type: 'module' };

package/src/schema.ts

@@ -2,7 +2,6 @@ import { castKey, castTo, getClass } from '@travetto/runtime';
 import { BindUtil, SchemaRegistryIndex, SchemaValidator, ValidationResultError, type ValidationError } from '@travetto/schema';
 
 import type { ParsedState, CliCommandShape } from './types.ts';
-import { CliValidationResultError } from './error.ts';
 
 const getSource = (source: string | undefined, defaultSource: ValidationError['source']): ValidationError['source'] => {
   switch (source) {
@@ -15,7 +14,7 @@ const getSource = (source: string | undefined, defaultSource: ValidationError['s
 };
 
 const transformErrors = (source: 'arg' | 'flag', error: unknown): ValidationError[] => {
-  if (error instanceof CliValidationResultError || error instanceof ValidationResultError) {
+  if (error instanceof ValidationResultError) {
     return error.details.errors.map(value => ({ source: getSource(value.source, source), ...value }));
   } else {
     throw error;
@@ -32,16 +31,16 @@ export class CliCommandSchemaUtil {
   /**
    * Bind parsed inputs to command
    */
-  static bindInput<T extends CliCommandShape>(cmd: T, state: ParsedState): unknown[] {
+  static bindInput<T extends CliCommandShape>(command: T, state: ParsedState): unknown[] {
     const template: Partial<T> = {};
     const bound: unknown[] = [];
 
-    for (const arg of state.all) {
-      switch (arg.type) {
+    for (const item of state.all) {
+      switch (item.type) {
         case 'flag': {
-          const key = castKey<T>(arg.fieldName);
-          const value = arg.value!;
-          if (arg.array) {
+          const key = castKey<T>(item.fieldName);
+          const value = item.value!;
+          if (item.array) {
             castTo<unknown[]>(template[key] ??= castTo([])).push(value);
           } else {
             template[key] = castTo(value);
@@ -49,36 +48,36 @@ export class CliCommandSchemaUtil {
           break;
         }
         case 'arg': {
-          if (arg.array) {
-            castTo<unknown[]>(bound[arg.index] ??= []).push(arg.input);
+          if (item.array) {
+            castTo<unknown[]>(bound[item.index] ??= []).push(item.input);
           } else {
-            bound[arg.index] = arg.input;
+            bound[item.index] = item.input;
           }
         }
       }
     }
 
-    const cls = getClass(cmd);
-    BindUtil.bindSchemaToObject(cls, cmd, template);
+    const cls = getClass(command);
+    BindUtil.bindSchemaToObject(cls, command, template);
     return BindUtil.coerceMethodParams(cls, 'main', bound);
   }
 
   /**
    * Validate command shape with the given arguments
    */
-  static async validate(cmd: CliCommandShape, args: unknown[]): Promise<typeof cmd> {
-    const cls = getClass(cmd);
+  static async validate(command: CliCommandShape, args: unknown[]): Promise<typeof command> {
+    const cls = getClass(command);
     const paramNames = SchemaRegistryIndex.get(cls).getMethod('main').parameters.map(config => config.name!);
 
     const results = await Promise.all([
-      SchemaValidator.validate(cls, cmd).then(() => [], transformFlagErrors),
+      SchemaValidator.validate(cls, command).then(() => [], transformFlagErrors),
       SchemaValidator.validateMethod(cls, 'main', args, paramNames).then(() => [], transformArgErrors),
     ]);
 
     const errors = results.flat();
     if (errors.length) {
-      throw new CliValidationResultError(cmd, errors);
+      throw new ValidationResultError(errors);
     }
-    return cmd;
+    return command;
   }
 }

package/src/service.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import rl from 'node:readline/promises';
 import net from 'node:net';
 
-import { ExecUtil, TimeUtil, Util } from '@travetto/runtime';
+import { ExecUtil, Runtime, RuntimeIndex, TimeUtil, Util } from '@travetto/runtime';
 
 const ports = (value: number | `${number}:${number}`): [number, number] =>
   typeof value === 'number' ?
@@ -36,6 +36,23 @@ export type ServiceAction = 'start' | 'stop' | 'status' | 'restart';
  */
 export class ServiceRunner {
 
+  /**
+   * Find all services
+   */
+  static async findServices(services: string[]): Promise<ServiceDescriptor[]> {
+    return (await Promise.all(
+      RuntimeIndex.find({
+        module: module => module.roles.includes('std'),
+        folder: folder => folder === 'support',
+        file: file => /support\/service[.]/.test(file.sourceFile)
+      })
+        .map(file => Runtime.importFrom<{ service: ServiceDescriptor }>(file.import).then(value => value.service))
+    ))
+      .filter(file => !!file)
+      .filter(file => services?.length ? services.includes(file.name) : true)
+      .toSorted((a, b) => a.name.localeCompare(b.name));
+  }
+
   #descriptor: ServiceDescriptor;
   constructor(descriptor: ServiceDescriptor) { this.#descriptor = descriptor; }
 

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Class } from '@travetto/runtime';
+import type { Any, Class } from '@travetto/runtime';
 
 type OrProm<T> = T | Promise<T>;
 type ParsedFlag = { type: 'flag', input: string, array?: boolean, fieldName: string, value?: unknown };
@@ -32,7 +32,7 @@ export interface CliCommandShape {
   help?(): OrProm<string[]>;
 }
 
-type PreMainHandler = (cmd: CliCommandShape) => (unknown | Promise<unknown>);
+export type PreMainHandler<T extends Any = Any> = { priority: number, handler: (cmd: T) => Any };
 
 /**
  * CLI Command schema shape
@@ -41,5 +41,5 @@ export interface CliCommandConfig {
   cls: Class<CliCommandShape>;
   name: string;
   runTarget?: boolean;
-  preMain?: PreMainHandler[];
+  preMain: PreMainHandler[];
 }

package/src/util.ts

@@ -2,11 +2,12 @@ import { spawn, type ChildProcess } from 'node:child_process';
 
 import { RuntimeError, JSONUtil, Env, ExecUtil, Runtime, ShutdownManager, Util, WatchUtil } from '@travetto/runtime';
 
-const IPC_ALLOWED_ENV = new Set(['NODE_OPTIONS']);
-const IPC_INVALID_ENV = new Set(['PS1', 'INIT_CWD', 'COLOR', 'LANGUAGE', 'PROFILEHOME', '_']);
-const validEnv = (key: string): boolean => IPC_ALLOWED_ENV.has(key) || (
-  !IPC_INVALID_ENV.has(key) && !/^(npm_|GTK|GDK|TRV|NODE|GIT|TERM_)/.test(key) && !/VSCODE/.test(key)
-);
+const IPC_VALID_ENV = new Set(['NODE_OPTIONS', 'PATH', Env.DEBUG.key, Env.NODE_ENV.key]);
+const IPC_INVALID_ENV = new Set([
+  Env.TRV_CLI_IPC, Env.TRV_DEBUG_IPC, Env.TRV_DEBUG_BREAK, Env.TRV_MANIFEST, Env.TRV_MODULE, Env.TRV_RESTART_TARGET
+].map(item => item.key));
+const validEnv = ([key]: [key: string, value: unknown]): boolean =>
+  IPC_VALID_ENV.has(key) || (key.startsWith('TRV_') && !IPC_INVALID_ENV.has(key));
 
 export class CliUtil {
   /**
@@ -14,8 +15,7 @@ export class CliUtil {
    */
   static getSimpleModuleName(placeholder: string, module?: string): string {
     const simple = (module ?? Runtime.main.name).replace(/[\/]/, '_').replace(/@/, '');
-    const targetModule = !simple || (!module && Runtime.monoRoot) ? '<module>' : simple;
-    return placeholder.replace('<module>', targetModule);
+    return simple ? placeholder.replace('<module>', simple) : placeholder;
   }
 
   /**
@@ -33,10 +33,11 @@ export class CliUtil {
     ShutdownManager.disableInterrupt();
 
     let child: ChildProcess | undefined;
-    void WatchUtil.watchCompilerEvents('file', () => ShutdownManager.shutdownChild(child!, { reason: 'restart', mode: 'exit' }));
+    await WatchUtil.watchCompilerEvents('file', () => ShutdownManager.shutdownChild(child!, { reason: 'restart', mode: 'exit' }));
+
     process
       .on('SIGINT', () => ShutdownManager.shutdownChild(child!, { mode: 'exit' }))
-      .on('message', msg => child?.send?.(msg!));
+      .on('message', message => child?.send?.(message!));
 
     const env = { ...process.env, ...Env.TRV_RESTART_TARGET.export(true) };
 
@@ -77,32 +78,32 @@ export class CliUtil {
       return; // Server not running, run normal
     }
 
-    const env: Record<string, string> = {};
     const request = {
       type: '@travetto/cli:run',
       data: {
         name,
-        env,
+        env: Object.fromEntries(Object.entries(process.env).filter(validEnv)),
         cwd: process.cwd(),
         args: process.argv.slice(3),
       }
     };
-    console.log('Triggering IPC request', request);
 
-    Object.entries(process.env).forEach(([key, value]) => validEnv(key) && (env[key] = value!));
+    console.log('Triggering IPC request', request);
     const sent = await doFetch({ method: 'POST', body: JSONUtil.toUTF8(request) });
 
     if (!sent.ok) {
       throw new RuntimeError(`IPC Request failed: ${sent.status} ${await sent.text()}`);
     }
+
+    await ShutdownManager.shutdown({ mode: 'exit' });
   }
 
   /**
    * Write data to channel and ensure its flushed before continuing
    */
   static async writeAndEnsureComplete(data: unknown, channel: 'stdout' | 'stderr' = 'stdout'): Promise<void> {
-    return await new Promise(resolve => process[channel].write(typeof data === 'string' ? data :
-      JSONUtil.toUTF8Pretty(data), () => resolve()));
+    await new Promise<unknown>(resolve => process[channel].write(typeof data === 'string' ? data :
+      JSONUtil.toUTF8Pretty(data), resolve));
   }
 
   /**

package/support/cli.service.ts

@@ -1,13 +1,14 @@
+import { stripVTControlCharacters } from 'node:util';
+
 import { type CliCommandShape, CliCommand, cliTpl } from '@travetto/cli';
 import { Terminal } from '@travetto/terminal';
 import { AsyncQueue, Util } from '@travetto/runtime';
 import { MethodValidator, type ValidationError } from '@travetto/schema';
 
 import { ServiceRunner, type ServiceAction } from '../src/service.ts';
-import { getServices } from './bin/util.ts';
 
-async function validateService(action: ServiceAction, services: string[]): Promise<ValidationError | undefined> {
-  const all = await getServices(services);
+async function validateService(_: ServiceAction, services: string[]): Promise<ValidationError | undefined> {
+  const all = await ServiceRunner.findServices(services);
 
   if (!all.length) {
     return { message: 'No services found', source: 'arg', kind: 'invalid', path: 'services' };
@@ -20,8 +21,10 @@ async function validateService(action: ServiceAction, services: string[]): Promi
 @CliCommand()
 export class CliServiceCommand implements CliCommandShape {
 
+  quiet = false;
+
   async help(): Promise<string[]> {
-    const all = await getServices([]);
+    const all = await ServiceRunner.findServices([]);
     return [
       cliTpl`${{ title: 'Available Services' }}`,
       '-'.repeat(20),
@@ -31,32 +34,48 @@ export class CliServiceCommand implements CliCommandShape {
 
   @MethodValidator(validateService)
   async main(action: ServiceAction, services: string[] = []): Promise<void> {
-    const all = await getServices(services);
+    const all = await ServiceRunner.findServices(services);
     const maxName = Math.max(...all.map(service => service.name.length), 'Service'.length) + 3;
     const maxVersion = Math.max(...all.map(service => `${service.version}`.length), 'Version'.length) + 3;
     const maxStatus = 20;
     const queue = new AsyncQueue<{ idx: number, text: string, done?: boolean }>();
 
+    const failureMessages: string[] = [];
+
     const jobs = all.map(async (descriptor, i) => {
       const identifier = descriptor.name.padEnd(maxName);
       const type = `${descriptor.version}`.padStart(maxVersion - 3).padEnd(maxVersion);
-      let msg: string;
+      let message: string;
       for await (const [valueType, value] of new ServiceRunner(descriptor).action(action)) {
         const details = { [valueType === 'message' ? 'subtitle' : valueType]: value };
-        queue.add({ idx: i, text: msg = cliTpl`${{ identifier }} ${{ type }} ${details}` });
+        queue.add({ idx: i, text: message = cliTpl`${{ identifier }} ${{ type }} ${details}` });
+        if (valueType === 'failure') {
+          failureMessages.push(message);
+        }
       }
-      queue.add({ idx: i, done: true, text: msg! });
+      queue.add({ idx: i, done: true, text: message! });
     });
 
     Promise.all(jobs).then(() => Util.queueMacroTask()).then(() => queue.close());
 
-    const term = new Terminal();
-    await term.writer.writeLines([
-      '',
-      cliTpl`${{ title: 'Service'.padEnd(maxName) }} ${{ title: 'Version'.padEnd(maxVersion) }} ${{ title: 'Status' }}`,
-      ''.padEnd(maxName + maxVersion + maxStatus + 3, '-'),
-    ]).commit();
 
-    await term.streamList(queue);
+    if (this.quiet) {
+      for await (const _ of queue) { }
+      if (failureMessages.length) {
+        console.error('Failure');
+        failureMessages.map(stripVTControlCharacters).map(item => console.error(item));
+      }
+    } else {
+      const term = new Terminal();
+      await term.writer.writeLines([
+        '',
+        cliTpl`${{ title: 'Service'.padEnd(maxName) }} ${{ title: 'Version'.padEnd(maxVersion) }} ${{ title: 'Status' }}`,
+        ''.padEnd(maxName + maxVersion + maxStatus + 3, '-'),
+      ]).commit();
+
+      await term.streamList(queue);
+    }
+
+    process.exitCode = failureMessages.length ? 1 : 0;
   }
 }

package/support/entry.trv.ts

@@ -1,4 +1,4 @@
 // @trv-no-transform
-import '@travetto/runtime/support/polyfill.js';
+import '@travetto/runtime/support/patch.js';
 import { ExecutionManager } from '@travetto/cli';
 ExecutionManager.run(process.argv);

package/src/error.ts

@@ -1,59 +0,0 @@
-import { RuntimeError, Runtime } from '@travetto/runtime';
-import type { ValidationError } from '@travetto/schema';
-
-import { cliTpl } from './color.ts';
-import type { CliCommandShape } from './types.ts';
-
-const COMMAND_PACKAGE = [
-  [/^test(:watch)?$/, 'test', false],
-  [/^lint(:register)?$/, 'eslint', false],
-  [/^model:(install|export)$/, 'model', true],
-  [/^openapi:(spec|client)$/, 'openapi', true],
-  [/^email:(compile|editor)$/, 'email-compiler', false],
-  [/^pack(:zip|:docker)?$/, 'pack', false],
-  [/^web:http$/, 'web-http', true],
-  [/^web:rpc-client$/, 'web-rpc', true],
-] as const;
-
-/**
- * Provides a contract for unknown commands
- */
-export class CliUnknownCommandError extends Error {
-
-  #getMissingCommandHelp(cmd: string): string | undefined {
-    const matchedConfig = COMMAND_PACKAGE.find(([regex]) => regex.test(cmd));
-    if (matchedConfig) {
-      const [, pkg, production] = matchedConfig;
-      const install = Runtime.getInstallCommand(`@travetto/${pkg}`, production);
-      return cliTpl`
-${{ title: 'Missing Package' }}\n${'-'.repeat(20)}\nTo use ${{ input: cmd }} please run:\n
-${{ identifier: install }}
-`;
-    }
-  }
-
-  help?: string;
-  cmd: string;
-
-  constructor(cmd: string) {
-    super(`Unknown command: ${cmd}`);
-    this.cmd = cmd;
-    this.help = this.#getMissingCommandHelp(cmd);
-  }
-
-  get defaultMessage(): string {
-    return cliTpl`${{ subtitle: 'Unknown command' }}: ${{ input: this.cmd }}`;
-  }
-}
-
-/**
- * Provides a basic error wrapper for cli validation issues
- */
-export class CliValidationResultError extends RuntimeError<{ errors: ValidationError[] }> {
-  command: CliCommandShape;
-
-  constructor(command: CliCommandShape, errors: ValidationError[]) {
-    super('', { details: { errors } });
-    this.command = command;
-  }
-}

package/support/bin/util.ts

@@ -1,16 +0,0 @@
-import { RuntimeIndex, Runtime } from '@travetto/runtime';
-import type { ServiceDescriptor } from '../../__index__.ts';
-
-export async function getServices(services: string[]): Promise<ServiceDescriptor[]> {
-  return (await Promise.all(
-    RuntimeIndex.find({
-      module: module => module.roles.includes('std'),
-      folder: folder => folder === 'support',
-      file: file => /support\/service[.]/.test(file.sourceFile)
-    })
-      .map(file => Runtime.importFrom<{ service: ServiceDescriptor }>(file.import).then(value => value.service))
-  ))
-    .filter(file => !!file)
-    .filter(file => services?.length ? services.includes(file.name) : true)
-    .toSorted((a, b) => a.name.localeCompare(b.name));
-}