@travetto/cli 3.4.9 → 4.0.0-rc.0

package/README.md

@@ -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#L104) `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#L36) 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

@@ -1,4 +1,5 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --disable-proto=delete --enable-source-maps
+process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps --disable-proto=delete`;
 
 // @ts-check
 import { getEntry } from '@travetto/compiler/bin/common.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/cli",
-  "version": "3.4.9",
+  "version": "4.0.0-rc.0",
   "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.0",
+    "@travetto/terminal": "^4.0.0-rc.0"
   },
   "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,5 +1,5 @@
-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';
@@ -15,7 +15,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,9 +25,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) => {
-        if (addEnv && 'env' in cmd && typeof cmd.env === 'string') {
-          defineEnv({ envName: cmd.env });
+      runTarget: cfg.runTarget,
+      preMain: async (cmd: CliCommandShape & { env?: string }) => {
+        if (addEnv) {
+          Env.TRV_ENV.set(cmd.env || Env.name);
         }
       }
     });
@@ -36,17 +37,17 @@ 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 }
       });
     }
@@ -55,12 +56,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,52 +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;
       }
     }
   }
@@ -69,27 +65,30 @@ export class ExecutionManager {
    * @param args
    */
   static async run(argv: string[]): Promise<void> {
-    await GlobalTerminal.init();
-
-    let command: CliCommandShape | undefined;
     try {
-      const { cmd, args, help } = await CliParseUtil.getArgs(argv);
+      const { cmd, args, help } = CliParseUtil.getArgs(argv);
 
       if (!cmd) {
         console.info!(await HelpUtil.renderAllHelp());
         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,11 +1,12 @@
 import { Primitive } from '@travetto/base';
-import { stripAnsiCodes } from '@travetto/terminal';
+import { StyleUtil } from '@travetto/terminal';
 
 import { cliTpl } from './color';
 import { CliCommandShape } from './types';
 import { CliCommandRegistry } from './registry';
 import { CliCommandSchemaUtil } from './schema';
 import { CliValidationResultError } from './error';
+import { isBoolFlag } from './parse';
 
 const validationSourceMap = {
   custom: '',
@@ -32,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}]` }}`);
     }
@@ -44,10 +45,10 @@ 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 (flag.type === 'boolean' && !flag.array) {
+      if (isBoolFlag(flag)) {
         if (flagVal === true) {
           aliases = (flag.flagNames ?? []).filter(x => !/^[-][^-]/.test(x));
         } else {
@@ -55,7 +56,7 @@ export class HelpUtil {
         }
       }
       const param = [cliTpl`${{ param: aliases.join(', ') }}`];
-      if (!(flag.type === 'boolean' && !flag.array)) {
+      if (!isBoolFlag(flag)) {
         const type = flag.type === 'string' && flag.choices && flag.choices.length <= 3 ? flag.choices?.join('|') : flag.type;
         param.push(cliTpl`${{ type: `<${type}>` }}`);
       }
@@ -68,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);
@@ -97,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.getLocalModules();
     }
 
     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)) {
           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];
@@ -12,22 +12,8 @@ const LONG_FLAG_WITH_EQ = /^--[a-z][^= ]+=\S+/i;
 const CONFIG_PRE = '+=';
 const ENV_PRE = 'env.';
 const SPACE = new Set([32, 7, 13, 10]);
-const MODULE_FLAG = '--module';
-const MODULE_SHORT = '-m';
-
-const getModuleValue = (arr: string[]): string => {
-  for (let i = 0; i < arr.length; i += 1) {
-    const x = arr[i];
-    if (x.startsWith(`${MODULE_FLAG}=`)) {
-      return x.split('=')[1];
-    } else if (!x.startsWith('-') && (arr[i - 1] === MODULE_SHORT || arr[i - 1] === MODULE_FLAG)) {
-      return x;
-    }
-  }
-  return process.env.TRV_MODULE || RootIndex.mainModuleName;
-};
 
-const isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
+export const isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
 
 const getInput = (cfg: { field?: CliCommandInput, rawText?: string, input: string, index?: number, value?: string }): ParsedInput => {
   const { field, input, rawText = input, value, index } = cfg;
@@ -46,6 +32,7 @@ const getInput = (cfg: { field?: CliCommandInput, rawText?: string, input: strin
   }
 };
 
+
 /**
  * Parsing support for the cli
  */
@@ -98,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`);
         }
