@travetto/cli 8.0.0-alpha.0 → 8.0.0-alpha.2

package/src/registry/decorator.ts

@@ -1,5 +1,5 @@
-import { type Class, type ClassInstance, Env, Runtime, RuntimeIndex, TypedObject, castTo, describeFunction, getClass } from '@travetto/runtime';
-import { type SchemaFieldConfig, SchemaRegistryIndex, type ValidationError } from '@travetto/schema';
+import { type Class, type ClassInstance, Env, Runtime, RuntimeIndex, castTo, describeFunction, getClass } from '@travetto/runtime';
+import { SchemaRegistryIndex, type ValidationError } from '@travetto/schema';
 
 import type { CliCommandShape } from '../types.ts';
 import { CliCommandRegistryIndex } from './registry-index.ts';
@@ -7,86 +7,15 @@ import { CliModuleUtil } from '../module.ts';
 import { CliParseUtil } from '../parse.ts';
 import { CliUtil } from '../util.ts';
 
-type Cmd = CliCommandShape & { profiles?: string[] };
-
-type CliCommandConfigOptions = {
-  runTarget?: boolean;
-  runtimeModule?: 'current' | 'command';
-  with?: {
-    /** Application environment */
-    profiles?: boolean;
-    /** Module to run for */
-    module?: boolean;
-    /** Should debug invocation trigger via ipc */
-    debugIpc?: boolean | 'optional';
-    /** Should restart on source change */
-    restartOnChange?: boolean | 'optional';
-  };
-};
+type CliCommandConfigOptions = { runTarget?: boolean };
+type CliFlagOptions = { full?: string, short?: string, envVars?: string[] };
 
