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

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 };
@@ -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;
-};
+export type PreMainHandler<T extends Any = Any> = { priority: number, handler: (cmd: T) => Any };
 
 /**
  * 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[];
 }

package/src/util.ts

@@ -2,13 +2,12 @@ import { spawn, type ChildProcess } from 'node:child_process';
 
 import { RuntimeError, JSONUtil, Env, ExecUtil, Runtime, ShutdownManager, Util, WatchUtil } from '@travetto/runtime';
 
-import type { CliCommandShape, CliCommandShapeFields } from './types.ts';
-
-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 {
   /**
@@ -16,34 +15,29 @@ export class CliUtil {
    */
   static getSimpleModuleName(placeholder: string, module?: string): string {
     const simple = (module ?? Runtime.main.name).replace(/[\/]/, '_').replace(/@/, '');
-    if (!simple) {
-      return placeholder;
-    } else if (!module && Runtime.monoRoot) {
-      return placeholder;
-    } else {
-      return placeholder.replace('<module>', simple);
-    }
+    return simple ? placeholder.replace('<module>', simple) : placeholder;
   }
 
   /**
    * Run a command as restartable, linking into self
    */
-  static async runWithRestartOnChange<T extends CliCommandShapeFields>(cmd: T): Promise<void> {
+  static async runWithRestartOnChange(restartOnChange?: boolean): Promise<void> {
     if (Env.TRV_RESTART_TARGET.isTrue) {
       Env.TRV_RESTART_TARGET.clear();
       ShutdownManager.disableInterrupt();
       return;
-    } else if (cmd.restartOnChange !== true) {
+    } else if (restartOnChange !== true) {
       return; // Not restarting, run normal
     }
 
     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) };
 
