@travetto/cli 3.4.10 → 4.0.0-rc.1

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/decorators.ts#L16) decorator
+   *  The class must use the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L15) decorator
 
 **Code: Basic Command**
 ```typescript
@@ -93,7 +93,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/decorators.ts#L16) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L16) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14) 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/decorators.ts#L15) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L15) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14) class. The fields of the class represent the flags that are available to the command.
 
 **Code: Basic Command with Flag**
 ```typescript
@@ -130,7 +130,7 @@ $ trv basic:flag --loud
 HELLO
 ```
 
-The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L16) supports the following data types for flags:
+The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L15) supports the following data types for flags:
    *  Boolean values
    *  Number values. The [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L172), [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L178), [@Precision](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L166), [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L107) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L117) decorators help provide additional validation.
    *  String values. [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L107), [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L117), [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) and [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L78) provide additional constraints
@@ -388,7 +388,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.  [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") does expose a cli target `run:rest` that will show up, to help run/debug a rest 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/decorators.ts#L16) 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.  [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") does expose a cli target `run:rest` that will show up, to help run/debug a rest 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/decorators.ts#L15) decorator.  This means the target will be visible within the editor tooling.
 
 **Code: Simple Run Target**
 ```typescript
@@ -415,6 +415,10 @@ export interface CliCommandShape<T extends unknown[] = unknown[]> {
    * Parsed state
    */
   _parsed?: ParsedState;
+  /**
+   * Config
+   */
+  _cfg?: CliCommandConfig;
   /**
    * Action target of the command
    */
@@ -492,12 +496,12 @@ export class RunRestCommand implements CliCommandShape {
 }
 ```
 
-As noted in the example above, `fields` is specified in this execution, with support for `module`, and `env`. These env flag is directly tied to the [GlobalEnv](https://github.com/travetto/travetto/tree/main/module/base/src/global-env.ts#L9) flags defined in the [Base](https://github.com/travetto/travetto/tree/main/module/base#readme "Environment config and common utilities for travetto applications.") module. 
+As noted in the example above, `fields` is specified in this execution, with support for `module`, and `env`. These env flag is directly tied to the [Runtime](https://github.com/travetto/travetto/tree/main/module/base/src/env.ts#L105) `name` defined in the [Base](https://github.com/travetto/travetto/tree/main/module/base#readme "Environment config and common utilities for travetto applications.") module. 
 
 The `module` field is slightly more complex, but is geared towards supporting commands within a monorepo context.  This flag ensures that a module is specified if running from the root of the monorepo, and that the module provided is real, and can run the desired command.  When running from an explicit module folder in the monorepo, the module flag is ignored.
 
 ### Custom Validation
-In addition to dependency injection, the command contract also allows for a custom validation function, which will have access to bound command (flags, and args) as well as the unknown arguments. When a command implements this method, any [CliValidationError](https://github.com/travetto/travetto/tree/main/module/cli/src/types.ts#L22) errors that are returned will be shared with the user, and fail to invoke the `main` method.
+In addition to dependency injection, the command contract also allows for a custom validation function, which will have access to bound command (flags, and args) as well as the unknown arguments. When a command implements this method, any [CliValidationError](https://github.com/travetto/travetto/tree/main/module/cli/src/types.ts#L37) errors that are returned will be shared with the user, and fail to invoke the `main` method.
 
 **Code: CliValidationError**
 ```typescript

package/__index__.ts

@@ -1,3 +1,4 @@
+/// <reference path="./src/trv.d.ts" />
 export * from './src/types';
 export * from './src/decorators';
 export * from './src/execute';

package/bin/trv.js

@@ -3,4 +3,4 @@
 // @ts-check
 import { getEntry } from '@travetto/compiler/bin/common.js';
 
-getEntry().then(ops => ops.compile('run')).then(load => load('@travetto/cli/support/entry.trv.js'));
+getEntry().then(ops => ops.getLoader()).then(load => load('@travetto/cli/support/entry.trv.js'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/cli",
-  "version": "3.4.10",
+  "version": "4.0.0-rc.1",
   "description": "CLI infrastructure for Travetto framework",
   "keywords": [
     "cli",
@@ -29,8 +29,8 @@
     "directory": "module/cli"
   },
   "dependencies": {
-    "@travetto/schema": "^3.4.4",
-    "@travetto/terminal": "^3.4.0"
+    "@travetto/schema": "^4.0.0-rc.1",
+    "@travetto/terminal": "^4.0.0-rc.1"
   },
   "travetto": {
     "displayName": "Command Line Interface"

package/src/color.ts

@@ -1,19 +1,16 @@
-import { Util } from '@travetto/base';
-import { GlobalTerminal } from '@travetto/terminal';
+import { StyleUtil } from '@travetto/terminal';
 
-const tplFn = GlobalTerminal.templateFunction({
-  input: 'oliveDrab',
-  output: 'pink',
-  path: 'teal',
-  success: 'green',
-  failure: 'red',
-  param: ['yellow', 'goldenrod'],
-  type: 'cyan',
-  description: ['white', 'gray'],
-  title: ['brightWhite', 'black'],
-  identifier: 'dodgerBlue',
-  subtitle: ['lightGray', 'darkGray'],
-  subsubtitle: 'darkGray'
-});
-
-export const cliTpl = Util.makeTemplate(tplFn);
+export const cliTpl = StyleUtil.getTemplate({
+  input: '#6b8e23', // Olive drab
+  output: '#ffc0cb', // Pink
+  path: '#008080', // Teal
+  success: '#00ff00', // Green
+  failure: '#ff0000', // Red
+  param: ['#ffff00', '#daa520'], // Yellow / Goldenrod
+  type: '#00ffff', // Teal
+  description: ['#e5e5e5', '#808080'], // White / Gray
+  title: ['#ffffff', '#000000'], // Bright white / black
+  identifier: '#1e90ff', // Dodger blue
+  subtitle: ['#d3d3d3', '#a9a9a9'], // Light gray / Dark Gray
+  subsubtitle: '#a9a9a9' // Dark gray
+});

package/src/decorators.ts

@@ -1,11 +1,10 @@
-import { Class, ClassInstance, defineEnv } from '@travetto/base';
-import { RootIndex } from '@travetto/manifest';
+import { Class, ClassInstance, Env } from '@travetto/base';
+import { RuntimeIndex, RuntimeContext } from '@travetto/manifest';
 import { SchemaRegistry } from '@travetto/schema';
 
 import { CliCommandShape, CliCommandShapeFields } from './types';
 import { CliCommandRegistry, CliCommandConfigOptions } from './registry';
 import { CliModuleUtil } from './module';
-import { CliUtil } from './util';
 import { CliParseUtil } from './parse';
 
 /**
@@ -15,7 +14,7 @@ import { CliParseUtil } from './parse';
  */
 export function CliCommand(cfg: CliCommandConfigOptions = {}) {
   return function <T extends CliCommandShape>(target: Class<T>): void {
-    const meta = RootIndex.getFunctionMetadata(target);
+    const meta = RuntimeIndex.getFunctionMetadata(target);
     if (!meta || meta.abstract) {
       return;
     }
@@ -25,10 +24,10 @@ export function CliCommand(cfg: CliCommandConfigOptions = {}) {
     const addEnv = cfg.addEnv ?? cfg.fields?.includes('env');
     const { commandModule } = CliCommandRegistry.registerClass(target, {
       hidden: cfg.hidden,
-      preMain: async (cmd) => {
+      runTarget: cfg.runTarget,
+      preMain: async (cmd: CliCommandShape & { env?: string }) => {
         if (addEnv) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          defineEnv({ envName: (cmd as { env?: string }).env ?? 'dev' });
+          Env.TRV_ENV.set(cmd.env || Env.name);
         }
       }
     });
@@ -37,19 +36,18 @@ export function CliCommand(cfg: CliCommandConfigOptions = {}) {
 
     if (addEnv) {
       SchemaRegistry.registerPendingFieldConfig(target, 'env', String, {
-        aliases: ['e', CliParseUtil.toEnvField('TRV_ENV')],
+        aliases: ['e', CliParseUtil.toEnvField(Env.TRV_ENV.key)],
         description: 'Application environment',
-        default: 'dev',
         required: { active: false }
       });
     }
 
     if (addModule) {
       SchemaRegistry.registerPendingFieldConfig(target, 'module', String, {
-        aliases: ['m', CliParseUtil.toEnvField('TRV_MODULE')],
+        aliases: ['m', CliParseUtil.toEnvField(Env.TRV_MODULE.key)],
         description: 'Module to run for',
         specifiers: ['module'],
-        required: { active: CliUtil.monoRoot }
+        required: { active: RuntimeContext.monoRoot }
       });
     }
 
@@ -57,12 +55,12 @@ export function CliCommand(cfg: CliCommandConfigOptions = {}) {
       (pendingCls.validators ??= []).push(async item => {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const { module: mod } = item as CliCommandShapeFields;
-        const runModule = (runtimeModule === 'command' ? commandModule : mod) || RootIndex.mainModuleName;
+        const runModule = (runtimeModule === 'command' ? commandModule : mod) || RuntimeContext.main.name;
 
         // If we need to run as a specific module
-        if (runModule !== RootIndex.mainModuleName) {
+        if (runModule !== RuntimeContext.main.name) {
           try {
-            RootIndex.reinitForModule(runModule);
+            RuntimeIndex.reinitForModule(runModule);
           } catch (err) {
             return { source: 'flag', message: `${runModule} is an unknown module`, kind: 'custom', path: '.' };
           }

package/src/error.ts

@@ -1,5 +1,4 @@
-import { RootIndex } from '@travetto/manifest';
-
+import { PackageUtil, RuntimeContext } from '@travetto/manifest';
 import { cliTpl } from './color';
 import { CliValidationError } from './types';
 
@@ -23,11 +22,7 @@ export class CliUnknownCommandError extends Error {
     const matchedCfg = COMMAND_PACKAGE.find(([re]) => re.test(cmd));
     if (matchedCfg) {
       const [, pkg, prod] = matchedCfg;
-      let install: string;
-      switch (RootIndex.manifest.packageManager) {
-        case 'npm': install = `npm i ${prod ? '' : '--save-dev '}@travetto/${pkg}`; break;
-        case 'yarn': install = `yarn add ${prod ? '' : '--dev '}@travetto/${pkg}`; break;
-      }
+      const install = PackageUtil.getInstallCommand(RuntimeContext, `@travetto/${pkg}`, prod);
       return cliTpl`
 ${{ title: 'Missing Package' }}\n${'-'.repeat(20)}\nTo use ${{ input: cmd }} please run:\n
 ${{ identifier: install }}

package/src/execute.ts

@@ -1,8 +1,7 @@
-import { GlobalTerminal } from '@travetto/terminal';
-import { ConsoleManager, GlobalEnv } from '@travetto/base';
+import { ConsoleManager, Env, ShutdownManager } from '@travetto/base';
 
 import { HelpUtil } from './help';
-import { CliCommandShape, RunResponse } from './types';
+import { CliCommandShape } from './types';
 import { CliCommandRegistry } from './registry';
 import { CliCommandSchemaUtil } from './schema';
 import { CliUnknownCommandError, CliValidationResultError } from './error';
@@ -14,53 +13,49 @@ import { CliUtil } from './util';
  */
 export class ExecutionManager {
 
-  /**
-   * Run the given command object with the given arguments
-   */
-  static async #runCommand(cmd: CliCommandShape, args: string[]): Promise<RunResponse> {
+  /** Prepare command for execution */
+  static async #prepareAndBind(cmd: CliCommandShape, args: string[]): Promise<unknown[]> {
     const schema = await CliCommandSchemaUtil.getSchema(cmd);
     args = await CliParseUtil.expandArgs(schema, args);
     cmd._parsed = await CliParseUtil.parse(schema, args);
-    const cfg = CliCommandRegistry.getConfig(cmd);
 
     await cmd.preBind?.();
-    const known = await CliCommandSchemaUtil.bindInput(cmd, cmd._parsed);
+    try {
+      const known = await CliCommandSchemaUtil.bindInput(cmd, cmd._parsed);
 
-    await cmd.preValidate?.();
-    await CliCommandSchemaUtil.validate(cmd, known);
+      await cmd.preValidate?.();
+      await CliCommandSchemaUtil.validate(cmd, known);
 
-    await cfg.preMain?.(cmd);
-    await cmd.preMain?.();
-    ConsoleManager.setDebug(GlobalEnv.debug, GlobalEnv.devMode);
-    return cmd.main(...known);
-  }
+      await cmd._cfg!.preMain?.(cmd);
+      await cmd.preMain?.();
 
-  /**
-   * On error, handle response
-   */
-  static async #onError(command: CliCommandShape | undefined, err: unknown): Promise<void> {
-    process.exitCode ||= 1; // Trigger error state
-    switch (true) {
-      case !(err instanceof Error): {
+      return known;
+    } catch (err) {
+      if (err instanceof CliValidationResultError) {
+        console.error!(await HelpUtil.renderValidationError(cmd, err));
+        console.error!(await HelpUtil.renderCommandHelp(cmd));
+        process.exit(1);
+      } else {
         throw err;
       }
-      case command && err instanceof CliValidationResultError: {
-        console.error!(await HelpUtil.renderValidationError(command, err));
-        console.error!(await HelpUtil.renderCommandHelp(command));
-        break;
-      }
-      case err instanceof CliUnknownCommandError: {
+    }
+  }
+
+  /** Fetch a single command */
+  static async #getCommand(cmd: string): Promise<CliCommandShape> {
+    try {
+      return await CliCommandRegistry.getInstance(cmd, true);
+    } catch (err) {
+      if (err instanceof CliUnknownCommandError) {
         if (err.help) {
           console.error!(err.help);
         } else {
           console.error!(err.defaultMessage, '\n');
           console.error!(await HelpUtil.renderAllHelp(''));
         }
-        break;
-      }
-      default: {
-        console.error!(err);
-        console.error!();
+        process.exit(1);
+      } else {
+        throw err;
       }
     }
   }
@@ -70,9 +65,6 @@ export class ExecutionManager {
    * @param args
    */
   static async run(argv: string[]): Promise<void> {
-    await GlobalTerminal.init();
-
-    let command: CliCommandShape | undefined;
     try {
       const { cmd, args, help } = CliParseUtil.getArgs(argv);
 
@@ -81,16 +73,22 @@ export class ExecutionManager {
         return;
       }
 
-      // Load a single command
-      command = await CliCommandRegistry.getInstance(cmd, true);
+      const command = await this.#getCommand(cmd);
+
       if (help) {
         console.log!(await HelpUtil.renderCommandHelp(command));
+        return;
       } else {
-        const result = await this.#runCommand(command, args);
+        const known = await this.#prepareAndBind(command, args);
+        ConsoleManager.debug(Env.debug);
+        const result = await command.main(...known);
         await CliUtil.listenForResponse(result);
       }
     } catch (err) {
-      await this.#onError(command, err);
+      console.error!(err);
+      console.error!();
+    } finally {
+      await ShutdownManager.gracefulShutdown(process.exitCode);
     }
   }
 }

package/src/help.ts

@@ -1,5 +1,5 @@
 import { Primitive } from '@travetto/base';
-import { stripAnsiCodes } from '@travetto/terminal';
+import { StyleUtil } from '@travetto/terminal';
 
 import { cliTpl } from './color';
 import { CliCommandShape } from './types';
@@ -33,7 +33,7 @@ export class HelpUtil {
 
     const usage: string[] = [cliTpl`${{ title: 'Usage:' }} ${{ param: commandName }} ${{ input: '[options]' }}`];
     for (const field of args) {
-      const type = field.type === 'string' && field.choices && field.choices.length <= 5 ? field.choices?.join('|') : field.type;
+      const type = field.type === 'string' && field.choices && field.choices.length <= 7 ? field.choices?.join('|') : field.type;
       const arg = `${field.name}${field.array ? '...' : ''}:${type}`;
       usage.push(cliTpl`${{ input: field.required ? `<${arg}>` : `[${arg}]` }}`);
     }
@@ -45,7 +45,7 @@ export class HelpUtil {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const key = flag.name as keyof CliCommandShape;
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const flagVal = command[key] as unknown as Exclude<Primitive, Error>;
+      const flagVal = command[key] as unknown as Primitive;
 
       let aliases = flag.flagNames ?? [];
       if (isBoolFlag(flag)) {
@@ -69,8 +69,8 @@ export class HelpUtil {
       descs.push(desc.join(' '));
     }
 
-    const paramWidths = params.map(x => stripAnsiCodes(x).length);
-    const descWidths = descs.map(x => stripAnsiCodes(x).length);
+    const paramWidths = params.map(x => StyleUtil.cleanText(x).length);
+    const descWidths = descs.map(x => StyleUtil.cleanText(x).length);
 
     const paramWidth = Math.max(...paramWidths);
     const descWidth = Math.max(...descWidths);
@@ -98,7 +98,7 @@ export class HelpUtil {
   static async renderAllHelp(title?: string): Promise<string> {
     const rows: string[] = [];
     const keys = [...CliCommandRegistry.getCommandMapping().keys()].sort((a, b) => a.localeCompare(b));
-    const maxWidth = keys.reduce((a, b) => Math.max(a, stripAnsiCodes(b).length), 0);
+    const maxWidth = keys.reduce((a, b) => Math.max(a, StyleUtil.cleanText(b).length), 0);
 
     for (const cmd of keys) {
       try {

package/src/module.ts

@@ -1,4 +1,4 @@
-import { IndexedModule, RootIndex } from '@travetto/manifest';
+import { IndexedModule, RuntimeIndex, RuntimeContext } from '@travetto/manifest';
 
 import { CliScmUtil } from './scm';
 
@@ -20,14 +20,14 @@ export class CliModuleUtil {
     fromHash ??= await CliScmUtil.findLastRelease();
 
     if (!fromHash) {
-      return RootIndex.getLocalModules();
+      return RuntimeIndex.getWorkspaceModules();
     }
 
     const out = new Map<string, IndexedModule>();
     for (const mod of await CliScmUtil.findChangedModules(fromHash, toHash)) {
       out.set(mod.name, mod);
       if (transitive) {
-        for (const sub of await RootIndex.getDependentModules(mod)) {
+        for (const sub of await RuntimeIndex.getDependentModules(mod, 'parents')) {
           out.set(sub.name, sub);
         }
       }
@@ -46,8 +46,8 @@ export class CliModuleUtil {
   static async findModules(mode: 'all' | 'changed', fromHash?: string, toHash?: string): Promise<IndexedModule[]> {
     return (mode === 'changed' ?
       await this.findChangedModulesRecursive(fromHash, toHash) :
-      [...RootIndex.getModuleList('all')].map(x => RootIndex.getModule(x)!)
-    ).filter(x => x.sourcePath !== RootIndex.manifest.workspacePath);
+      [...RuntimeIndex.getModuleList('all')].map(x => RuntimeIndex.getModule(x)!)
+    ).filter(x => x.sourcePath !== RuntimeContext.workspace.path);
   }
 
   /**

package/src/parse.ts

@@ -1,6 +1,6 @@
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
 
-import { RootIndex, path } from '@travetto/manifest';
+import { RuntimeIndex, RuntimeContext, path } from '@travetto/manifest';
 import { CliCommandInput, CliCommandSchema, ParsedState } from './types';
 
 type ParsedInput = ParsedState['all'][number];
@@ -85,10 +85,10 @@ export class CliParseUtil {
 
     // We have a file
     const rel = (key.includes('/') ? key : `@/support/pack.${key}.flags`)
-      .replace('@@/', `${RootIndex.manifest.workspacePath}/`)
+      .replace('@@/', `${RuntimeContext.workspace.path}/`)
       .replace('@/', `${mod}/`)
       .replace(/^(@[^\/]+\/[^\/]+)(\/.*)$/, (_, imp, rest) => {
-        const val = RootIndex.getModule(imp);
+        const val = RuntimeIndex.getModule(imp);
         if (!val) {
           throw new Error(`Unknown module file: ${_}, unable to proceed`);
         }
@@ -144,9 +144,10 @@ export class CliParseUtil {
     const mod = args.reduce(
       (m, x, i, arr) =>
         (i < SEP ? check(arr[i - 1], x) ?? check(...x.split('=')) : undefined) ?? m,
-      process.env[ENV_KEY] || RootIndex.mainModuleName
+      process.env[ENV_KEY] || RuntimeContext.main.name
     );
-    return (await Promise.all(args.map((x, i) => x.startsWith(CONFIG_PRE) && (i < SEP || SEP < 0) ? this.readFlagFile(x, mod) : x))).flat();
+    return (await Promise.all(args.map((x, i) =>
+      x.startsWith(CONFIG_PRE) && (i < SEP || SEP < 0) ? this.readFlagFile(x, mod) : x))).flat();
   }
 
   /**

package/src/registry.ts

@@ -1,7 +1,7 @@
-import { Class, ConcreteClass, GlobalEnv } from '@travetto/base';
-import { RootIndex } from '@travetto/manifest';
+import { Class, ConcreteClass, Env } from '@travetto/base';
+import { RuntimeIndex } from '@travetto/manifest';
 
-import { CliCommandShape } from './types';
+import { CliCommandConfig, CliCommandShape } from './types';
 import { CliUnknownCommandError } from './error';
 
 export type CliCommandConfigOptions = {
@@ -14,14 +14,6 @@ export type CliCommandConfigOptions = {
   fields?: ('module' | 'env')[];
 };
 
-export type CliCommandConfig = {
-  name: string;
-  commandModule: string;
-  cls: ConcreteClass<CliCommandShape>;
-  hidden?: boolean;
-  preMain?: (cmd: CliCommandShape) => void | Promise<void>;
-};
-
 const CLI_FILE_REGEX = /\/cli[.](?<name>.*)[.]tsx?$/;
 const getName = (s: string): string => (s.match(CLI_FILE_REGEX)?.groups?.name ?? s).replaceAll('_', ':');
 
@@ -44,8 +36,8 @@ class $CliCommandRegistry {
   getCommandMapping(): Map<string, string> {
     if (!this.#fileMapping) {
       const all = new Map<string, string>();
-      for (const e of RootIndex.find({
-        module: m => GlobalEnv.devMode || m.prod,
+      for (const e of RuntimeIndex.find({
+        module: m => !Env.production || m.prod,
         folder: f => f === 'support',
         file: f => f.role === 'std' && CLI_FILE_REGEX.test(f.sourceFile)
       })) {
@@ -60,12 +52,12 @@ class $CliCommandRegistry {
    * Registers a cli command
    */
   registerClass(cls: Class, cfg: Partial<CliCommandConfig>): CliCommandConfig {
-    const source = RootIndex.getFunctionMetadata(cls)!.source;
+    const source = RuntimeIndex.getFunctionMetadata(cls)!.source;
     this.#commands.set(cls, {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       cls: cls as ConcreteClass,
       name: getName(source),
-      commandModule: RootIndex.getModuleFromSource(source)!.name,
+      commandModule: RuntimeIndex.getModuleFromSource(source)!.name,
       ...cfg,
     });
     return this.#commands.get(cls)!;
@@ -101,6 +93,7 @@ class $CliCommandRegistry {
         if (cfg) {
           const inst = new cfg.cls();
           if (!inst.isActive || inst.isActive()) {
+            inst._cfg = this.getConfig(inst);
             return inst;
           }
         }

package/src/schema.ts

@@ -1,4 +1,4 @@
-import { Class, ConsoleManager, GlobalEnv } from '@travetto/base';
+import { Class } from '@travetto/base';
 import { BindUtil, FieldConfig, SchemaRegistry, SchemaValidator, ValidationResultError } from '@travetto/schema';
 
 import { CliCommandRegistry } from './registry';
@@ -59,16 +59,11 @@ export class CliCommandSchemaUtil {
     }
 
     // Ensure finalized
-    try {
-      ConsoleManager.setDebug(false);
-      const parent = SchemaRegistry.getParentClass(cls);
-      if (parent?.Ⲑid) {
-        SchemaRegistry.onInstall(parent, { type: 'added', curr: parent });
-      }
-      SchemaRegistry.onInstall(cls, { type: 'added', curr: cls });
-    } finally {
-      ConsoleManager.setDebug(GlobalEnv.debug, GlobalEnv.devMode);
+    const parent = SchemaRegistry.getParentClass(cls);
+    if (parent?.Ⲑid) {
+      SchemaRegistry.onInstall(parent, { type: 'added', curr: parent });
     }
+    SchemaRegistry.onInstall(cls, { type: 'added', curr: cls });
 
     const schema = await SchemaRegistry.getViewSchema(cls);
     const flags = Object.values(schema.schema).map(fieldToInput);

package/src/scm.ts

@@ -1,7 +1,8 @@
-import fs from 'fs/promises';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
 
-import { Env, ExecUtil } from '@travetto/base';
-import { IndexedFile, IndexedModule, RootIndex, path } from '@travetto/manifest';
+import { ExecUtil } from '@travetto/base';
+import { IndexedFile, IndexedModule, RuntimeIndex, RuntimeContext, path } from '@travetto/manifest';
 
 export class CliScmUtil {
   /**
@@ -19,11 +20,11 @@ export class CliScmUtil {
    */
   static async getAuthor(): Promise<{ name?: string, email: string }> {
     const [name, email] = await Promise.all([
-      await ExecUtil.spawn('git', ['config', 'user.name'], { catchAsResult: true }).result,
-      await ExecUtil.spawn('git', ['config', 'user.email']).result,
+      ExecUtil.getResult(spawn('git', ['config', 'user.name']), { catch: true }),
+      ExecUtil.getResult(spawn('git', ['config', 'user.email'])),
     ]);
     return {
-      name: (name.valid ? name.stdout.trim() : '') || Env.get('USER'),
+      name: (name.valid ? name.stdout.trim() : '') || process.env.USER,
       email: email.stdout.trim()
     };
   }
@@ -33,9 +34,8 @@ export class CliScmUtil {
    * @returns
    */
   static async findLastRelease(): Promise<string | undefined> {
-    const root = await RootIndex.manifest;
-    const { result } = ExecUtil.spawn('git', ['log', '--pretty=oneline'], { cwd: root.workspacePath });
-    return (await result).stdout
+    const result = await ExecUtil.getResult(spawn('git', ['log', '--pretty=oneline'], { cwd: RuntimeContext.workspace.path }));
+    return result.stdout
       .split(/\n/)
       .find(x => /Publish /.test(x))?.split(/\s+/)?.[0];
   }
@@ -46,11 +46,11 @@ export class CliScmUtil {
    * @returns
    */
   static async findChangedFiles(fromHash: string, toHash: string = 'HEAD'): Promise<string[]> {
-    const ws = RootIndex.manifest.workspacePath;
-    const res = await ExecUtil.spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: ws }).result;
+    const ws = RuntimeContext.workspace.path;
+    const res = await ExecUtil.getResult(spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: ws }));
     const out = new Set<string>();
     for (const line of res.stdout.split(/\n/g)) {
-      const entry = RootIndex.getEntry(path.resolve(ws, line));
+      const entry = RuntimeIndex.getEntry(path.resolve(ws, line));
       if (entry) {
         out.add(entry.sourceFile);
       }
@@ -67,9 +67,9 @@ export class CliScmUtil {
   static async findChangedModules(fromHash: string, toHash?: string): Promise<IndexedModule[]> {
     const files = await this.findChangedFiles(fromHash, toHash);
     const mods = files
-      .map(x => RootIndex.getFromSource(x))
+      .map(x => RuntimeIndex.getFromSource(x))
       .filter((x): x is IndexedFile => !!x)
-      .map(x => RootIndex.getModule(x.module))
+      .map(x => RuntimeIndex.getModule(x.module))
       .filter((x): x is IndexedModule => !!x);
 
     return [...new Set(mods)]
@@ -80,15 +80,15 @@ export class CliScmUtil {
    * Create a commit
    */
   static createCommit(message: string): Promise<string> {
-    return ExecUtil.spawn('git', ['commit', '.', '-m', message]).result.then(r => r.stdout);
+    return ExecUtil.getResult(spawn('git', ['commit', '.', '-m', message])).then(r => r.stdout);
   }
 
   /**
    * Verify if workspace is dirty
    */
   static async isWorkspaceDirty(): Promise<boolean> {
-    const res1 = await ExecUtil.spawn('git', ['diff', '--quiet', '--exit-code'], { catchAsResult: true }).result;
-    const res2 = await ExecUtil.spawn('git', ['diff', '--quiet', '--exit-code', '--cached'], { catchAsResult: true }).result;
+    const res1 = await ExecUtil.getResult(spawn('git', ['diff', '--quiet', '--exit-code']), { catch: true });
+    const res2 = await ExecUtil.getResult(spawn('git', ['diff', '--quiet', '--exit-code', '--cached']), { catch: true });
     return !res1.valid || !res2.valid;
   }
 }

package/src/trv.d.ts

@@ -0,0 +1,15 @@
+import '@travetto/base';
+
+declare global {
+  interface TravettoEnv {
+    /** 
+     * Provides an IPC http url for the CLI to communicate with. 
+     * This facilitates cli-based invocation for external usage.
+     */
+    TRV_CLI_IPC: string;
+    /** 
+     * Determines (assuming the operation supports it), that restart behavior can trigger  
+     */
+    TRV_CAN_RESTART: boolean;
+  }
+}

package/src/types.ts

@@ -1,14 +1,29 @@
-import { Closeable } from '@travetto/base';
+import { ConcreteClass } from '@travetto/base';
 
 type OrProm<T> = T | Promise<T>;
 
-export type RunResponse = { wait(): Promise<unknown> } | { on(event: 'close', cb: Function): unknown } | Closeable | void | undefined;
+export type RunResponse =
+  { wait(): Promise<unknown> } |
+  { on(event: 'close', cb: Function): unknown } |
+  { close: () => (void | Promise<void>) } | void | undefined;
 
 type ParsedFlag = { type: 'flag', input: string, array?: boolean, fieldName: string, value?: unknown };
 type ParsedArg = { type: 'arg', input: string, array?: boolean, index: number };
 type ParsedUnknown = { type: 'unknown', input: string };
 type ParsedInput = ParsedUnknown | ParsedFlag | ParsedArg;
 
+/**
+ * Command configuration
+ */
+export type CliCommandConfig = {
+  name: string;
+  commandModule: string;
+  runTarget?: boolean;
+  cls: ConcreteClass<CliCommandShape>;
+  hidden?: boolean;
+  preMain?: (cmd: CliCommandShape) => void | Promise<void>;
+};
+
 export type ParsedState = {
   inputs: string[];
   all: ParsedInput[];
@@ -38,6 +53,10 @@ export interface CliCommandShape<T extends unknown[] = unknown[]> {
    * Parsed state
    */
   _parsed?: ParsedState;
+  /**
+   * Config
+   */
+  _cfg?: CliCommandConfig;
   /**
    * Action target of the command
    */

package/src/util.ts

@@ -1,26 +1,24 @@
-import { Env, ExecUtil, GlobalEnv, ShutdownManager } from '@travetto/base';
-import { RootIndex, path } from '@travetto/manifest';
+import { spawn } from 'node:child_process';
+
+import { Env, ExecUtil, ShutdownManager } from '@travetto/base';
+import { RuntimeContext } from '@travetto/manifest';
 
 import { CliCommandShape, CliCommandShapeFields, RunResponse } from './types';
-import { CliCommandRegistry } from './registry';
 
-export class CliUtil {
-  /**
-   * Are we running from a mono-root?
-   */
-  static get monoRoot(): boolean {
-    return !!RootIndex.manifest.monoRepo && RootIndex.mainModule.sourcePath === RootIndex.manifest.workspacePath;
-  }
+const IPC_ALLOWED_ENV = new Set(['NODE_OPTIONS']);
+const IPC_INVALID_ENV = new Set(['PS1', 'INIT_CWD', 'COLOR', 'LANGUAGE', 'PROFILEHOME', '_']);
+const validEnv = (k: string): boolean => IPC_ALLOWED_ENV.has(k) || (!IPC_INVALID_ENV.has(k) && !/^(npm_|GTK|GDK|TRV|NODE|GIT|TERM_)/.test(k) && !/VSCODE/.test(k));
 
+export class CliUtil {
   /**
    * Get a simplified version of a module name
    * @returns
    */
   static getSimpleModuleName(placeholder: string, module?: string): string {
-    const simple = (module ?? RootIndex.mainModuleName).replace(/[\/]/, '_').replace(/@/, '');
+    const simple = (module ?? RuntimeContext.main.name).replace(/[\/]/, '_').replace(/@/, '');
     if (!simple) {
       return placeholder;
-    } else if (!module && this.monoRoot) {
+    } else if (!module && RuntimeContext.monoRoot) {
       return placeholder;
     } else {
       return placeholder.replace('<module>', simple);
@@ -31,57 +29,47 @@ export class CliUtil {
    * Run a command as restartable, linking into self
    */
   static runWithRestart<T extends CliCommandShapeFields & CliCommandShape>(cmd: T): Promise<unknown> | undefined {
-    const canRestart = cmd.canRestart ??= GlobalEnv.devMode;
-
-    if (canRestart === false || Env.isFalse('TRV_CAN_RESTART')) {
-      delete process.env.TRV_CAN_RESTART;
+    if (Env.TRV_CAN_RESTART.isFalse || !(cmd.canRestart ?? !Env.production)) {
+      Env.TRV_CAN_RESTART.clear();
       return;
     }
-    return ExecUtil.spawnWithRestart(process.argv0, process.argv.slice(1), {
-      env: { TRV_DYNAMIC: '1', TRV_CAN_RESTART: '0' },
+    return ExecUtil.withRestart(() => spawn(process.argv0, process.argv.slice(1), {
+      env: {
+        ...process.env,
+        ...Env.TRV_CAN_RESTART.export(false)
+      },
       stdio: [0, 1, 2, 'ipc']
-    });
+    }));
   }
 
   /**
    * Dispatch IPC payload
    */
   static async triggerIpc<T extends CliCommandShape>(action: 'run', cmd: T): Promise<boolean> {
-    const ipcUrl = process.env.TRV_CLI_IPC;
-
-    if (!ipcUrl) {
+    if (!Env.TRV_CLI_IPC.isSet) {
       return false;
     }
 
-    const info = await fetch(ipcUrl).catch(() => ({ ok: false }));
+    const info = await fetch(Env.TRV_CLI_IPC.val!).catch(() => ({ ok: false }));
 
     if (!info.ok) { // Server not running
       return false;
     }
 
-    const cfg = CliCommandRegistry.getConfig(cmd);
+    const env: Record<string, string> = {};
     const req = {
       type: `@travetto/cli:${action}`,
       data: {
-        name: cfg.name,
-        commandModule: cfg.commandModule,
-        module: RootIndex.manifest.mainModule,
+        name: cmd._cfg!.name, env,
+        commandModule: cmd._cfg!.commandModule,
+        module: RuntimeContext.main.name,
         args: process.argv.slice(3),
       }
     };
-
     console.log('Triggering IPC request', req);
 
-    const defaultEnvKeys = new Set(['PS1', 'INIT_CWD', 'COLOR', 'LANGUAGE', 'PROFILEHOME', '_']);
-    const env = Object.fromEntries(
-      Object.entries(process.env).filter(([k]) =>
-        !defaultEnvKeys.has(k) && !/^(npm_|GTK|GDK|TRV|NODE|GIT|TERM_)/.test(k) && !/VSCODE/.test(k)
-      )
-    );
-
-    Object.assign(req.data, { env });
-
-    const sent = await fetch(ipcUrl, { method: 'POST', body: JSON.stringify(req) });
+    Object.entries(process.env).forEach(([k, v]) => validEnv(k) && (env[k] = v!));
+    const sent = await fetch(Env.TRV_CLI_IPC.val!, { method: 'POST', body: JSON.stringify(req) });
     return sent.ok;
   }
 
@@ -89,8 +77,7 @@ export class CliUtil {
    * Debug if IPC available
    */
   static async debugIfIpc<T extends CliCommandShapeFields & CliCommandShape>(cmd: T): Promise<boolean> {
-    const canDebug = cmd.debugIpc ??= GlobalEnv.devMode;
-    return canDebug !== false && this.triggerIpc('run', cmd);
+    return (cmd.debugIpc ?? !Env.production) && this.triggerIpc('run', cmd);
   }
 
   /**
@@ -107,7 +94,7 @@ export class CliUtil {
     // Listen to result if non-empty
     if (result !== undefined && result !== null) {
       if ('close' in result) {
-        ShutdownManager.onShutdown(result, result); // Tie shutdown into app close
+        ShutdownManager.onGracefulShutdown(async () => result.close()); // Tie shutdown into app close
       }
       if ('wait' in result) {
         await result.wait(); // Wait for close signal

package/support/cli.cli_schema.ts

@@ -1,5 +1,7 @@
+import { Env } from '@travetto/base';
+
 import { CliCommand } from '../src/decorators';
-import { CliCommandSchema, CliValidationError } from '../src/types';
+import { CliCommandSchema, CliCommandShape, CliValidationError } from '../src/types';
 import { CliCommandRegistry } from '../src/registry';
 import { CliCommandSchemaUtil } from '../src/schema';
 import { CliUtil } from '../src/util';
@@ -8,7 +10,7 @@ import { CliUtil } from '../src/util';
  * Generates the schema for all CLI operations
  */
 @CliCommand({ hidden: true })
-export class CliSchemaCommand {
+export class CliSchemaCommand implements CliCommandShape {
 
   async #getSchema(name: string): Promise<CliCommandSchema> {
     const inst = await CliCommandRegistry.getInstance(name);
@@ -24,6 +26,10 @@ export class CliSchemaCommand {
     }
   }
 
+  preMain(): void {
+    Env.DEBUG.set(false);
+  }
+
   async main(name?: string): Promise<void> {
     let output: unknown = undefined;
     if (name) {

package/support/cli.main.ts

@@ -1,8 +1,7 @@
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
 
-import { ShutdownManager } from '@travetto/base';
 import { CliCommandShape, CliCommand, CliValidationError, ParsedState } from '@travetto/cli';
-import { path, RootIndex } from '@travetto/manifest';
+import { path, RuntimeIndex, RuntimeContext } from '@travetto/manifest';
 import { Ignore } from '@travetto/schema';
 
 /**
@@ -18,10 +17,10 @@ export class MainCommand implements CliCommandShape {
     // If referenced file exists
     let file = fileOrImport;
     if (await (fs.stat(path.resolve(fileOrImport)).then(() => true, () => false))) {
-      file = path.join(RootIndex.manifest.mainModule, fileOrImport);
+      file = path.join(RuntimeContext.main.name, fileOrImport);
     }
 
-    return RootIndex.getFromImport(file)?.import;
+    return RuntimeIndex.getFromImport(file)?.import;
   }
 
   async validate(fileOrImport: string): Promise<CliValidationError | undefined> {
@@ -32,13 +31,20 @@ export class MainCommand implements CliCommandShape {
   }
 
   async main(fileOrImport: string, args: string[] = []): Promise<void> {
+    let res: unknown;
     try {
       const imp = await this.#getImport(fileOrImport);
       const mod = await import(imp!);
-
-      await ShutdownManager.exitWithResponse(await mod.main(...args, ...this._parsed.unknown));
+      res = await mod.main(...args, ...this._parsed.unknown);
     } catch (err) {
-      await ShutdownManager.exitWithResponse(err, true);
+      res = err;
+      process.exitCode = Math.max(process.exitCode ?? 1, 1);
+    }
+
+    if (res !== undefined) {
+      if (process.connected) { process.send?.(res); }
+      const payload = typeof res === 'string' ? res : (res instanceof Error ? res.stack : JSON.stringify(res));
+      process[process.exitCode ? 'stderr' : 'stdout'].write(`${payload}\n`);
     }
   }
 }

package/support/entry.trv.ts

@@ -1,14 +1,2 @@
-import path from 'path';
-
-async function entry(): Promise<void> {
-  const { init, cleanup } = await import('@travetto/base/support/init.js');
-  await init();
-  try {
-    const { ExecutionManager } = await import('@travetto/cli/src/execute.js');
-    await ExecutionManager.run(process.argv);
-  } finally {
-    await cleanup();
-  }
-}
-
-entry().then(() => path);
+import { ExecutionManager } from '@travetto/cli';
+ExecutionManager.run(process.argv);