@travetto/repo 8.0.0-alpha.8 → 8.0.0

package/README.md

@@ -13,21 +13,27 @@ npm install @travetto/repo
 yarn add @travetto/repo
 ```
 
-The repo module aims to provide concise monorepo based tools.  The monorepo support within the [Travetto](https://travetto.dev) framework, is backed by the built in functionality of [Npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)/[Yarn](https://yarnpkg.com).  This module is not a requirement for monorepo support, but provides some quality of life improvements for:
+The repo module aims to provide concise monorepo based tools. The monorepo support within the [Travetto](https://travetto.dev) framework, is backed by the built in functionality of [Npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)/[Yarn](https://yarnpkg.com). This module is not a requirement for monorepo support, but provides some quality of life improvements for:
    *  Versioning releases
    *  Publishing releases
    *  Listing local modules
    *  Running commands on all workspace modules
 
-## CLI - 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.
+## 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 --help
 
 Usage: repo:version [options] <level:major|minor|patch|premajor|preminor|prepatch|prerelease> [prefix:string]
 
+Description:
+  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)
@@ -37,7 +43,7 @@ Options:
   --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:
+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:
 
 **Terminal: Cutting a release candidate**
 ```bash
@@ -56,17 +62,24 @@ 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
-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.
+## 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 --help
 
 Usage: repo:publish [options]
 
+Description:
+  Publish unpublished workspace modules to the package registry.
+
+  The command performs a staleness scan first, then publishes candidates.
+  Dry-run mode is enabled by default.
+
 Options:
   --dry-run, --no-dry-run  Dry Run? (default: true)