-type WithConfig = Required<Exclude<CliCommandConfigOptions['with'], undefined>>;
-type WithHandler<K extends keyof WithConfig> = (config?: WithConfig[K]) => ({
-  name: K;
-  field: Partial<SchemaFieldConfig>;
-  run?: (cmd: Cmd) => (Promise<unknown> | unknown);
-} | undefined);
-
-const FIELD_CONFIG: { [K in keyof WithConfig]: WithHandler<K> } = {
-  profiles: (config) => {
-    if (!config) { return; }
-    return {
-      name: 'profiles',
-      run: cmd => cmd.profiles && Env.TRV_PROFILES.set([...cmd.profiles, ...(Env.TRV_PROFILES.list ?? [])]),
-      field: {
-        type: String,
-        aliases: ['--profile', '--profiles', CliParseUtil.toEnvField(Env.TRV_PROFILES.key)],
-        description: 'Application profiles',
-        required: { active: false },
-      },
-    };
-  },
-  module: (config) => {
-    if (!config) { return; }
-    return {
-      name: 'module',
-      field: {
-        type: String,
-        aliases: ['-m', CliParseUtil.toEnvField(Env.TRV_MODULE.key)],
-        description: 'Module to run for',
-        specifiers: ['module'],
-        required: { active: Runtime.monoRoot },
-      },
-    };
-  },
-  debugIpc: (config) => {
-    if (!config) { return; }
-    return {
-      name: 'debugIpc',
-      run: cmd => CliUtil.runWithDebugIpc(cmd),
-      field: {
-        type: Boolean,
-        aliases: ['-di', CliParseUtil.toEnvField(Env.TRV_DEBUG_IPC.key)],
-        description: 'Should debug invocation trigger via ipc',
-        default: config !== 'optional',
-        required: { active: false },
-      },
-    };
-  },
-  restartOnChange: (config) => {
-    if (!config) { return; }
-    return {
-      name: 'restartOnChange',
-      run: cmd => CliUtil.runWithRestartOnChange(cmd),
-      field: {
-        type: Boolean,
-        aliases: ['-rc'],
-        description: 'Should the invocation automatically restart on source changes',
-        default: config !== 'optional' && Runtime.localDevelopment,
-        required: { active: false },
-      },
-    };
-  }
-};
+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
@@ -97,70 +26,139 @@ const FIELD_CONFIG: { [K in keyof WithConfig]: WithHandler<K> } = {
  */
 export function CliCommand(config: CliCommandConfigOptions = {}) {
   return function <T extends CliCommandShape>(target: Class<T>): void {
-    const adapter = SchemaRegistryIndex.getForRegister(target);
-    const description = describeFunction(target) ?? {};
-
-    if (!target.Ⲑid || description.abstract) {
-      return;
+    if (target.Ⲑid && !describeFunction(target)?.abstract) {
+      CliCommandRegistryIndex.getForRegister(target).register(config);
     }
+  };
+}
 
-    const VALID_FIELDS = TypedObject.keys(FIELD_CONFIG).map((name) => FIELD_CONFIG[name](castTo(config.with?.[name]))).filter(x => !!x);
+/**
+ * Decorator to register a CLI command flag
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function CliFlag(config: CliFlagOptions) {
+  return function (instance: ClassInstance, property: string): void {
+    SchemaRegistryIndex.getForRegister(getClass(instance))
+      .registerField(property, CliParseUtil.buildAliases(config));
+  };
+}
 
-    CliCommandRegistryIndex.getForRegister(target).register({
-      runTarget: config.runTarget,
-      preMain: async (cmd: Cmd) => {
-        for (const field of VALID_FIELDS) {
-          await field.run?.(cmd);
-        }
-      }
+/**
+ * Decorator to register a CLI command file flag
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function CliFileFlag(config: CliFlagOptions & { fileExtensions: string[] }) {
+  return function (instance: ClassInstance, property: string): void {
+    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, {
+      ...CliParseUtil.buildAliases(config),
+      specifiers: ['file', ...config.fileExtensions.map(ext => `ext:${ext.replace(/[*.]/g, '')}`)]
     });
+  };
+}
 
-    const commandModule = description.module;
+/**
+ * Registers a flag to support profiles via the `TRV_PROFILES` environment variable
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function CliProfilesFlag(config: CliFlagOptions = {}) {
+  return function <K extends string>(instance: Partial<Record<K, string[]>>, property: K): void {
+    const cls = getClass(instance);
+    SchemaRegistryIndex.getForRegister(cls).registerField(property, {
+      ...CliParseUtil.buildAliases(config, Env.TRV_PROFILES.key),
+      required: { active: false },
+      description: 'Application profiles'
+    });
 
-    for (const { name, field: { type, ...field } } of VALID_FIELDS) {
-      adapter.registerField(name, { type }, field);
-      Object.defineProperty(target.prototype, name, { value: field.default, writable: true });
-    }
+    runBeforeMain(cls, (cmd: typeof instance) =>
+      Env.TRV_PROFILES.set([...cmd[property] ?? [], ...(Env.TRV_PROFILES.list ?? [])])
+    );
+  };
+};
 
-    const runtimeModule = config.runtimeModule ?? (config.with?.module ? 'current' : undefined);
+/**
+ * Registers a flag to support targeting a specific module
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function CliModuleFlag(config: CliFlagOptions & { scope?: 'current' | 'command' } = { scope: 'current' }) {
+  return function <K extends string>(instance: Partial<Record<K, string>>, property: K): void {
+    const cls = getClass(instance);
+    const description = describeFunction(cls) ?? {};
+    const commandModule = description.module;
 
-    if (runtimeModule) { // Validate module
-      adapter.register({
-        validators: [async ({ module }): Promise<ValidationError | undefined> => {
-          const runModule = (runtimeModule === 'command' ? commandModule : module) || Runtime.main.name;
+    SchemaRegistryIndex.getForRegister(cls).registerField(property, {
+      ...CliParseUtil.buildAliases(config, Env.TRV_MODULE.key),
+      description: 'Module to run for',
+      specifiers: ['module'],
+      required: { active: Runtime.monoRoot },
+    });
 
-          // 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: '.' };
-            }
+    SchemaRegistryIndex.getForRegister(cls).register({
+      validators: [async (cmd: CliCommandShape): Promise<ValidationError | undefined> => {
+        const typed: (typeof cmd) & { [property]?: string } = castTo(cmd);
+        const providedModule = typed[property];
+        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 (!(await CliModuleUtil.moduleHasDependency(runModule, commandModule))) {
-            return { source: 'flag', message: `${runModule} does not have ${commandModule} as a dependency`, kind: 'custom', path: '.' };
-          }
-        }],
-      });
-    }
+        if (!(await CliModuleUtil.moduleHasDependency(runModule, commandModule))) {
+          return { source: 'flag', message: `${runModule} does not have ${commandModule} as a dependency`, kind: 'custom', path: property };
+        }
+      }],
+    });
   };
 }
 
 /**
- * Decorator to register a CLI command flag
+ * Registers a flag to support restarting on source changes
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function CliFlag(config: { full?: string, short?: string, fileExtensions?: string[], envVars?: string[] } = {}) {
-  return function (instance: ClassInstance, property: string): void {
-    const aliases = [
-      ...(config.full ? [config.full.startsWith('-') ? config.full : `--${config.full}`] : []),
-      ...(config.short ? [config.short.startsWith('-') ? config.short : `-${config.short}`] : []),
-      ...(config.envVars ? config.envVars.map(CliParseUtil.toEnvField) : [])
-    ];
-    const specifiers = config.fileExtensions?.length ? ['file', ...config.fileExtensions.map(ext => `ext:${ext.replace(/[*.]/g, '')}`)] : [];
-
-    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, { aliases, specifiers });
+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);
+    SchemaRegistryIndex.getForRegister(cls).registerField(property, {
+      ...CliParseUtil.buildAliases(config),
+      description: 'Should the invocation automatically restart on source changes',
+      default: Runtime.localDevelopment,
+      required: { active: false },
+    });
+
+    runBeforeMain(cls, (cmd: typeof instance) => CliUtil.runWithRestartOnChange(cmd[property]), true);
+  };
+}
+
+/**
+ * Registers a flag to support debugging invocations triggered via IPC
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
+ */
+export function CliDebugIpcFlag(config: CliFlagOptions = {}) {
+  return function <K extends string, T extends Partial<Record<K, boolean>>>(instance: T, property: K): void {
+    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 },
+    });
+
+    runBeforeMain(cls,
+      (cmd: typeof instance & CliCommandShape) => {
+        const cliConfig = CliCommandRegistryIndex.get(cls);
+        return cmd[property] && CliUtil.runWithDebugIpc(cliConfig.name);
+      },
+      true
+    );
   };
 }

