@travetto/cli 7.0.0-rc.2 → 7.0.0-rc.3

package/README.md

@@ -472,7 +472,7 @@ import type { WebHttpServer } from '../src/types.ts';
 /**
  * Run a web server
  */
-@CliCommand({ runTarget: true, with: { debugIpc: true, canRestart: true, module: true, env: true } })
+@CliCommand({ runTarget: true, with: { debugIpc: true, restartForDev: true, module: true, env: true } })
 export class WebHttpCommand implements CliCommandShape {
 
   /** Port to run on */
@@ -502,7 +502,7 @@ export class WebHttpCommand 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 [Runtime](https://github.com/travetto/travetto/tree/main/module/runtime/src/context.ts#L12) `name` defined in the [Runtime](https://github.com/travetto/travetto/tree/main/module/runtime#readme "Runtime 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/runtime/src/context.ts#L13) `name` defined in the [Runtime](https://github.com/travetto/travetto/tree/main/module/runtime#readme "Runtime 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.
 

package/bin/trv.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 
+globalThis.__entry_point__ = __filename;
+
 // @ts-check
 require('@travetto/compiler/bin/entry.common.js')
   .load(operations => operations.exec('@travetto/cli/support/entry.trv.js'));

package/package.json

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

package/src/error.ts

@@ -21,7 +21,7 @@ const COMMAND_PACKAGE = [
 export class CliUnknownCommandError extends Error {
 
   #getMissingCommandHelp(cmd: string): string | undefined {
-    const matchedConfig = COMMAND_PACKAGE.find(([re]) => re.test(cmd));
+    const matchedConfig = COMMAND_PACKAGE.find(([regex]) => regex.test(cmd));
     if (matchedConfig) {
       const [, pkg, prod] = matchedConfig;
       const install = PackageUtil.getInstallCommand(Runtime, `@travetto/${pkg}`, prod);

package/src/registry/decorator.ts

@@ -19,8 +19,8 @@ type CliCommandConfigOptions = {
     module?: boolean;
     /** Should debug invocation trigger via ipc */
     debugIpc?: boolean;
-    /** Should the invocation automatically restart on exit */
-    canRestart?: boolean;
+    /** Should restart on code change */
+    restartForDev?: boolean;
   };
 };
 
@@ -53,7 +53,7 @@ const FIELD_CONFIG: {
     },
     {
       name: 'debugIpc',
-      run: cmd => CliUtil.debugIfIpc(cmd).then((flag) => flag && process.exit(0)),
+      run: cmd => CliUtil.debugIfIpc(cmd).then((executed) => executed && process.exit(0)),
       field: {
         type: Boolean,
         aliases: ['-di'],
@@ -63,13 +63,13 @@ const FIELD_CONFIG: {
       },
     },
     {
-      name: 'canRestart',
-      run: cmd => CliUtil.runWithRestart(cmd)?.then((flag) => flag && process.exit(0)),
+      name: 'restartForDev',
+      run: cmd => CliUtil.runWithRestartOnCodeChanges(cmd),
       field: {
         type: Boolean,
         aliases: ['-cr'],
-        description: 'Should the invocation automatically restart on exit',
-        default: false,
+        description: 'Should the invocation automatically restart on source changes',
+        default: Runtime.env === 'development',
         required: { active: false },
       },
     }

package/src/registry/registry-adapter.ts

@@ -27,7 +27,7 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
     (schema.fields ??= {}).help = {
       type: Boolean,
       name: 'help',
-      owner: this.#cls,
+      class: this.#cls,
       description: 'display help for command',
       required: { active: false },
       default: false,

package/src/registry/registry-index.ts

@@ -1,4 +1,4 @@
-import { Class, getClass, getParentClass, Runtime, RuntimeIndex } from '@travetto/runtime';
+import { Class, getClass, getParentClass, isClass, Runtime, RuntimeIndex } from '@travetto/runtime';
 import { RegistryAdapter, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
 import { SchemaClassConfig, SchemaRegistryIndex } from '@travetto/schema';
 
@@ -32,6 +32,8 @@ export class CliCommandRegistryIndex implements RegistryIndex {
 
   store = new RegistryIndexStore(CliCommandRegistryAdapter);
 
+  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+
   /**
    * Get list of all commands available
    */
@@ -50,11 +52,6 @@ export class CliCommandRegistryIndex implements RegistryIndex {
     return this.#fileMapping;
   }
 
-
-  process(): void {
-    // Do nothing for now?
-  }
-
   /**
    * Import command into an instance
    */
@@ -70,7 +67,7 @@ export class CliCommandRegistryIndex implements RegistryIndex {
     const found = this.#commandMapping.get(name)!;
     const values = Object.values(await Runtime.importFrom<Record<string, Class>>(found));
     const filtered = values
-      .filter((value): value is Class => typeof value === 'function')
+      .filter(isClass)
       .reduce<Class[]>((classes, cls) => {
         const parent = getParentClass(cls);
         if (parent && !classes.includes(parent)) {
@@ -87,7 +84,7 @@ export class CliCommandRegistryIndex implements RegistryIndex {
     // Initialize any uninitialized commands
     if (uninitialized.length) {
       // Ensure processed
-      Registry.process(uninitialized.map(cls => ({ type: 'added', current: cls })));
+      Registry.process(uninitialized);
     }
 
     for (const cls of values) {

package/src/schema-export.ts

@@ -35,8 +35,8 @@ export interface CliCommandSchema<K extends string = string> {
 export class CliSchemaExportUtil {
 
   /**
-    * Get the base type for a CLI command input
-    */
+   * Get the base type for a CLI command input
+   */
   static baseInputType(config: SchemaInputConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
     switch (config.type) {
       case Date: return { type: 'date' };

package/src/types.ts

@@ -88,9 +88,9 @@ export type CliCommandShapeFields = {
    */
   debugIpc?: boolean;
   /**
-   * Should the invocation run with auto-restart
+   * Should the invocation run with auto-restart on source changes
    */
-  canRestart?: boolean;
+  restartForDev?: boolean;
   /**
    * The module to run the command from
    */

package/src/util.ts

@@ -1,15 +1,24 @@
-import { spawn } from 'node:child_process';
+import { spawn, type ChildProcess } from 'node:child_process';
 
-import { describeFunction, Env, ExecUtil, Runtime } from '@travetto/runtime';
+import { describeFunction, Env, ExecUtil, Runtime, listenForSourceChanges, type ExecutionResult, ShutdownManager } from '@travetto/runtime';
 
 import { CliCommandShape, CliCommandShapeFields } from './types.ts';
 
+const CODE_RESTART = { type: 'code_change', code: 200 };
 const IPC_ALLOWED_ENV = new Set(['NODE_OPTIONS']);
 const IPC_INVALID_ENV = new Set(['PS1', 'INIT_CWD', 'COLOR', 'LANGUAGE', 'PROFILEHOME', '_']);
 const validEnv = (key: string): boolean => IPC_ALLOWED_ENV.has(key) || (
   !IPC_INVALID_ENV.has(key) && !/^(npm_|GTK|GDK|TRV|NODE|GIT|TERM_)/.test(key) && !/VSCODE/.test(key)
 );
 
+const isCodeRestart = (input: unknown): input is typeof CODE_RESTART =>
+  typeof input === 'object' && !!input && 'type' in input && input.type === CODE_RESTART.type;
+
+type RunWithRestartOptions = {
+  maxRetriesPerMinute?: number;
+  relayInterrupt?: boolean;
+};
+
 export class CliUtil {
   /**
    * Get a simplified version of a module name
@@ -28,21 +37,68 @@ export class CliUtil {
   /**
    * Run a command as restartable, linking into self
    */
-  static runWithRestart<T extends CliCommandShapeFields & CliCommandShape>(cmd: T, ipc?: boolean): Promise<unknown> | undefined {
-    if (ipc && process.connected) {
-      process.once('disconnect', () => process.exit());
+  static async runWithRestartOnCodeChanges<T extends CliCommandShapeFields & CliCommandShape>(cmd: T, config?: RunWithRestartOptions): Promise<boolean> {
+
+    if (Env.TRV_CAN_RESTART.isFalse || cmd.restartForDev !== true) {
+      process.on('message', event => isCodeRestart(event) && process.exit(event.code));
+      return false;
     }
-    if (Env.TRV_CAN_RESTART.isFalse || !(cmd.canRestart ?? !Runtime.production)) {
-      Env.TRV_CAN_RESTART.clear();
-      return;
+
+    let result: ExecutionResult | undefined;
+    let exhaustedRestarts = false;
+    let subProcess: ChildProcess | undefined;
+
+    const env = { ...process.env, ...Env.TRV_CAN_RESTART.export(false) };
+    const maxRetries = config?.maxRetriesPerMinute ?? 5;
+    const relayInterrupt = config?.relayInterrupt ?? true;
+    const restarts: number[] = [];
+    listenForSourceChanges(() => { subProcess?.send(CODE_RESTART); });
+
+    if (!relayInterrupt) {
+      process.removeAllListeners('SIGINT'); // Remove any existing listeners
+      process.on('SIGINT', () => { }); // Prevents SIGINT from killing parent process, the child will handle
     }
-    return ExecUtil.withRestart(() => spawn(process.argv0, process.argv.slice(1), {
-      env: {
-        ...process.env,
-        ...Env.TRV_CAN_RESTART.export(false)
-      },
-      stdio: [0, 1, 2, ipc ? 'ipc' : undefined]
-    }));
+
+    while (
+      (result === undefined || result.code === CODE_RESTART.code) &&
+      !exhaustedRestarts
+    ) {
+      if (restarts.length) {
+        console.error('Restarting...', { pid: process.pid, time: restarts[0] });
+      }
+
+      // Ensure restarts length is capped
+      subProcess = spawn(process.argv0, process.argv.slice(1), { env, stdio: [0, 1, 2, 'ipc'] })
+        .on('message', value => process.send?.(value));
+
+      const interrupt = (): void => { subProcess?.kill('SIGINT'); };
+      const toMessage = (value: unknown): void => { subProcess?.send(value!); };
+
+      // Proxy kill requests
+      process.on('message', toMessage);
+      if (relayInterrupt) {
+        process.on('SIGINT', interrupt);
+      }
+
+      result = await ExecUtil.getResult(subProcess, { catch: true });
+      process.exitCode = subProcess.exitCode;
+      process.off('message', toMessage);
+      process.off('SIGINT', interrupt);
+
+      if (restarts.length >= maxRetries) {
+        exhaustedRestarts = (Date.now() - restarts[0]) < (10 * 1000);
+        restarts.shift();
+      }
+      restarts.push(Date.now());
+    }
+
+
+    if (exhaustedRestarts) {
+      console.error(`Bailing, due to ${maxRetries} restarts in under 10s`);
+    }
+
+    await ShutdownManager.gracefulShutdown('cli-restart');
+    process.exit();
   }
 
   /**
@@ -82,7 +138,7 @@ export class CliUtil {
    * Debug if IPC available
    */
   static async debugIfIpc<T extends CliCommandShapeFields & CliCommandShape>(cmd: T): Promise<boolean> {
-    return (cmd.debugIpc ?? !Runtime.production) && this.triggerIpc('run', cmd);
+    return cmd.debugIpc === true && this.triggerIpc('run', cmd);
   }
 
   /**
@@ -91,4 +147,11 @@ export class CliUtil {
   static async writeAndEnsureComplete(data: unknown, channel: 'stdout' | 'stderr' = 'stdout'): Promise<void> {
     return await new Promise(resolve => process[channel].write(typeof data === 'string' ? data : JSON.stringify(data, null, 2), () => resolve()));
   }
+
+  /**
+   * Read extended options from cli inputs, in the form of -o key:value or -o key
+   */
+  static readExtendedOptions(options?: string[]): Record<string, string | boolean> {
+    return Object.fromEntries((options ?? [])?.map(option => [...option.split(':'), true]));
+  }
 }