+  -o, --otp <string>       OTP Token
   --help                   display help for command
 ```
 
@@ -79,15 +92,24 @@ 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 --help
 
 Usage: repo:list [options]
 
+Description:
+  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")
@@ -96,10 +118,6 @@ Options:
   --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
@@ -127,8 +145,9 @@ module/email
 module/email-compiler
 module/email-inky
 module/email-nodemailer
-module/eslint
 module/image
+module/lint
+module/llm-support
 module/log
 module/manifest
 module/model
@@ -136,6 +155,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 +171,6 @@ module/pack
 module/registry
 module/repo
 module/runtime
-module/scaffold
 module/schema
 module/schema-faker
 module/terminal
@@ -167,15 +186,20 @@ 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 --help
 
 Usage: repo:exec [options] <cmd:string> [args...:string]
 
+Description:
+  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)
@@ -213,8 +237,9 @@ global-test/model_auth-session <workspace-root>/global-test/model_auth-session
          module/email-compiler <workspace-root>/module/email-compiler
              module/email-inky <workspace-root>/module/email-inky
        module/email-nodemailer <workspace-root>/module/email-nodemailer
-                 module/eslint <workspace-root>/module/eslint
                   module/image <workspace-root>/module/image
+                   module/lint <workspace-root>/module/lint
+            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 +247,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 +263,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/__index__.ts

@@ -1,2 +1,2 @@
 export * from './support/bin/exec.ts';
-export * from './support/bin/package-manager.ts';
+export * from './support/bin/package-manager.ts';

package/package.json

@@ -1,32 +1,35 @@
 {
   "name": "@travetto/repo",
-  "version": "8.0.0-alpha.8",
-  "type": "module",
+  "version": "8.0.0",
   "description": "Monorepo utilities",
   "keywords": [
+    "monorepo",
     "travetto",
-    "typescript",
-    "monorepo"
+    "typescript"
   ],
-  "main": "__index__.ts",
   "homepage": "https://travetto.io",
   "license": "MIT",
   "author": {
-    "email": "travetto.framework@gmail.com",
-    "name": "Travetto Framework"
+    "name": "Travetto Framework",
+    "email": "travetto.framework@gmail.com"
   },
-  "files": [
-    "support"
-  ],
   "repository": {
     "url": "git+https://github.com/travetto/travetto.git",
     "directory": "module/repo"
   },
+  "files": [
+    "support"
+  ],
+  "type": "module",
+  "main": "__index__.ts",
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "@travetto/worker": "^8.0.0-alpha.7"
+    "@travetto/worker": "^8.0.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.12"
+    "@travetto/cli": "^8.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {
@@ -35,8 +38,5 @@
   },
   "travetto": {
     "displayName": "Repo"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/support/bin/exec.ts

@@ -1,27 +1,80 @@
 import type { ChildProcess } from 'node:child_process';
 
-import { type ExecutionResult, Env, Util, ExecUtil, castTo, CodecUtil } from '@travetto/runtime';
 import { CliModuleUtil } from '@travetto/cli';
 import type { IndexedModule } from '@travetto/manifest';
-import { StyleUtil, Terminal, TerminalUtil } from '@travetto/terminal';
+import { AsyncQueue, CodecUtil, Env, ExecUtil, type ExecutionResult, Runtime, RuntimeIndex, Util } from '@travetto/runtime';
+import { type ProgressEvent, StyleUtil, Terminal, TerminalUtil } from '@travetto/terminal';
 import { WorkPool } from '@travetto/worker';
 
-const COLORS = ([...[
-  '#8787ff', '#87afff', '#87d7ff', '#87ff87', '#87ffaf', '#87ffd7', '#87ffff', '#af87ff', '#afafd7', '#afafff', '#afd7af', '#afd7d7', '#afd7ff', '#afff87', '#afffaf',
-  '#afffd7', '#afffff', '#d787ff', '#d7afaf', '#d7afd7', '#d7afff', '#d7d7af', '#d7d7d7', '#d7d7ff', '#d7ff87', '#d7ffaf', '#d7ffd7', '#d7ffff', '#ff8787', '#ff87af',
-  '#ff87d7', '#ff87ff', '#ffaf87', '#ffafaf', '#ffafd7', '#ffafff', '#ffd787', '#ffd7af', '#ffd7d7', '#ffd7ff', '#ffff87', '#ffffaf', '#ffffd7', '#ffffff', '#bcbcbc',
-  '#c6c6c6', '#d0d0d0', '#dadada', '#e4e4e4', '#eeeeee'
-] as const]).toSorted(() => Math.random() < .5 ? -1 : 1).map(color => StyleUtil.getStyle(color));
-
-type ModuleRunConfig<T = ExecutionResult<string>> = {
+const COLORS = [
+  ...([
+    '#8787ff',
+    '#87afff',
+    '#87d7ff',
+    '#87ff87',
+    '#87ffaf',
+    '#87ffd7',
+    '#87ffff',
+    '#af87ff',
+    '#afafd7',
+    '#afafff',
+    '#afd7af',
+    '#afd7d7',
+    '#afd7ff',
+    '#afff87',
+    '#afffaf',
+    '#afffd7',
+    '#afffff',
+    '#d787ff',
+    '#d7afaf',
+    '#d7afd7',
+    '#d7afff',
+    '#d7d7af',
+    '#d7d7d7',
+    '#d7d7ff',
+    '#d7ff87',
+    '#d7ffaf',
+    '#d7ffd7',
+    '#d7ffff',
+    '#ff8787',
+    '#ff87af',
+    '#ff87d7',
+    '#ff87ff',
+    '#ffaf87',
+    '#ffafaf',
+    '#ffafd7',
+    '#ffafff',
+    '#ffd787',
+    '#ffd7af',
+    '#ffd7d7',
+    '#ffd7ff',
+    '#ffff87',
+    '#ffffaf',
+    '#ffffd7',
+    '#ffffff',
+    '#bcbcbc',
+    '#c6c6c6',
+    '#d0d0d0',
+    '#dadada',
+    '#e4e4e4',
+    '#eeeeee'
+  ] as const)
+]
+  .toSorted(() => (Math.random() < 0.5 ? -1 : 1))
+  .map(color => StyleUtil.getStyle(color));
+
+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);
@@ -30,7 +83,6 @@ const colorize = (value: string, idx: number): string => COLORS[idx % COLORS.len
  * Tools for running commands across all modules of the monorepo
  */
 export class RepoExecUtil {
-
   /**
    * Build equal sized prefix labels for outputting
    * @param modules
@@ -45,56 +97,108 @@ 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) => {
-      try {
-        if (!(await config.filter?.(module) === false)) {
+    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 {
           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()
-            );
+            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()
-            );
+            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);
+
+          active.delete(listKey);
+          [...active].sort().forEach((text, idx) => {
+            activeItems.add({ idx, text });
+          });
+          for (let j = active.size; j < workerCount; j += 1) {
+            activeItems.add({ idx: j, text: '' }); // Force update to remove item if needed
+          }
+
+          results.set(module, result);
+          return result;
+        } finally {
+          processes.get(module!)?.kill();
         }
-        return config.progressMessage?.(module) ?? module.name;
-      } finally {
-        processes.get(module!)?.kill();
+      },
+      modulesToRun,
+      {
+        max: workerCount,
+        min: workerCount,
+        total: modules.length,
+        isSuccess: config.isSuccess ?? ((result: ExecutionResult): boolean => result.valid)
       }
-    }, modules, modules.length, { max: workerCount, min: workerCount });
+    );
 
     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
@@ -103,4 +207,4 @@ export class RepoExecUtil {
 
     return results;
   }
-}
+}

package/support/bin/package-manager.ts

@@ -1,17 +1,79 @@
-import path from 'node:path';
-import { spawn, type ChildProcess } from 'node:child_process';
+import { type ChildProcess, spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 
-import { JSONUtil, type ExecutionResult, Runtime } from '@travetto/runtime';
-import { type IndexedModule, type Package, PackageUtil } from '@travetto/manifest';
 import { CliModuleUtil } from '@travetto/cli';
+import { type IndexedModule, type Package, PackageUtil } from '@travetto/manifest';
+import { ExecUtil, type ExecutionResult, JSONUtil, Runtime } from '@travetto/runtime';
+import { TerminalUtil } from '@travetto/terminal';
 
 export type SemverLevel = 'minor' | 'patch' | 'major' | 'prerelease' | 'premajor' | 'preminor' | 'prepatch';
 
+/* cspell:words EOTP EPUBLISHCONFLICT ENEEDAUTH */
+
 /**
  * Utilities for working with package managers
  */
 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
@@ -21,7 +83,9 @@ export class PackageManager {
     switch (Runtime.workspace.manager) {
       case 'npm':
       case 'yarn':
-      case 'pnpm': args = ['info', `${module.name}@${module.version}`, '--json']; break;
+      case 'pnpm':
+        args = ['info', `${module.name}@${module.version}`, '--json'];
+        break;
     }
     return spawn(Runtime.workspace.manager, args, { cwd: module.sourceFolder });
   }
@@ -29,14 +93,17 @@ 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 stdout = ExecUtil.toString(result, 'stdout');
     type PackageInfo = { dist?: { integrity?: string } };
-    let parsed = JSONUtil.fromUTF8<PackageInfo | { data: PackageInfo }>(result.stdout || '{}');
-    if ('data' in parsed) { // Yarn support
+    let parsed = JSONUtil.fromUTF8<PackageInfo | { data: PackageInfo }>(stdout || '{}');
+    if ('data' in parsed) {
+      // Yarn support
       parsed = parsed.data;
     }
     return parsed.dist?.integrity !== undefined;
@@ -51,7 +118,9 @@ export class PackageManager {
     switch (Runtime.workspace.manager) {
       case 'npm':
       case 'yarn':
-      case 'pnpm': args = ['version', '--no-workspaces-update', level, ...(preid ? ['--preid', preid] : [])]; break;
+      case 'pnpm':
+        args = ['version', '--no-workspaces-update', level, ...(preid ? ['--preid', preid] : [])];
+        break;
     }
     return spawn(Runtime.workspace.manager, [...args, ...moduleArgs], { cwd: Runtime.workspace.path, stdio: 'inherit' });
   }
@@ -64,7 +133,9 @@ export class PackageManager {
     switch (Runtime.workspace.manager) {
       case 'npm':
       case 'yarn':
-      case 'pnpm': args = ['pack', '--dry-run']; break;
+      case 'pnpm':
+        args = ['pack', '--dry-run'];
+        break;
     }
     return spawn(Runtime.workspace.manager, args, { cwd: module.sourcePath });
   }
@@ -72,7 +143,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);
     }
@@ -82,7 +153,9 @@ 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 });
   }
@@ -112,12 +185,7 @@ export class PackageManager {
     });
 
     for (const { pkg } of packages) {
-      for (const group of [
-        pkg.dependencies ?? {},
-        pkg.devDependencies ?? {},
-        pkg.optionalDependencies ?? {},
-        pkg.peerDependencies ?? {}
-      ]) {
+      for (const group of [pkg.dependencies ?? {}, pkg.devDependencies ?? {}, pkg.optionalDependencies ?? {}, pkg.peerDependencies ?? {}]) {
         for (const [module, ver] of Object.entries(versions)) {
           if (module in group && !/^[*]|(file:.*)$/.test(group[module])) {
             group[module] = ver;
@@ -132,4 +200,4 @@ export class PackageManager {
 
     return versions;
   }
-}
+}

package/support/cli.repo_exec.ts

@@ -1,23 +1,26 @@
 import { spawn } from 'node:child_process';
 
-import { CliCommand, CliParseUtil, type CliCommandShape } from '@travetto/cli';
-import { WorkPool } from '@travetto/worker';
+import { CliCommand, type CliCommandShape, CliParseUtil } from '@travetto/cli';
 import { Env } from '@travetto/runtime';
 import { Max, Min } from '@travetto/schema';
+import { WorkPool } from '@travetto/worker';
 
 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 {
-
   /** Only changed modules */
   changed = false;
 
   /** Number of concurrent workers */
-  @Min(1) @Max(WorkPool.MAX_SIZE)
+  @Min(1)
+  @Max(WorkPool.MAX_SIZE)
   workers = WorkPool.DEFAULT_SIZE;
 
   /** Prefix output by folder */
@@ -32,23 +35,24 @@ export class RepoExecCommand implements CliCommandShape {
 
   async main(cmd: string, args: string[] = []): Promise<void> {
     const parsed = CliParseUtil.getState(this);
-    const finalArgs = [...args, ...parsed?.unknown ?? []];
+    const finalArgs = [...args, ...(parsed?.unknown ?? [])];
 
     await RepoExecUtil.execOnModules(
       this.changed ? 'changed' : 'workspace',
-      module => spawn(cmd, finalArgs, {
-        cwd: module.sourceFolder,
-        env: {
-          ...process.env,
-          ...Env.TRV_MODULE.export(module.name),
-          ...Env.TRV_MANIFEST.export(undefined)
-        }
-      }),
+      module =>
+        spawn(cmd, finalArgs, {
+          cwd: module.sourceFolder,
+          env: {
+            ...process.env,
+            ...Env.TRV_MODULE.export(module.name),
+            ...Env.TRV_MANIFEST.export(undefined)
+          }
+        }),
       {
-        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,
+        workerCount: this.workers
       }
     );
   }

package/support/cli.repo_list.ts

@@ -1,14 +1,16 @@
-import { type CliCommandShape, CliCommand, CliModuleUtil } from '@travetto/cli';
+import { CliCommand, type CliCommandShape, CliModuleUtil } from '@travetto/cli';
 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 {
-
   /** Only show changed modules */
   changed = false;
 
@@ -28,7 +30,6 @@ export class ListModuleCommand implements CliCommandShape {
   toHash?: string;
 
   async main(): Promise<void> {
-
     const modules = await CliModuleUtil.findModules(this.changed ? 'changed' : 'workspace', this.fromHash, this.toHash);
     switch (this.format) {
       case 'list': {
@@ -39,11 +40,12 @@ export class ListModuleCommand implements CliCommandShape {
       }
       case 'json': {
         const outputMap = CliModuleUtil.getDependencyGraph(modules);
-        await write(JSONUtil.toUTF8(
-          Object.entries(outputMap)
-            .map(([name, children]) => ({ name, children, workspace: RuntimeIndex.getModule(name)?.workspace })),
-          { indent: 2 }
-        ));
+        await write(
+          JSONUtil.toUTF8(
+            Object.entries(outputMap).map(([name, children]) => ({ name, children, workspace: RuntimeIndex.getModule(name)?.workspace })),
+            { indent: 2 }
+          )
+        );
         break;
       }
       case 'graph': {
@@ -60,4 +62,4 @@ export class ListModuleCommand implements CliCommandShape {
       }
     }
   }
-}
+}

package/support/cli.repo_publish.ts

@@ -1,36 +1,77 @@
-import { type CliCommandShape, CliCommand } from '@travetto/cli';
+import { CliCommand, type CliCommandShape, cliTpl } from '@travetto/cli';
+import { RuntimeError } from '@travetto/runtime';
 
-import { PackageManager } from './bin/package-manager.ts';
 import { RepoExecUtil } from './bin/exec.ts';
+import { PackageManager } from './bin/package-manager.ts';
 
 /**
- * Publish all pending modules
+ * Publish unpublished workspace modules to the package registry.
+ *
+ * The command performs a staleness scan first, then publishes candidates.
+ * Dry-run mode is enabled by default.
  */
 @CliCommand()
 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),
-      {
-        progressMessage: (module) => `Published [%idx/%total] -- ${module?.name}`,
-        showStdout: false,
-        filter: module => published.get(module) === false
+    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 => `Publishing [%completed/%total] -- ${module?.name ?? ''} (Failed %failed)`,
+      showStdout: 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

@@ -1,12 +1,16 @@
-import { type CliCommandShape, CliCommand } from '@travetto/cli';
+import { CliCommand, type CliCommandShape } 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 {
   async main(): Promise<void> {
     await PackageManager.synchronizeVersions();
   }
-}
+}

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 { CliCommand, type CliCommandShape, CliModuleUtil, CliScmUtil } from '@travetto/cli';
+import { ExecUtil, Runtime, RuntimeError } from '@travetto/runtime';
 import { Validator } from '@travetto/schema';
 
 import { PackageManager, type SemverLevel } from './bin/package-manager.ts';
@@ -9,11 +9,14 @@ 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) => {
-  if (!cmd.force && await CliScmUtil.isWorkspaceDirty()) {
+@Validator(async cmd => {
+  if (!cmd.force && (await CliScmUtil.isWorkspaceDirty())) {
     return { message: 'Cannot update versions with uncommitted changes', path: 'custom', kind: 'invalid' };
   }
 })
@@ -35,7 +38,7 @@ export class RepoVersionCommand implements CliCommandShape {
   async main(level: SemverLevel, prefix?: string): Promise<void> {
     const mode = this.mode ?? (CHANGE_LEVELS.has(level) ? 'changed' : 'workspace');
 
-    this.tag ??= (level === 'minor' || level === 'major');
+    this.tag ??= level === 'minor' || level === 'major';
 
     const allModules = await CliModuleUtil.findModules(mode === 'direct' ? 'all' : mode);
 
@@ -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());
     }
   }
-}
+}