@travetto/repo 8.0.0-alpha.2 → 8.0.0-alpha.21

package/README.md

@@ -19,22 +19,27 @@ The repo module aims to provide concise monorepo based tools.  The monorepo supp
    *  Listing local modules
    *  Running commands on all workspace modules
 
-## CLI - Version
+## CLI - repo:version
 The versioning operation will find all the changed modules (and the modules that depend on the changed), and will update the versions in accordance with the user preferences.  The versioning logic is backed by [Npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)/[Yarn](https://yarnpkg.com)'s versioning functionality and so it is identical to using the tool manually. The determination of what has or hasn't changed is relative to the last versioning commit.
 
-**Terminal: Version execution**
+**Terminal: Help for repo:version**
 ```bash
-$ trv repo:version -h
+$ trv repo:version --help
 
 Usage: repo:version [options] <level:major|minor|patch|premajor|preminor|prepatch|prerelease> [prefix:string]
 
+Bump workspace module versions and optionally commit/tag release metadata.
+
+Supports changed/all/direct module targeting and synchronizes dependency
+versions after the version bump operation completes.
+
 Options:
   --mode <all|changed|direct>  The mode for versioning
   -f, --force                  Force operation, even in a dirty workspace (default: false)
   --commit, --no-commit        Produce release commit message (default: true)
   -m, --modules <string>       The module when mode is single
   -t, --tag                    Should we create a tag for the version
-  -h, --help                   display help for command
+  --help                       display help for command
 ```
 
 Level is a standard semver level of: major, minor, patch or prerelease.  The prefix argument only applies to the prerelease and allows for determining the prerelease level.  For example:
@@ -56,18 +61,23 @@ Date:   Thu Feb 23 17:51:37 2023 -0500
     Publish @travetto/asset,@travetto/asset-web,@travetto/auth,@travetto/auth-model,@travetto/auth-web,@travetto/auth-web-jwt,@travetto/auth-web-passport,@travetto/auth-web-session,...
 ```
 
-## CLI - Publish
+## CLI - repo:publish
 The publish functionality is relatively naive, but consistent.  The code will look at all modules in the mono-repo and check the listed version against what is available in the npm registry.  If the local version is newer, it is a candidate for publishing.
 
-**Terminal: Publish execution**
+**Terminal: Help for repo:publish**
 ```bash
-$ trv repo:publish -h
+$ trv repo:publish --help
 
 Usage: repo:publish [options]
 
+Publish unpublished workspace modules to the package registry.
+
+The command performs a publishability scan first, then publishes candidates.
+Dry-run mode is enabled by default.
+
 Options:
   --dry-run, --no-dry-run  Dry Run? (default: true)
-  -h, --help               display help for command
+  --help                   display help for command
 ```
 
 By default the tool will execute a dry run only, and requires passing a flag to disable the dry run.
@@ -79,27 +89,31 @@ npx trv repo:publish --no-dry-run
 
 If no modules are currently changed, then the command will indicate there is no work to do, and exit gracefully.
 
-## CLI - List
+## CLI - repo:list
 The listing functionality provides the ability to get the workspace modules in the following formats:
+   *  `list` - Standard text list, each module on its own line
+   *  `graph` - Modules as a digraph, mapping interdependencies
+   *  `json` - Graph of modules in JSON form, with additional data (useful for quickly building a dependency graph)
 
-**Terminal: List execution**
+**Terminal: Help for repo:list**
 ```bash
-$ trv repo:list -h
+$ trv repo:list --help
 
 Usage: repo:list [options]
 
+List workspace modules and their relationships.
+
+Output can be emitted as plain list, graphviz digraph, or JSON dependency
+graph suitable for automation.
+
 Options:
   -c, --changed                   Only show changed modules (default: false)
   -f, --format <graph|json|list>  Output format (default: "list")
   -fh, --from-hash <string>       Start revision to check against
   -th, --to-hash <string>         End revision to check against
-  -h, --help                      display help for command
+  --help                          display help for command
 ```
 
-   *  `list` - Standard text list, each module on its own line
-   *  `graph` - Modules as a digraph, mapping interdependencies
-   *  `json` - Graph of modules in JSON form, with additional data (useful for quickly building a dependency graph)
-
 **Terminal: List execution of Monorepo**
 ```bash
 $ trv repo:list
@@ -129,6 +143,7 @@ module/email-inky
 module/email-nodemailer
 module/eslint
 module/image
+module/llm-support
 module/log
 module/manifest
 module/model
@@ -136,6 +151,7 @@ module/model-dynamodb
 module/model-elasticsearch
 module/model-file
 module/model-firestore
+module/model-indexed
 module/model-memory
 module/model-mongo
 module/model-mysql
@@ -151,7 +167,6 @@ module/pack
 module/registry
 module/repo
 module/runtime
-module/scaffold
 module/schema
 module/schema-faker
 module/terminal
@@ -167,21 +182,25 @@ module/worker
 related/todo-app
 ```
 
-## CLI - Exec
-The exec command allows for running commands on all modules, or just changed modules.
+## CLI - repo:exec
 
-**Terminal: Exec execution**
+**Terminal: Help for repo:exec**
 ```bash
-$ trv repo:exec -h
+$ trv repo:exec --help
 
 Usage: repo:exec [options] <cmd:string> [args...:string]
 
+Execute a shell command across workspace modules.
+
+Supports running for all modules or only changed modules, with optional
+concurrency and output prefixing controls.
+
 Options:
   -c, --changed                        Only changed modules (default: false)
   -w, --workers <number>               Number of concurrent workers (default: 9)
   --prefix-output, --no-prefix-output  Prefix output by folder (default: true)
   --show-stdout, --no-show-stdout      Show stdout (default: true)
-  -h, --help                           display help for command
+  --help                               display help for command
 ```
 
 The standard format includes prefixed output to help identify which module produced which output.
@@ -215,6 +234,7 @@ global-test/model_auth-session <workspace-root>/global-test/model_auth-session
        module/email-nodemailer <workspace-root>/module/email-nodemailer
                  module/eslint <workspace-root>/module/eslint
                   module/image <workspace-root>/module/image
+            module/llm-support <workspace-root>/module/llm-support
                     module/log <workspace-root>/module/log
                module/manifest <workspace-root>/module/manifest
                   module/model <workspace-root>/module/model
@@ -222,6 +242,7 @@ global-test/model_auth-session <workspace-root>/global-test/model_auth-session
     module/model-elasticsearch <workspace-root>/module/model-elasticsearch
              module/model-file <workspace-root>/module/model-file
         module/model-firestore <workspace-root>/module/model-firestore
+          module/model-indexed <workspace-root>/module/model-indexed
            module/model-memory <workspace-root>/module/model-memory
             module/model-mongo <workspace-root>/module/model-mongo
             module/model-mysql <workspace-root>/module/model-mysql
@@ -237,7 +258,6 @@ global-test/model_auth-session <workspace-root>/global-test/model_auth-session
                module/registry <workspace-root>/module/registry
                    module/repo .
                 module/runtime <workspace-root>/module/runtime
-               module/scaffold <workspace-root>/module/scaffold
                  module/schema <workspace-root>/module/schema
            module/schema-faker <workspace-root>/module/schema-faker
                module/terminal <workspace-root>/module/terminal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/repo",
-  "version": "8.0.0-alpha.2",
+  "version": "8.0.0-alpha.21",
   "type": "module",
   "description": "Monorepo utilities",
   "keywords": [
@@ -23,10 +23,10 @@
     "directory": "module/repo"
   },
   "dependencies": {
-    "@travetto/worker": "^8.0.0-alpha.2"
+    "@travetto/worker": "^8.0.0-alpha.17"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.3"
+    "@travetto/cli": "^8.0.0-alpha.23"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/support/bin/exec.ts

@@ -1,9 +1,9 @@
 import type { ChildProcess } from 'node:child_process';
 
-import { type ExecutionResult, Env, Util, ExecUtil, castTo, CodecUtil } from '@travetto/runtime';
+import { type ExecutionResult, Env, Util, ExecUtil, CodecUtil, Runtime, RuntimeIndex, AsyncQueue } from '@travetto/runtime';
 import { CliModuleUtil } from '@travetto/cli';
 import type { IndexedModule } from '@travetto/manifest';
-import { StyleUtil, Terminal, TerminalUtil } from '@travetto/terminal';
+import { StyleUtil, Terminal, TerminalUtil, type ProgressEvent } from '@travetto/terminal';
 import { WorkPool } from '@travetto/worker';
 
 const COLORS = ([...[
@@ -13,15 +13,18 @@ const COLORS = ([...[
   '#c6c6c6', '#d0d0d0', '#dadada', '#e4e4e4', '#eeeeee'
 ] as const]).toSorted(() => Math.random() < .5 ? -1 : 1).map(color => StyleUtil.getStyle(color));
 
-type ModuleRunConfig<T = ExecutionResult<string>> = {
+type ModuleRunConfig = {
   progressMessage?: (module: IndexedModule | undefined) => string;
   filter?: (module: IndexedModule) => boolean | Promise<boolean>;
-  transformResult?: (module: IndexedModule, result: ExecutionResult<string>) => T;
+  progressListKey?: (module: IndexedModule) => string;
+  isSuccess?: (result: ExecutionResult) => boolean;
+  showProgressList?: boolean;
   workerCount?: number;
   prefixOutput?: boolean;
   showStdout?: boolean;
   showStderr?: boolean;
   stableOutput?: boolean;
+  includeMonorepoRoot?: boolean;
 };
 
 const colorize = (value: string, idx: number): string => COLORS[idx % COLORS.length](value);
@@ -45,56 +48,99 @@ export class RepoExecUtil {
   /**
    * Run on all modules
    */
-  static async execOnModules<T = ExecutionResult>(
+  static async execOnModules(
     mode: 'all' | 'workspace' | 'changed',
     operation: (module: IndexedModule) => ChildProcess,
-    config: ModuleRunConfig<T> = {}
-  ): Promise<Map<IndexedModule, T>> {
+    config: ModuleRunConfig = {}
+  ): Promise<Map<IndexedModule, ExecutionResult>> {
 
     config.showStdout = config.showStdout ?? (Env.DEBUG.isSet && !Env.DEBUG.isFalse);
     config.showStderr = config.showStderr ?? true;
-    const transform = config.transformResult ?? ((module, result): T => castTo(result));
 
     const workerCount = config.workerCount ?? WorkPool.DEFAULT_SIZE;
 
     const modules = await CliModuleUtil.findModules(mode);
-    const results = new Map<IndexedModule, T>();
+    const results = new Map<IndexedModule, ExecutionResult>();
     const processes = new Map<IndexedModule, ChildProcess>();
 
     const prefixes = config.prefixOutput !== false ? this.#buildPrefixes(modules) : {};
     const stdoutTerm = new Terminal(process.stdout);
     const stderrTerm = new Terminal(process.stderr);
 
-    const work = WorkPool.runStreamProgress(async (module) => {
+    if (Runtime.workspace.mono && config.includeMonorepoRoot && !modules.some(module => module.name === Runtime.workspace.name)) {
+      modules.push(RuntimeIndex.getModule(Runtime.workspace.name)!);
+    }
+
+    const active = new Set<string>();
+    const activeItems = new AsyncQueue<{ idx: number, text: string }>();
+    const listHeader = ['', 'Modules in progress', '-------------------'];
+
+    if (stdoutTerm.interactive && config.showProgressList) {
+      stdoutTerm.writer.writeLines(listHeader).commit();
+    }
+
+    const modulesToRun = (config.filter ? await Promise.all(
+      modules.map(async module => (await config.filter!(module)) ? module : undefined)
+    ) : modules)
+      .filter((module): module is IndexedModule => !!module);
+
+    const work = WorkPool.runStream<IndexedModule, ExecutionResult>(async (module) => {
       try {
-        if (!(await config.filter?.(module) === false)) {
-          const prefix = prefixes[module.sourceFolder] ?? '';
-          const subProcess = operation(module);
-          processes.set(module, subProcess);
-
-          if (config.showStdout && subProcess.stdout) {
-            CodecUtil.readLines(subProcess.stdout, line =>
-              stdoutTerm.writer.writeLine(`${prefix}${line.trimEnd()}`).commit()
-            );
-          }
-          if (config.showStderr && subProcess.stderr) {
-            CodecUtil.readLines(subProcess.stderr, line =>
-              stderrTerm.writer.writeLine(`${prefix}${line.trimEnd()}`).commit()
-            );
-          }
-
-          const result = await ExecUtil.getResult(subProcess, { catch: true });
-          const output = transform(module, result);
-          results.set(module, output);
+        const prefix = prefixes[module.sourceFolder] ?? '';
+        const listKey = config.progressListKey?.(module) ?? ` * ${module.name}`;
+        active.add(listKey);
+        [...active].sort().forEach((text, idx) => activeItems.add({ idx, text }));
+
+        const subProcess = operation(module);
+        processes.set(module, subProcess);
+
+        if (config.showStdout && subProcess.stdout) {
+          CodecUtil.readLines(subProcess.stdout, line =>
+            stdoutTerm.writer.writeLine(`${prefix}${line.trimEnd()}`).commit()
+          );
+        }
+        if (config.showStderr && subProcess.stderr) {
+          CodecUtil.readLines(subProcess.stderr, line =>
+            stderrTerm.writer.writeLine(`${prefix}${line.trimEnd()}`).commit()
+          );
         }
-        return config.progressMessage?.(module) ?? module.name;
+
+        const result = await ExecUtil.getResult(subProcess, { catch: true });
+
+        active.delete(listKey);
+        [...active].sort().forEach((text, idx) => activeItems.add({ idx, text }));
+        for (let j = active.size; j < workerCount; j++) {
+          activeItems.add({ idx: j, text: '' }); // Force update to remove item if needed
+        }
+
+        results.set(module, result);
+        return result;
       } finally {
         processes.get(module!)?.kill();
       }
-    }, modules, modules.length, { max: workerCount, min: workerCount });
+    }, modulesToRun, {
+      max: workerCount,
+      min: workerCount,
+      total: modules.length,
+      isSuccess: config.isSuccess ?? ((result: ExecutionResult): boolean => result.valid),
+    });
 
     if (config.progressMessage && stdoutTerm.interactive) {
-      await stdoutTerm.streamToBottom(Util.mapAsyncIterable(work, TerminalUtil.progressBarUpdater(stdoutTerm, { withWaiting: true })));
+      if (config.showProgressList) {
+        stdoutTerm.streamList(activeItems);
+      }
+      await stdoutTerm.streamToBottom(
+        Util.mapAsyncIterable(
+          Util.mapAsyncIterable(work, (event): ProgressEvent<string> => {
+            const message = config.progressMessage?.(modulesToRun[event.progress.completed]) ?? 'Completed %completed/%total (%failed failed)';
+            return { ...event.progress, value: message };
+          }),
+          TerminalUtil.progressBarUpdater(stdoutTerm, { withWaiting: true }))
+      );
+
+      if (stdoutTerm.interactive && config.showProgressList) {
+        stdoutTerm.writer.changePosition({ y: -listHeader.length, x: 0 }).storePosition().writeLines(Array(listHeader.length).fill('')).restoreOnCommit().commit();
+      }
     } else {
       for await (const _ of work) {
         // Ensure its all consumed

package/support/bin/package-manager.ts

@@ -2,9 +2,10 @@ import path from 'node:path';
 import { spawn, type ChildProcess } from 'node:child_process';
 import fs from 'node:fs/promises';
 
-import { JSONUtil, type ExecutionResult, Runtime } from '@travetto/runtime';
+import { JSONUtil, type ExecutionResult, Runtime, ExecUtil } from '@travetto/runtime';
 import { type IndexedModule, type Package, PackageUtil } from '@travetto/manifest';
 import { CliModuleUtil } from '@travetto/cli';
+import { TerminalUtil } from '@travetto/terminal';
 
 export type SemverLevel = 'minor' | 'patch' | 'major' | 'prerelease' | 'premajor' | 'preminor' | 'prepatch';
 
@@ -13,6 +14,65 @@ export type SemverLevel = 'minor' | 'patch' | 'major' | 'prerelease' | 'premajor
  */
 export class PackageManager {
 
+  /**
+   * Check if npm login is needed
+   */
+  static async needsLogin(): Promise<boolean> {
+    const result = await ExecUtil.getResult(spawn('npm', ['whoami']), { catch: true });
+    return !result.valid;
+  }
+
+  /**
+   * Check if OTP is needed for publishing
+   */
+  static async needsOtp(): Promise<boolean> {
+    try {
+      const result = await ExecUtil.getResult(spawn('npm', ['profile', 'get', '--json']), { catch: true });
+      if (result.valid) {
+        const info = JSONUtil.fromUTF8<{ tfa?: { mode?: string } }>(result.stdout);
+        return !!info?.tfa?.mode;
+      }
+    } catch {
+      // Ignore errors checking for OTP profile
+    }
+    return false;
+  }
+
+  /**
+   * Request an OTP token if required
+   */
+  static async requestOtp(): Promise<string | undefined> {
+    if (TerminalUtil.isInteractive()) {
+      console.log([
+        'OTP token is required for publishing. Please provide an OTP token to proceed with publishing.',
+        'This value will not be stored, and is only used for the current publish operation.'
+      ].join(' '));
+      return await TerminalUtil.prompt('Enter OTP token: ');
+    }
+  }
+
+  /**
+   * Classify publish error from execution result
+   */
+  static classifyPublishError(result: ExecutionResult): string {
+    const errorText = ExecUtil.toString(result, 'any');
+
+    if (/EOTP|one-time password|two-factor|OTP/i.test(errorText)) {
+      return 'Two-factor authentication (OTP) failed or was missing.';
+    }
+    if (/EPUBLISHCONFLICT|E403(.){,100}previously published|cannot publish over/i.test(errorText)) {
+      return 'Version conflict: This version has already been published to the registry.';
+    }
+    if (/ENEEDAUTH|E401|login|unauthorized/i.test(errorText)) {
+      return 'Authentication failed: Please log in or check your registry credentials.';
+    }
+    if (/E403|permission|not allowed/i.test(errorText)) {
+      return 'Permission denied: You do not have access to publish this package.';
+    }
+
+    return errorText || 'Unknown publishing error.';
+  }
+
   /**
    * Is a module already published
    */
@@ -29,13 +89,19 @@ export class PackageManager {
   /**
    * Validate published result
    */
-  static validatePublishedResult(result: ExecutionResult<string>): boolean {
-    if (!result.valid && !result.stderr.includes('E404')) {
-      throw new Error(result.stderr);
+  static validatePublishedResult(result: ExecutionResult): boolean {
+    const stderr = ExecUtil.toString(result, 'stderr');
+    if (!result.valid && !stderr.includes('E404')) {
+      throw new Error(stderr);
     }
 
-    const parsed = JSONUtil.fromUTF8<{ data: { dist?: { integrity?: string } } }>(result.stdout || '{}');
-    return parsed.data?.dist?.integrity !== undefined;
+    const stdout = ExecUtil.toString(result, 'stdout');
+    type PackageInfo = { dist?: { integrity?: string } };
+    let parsed = JSONUtil.fromUTF8<PackageInfo | { data: PackageInfo }>(stdout || '{}');
+    if ('data' in parsed) { // Yarn support
+      parsed = parsed.data;
+    }
+    return parsed.dist?.integrity !== undefined;
   }
 
   /**
@@ -68,7 +134,7 @@ export class PackageManager {
   /**
    * Publish a module
    */
-  static publish(module: IndexedModule, dryRun: boolean | undefined): ChildProcess {
+  static publish(module: IndexedModule, dryRun: boolean | undefined, otp?: string): ChildProcess {
     if (dryRun) {
       return this.dryRunPackaging(module);
     }
@@ -78,7 +144,7 @@ export class PackageManager {
     switch (Runtime.workspace.manager) {
       case 'npm':
       case 'yarn':
-      case 'pnpm': args = ['publish', '--tag', versionTag, '--access', 'public']; break;
+      case 'pnpm': args = ['publish', '--tag', versionTag, '--access', 'public', ...(otp ? ['--otp', otp] : [])]; break;
     }
     return spawn(Runtime.workspace.manager, args, { cwd: module.sourcePath });
   }

package/support/cli.repo_exec.ts

@@ -8,7 +8,10 @@ import { Max, Min } from '@travetto/schema';
 import { RepoExecUtil } from './bin/exec.ts';
 
 /**
- * Repo execution
+ * Execute a shell command across workspace modules.
+ *
+ * Supports running for all modules or only changed modules, with optional
+ * concurrency and output prefixing controls.
  */
 @CliCommand()
 export class RepoExecCommand implements CliCommandShape {
@@ -45,7 +48,7 @@ export class RepoExecCommand implements CliCommandShape {
         }
       }),
       {
-        progressMessage: module => `Running '${cmd} ${finalArgs.join(' ')}' [%idx/%total] ${module?.sourceFolder ?? ''}`,
+        progressMessage: module => `Running '${cmd} ${finalArgs.join(' ')}' [%completed/%total] ${module?.sourceFolder ?? ''}`,
         showStdout: this.showStdout,
         prefixOutput: this.prefixOutput,
         workerCount: this.workers,

package/support/cli.repo_list.ts

@@ -4,7 +4,10 @@ import { JSONUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
 const write = (line: string): Promise<void> => new Promise(resolve => process.stdout.write(`${line}\n`, () => resolve()));
 
 /**
- * Allows for listing of modules
+ * List workspace modules and their relationships.
+ *
+ * Output can be emitted as plain list, graphviz digraph, or JSON dependency
+ * graph suitable for automation.
  */
 @CliCommand()
 export class ListModuleCommand implements CliCommandShape {

package/support/cli.repo_publish.ts

@@ -1,10 +1,14 @@
-import { type CliCommandShape, CliCommand } from '@travetto/cli';
+import { type CliCommandShape, CliCommand, cliTpl } from '@travetto/cli';
+import { RuntimeError } from '@travetto/runtime';
 
 import { PackageManager } from './bin/package-manager.ts';
 import { RepoExecUtil } from './bin/exec.ts';
 
 /**
- * Publish all pending modules
+ * Publish unpublished workspace modules to the package registry.
+ *
+ * The command performs a publishability scan first, then publishes candidates.
+ * Dry-run mode is enabled by default.
  */
 @CliCommand()
 export class RepoPublishCommand implements CliCommandShape {
@@ -12,25 +16,62 @@ export class RepoPublishCommand implements CliCommandShape {
   /** Dry Run? */
   dryRun = true;
 
+  /** OTP Token */
+  otp?: string;
+
   async main(): Promise<void> {
     const published = await RepoExecUtil.execOnModules('workspace', module => PackageManager.isPublished(module), {
       filter: module => !!module.workspace && !module.internal,
-      progressMessage: (module) => `Checking published [%idx/%total] -- ${module?.name}`,
+      progressMessage: (module) => `Checking published [%completed/%total] -- ${module?.name ?? ''}`,
       showStderr: false,
-      transformResult: (module, result) => PackageManager.validatePublishedResult(result),
+      showProgressList: true,
+      isSuccess: () => true
     });
 
+    const unpublished = [...published.entries()]
+      .filter(([, result]) => !PackageManager.validatePublishedResult(result))
+      .map(([module]) => module);
+
     if (this.dryRun) {
-      console.log('Unpublished modules', [...published.entries()].filter(entry => !entry[1]).map(([module]) => module.sourceFolder));
+      console.log('Unpublished modules', unpublished.map(module => module.sourceFolder));
     }
 
-    await RepoExecUtil.execOnModules(
-      'workspace', module => PackageManager.publish(module, this.dryRun),
+    let otp = this.otp;
+    if (unpublished.length > 0 && !this.dryRun) {
+      if (await PackageManager.needsLogin()) {
+        throw new RuntimeError('NPM login is required to publish. Please run "npm login" to authenticate.');
+      }
+      if (!otp && await PackageManager.needsOtp()) {
+        otp = await PackageManager.requestOtp();
+      }
+      if (!otp) {
+        throw new RuntimeError('OTP token is required for publishing, but was not provided.');
+      }
+    }
+
+    const unpublishedSet = new Set(unpublished);
+
+    const results = await RepoExecUtil.execOnModules(
+      'workspace',
+      module => PackageManager.publish(module, this.dryRun, otp),
       {
-        progressMessage: (module) => `Published [%idx/%total] -- ${module?.name}`,
+        progressMessage: (module) => `Publishing [%completed/%total] -- ${module?.name ?? ''} (Failed %failed)`,
         showStdout: false,
-        filter: module => published.get(module) === false
+        showStderr: false,
+        showProgressList: true,
+        filter: module => unpublishedSet.has(module)
       }
     );
+
+    const failures = [...results.entries()].filter(([, result]) => !result.valid);
+    if (failures.length > 0) {
+      console.error(cliTpl`\n${{ title: 'Failed to publish the following modules:' }}`);
+      console.error(cliTpl`${'-'.repeat(50)}`);
+      const nameWidth = Math.max(...failures.map(([module]) => module.name.length));
+      for (const [module, result] of failures) {
+        console.error(cliTpl`${{ identifier: module.name.padStart(nameWidth, ' ') }}: ${{ description: PackageManager.classifyPublishError(result) }}`);
+      }
+      process.exitCode = 1;
+    }
   }
 }

package/support/cli.repo_version-sync.ts

@@ -2,7 +2,10 @@ import { type CliCommandShape, CliCommand } from '@travetto/cli';
 import { PackageManager } from './bin/package-manager.ts';
 
 /**
- * Enforces all packages to write out their versions and dependencies
+ * Synchronize package versions and dependency ranges across the monorepo.
+ *
+ * Ensures package metadata reflects workspace version policy before publishing
+ * or release operations.
  */
 @CliCommand()
 export class VersionSyncCommand implements CliCommandShape {

package/support/cli.repo_version.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 
 import { CliModuleUtil, type CliCommandShape, CliCommand, CliScmUtil } from '@travetto/cli';
-import { ExecUtil, Runtime } from '@travetto/runtime';
+import { ExecUtil, Runtime, RuntimeError } from '@travetto/runtime';
 import { Validator } from '@travetto/schema';
 
 import { PackageManager, type SemverLevel } from './bin/package-manager.ts';
@@ -9,7 +9,10 @@ import { PackageManager, type SemverLevel } from './bin/package-manager.ts';
 const CHANGE_LEVELS = new Set<SemverLevel>(['prerelease', 'patch', 'prepatch']);
 
 /**
- * Version all changed dependencies
+ * Bump workspace module versions and optionally commit/tag release metadata.
+ *
+ * Supports changed/all/direct module targeting and synchronizes dependency
+ * versions after the version bump operation completes.
  */
 @CliCommand()
 @Validator(async (cmd) => {
@@ -43,7 +46,7 @@ export class RepoVersionCommand implements CliCommandShape {
 
     // Do we have valid changes?
     if (!modules.length) {
-      throw new Error('No modules available for versioning');
+      throw new RuntimeError('No modules available for versioning');
     }
 
     await ExecUtil.getResult(PackageManager.version(modules, level, prefix));
@@ -57,7 +60,7 @@ export class RepoVersionCommand implements CliCommandShape {
       }
 
       // Touch package when done to trigger restart of compiler
-      await fs.utimes(Runtime.workspaceRelative('package.json'), Date.now(), Date.now());
+      await fs.utimes(Runtime.workspaceRelative('package.json'), new Date(), new Date());
     }
   }
 }