@@ -72,43 +66,44 @@ export class CliUtil {
   /**
    * Dispatch IPC payload
    */
-  static async runWithDebugIpc<T extends CliCommandShapeFields & CliCommandShape>(cmd: T): Promise<void> {
-    if (cmd.debugIpc !== true || !Env.TRV_CLI_IPC.isSet) {
+  static async runWithDebugIpc(name: string): Promise<void> {
+    if (!Env.TRV_CLI_IPC.isSet) {
       return; // Not debugging, run normal
     }
 
-    const info = await fetch(Env.TRV_CLI_IPC.value!).catch(() => ({ ok: false }));
+    const doFetch = fetch.bind(null, Env.TRV_CLI_IPC.value!);
 
+    const info = await doFetch().catch(() => ({ ok: false }));
     if (!info.ok) {
       return; // Server not running, run normal
     }
 
-    const env: Record<string, string> = {};
     const request = {
       type: '@travetto/cli:run',
       data: {
-        name: cmd._cfg!.name,
-        env,
-        module: cmd.module ?? Runtime.main.name,
+        name,
+        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!));
-    const sent = await fetch(Env.TRV_CLI_IPC.value!, { method: 'POST', body: JSONUtil.toUTF8(request) });
+    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.cli_schema.ts

@@ -1,12 +1,29 @@
 import { Env } from '@travetto/runtime';
-import { IsPrivate } from '@travetto/schema';
+import { IsPrivate, MethodValidator, type ValidationError } from '@travetto/schema';
 
 import { CliCommand } from '../src/registry/decorator.ts';
-import type { CliCommandShape, CliValidationError } from '../src/types.ts';
+import type { CliCommandShape } from '../src/types.ts';
 import { CliCommandRegistryIndex } from '../src/registry/registry-index.ts';
 import { CliUtil } from '../src/util.ts';
 import { CliSchemaExportUtil } from '../src/schema-export.ts';
 
+async function nameValidator(names?: string[]): Promise<ValidationError | undefined> {
+  if (!names || names.length === 0) {
+    return;
+  }
+  const resolved = await CliCommandRegistryIndex.load(names);
+  const invalid = names.find(name => !resolved.find(result => result.command === name));
+
+  if (invalid) {
+    return {
+      source: 'arg',
+      kind: 'invalid',
+      path: 'names',
+      message: `name: ${invalid} is not a valid cli command`
+    };
+  }
+}
+
 /**
  * Generates the schema for all CLI operations
  */
@@ -14,25 +31,11 @@ import { CliSchemaExportUtil } from '../src/schema-export.ts';
 @IsPrivate()
 export class CliSchemaCommand implements CliCommandShape {
 
-  async validate(names?: string[]): Promise<CliValidationError | undefined> {
-    if (!names || names.length === 0) {
-      return;
-    }
-    const resolved = await CliCommandRegistryIndex.load(names);
-    const invalid = names.find(name => !resolved.find(result => result.command === name));
-
-    if (invalid) {
-      return {
-        source: 'arg',
-        message: `name: ${invalid} is not a valid cli command`
-      };
-    }
-  }
-
-  preMain(): void {
+  finalize(): void {
     Env.DEBUG.set(false);
   }
 
+  @MethodValidator(nameValidator)
   async main(names?: string[]): Promise<void> {
     const resolved = await CliCommandRegistryIndex.load(names);
 

package/support/cli.main.ts

@@ -1,6 +1,14 @@
 import { JSONUtil, Runtime } from '@travetto/runtime';
-import { type CliCommandShape, CliCommand, type CliValidationError, type ParsedState } from '@travetto/cli';
-import { Ignore, IsPrivate } from '@travetto/schema';
+import { type CliCommandShape, CliCommand, CliParseUtil } from '@travetto/cli';
+import { IsPrivate, MethodValidator, type ValidationError } from '@travetto/schema';
+
+async function validateMain(fileOrImport: string): Promise<ValidationError | undefined> {
+  try {
+    await Runtime.importFrom(fileOrImport);
+  } catch {
+    return { message: `Unknown file: ${fileOrImport}`, source: 'arg', kind: 'invalid', path: 'fileOrImport' };
+  }
+};
 
 /**
  * Allows for running of main entry points
@@ -9,22 +17,13 @@ import { Ignore, IsPrivate } from '@travetto/schema';
 @IsPrivate()
 export class MainCommand implements CliCommandShape {
 
-  @Ignore()
-  _parsed: ParsedState;
-
-  async validate(fileOrImport: string): Promise<CliValidationError | undefined> {
-    try {
-      await Runtime.importFrom(fileOrImport);
-    } catch {
-      return { message: `Unknown file: ${fileOrImport}` };
-    }
-  }
-
+  @MethodValidator(validateMain)
   async main(fileOrImport: string, args: string[] = []): Promise<void> {
+    const parsed = CliParseUtil.getState(this);
     let result: unknown;
     try {
       const module = await Runtime.importFrom<{ main(..._: unknown[]): Promise<unknown> }>(fileOrImport);
-      result = await module.main(...args, ...this._parsed.unknown);
+      result = await module.main(...args, ...parsed?.unknown ?? []);
     } catch (error) {
       result = error;
       process.exitCode = Math.max(process.exitCode ? +process.exitCode : 1, 1);

package/support/cli.service.ts

@@ -1,8 +1,19 @@
-import { type CliCommandShape, CliCommand, cliTpl, type CliValidationError } from '@travetto/cli';
+import { stripVTControlCharacters } from 'node:util';
+
+import { type CliCommandShape, CliCommand, cliTpl } from '@travetto/cli';
 import { Terminal } from '@travetto/terminal';
-import { AsyncQueue, Runtime, RuntimeIndex, Util } from '@travetto/runtime';
+import { AsyncQueue, Util } from '@travetto/runtime';
+import { MethodValidator, type ValidationError } from '@travetto/schema';
+
+import { ServiceRunner, type ServiceAction } from '../src/service.ts';
 
-import { ServiceRunner, type ServiceDescriptor, type ServiceAction } from '../src/service.ts';
+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' };
+  }
+}
 
 /**
  * Allows for running services
@@ -10,30 +21,10 @@ import { ServiceRunner, type ServiceDescriptor, type ServiceAction } from '../sr
 @CliCommand()
 export class CliServiceCommand implements CliCommandShape {
 
-  async #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));
-  }
-
-  async validate(action: ServiceAction, services: string[]): Promise<CliValidationError | undefined> {
-    const all = await this.#getServices(services);
-
-    if (!all.length) {
-      return { message: 'No services found' };
-    }
-  }
+  quiet = false;
 
   async help(): Promise<string[]> {
-    const all = await this.#getServices([]);
+    const all = await ServiceRunner.findServices([]);
     return [
       cliTpl`${{ title: 'Available Services' }}`,
       '-'.repeat(20),
@@ -41,33 +32,50 @@ export class CliServiceCommand implements CliCommandShape {
     ];
   }
 
+  @MethodValidator(validateService)
   async main(action: ServiceAction, services: string[] = []): Promise<void> {
-    const all = await this.#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,58 +0,0 @@
-import { RuntimeError, Runtime } from '@travetto/runtime';
-
-import { cliTpl } from './color.ts';
-import type { CliValidationError, 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: CliValidationError[] }> {
-  command: CliCommandShape;
-
-  constructor(command: CliCommandShape, errors: CliValidationError[]) {
-    super('', { details: { errors } });
-    this.command = command;
-  }
-}