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

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';
 
@@ -7,7 +7,7 @@ import { CliUnknownCommandError } from '../error.ts';
 import { CliCommandRegistryAdapter } from './registry-adapter.ts';
 
 const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
-const getName = (s: string): string => (s.match(CLI_FILE_REGEX)?.groups?.name ?? s).replaceAll('_', ':');
+const getName = (field: string): string => (field.match(CLI_FILE_REGEX)?.groups?.name ?? field).replaceAll('_', ':');
 
 type CliCommandLoadResult = { command: string, config: CliCommandConfig, instance: CliCommandShape, schema: SchemaClassConfig };
 
@@ -32,29 +32,26 @@ export class CliCommandRegistryIndex implements RegistryIndex {
 
   store = new RegistryIndexStore(CliCommandRegistryAdapter);
 
+  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+
   /**
    * Get list of all commands available
    */
   get #commandMapping(): Map<string, string> {
     if (!this.#fileMapping) {
       const all = new Map<string, string>();
-      for (const e of RuntimeIndex.find({
-        module: m => !Runtime.production || m.prod,
-        folder: f => f === 'support',
-        file: f => f.role === 'std' && CLI_FILE_REGEX.test(f.sourceFile)
+      for (const entry of RuntimeIndex.find({
+        module: mod => !Runtime.production || mod.prod,
+        folder: folder => folder === 'support',
+        file: file => file.role === 'std' && CLI_FILE_REGEX.test(file.sourceFile)
       })) {
-        all.set(getName(e.sourceFile), e.import);
+        all.set(getName(entry.sourceFile), entry.import);
       }
       this.#fileMapping = all;
     }
     return this.#fileMapping;
   }
 
-
-  process(): void {
-    // Do nothing for now?
-  }
-
   /**
    * Import command into an instance
    */
@@ -70,32 +67,32 @@ 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((v): v is Class => typeof v === 'function')
-      .reduce<Class[]>((acc, v) => {
-        const parent = getParentClass(v);
-        if (parent && !acc.includes(parent)) {
-          acc.push(parent);
+      .filter(isClass)
+      .reduce<Class[]>((classes, cls) => {
+        const parent = getParentClass(cls);
+        if (parent && !classes.includes(parent)) {
+          classes.push(parent);
         }
-        acc.push(v);
-        return acc;
+        classes.push(cls);
+        return classes;
       }, []);
 
     const uninitialized = filtered
-      .filter(v => !this.store.finalized(v));
+      .filter(cls => !this.store.finalized(cls));
 
 
     // Initialize any uninitialized commands
     if (uninitialized.length) {
       // Ensure processed
-      Registry.process(uninitialized.map(v => ({ type: 'added', curr: v })));
+      Registry.process(uninitialized);
     }
 
-    for (const v of values) {
-      const cfg = this.store.get(v);
-      if (!cfg) {
+    for (const cls of values) {
+      const config = this.store.get(cls);
+      if (!config) {
         continue;
       }
-      const result = cfg.getInstance();
+      const result = config.getInstance();
       if (result.isActive !== undefined && !result.isActive()) {
         continue;
       }
@@ -112,11 +109,11 @@ export class CliCommandRegistryIndex implements RegistryIndex {
   async load(names?: string[]): Promise<CliCommandLoadResult[]> {
     const keys = names ?? [...this.#commandMapping.keys()];
 
-    const list = await Promise.all(keys.map(async x => {
-      const instance = await this.#getInstance(x);
+    const list = await Promise.all(keys.map(async key => {
+      const instance = await this.#getInstance(key);
       const config = this.store.get(getClass(instance)).get();
       const schema = SchemaRegistryIndex.getConfig(getClass(instance));
-      return { command: x, instance, config, schema };
+      return { command: key, instance, config, schema };
     }));
 
     return list.sort((a, b) => a.command.localeCompare(b.command));

package/src/schema-export.ts

@@ -35,20 +35,20 @@ export interface CliCommandSchema<K extends string = string> {
 export class CliSchemaExportUtil {
 
   /**
-    * Get the base type for a CLI command input
-    */
-  static baseInputType(x: SchemaInputConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
-    switch (x.type) {
+   * 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' };
       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 {
+          case config.specifiers?.includes('module'): return { type: 'module' };
+          case config.specifiers?.includes('file'): return {
             type: 'file',
-            fileExtensions: x.specifiers?.map(s => s.split('ext:')[1]).filter(s => !!s)
+            fileExtensions: config.specifiers?.map(specifier => specifier.split('ext:')[1]).filter(specifier => !!specifier)
           };
         }
       }
@@ -59,30 +59,30 @@ export class CliSchemaExportUtil {
   /**
    * Process input configuration for CLI commands
    */
-  static processInput(x: SchemaInputConfig): CliCommandInput {
+  static processInput(config: SchemaInputConfig): CliCommandInput {
     return {
-      ...this.baseInputType(x),
-      ...(('name' in x && typeof x.name === 'string') ? { name: x.name } : { name: '' }),
-      description: x.description,
-      array: x.array,
-      required: x.required?.active !== false,
-      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.', ''))
+      ...this.baseInputType(config),
+      ...(('name' in config && typeof config.name === 'string') ? { name: config.name } : { name: '' }),
+      description: config.description,
+      array: config.array,
+      required: config.required?.active !== false,
+      choices: config.enum?.values,
+      default: Array.isArray(config.default) ? config.default.slice(0) : config.default,
+      flagNames: (config.aliases ?? []).slice(0).filter(value => !value.startsWith('env.')),
+      envVars: (config.aliases ?? []).slice(0).filter(value => value.startsWith('env.')).map(value => value.replace('env.', ''))
     };
   }
 
   static exportSchema(cls: Class): CliCommandSchema {
     const schema = SchemaRegistryIndex.getConfig(cls);
     const config = CliCommandRegistryIndex.get(cls);
-    const processed = Object.values(schema.fields).map(v => this.processInput(v));
+    const processed = Object.values(schema.fields).map(value => this.processInput(value));
     return {
       name: config.name,
       module: describeFunction(config.cls).module,
       description: schema.description,
-      flags: processed.filter(v => v.flagNames && v.flagNames.length > 0),
-      args: processed.filter(v => !v.flagNames || v.flagNames.length === 0),
+      flags: processed.filter(value => value.flagNames && value.flagNames.length > 0),
+      args: processed.filter(value => !value.flagNames || value.flagNames.length === 0),
       runTarget: config.runTarget ?? false,
       commandModule: describeFunction(cls).module,
     };

package/src/schema.ts

@@ -57,29 +57,29 @@ export class CliCommandSchemaUtil {
    */
   static async validate(cmd: CliCommandShape, args: unknown[]): Promise<typeof cmd> {
     const cls = getClass(cmd);
-    const paramNames = SchemaRegistryIndex.get(cls).getMethod('main').parameters.map(x => x.name!);
+    const paramNames = SchemaRegistryIndex.get(cls).getMethod('main').parameters.map(config => config.name!);
 
     const validators = [
       (): Promise<void> => SchemaValidator.validate(cls, cmd).then(() => { }),
       (): Promise<void> => SchemaValidator.validateMethod(cls, 'main', args, paramNames),
       async (): Promise<void> => {
-        const res = await cmd.validate?.(...args);
-        if (res) {
-          throw new CliValidationResultError(cmd, Array.isArray(res) ? res : [res]);
+        const result = await cmd.validate?.(...args);
+        if (result) {
+          throw new CliValidationResultError(cmd, Array.isArray(result) ? result : [result]);
         }
       },
     ];
 
     const SOURCES = ['flag', 'arg', 'custom'] as const;
 
-    const results = validators.map((x, i) => x().catch(err => {
-      if (!(err instanceof CliValidationResultError) && !(err instanceof ValidationResultError)) {
-        throw err;
+    const results = validators.map((validator, i) => validator().catch(error => {
+      if (!(error instanceof CliValidationResultError) && !(error instanceof ValidationResultError)) {
+        throw error;
       }
-      return err.details.errors.map(v => ({ ...v, source: getSource(v.source, SOURCES[i]) }));
+      return error.details.errors.map(value => ({ ...value, source: getSource(value.source, SOURCES[i]) }));
     }));
 
-    const errors = (await Promise.all(results)).flatMap(x => (x ?? []));
+    const errors = (await Promise.all(results)).flatMap(result => (result ?? []));
     if (errors.length) {
       throw new CliValidationResultError(cmd, errors);
     }

package/src/scm.ts

@@ -38,7 +38,7 @@ export class CliScmUtil {
     const result = await ExecUtil.getResult(spawn('git', ['log', '--pretty=oneline'], { cwd: Runtime.workspace.path }));
     return result.stdout
       .split(/\n/)
-      .find(x => /Publish /.test(x))?.split(/\s+/)?.[0];
+      .find(line => /Publish /.test(line))?.split(/\s+/)?.[0];
   }
 
   /**
@@ -47,14 +47,14 @@ export class CliScmUtil {
    * @returns
    */
   static async findChangedFiles(fromHash: string, toHash: string = 'HEAD'): Promise<string[]> {
-    const ws = Runtime.workspace.path;
-    const result = await ExecUtil.getResult(spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: ws }), { catch: true });
+    const rootPath = Runtime.workspace.path;
+    const result = await ExecUtil.getResult(spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: rootPath }), { catch: true });
     if (!result.valid) {
       throw new AppError('Unable to detect changes between', { category: 'data', details: { fromHash, toHash, output: (result.stderr || result.stdout) } });
     }
     const out = new Set<string>();
     for (const line of result.stdout.split(/\n/g)) {
-      const entry = RuntimeIndex.getEntry(path.resolve(ws, line));
+      const entry = RuntimeIndex.getEntry(path.resolve(rootPath, line));
       if (entry) {
         out.add(entry.sourceFile);
       }
@@ -71,10 +71,10 @@ export class CliScmUtil {
   static async findChangedModules(fromHash: string, toHash?: string): Promise<IndexedModule[]> {
     const files = await this.findChangedFiles(fromHash, toHash);
     const mods = files
-      .map(x => RuntimeIndex.getFromSource(x))
-      .filter(x => !!x)
-      .map(x => RuntimeIndex.getModule(x.module))
-      .filter(x => !!x);
+      .map(file => RuntimeIndex.getFromSource(file))
+      .filter(file => !!file)
+      .map(file => RuntimeIndex.getModule(file.module))
+      .filter(mod => !!mod);
 
     return [...new Set(mods)]
       .toSorted((a, b) => a.name.localeCompare(b.name));
@@ -84,7 +84,7 @@ export class CliScmUtil {
    * Create a commit
    */
   static createCommit(message: string): Promise<string> {
-    return ExecUtil.getResult(spawn('git', ['commit', '.', '-m', message])).then(r => r.stdout);
+    return ExecUtil.getResult(spawn('git', ['commit', '.', '-m', message])).then(result => result.stdout);
   }
 
   /**
@@ -92,7 +92,7 @@ export class CliScmUtil {
    */
   static createTag(version: string): Promise<string> {
     version = version.replace(/[^0-9a-z_\-.]/g, '');
-    return ExecUtil.getResult(spawn('git', ['tag', '-a', `${version}`, '-m', `Release ${version}`])).then(r => r.stdout);
+    return ExecUtil.getResult(spawn('git', ['tag', '-a', `${version}`, '-m', `Release ${version}`])).then(result => result.stdout);
   }
 
   /**

package/src/service.ts

@@ -5,11 +5,11 @@ import net from 'node:net';
 
 import { ExecUtil, TimeUtil, Util } from '@travetto/runtime';
 
-const ports = (val: number | `${number}:${number}`): [number, number] =>
-  typeof val === 'number' ?
-    [val, val] :
+const ports = (value: number | `${number}:${number}`): [number, number] =>
+  typeof value === 'number' ?
+    [value, value] :
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    val.split(':').map(x => parseInt(x, 10)) as [number, number];
+    value.split(':').map(number => parseInt(number, 10)) as [number, number];
 
 type BodyCheck = (body: string) => boolean;
 
@@ -36,26 +36,26 @@ export type ServiceAction = 'start' | 'stop' | 'status' | 'restart';
  */
 export class ServiceRunner {
 
-  svc: ServiceDescriptor;
-  constructor(svc: ServiceDescriptor) { this.svc = svc; }
+  #descriptor: ServiceDescriptor;
+  constructor(descriptor: ServiceDescriptor) { this.#descriptor = descriptor; }
 
   async #isRunning(full = false): Promise<boolean> {
-    const port = ports(this.svc.port!)[0];
+    const port = ports(this.#descriptor.port!)[0];
     const start = Date.now();
-    const timeoutMs = TimeUtil.asMillis(full ? this.svc.startupTimeout ?? 5000 : 100);
+    const timeoutMs = TimeUtil.asMillis(full ? this.#descriptor.startupTimeout ?? 5000 : 100);
     while ((Date.now() - start) < timeoutMs) {
       try {
         const sock = net.createConnection(port, 'localhost');
-        await new Promise<void>((res, rej) =>
-          sock.on('connect', res).on('timeout', rej).on('error', rej)
+        await new Promise<void>((resolve, reject) =>
+          sock.on('connect', resolve).on('timeout', reject).on('error', reject)
         ).finally(() => sock.destroy());
 
-        if (!this.svc.ready?.url || !full) {
+        if (!this.#descriptor.ready?.url || !full) {
           return true;
         } else {
-          const response = await fetch(this.svc.ready.url, { method: 'GET' });
+          const response = await fetch(this.#descriptor.ready.url, { method: 'GET' });
           const text = await response.text();
-          if (response.ok && (this.svc.ready.test?.(text) ?? true)) {
+          if (response.ok && (this.#descriptor.ready.test?.(text) ?? true)) {
             return true;
           }
         }
@@ -68,14 +68,14 @@ export class ServiceRunner {
   }
 
   async #hasImage(): Promise<boolean> {
-    const result = await ExecUtil.getResult(spawn('docker', ['image', 'inspect', this.svc.image]), { catch: true });
+    const result = await ExecUtil.getResult(spawn('docker', ['image', 'inspect', this.#descriptor.image]), { catch: true });
     return result.valid;
   }
 
   async * #pullImage(): AsyncIterable<string> {
-    const proc = spawn('docker', ['pull', this.svc.image], { stdio: [0, 'pipe', 'pipe'] });
-    yield* rl.createInterface(proc.stdout!);
-    await ExecUtil.getResult(proc);
+    const subProcess = spawn('docker', ['pull', this.#descriptor.image], { stdio: [0, 'pipe', 'pipe'] });
+    yield* rl.createInterface(subProcess.stdout!);
+    await ExecUtil.getResult(subProcess);
   }
 
   async #startContainer(): Promise<string> {
@@ -83,16 +83,16 @@ export class ServiceRunner {
       'run',
       '--rm',
       '--detach',
-      ...this.svc.privileged ? ['--privileged'] : [],
-      '--label', `trv-${this.svc.name}`,
-      ...Object.entries(this.svc.env ?? {}).flatMap(([k, v]) => ['--env', `${k}=${v}`]),
-      ...this.svc.port ? ['-p', ports(this.svc.port).join(':')] : [],
-      ...Object.entries(this.svc.volumes ?? {}).flatMap(([k, v]) => ['--volume', `${k}:${v}`]),
-      this.svc.image,
-      ...this.svc.args ?? [],
+      ...this.#descriptor.privileged ? ['--privileged'] : [],
+      '--label', `trv-${this.#descriptor.name}`,
+      ...Object.entries(this.#descriptor.env ?? {}).flatMap(([key, value]) => ['--env', `${key}=${value}`]),
+      ...this.#descriptor.port ? ['-p', ports(this.#descriptor.port).join(':')] : [],
+      ...Object.entries(this.#descriptor.volumes ?? {}).flatMap(([key, value]) => ['--volume', `${key}:${value}`]),
+      this.#descriptor.image,
+      ...this.#descriptor.args ?? [],
     ];
 
-    for (const item of Object.keys(this.svc.volumes ?? {})) {
+    for (const item of Object.keys(this.#descriptor.volumes ?? {})) {
       await fs.mkdir(item, { recursive: true });
     }
 
@@ -100,38 +100,38 @@ export class ServiceRunner {
   }
 
   async #getContainerId(): Promise<string | undefined> {
-    return (await ExecUtil.getResult(spawn('docker', ['ps', '-q', '--filter', `label=trv-${this.svc.name}`]))).stdout.trim();
+    return (await ExecUtil.getResult(spawn('docker', ['ps', '-q', '--filter', `label=trv-${this.#descriptor.name}`]))).stdout.trim();
   }
 
-  async #killContainer(cid: string): Promise<void> {
-    await ExecUtil.getResult(spawn('docker', ['kill', cid]));
+  async #killContainer(containerId: string): Promise<void> {
+    await ExecUtil.getResult(spawn('docker', ['kill', containerId]));
   }
 
-  async * action(op: ServiceAction): AsyncIterable<['success' | 'failure' | 'message', string]> {
+  async * action(operation: ServiceAction): AsyncIterable<['success' | 'failure' | 'message', string]> {
     try {
-      const cid = await this.#getContainerId();
-      const port = this.svc.port ? ports(this.svc.port)[0] : 0;
-      const running = !!cid && (!port || await this.#isRunning());
+      const containerId = await this.#getContainerId();
+      const port = this.#descriptor.port ? ports(this.#descriptor.port)[0] : 0;
+      const running = !!containerId && (!port || await this.#isRunning());
 
-      if (running && !cid) { // We don't own
-        return yield [op === 'status' ? 'message' : 'failure', 'Running but not managed'];
+      if (running && !containerId) { // We don't own
+        return yield [operation === 'status' ? 'message' : 'failure', 'Running but not managed'];
       }
 
-      if (op === 'status') {
-        return yield !cid ? ['message', 'Not running'] : ['success', `Running ${cid}`];
-      } else if (op === 'start' && running) {
+      if (operation === 'status') {
+        return yield !containerId ? ['message', 'Not running'] : ['success', `Running ${containerId}`];
+      } else if (operation === 'start' && running) {
         return yield ['message', 'Skipping, already running'];
-      } else if (op === 'stop' && !running) {
+      } else if (operation === 'stop' && !running) {
         return yield ['message', 'Skipping, already stopped'];
       }
 
-      if (running && (op === 'restart' || op === 'stop')) {
+      if (running && (operation === 'restart' || operation === 'stop')) {
         yield ['message', 'Stopping'];
-        await this.#killContainer(cid);
+        await this.#killContainer(containerId);
         yield ['success', 'Stopped'];
       }
 
-      if (op === 'restart' || op === 'start') {
+      if (operation === 'restart' || operation === 'start') {
         if (!await this.#hasImage()) {
           yield ['message', 'Starting image download'];
           for await (const line of await this.#pullImage()) {
@@ -144,7 +144,7 @@ export class ServiceRunner {
         const out = await this.#startContainer();
 
         if (port) {
-          yield ['message', `Waiting for ${this.svc.ready?.url ?? 'container'}...`];
+          yield ['message', `Waiting for ${this.#descriptor.ready?.url ?? 'container'}...`];
           if (!await this.#isRunning(true)) {
             yield ['failure', 'Failed to start service correctly'];
           }

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,12 +1,23 @@
-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 = (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));
+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 {
   /**
@@ -26,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();
   }
 
   /**
@@ -51,14 +109,14 @@ export class CliUtil {
       return false;
     }
 
-    const info = await fetch(Env.TRV_CLI_IPC.val!).catch(() => ({ ok: false }));
+    const info = await fetch(Env.TRV_CLI_IPC.value!).catch(() => ({ ok: false }));
 
     if (!info.ok) { // Server not running
       return false;
     }
 
     const env: Record<string, string> = {};
-    const req = {
+    const request = {
       type: `@travetto/cli:${action}`,
       data: {
         name: cmd._cfg!.name,
@@ -69,10 +127,10 @@ export class CliUtil {
         args: process.argv.slice(3),
       }
     };
-    console.log('Triggering IPC request', req);
+    console.log('Triggering IPC request', request);
 
-    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) });
+    Object.entries(process.env).forEach(([key, value]) => validEnv(key) && (env[key] = value!));
+    const sent = await fetch(Env.TRV_CLI_IPC.value!, { method: 'POST', body: JSON.stringify(request) });
     return sent.ok;
   }
 
@@ -80,13 +138,20 @@ 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);
   }
 
   /**
    * Write data to channel and ensure its flushed before continuing
    */
   static async writeAndEnsureComplete(data: unknown, channel: 'stdout' | 'stderr' = 'stdout'): Promise<void> {
-    return await new Promise(r => process[channel].write(typeof data === 'string' ? data : JSON.stringify(data, null, 2), () => r()));
+    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]));
   }
 }

package/support/cli.cli_schema.ts

@@ -20,7 +20,7 @@ export class CliSchemaCommand implements CliCommandShape {
       return;
     }
     const resolved = await CliCommandRegistryIndex.load(names);
-    const invalid = names.find(x => !resolved.find(r => r.command === x));
+    const invalid = names.find(name => !resolved.find(result => result.command === name));
 
     if (invalid) {
       return {
@@ -38,7 +38,7 @@ export class CliSchemaCommand implements CliCommandShape {
     const resolved = await CliCommandRegistryIndex.load(names);
 
     const output = resolved
-      .map(x => CliSchemaExportUtil.exportSchema(x.config.cls));
+      .map(result => CliSchemaExportUtil.exportSchema(result.config.cls));
 
     await CliUtil.writeAndEnsureComplete(output);
   }

package/support/cli.main.ts

@@ -25,8 +25,8 @@ export class MainCommand implements CliCommandShape {
     try {
       const mod = await Runtime.importFrom<{ main(..._: unknown[]): Promise<unknown> }>(fileOrImport);
       result = await mod.main(...args, ...this._parsed.unknown);
-    } catch (err) {
-      result = err;
+    } catch (error) {
+      result = error;
       process.exitCode = Math.max(process.exitCode ? +process.exitCode : 1, 1);
     }