package/src/registry/registry-adapter.ts

@@ -11,6 +11,16 @@ const getName = (name: string): string => (name.match(CLI_FILE_REGEX)?.groups?.n
 const stripDashes = (flag?: string): string | undefined => flag?.replace(/^-+/, '');
 const toFlagName = (field: string): string => field.replace(/([a-z])([A-Z])/g, (_, left: string, right: string) => `${left}-${right.toLowerCase()}`);
 
+function combineClasses(base: CliCommandConfig, ...configs: Partial<CliCommandConfig>[]): CliCommandConfig {
+  for (const config of configs) {
+    base.runTarget = config.runTarget ?? base.runTarget;
+    if (config.preMain) {
+      base.preMain = [...base.preMain ?? [], ...config.preMain ?? []];
+    }
+  }
+  return base;
+}
+
 export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConfig> {
   #cls: Class;
   #config: CliCommandConfig;
@@ -76,17 +86,14 @@ 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) };
-    Object.assign(this.#config, ...configs);
-    return this.#config;
+    this.#config ??= { cls: this.#cls, name: getName(metadata.import), preMain: [], runTarget: true };
+    return combineClasses(this.#config, ...configs);
   }
 
   /**
    * Get instance of the command
    */
   getInstance(): CliCommandShape {
-    const instance: CliCommandShape = classConstruct(this.#cls);
-    instance._cfg = this.#config;
-    return instance;
+    return classConstruct(this.#cls);
   }
 }

package/src/registry/registry-index.ts

@@ -3,7 +3,6 @@ import { type RegistryAdapter, type RegistryIndex, RegistryIndexStore, Registry
 import { type SchemaClassConfig, SchemaRegistryIndex } from '@travetto/schema';
 
 import type { CliCommandConfig, CliCommandShape } from '../types.ts';
-import { CliUnknownCommandError } from '../error.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);
@@ -57,7 +58,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)) {
@@ -92,13 +93,10 @@ export class CliCommandRegistryIndex implements RegistryIndex {
         continue;
       }
       const result = config.getInstance();
-      if (result.isActive !== undefined && !result.isActive()) {
-        continue;
-      }
       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

@@ -1,19 +1,29 @@
 import { castKey, castTo, getClass } from '@travetto/runtime';
-import { BindUtil, SchemaRegistryIndex, SchemaValidator, ValidationResultError } from '@travetto/schema';
+import { BindUtil, SchemaRegistryIndex, SchemaValidator, ValidationResultError, type ValidationError } from '@travetto/schema';
 
-import type { ParsedState, CliCommandShape, CliValidationError } from './types.ts';
-import { CliValidationResultError } from './error.ts';
+import type { ParsedState, CliCommandShape } from './types.ts';
 
-const getSource = (source: string | undefined, def: CliValidationError['source']): CliValidationError['source'] => {
+const getSource = (source: string | undefined, defaultSource: ValidationError['source']): ValidationError['source'] => {
   switch (source) {
     case 'custom':
     case 'arg':
     case 'flag': return source;
-    case undefined: return def;
+    case undefined: return defaultSource;
     default: return 'custom';
   }
 };
 
+const transformErrors = (source: 'arg' | 'flag', error: unknown): ValidationError[] => {
+  if (error instanceof ValidationResultError) {
+    return error.details.errors.map(value => ({ source: getSource(value.source, source), ...value }));
+  } else {
+    throw error;
+  }
+};
+
+const transformArgErrors = (error: unknown): ValidationError[] => transformErrors('arg', error);
+const transformFlagErrors = (error: unknown): ValidationError[] => transformErrors('flag', error);
+
 /**
  * Allows binding describing/binding inputs for commands
  */
@@ -21,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);
@@ -38,51 +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 validators = [
-      (): Promise<void> => SchemaValidator.validate(cls, cmd).then(() => { }),
-      (): Promise<void> => SchemaValidator.validateMethod(cls, 'main', args, paramNames),
-      async (): Promise<void> => {
-        const result = await cmd.validate?.(...args);
-        if (result) {
-          throw new CliValidationResultError(cmd, Array.isArray(result) ? result : [result]);
-        }
-      },
-    ];
-
-    const SOURCES = ['flag', 'arg', 'custom'] as const;
-
-    const results = validators.map((validator, i) => validator().catch(error => {
-      if (!(error instanceof CliValidationResultError) && !(error instanceof ValidationResultError)) {
-        throw error;
-      }
-      return error.details.errors.map(value => ({ ...value, source: getSource(value.source, SOURCES[i]) }));
-    }));
+    const results = await Promise.all([
+      SchemaValidator.validate(cls, command).then(() => [], transformFlagErrors),
+      SchemaValidator.validateMethod(cls, 'main', args, paramNames).then(() => [], transformArgErrors),
+    ]);
 
-    const errors = (await Promise.all(results)).flatMap(result => (result ?? []));
+    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

@@ -13,89 +13,26 @@ export type ParsedState = {
   unknown: string[];
 };
 
-/**
- * Constrained version of Schema's Validation Error
- * @concrete
- */
-export interface CliValidationError {
-  /**
-   * The error message
-   */
-  message: string;
-  /**
-   * Source of validation
-   */
-  source?: 'flag' | 'arg' | 'custom';
-};
-
 /**
  * CLI Command Contract
  * @concrete
  */
-export interface CliCommandShape<T extends unknown[] = unknown[]> {
-  /**
-   * Parsed state
-   */
-  _parsed?: ParsedState;
-  /**
-   * Config
-   */
-  _cfg?: CliCommandConfig;
+export interface CliCommandShape {
   /**
    * Action target of the command
    */
-  main(...args: T): OrProm<undefined | void>;
+  main(...args: unknown[]): OrProm<undefined | void>;
   /**
    * Run before main runs
    */
-  preMain?(): OrProm<void>;
+  finalize?(help?: boolean): OrProm<void>;
   /**
    * Extra help
    */
   help?(): OrProm<string[]>;
-  /**
-   * Run before help is displayed
-   */
-  preHelp?(): OrProm<void>;
-  /**
-   * Is the command active/eligible for usage
-   */
-  isActive?(): boolean;
-  /**
-   * Run before binding occurs
-   */
-  preBind?(): OrProm<void>;
-  /**
-   * Run before validation occurs
-   */
-  preValidate?(): OrProm<void>;
-  /**
-   * Validation method
-   */
-  validate?(...args: T): OrProm<CliValidationError | CliValidationError[] | undefined>;
 }
 
-/**
- * Command shape common fields
- */
-export type CliCommandShapeFields = {
-  /**
-   * Profiles to run the application under
-   */
-  profiles?: string[];
-  /**
-   * Should the cli invocation trigger a debug session, via IPC
-   */
-  debugIpc?: boolean;
-  /**
-   * Should the invocation run with auto-restart on source changes
-   */
-  restartOnChange?: boolean;
-  /**
-   * The module to run the command from
-   */
-  module?: string;
-};
+type PreMainHandler = (cmd: CliCommandShape) => (unknown | Promise<unknown>);
 
 /**
  * CLI Command schema shape
@@ -104,5 +41,5 @@ export interface CliCommandConfig {
   cls: Class<CliCommandShape>;
   name: string;
   runTarget?: boolean;
-  preMain?: (cmd: CliCommandShape) => void | Promise<void>;
+  preMain?: PreMainHandler[];
 }