@@ -130,7 +117,7 @@ export class CliParseUtil {
    * Parse args to extract command from argv along with other params.  Will skip
    * argv[0] and argv[1] if equal to process.argv[0:2]
    */
-  static async getArgs(argv: string[]): Promise<{ cmd?: string, args: string[], help?: boolean }> {
+  static getArgs(argv: string[]): { cmd?: string, args: string[], help?: boolean } {
     let offset = 0;
     if (argv[0] === process.argv[0] && argv[1] === process.argv[1]) {
       offset = 2;
@@ -138,22 +125,31 @@ export class CliParseUtil {
     const out = argv.slice(offset);
     const max = out.includes(RAW_SEP) ? out.indexOf(RAW_SEP) : out.length;
     const valid = out.slice(0, max);
-    const mod = getModuleValue(valid);
     const cmd = valid.length > 0 && !valid[0].startsWith('-') ? valid[0] : undefined;
     const helpIdx = valid.findIndex(x => HELP_FLAG.test(x));
-    const args = [];
-    for (const item of out.slice(cmd ? 1 : 0)) {
-      if (item.startsWith(CONFIG_PRE)) {
-        args.push(...await this.readFlagFile(item, mod));
-      } else {
-        args.push(item);
-      }
-    }
-    args.push(...out.slice(max));
+    const args = out.slice(cmd ? 1 : 0);
     const res = { cmd, args, help: helpIdx >= 0 };
     return res;
   }
 
+  /**
+   * Expand flag arguments into full argument list
+   */
+  static async expandArgs(schema: CliCommandSchema, args: string[]): Promise<string[]> {
+    const SEP = args.includes(RAW_SEP) ? args.indexOf(RAW_SEP) : args.length;
+    const input = schema.flags.find(x => x.type === 'module');
+    const ENV_KEY = input?.flagNames?.filter(x => x.startsWith(ENV_PRE)).map(x => x.replace(ENV_PRE, ''))[0] ?? '';
+    const flags = new Set(input?.flagNames ?? []);
+    const check = (k?: string, v?: string): string | undefined => flags.has(k!) ? v : undefined;
+    const mod = args.reduce(
+      (m, x, i, arr) =>
+        (i < SEP ? check(arr[i - 1], x) ?? check(...x.split('=')) : undefined) ?? m,
+      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();
+  }
+
   /**
    * Parse inputs to command
    */

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,36 +1,46 @@
-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';
-import { CliCommandInput, CliCommandSchema, CliCommandShape } from './types';
+import { ParsedState, CliCommandInput, CliCommandSchema, CliCommandShape } from './types';
 import { CliValidationResultError } from './error';
-import { ParsedState } from './parse';
 
 const LONG_FLAG = /^--[a-z][^= ]+/i;
 const SHORT_FLAG = /^-[a-z]/i;
 
 const isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
 
-function fieldToInput(x: FieldConfig): CliCommandInput {
-  const type = x.type === Date ? 'date' :
-    x.type === Boolean ? 'boolean' :
-      x.type === String ? (x.specifiers?.includes('file') ? 'file' : 'string') :
-        x.type === Number ? 'number' :
-          x.type === RegExp ? 'regex' : 'string';
-  return ({
-    name: x.name,
-    description: x.description,
-    array: x.array,
-    required: x.required?.active,
-    choices: x.enum?.values,
-    fileExtensions: type === 'file' ? x.specifiers?.filter(s => s.startsWith('ext:')).map(s => s.split('ext:')[1]) : undefined,
-    type,
-    default: Array.isArray(x.default) ? x.default.slice(0) : x.default,
-    flagNames: (x.aliases ?? []).slice(0).filter(v => !v.startsWith('env.')),
-    envVars: (x.aliases ?? []).slice(0).filter(v => v.startsWith('env.')).map(v => v.replace('env.', ''))
-  });
+function baseType(x: FieldConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
+  switch (x.type) {
+    case Date: return { type: 'date' };
+    case Boolean: return { type: 'boolean' };
+    case Number: return { type: 'number' };
+    case RegExp: return { type: 'regex' };
+    case String: {
+      switch (true) {
+        case x.specifiers?.includes('module'): return { type: 'module' };
+        case x.specifiers?.includes('file'): return {
+          type: 'file',
+          fileExtensions: x.specifiers?.map(s => s.split('ext:')[1]).filter(s => !!s)
+        };
+      }
+    }
+  }
+  return { type: 'string' };
 }
 
+const fieldToInput = (x: FieldConfig): CliCommandInput => ({
+  ...baseType(x),
+  name: x.name,
+  description: x.description,
+  array: x.array,
+  required: x.required?.active,
+  choices: x.enum?.values,
+  default: Array.isArray(x.default) ? x.default.slice(0) : x.default,
+  flagNames: (x.aliases ?? []).slice(0).filter(v => !v.startsWith('env.')),
+  envVars: (x.aliases ?? []).slice(0).filter(v => v.startsWith('env.')).map(v => v.replace('env.', ''))
+});
+
 /**
  * Allows binding describing/binding inputs for commands
  */
@@ -49,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,7 @@
-import fs from 'fs/promises';
+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 {
   /**
@@ -23,7 +23,7 @@ export class CliScmUtil {
       await ExecUtil.spawn('git', ['config', 'user.email']).result,
     ]);
     return {
-      name: (name.valid ? name.stdout.trim() : '') || Env.get('USER'),
+      name: (name.valid ? name.stdout.trim() : '') || process.env.USER,
       email: email.stdout.trim()
     };
   }
@@ -33,8 +33,7 @@ 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 });
+    const { result } = ExecUtil.spawn('git', ['log', '--pretty=oneline'], { cwd: RuntimeContext.workspace.path });
     return (await result).stdout
       .split(/\n/)
       .find(x => /Publish /.test(x))?.split(/\s+/)?.[0];
@@ -46,11 +45,11 @@ export class CliScmUtil {
    * @returns
    */
   static async findChangedFiles(fromHash: string, toHash: string = 'HEAD'): Promise<string[]> {
-    const ws = RootIndex.manifest.workspacePath;
+    const ws = RuntimeContext.workspace.path;
     const res = await ExecUtil.spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: ws }).result;
     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 +66,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)]

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
    */
@@ -100,7 +119,7 @@ export type CliCommandShapeFields = {
 export type CliCommandInput = {
   name: string;
   description?: string;
-  type: 'string' | 'file' | 'number' | 'boolean' | 'date' | 'regex';
+  type: 'string' | 'file' | 'number' | 'boolean' | 'date' | 'regex' | 'module';
   fileExtensions?: string[];
   choices?: unknown[];
   required?: boolean;

package/src/util.ts

@@ -1,15 +1,18 @@
-import { Env, ExecUtil, GlobalEnv, ShutdownManager } from '@travetto/base';
-import { RootIndex, path } from '@travetto/manifest';
+import { Env, ExecUtil, ShutdownManager } from '@travetto/base';
+import { RuntimeIndex, RuntimeContext } from '@travetto/manifest';
 
 import { CliCommandShape, CliCommandShapeFields, RunResponse } from './types';
-import { CliCommandRegistry } from './registry';
+
+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 {
   /**
    * Are we running from a mono-root?
    */
   static get monoRoot(): boolean {
-    return !!RootIndex.manifest.monoRepo && RootIndex.mainModule.sourcePath === RootIndex.manifest.workspacePath;
+    return !!RuntimeContext.workspace.mono && RuntimeIndex.mainModule.sourcePath === RuntimeContext.workspace.path;
   }
 
   /**
@@ -17,7 +20,7 @@ export class CliUtil {
    * @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) {
@@ -31,14 +34,15 @@ 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' },
+      env: {
+        ...Env.TRV_DYNAMIC.export(true),
+        ...Env.TRV_CAN_RESTART.export(false)
+      },
       stdio: [0, 1, 2, 'ipc']
     });
   }
@@ -47,41 +51,30 @@ export class CliUtil {
    * 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 +82,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 +99,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,8 @@
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
 
-import { ShutdownManager } from '@travetto/base';
+import { ExecUtil } 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 +18,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> {
@@ -36,9 +36,9 @@ export class MainCommand implements CliCommandShape {
       const imp = await this.#getImport(fileOrImport);
       const mod = await import(imp!);
 
-      await ShutdownManager.exitWithResponse(await mod.main(...args, ...this._parsed.unknown));
+      ExecUtil.sendResponse(await mod.main(...args, ...this._parsed.unknown));
     } catch (err) {
-      await ShutdownManager.exitWithResponse(err, true);
+      ExecUtil.sendResponse(err, true);
     }
   }
 }

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);