@travetto/cli 3.4.10 → 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.10",
+  "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,10 +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) => {
+      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,16 +37,15 @@ 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 }
@@ -57,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,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.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];
@@ -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,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
    */

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