@travetto/pack 3.0.3 → 3.1.0-rc.0

package/README.md

@@ -26,20 +26,21 @@ There are three primary cli commands for packing your code:
 ```bash
 $ trv pack --help
 
-Usage:  pack [options] [args...]
+Usage: pack [options]
 
 Options:
-  -w, --workspace <workspace>         Workspace for building
-  -c, --no-clean                      Disables: Clean workspace
-  -o, --output <output>               Output location
-  -es, --main-scripts <main-scripts>  Create entry scripts
-  -f, --main-name <main-name>         Main name for build artifact
-  -e, --entry-point <entry-point>     Entry point (default: "@travetto/cli/support/entry.cli")
-  -m, --no-minify                     Disables: Minify output
-  -sm, --sourcemap                    Bundle source maps
-  -is, --include-sources              Include source with source maps
-  -x, --eject-file <eject-file>       Eject commands to file
-  -h, --help                          display help for command
+  -w, --workspace <string>           Workspace for building (default: "/tmp/<temp-folder>")
+  --clean, --no-clean                Clean workspace (default: true)
+  -o, --output <string>              Output location
+  --main-scripts, --no-main-scripts  Create entry scripts (default: true)
+  -f, --main-name <string>           Main name for build artifact
+  -e, --entry-point <string>         Entry point (default: "@travetto/cli/support/entry.cli")
+  --minify, --no-minify              Minify output (default: true)
+  -sm, --sourcemap                   Bundle source maps (default: false)
+  -is, --include-sources             Include source with source maps (default: false)
+  -x, --eject-file <string>          Eject commands to file
+  -m, --module <string>              Module to run for
+  -h, --help                         display help for command
 ```
 
 This command line operation will compile your project, and produce a ready to use workspace as a deliverable. Additionally, you can pass in a file to the `eject-file` flag that will allow for a script to be produced (base on the host operating system). 
@@ -86,20 +87,21 @@ This command is nearly identical to the standard `pack` operation, except for th
 ```bash
 $ trv pack:zip --help
 
-Usage:  pack:zip [options] [args...]
+Usage: pack:zip [options]
 
 Options:
-  -w, --workspace <workspace>         Workspace for building
-  -c, --no-clean                      Disables: Clean workspace
-  -o, --output <output>               Output location (default: "travetto_pack.zip")
-  -es, --main-scripts <main-scripts>  Create entry scripts
-  -f, --main-name <main-name>         Main name for build artifact
-  -e, --entry-point <entry-point>     Entry point (default: "@travetto/cli/support/entry.cli")
-  -m, --no-minify                     Disables: Minify output
-  -sm, --sourcemap                    Bundle source maps
-  -is, --include-sources              Include source with source maps
-  -x, --eject-file <eject-file>       Eject commands to file
-  -h, --help                          display help for command
+  -w, --workspace <string>           Workspace for building (default: "/tmp/<temp-folder>")
+  --clean, --no-clean                Clean workspace (default: true)
+  -o, --output <string>              Output location (default: "travetto_pack.zip")
+  --main-scripts, --no-main-scripts  Create entry scripts (default: true)
+  -f, --main-name <string>           Main name for build artifact
+  -e, --entry-point <string>         Entry point (default: "@travetto/cli/support/entry.cli")
+  --minify, --no-minify              Minify output (default: true)
+  -sm, --sourcemap                   Bundle source maps (default: false)
+  -is, --include-sources             Include source with source maps (default: false)
+  -x, --eject-file <string>          Eject commands to file
+  -m, --module <string>              Module to run for
+  -h, --help                         display help for command
 ```
 
 ## CLI - pack:docker
@@ -109,27 +111,28 @@ This command starts off identical to the standard `pack` operation, but it conta
 ```bash
 $ trv pack:docker --help
 
-Usage:  pack:docker [options] [args...]
+Usage: pack:docker [options]
 
 Options:
-  -w, --workspace <workspace>               Workspace for building
-  -c, --no-clean                            Disables: Clean workspace
-  -o, --output <output>                     Output location
-  -es, --main-scripts <main-scripts>        Create entry scripts
-  -f, --main-name <main-name>               Main name for build artifact
-  -e, --entry-point <entry-point>           Entry point (default: "@travetto/cli/support/entry.cli")
-  -m, --no-minify                           Disables: Minify output
-  -sm, --sourcemap                          Bundle source maps
-  -is, --include-sources                    Include source with source maps
-  -x, --eject-file <eject-file>             Eject commands to file
-  -df, --docker-factory <docker-factory>    Docker Factory source (default: "@travetto/pack/support/pack.dockerfile")
-  -di, --docker-image <docker-image>        Docker Image to extend (default: "node:18-alpine3.16")
-  -dn, --docker-name <docker-name>          Docker Image Name (default: "travetto_pack")
-  -dt, --docker-tag <docker-tag>            Docker Image Tag (default: ["latest"])
-  -dp, --docker-port <docker-port>          Docker Image Port (default: [])
-  -dx, --docker-push                        Docker Push Tags
-  -dr, --docker-registry <docker-registry>  Docker Registry
-  -h, --help                                display help for command
+  -w, --workspace <string>           Workspace for building (default: "/tmp/<temp-folder>")
+  --clean, --no-clean                Clean workspace (default: true)
+  -o, --output <string>              Output location
+  --main-scripts, --no-main-scripts  Create entry scripts (default: true)
+  -f, --main-name <string>           Main name for build artifact
+  -e, --entry-point <string>         Entry point (default: "@travetto/cli/support/entry.cli")
+  --minify, --no-minify              Minify output (default: true)
+  -sm, --sourcemap                   Bundle source maps (default: false)
+  -is, --include-sources             Include source with source maps (default: false)
+  -x, --eject-file <string>          Eject commands to file
+  -df, --docker-factory <string>     Docker Factory source  (default: "@travetto/pack/support/pack.dockerfile")
+  -di, --docker-image <string>       Docker Image to extend  (default: "node:18-alpine3.16")
+  -dn, --docker-name <string>        Docker Image Name  (default: "travetto_pack")
+  -dt, --docker-tag <string>         Docker Image Tag  (default: ["latest"])
+  -dp, --docker-port <number>        Docker Image Port  (default: [])
+  -dx, --docker-push                 Docker Push Tags  (default: false)
+  -dr, --docker-registry <string>    Docker Registry
+  -m, --module <string>              Module to run for
+  -h, --help                         display help for command
 ```
 
 The additional flags provided are allow for specifying the base image, the final docker image name (and tags), and which registry to push to (if  any).  Additionally, there are flags for exposing which ports the image should expect to open as well.   When using the `--eject-file`  flag, the output script will produce the entire Dockerfile output inline, so that it can be easily modified as needed. 
@@ -145,82 +148,78 @@ As indicated, any of the pack operations can be ejected, and produce an output t
 
 **Terminal: Sample Ejected File**
 ```bash
-$ trv pack:docker -x /dev/stdout run rest
+$ trv pack:docker -x /dev/stdout run:rest
 
 #!/bin/sh
-export DIST=/tmp/_home_tim_Code_travetto_related_todo-app
+export DIST=/tmp/<temp-folder>
 export TRV_OUT=<workspace-root>/.trv_output
 export ROOT=<workspace-root>/related/todo-app
 export MOD=@travetto/todo-app
 
 # Cleaning Output $DIST 
 
-echo "Cleaning Output $DIST
-"
+echo "Cleaning Output $DIST"
+
 rm -rf $DIST
 mkdir -p $DIST
 
 # Writing .env.js 
 
-echo "Writing .env.js
-"
+echo "Writing .env.js"
+
 echo "process.env.TRV_MANIFEST = 'node_modules/$MOD';" > $DIST/.env.js
+echo "process.env.TRV_MODULE = '$MOD';" >> $DIST/.env.js
 echo "process.env.TRV_CLI_IPC = '';" >> $DIST/.env.js
 
 # Writing package.json 
 
-echo "Writing package.json
-"
+echo "Writing package.json"
+
 echo "{\"type\":\"commonjs\"}" > $DIST/package.json
 
-# Writing entry scripts entry.cli.sh args=(run rest) 
+# Writing entry scripts todo-app.sh args=(run:rest) 
+
+echo "Writing entry scripts todo-app.sh args=(run:rest)"
 
-echo "Writing entry scripts entry.cli.sh args=(run rest)
-"
-echo "#!/bin/sh" > $DIST/entry.cli.sh
-echo "cd \$(dirname \"\$0\")" >> $DIST/entry.cli.sh
-echo "node entry.cli.js run rest \$@" >> $DIST/entry.cli.sh
-chmod 755 $DIST/entry.cli.sh
+echo "#!/bin/sh" > $DIST/todo-app.sh
+echo "cd \$(dirname \"\$0\")" >> $DIST/todo-app.sh
+echo "node todo-app.js run:rest \$@" >> $DIST/todo-app.sh
+chmod 755 $DIST/todo-app.sh
 
-# Writing entry scripts entry.cli.cmd args=(run rest) 
+# Writing entry scripts todo-app.cmd args=(run:rest) 
 
-echo "Writing entry scripts entry.cli.cmd args=(run rest)
-"
-echo "" > $DIST/entry.cli.cmd
-echo "cd %~p0" >> $DIST/entry.cli.cmd
-echo "node entry.cli.js run rest %*" >> $DIST/entry.cli.cmd
-chmod 755 $DIST/entry.cli.cmd
+echo "Writing entry scripts todo-app.cmd args=(run:rest)"
+
+echo "" > $DIST/todo-app.cmd
+echo "cd %~p0" >> $DIST/todo-app.cmd
+echo "node todo-app.js run:rest %*" >> $DIST/todo-app.cmd
+chmod 755 $DIST/todo-app.cmd
 
 # Copying over resources 
 
-echo "Copying over resources
-"
+echo "Copying over resources"
+
 mkdir -p $DIST/node_modules/$MOD
 cp $TRV_OUT/node_modules/$MOD/package.json $DIST/node_modules/$MOD/package.json
 mkdir -p $DIST/node_modules/@travetto/manifest
 cp $TRV_OUT/node_modules/@travetto/manifest/package.json $DIST/node_modules/@travetto/manifest/package.json
 cp -r -p $ROOT/resources $DIST/resources
 
-# Generating App Cache node_modules/$MOD/trv-app-cache.json 
-
-echo "Generating App Cache node_modules/$MOD/trv-app-cache.json
-"
-mkdir -p $DIST/node_modules/$MOD
-DEBUG=0 TRV_MODULE=$MOD npx trv main @travetto/app/support/bin/list > $DIST/node_modules/$MOD/trv-app-cache.json
-
 # Writing Manifest node_modules/$MOD 
 
-echo "Writing Manifest node_modules/$MOD
-"
+echo "Writing Manifest node_modules/$MOD"
+
 TRV_MODULE=$MOD npx trv manifest $DIST/node_modules/$MOD prod
 
-# Bundling Output minify=true sourcemap= entryPoint=@travetto/cli/support/entry.cli 
+# Bundling Output minify=true sourcemap=false entryPoint=@travetto/cli/support/entry.cli 
+
+echo "Bundling Output minify=true sourcemap=false entryPoint=@travetto/cli/support/entry.cli"
 
-echo "Bundling Output minify=true sourcemap= entryPoint=@travetto/cli/support/entry.cli
-"
 export BUNDLE_ENTRY=node_modules/@travetto/cli/support/entry.cli.js
-export BUNDLE_MAIN_FILE=entry.cli.js
+export BUNDLE_MAIN_FILE=todo-app.js
 export BUNDLE_COMPRESS=true
+export BUNDLE_SOURCEMAP=false
+export BUNDLE_SOURCES=false
 export BUNDLE_OUTPUT=$DIST
 export BUNDLE_FORMAT=commonjs
 export TRV_MANIFEST=$TRV_OUT/node_modules/$MOD
@@ -230,24 +229,24 @@ cd $ROOT
 
 # Generating Docker File $DIST/Dockerfile @travetto/pack/support/pack.dockerfile 
 
-echo "Generating Docker File $DIST/Dockerfile @travetto/pack/support/pack.dockerfile
-"
+echo "Generating Docker File $DIST/Dockerfile @travetto/pack/support/pack.dockerfile"
+
 echo "FROM node:18-alpine3.16" > $DIST/Dockerfile
 echo "WORKDIR /app" >> $DIST/Dockerfile
 echo "COPY . ." >> $DIST/Dockerfile
 echo "" >> $DIST/Dockerfile
-echo "ENTRYPOINT [\"/app/entry.cli.sh\"]" >> $DIST/Dockerfile
+echo "ENTRYPOINT [\"/app/todo-app.sh\"]" >> $DIST/Dockerfile
 
 # Pulling Docker Base Image node:18-alpine3.16 
 
-echo "Pulling Docker Base Image node:18-alpine3.16
-"
+echo "Pulling Docker Base Image node:18-alpine3.16"
+
 docker pull node:18-alpine3.16
 
 # Building Docker Container latest 
 
-echo "Building Docker Container latest
-"
+echo "Building Docker Container latest"
+
 cd $DIST
 docker build -t travetto_todo-app:latest .
 cd $ROOT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/pack",
-  "version": "3.0.3",
+  "version": "3.1.0-rc.0",
   "description": "Code packing utilities",
   "keywords": [
     "travetto",
@@ -28,12 +28,12 @@
     "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-terser": "^0.4.0",
-    "@travetto/base": "^3.0.3",
+    "@travetto/base": "^3.1.0-rc.0",
     "rollup": "^3.17.2",
     "rollup-plugin-sourcemaps": "^0.6.3"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.3"
+    "@travetto/cli": "^3.1.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/support/bin/operation.ts

@@ -12,6 +12,9 @@ async function writeRawFile(file: string, contents: string, mode?: string): Prom
   await fs.writeFile(file, contents, { encoding: 'utf8', mode });
 }
 
+/**
+ * General pack operations
+ */
 export class PackOperation {
 
   static async * title(cfg: CommonPackConfig, title: string): AsyncIterable<string[]> {
@@ -118,6 +121,7 @@ export class PackOperation {
     const file = '.env.js';
     const env = {
       TRV_MANIFEST: `node_modules/${cfg.module}`,
+      TRV_MODULE: cfg.module,
       TRV_CLI_IPC: ''
     };
 
@@ -212,33 +216,6 @@ export class PackOperation {
     }
   }
 
-  /**
-   * Generate the trv-app-cache.json for @travetto/app, which is needed for 'running' programs
-   */
-  static async * primeAppCache(cfg: CommonPackConfig): AsyncIterable<string[]> {
-    const isRun = /entry[.]cli/.test(cfg.entryPoint) && cfg.entryArguments.filter(x => !x.startsWith('-'))[0] === 'run';
-    if (!isRun) {
-      return;
-    }
-
-    const appCacheCmd = ['npx', 'trv', 'main', '@travetto/app/support/bin/list'];
-    const sub = path.join(RootIndex.manifest.modules[RootIndex.mainModule.name].outputFolder, 'trv-app-cache.json');
-    const env = { DEBUG: '0', TRV_MODULE: cfg.module };
-    const appCache = path.resolve(cfg.workspace, sub);
-
-    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Generating App Cache' }} ${{ path: sub }}`);
-
-    if (cfg.ejectFile) {
-      yield ActiveShellCommand.mkdir(path.dirname(appCache));
-      yield [...Object.entries(env).map(x => `${x[0]}=${x[1]}`), ...appCacheCmd, '>', appCache];
-    } else {
-      const { stdout } = await ExecUtil.spawn(appCacheCmd[0], appCacheCmd.slice(1), { env }).result;
-
-      await fs.mkdir(path.dirname(appCache), { recursive: true });
-      await fs.writeFile(appCache, stdout, 'utf8');
-    }
-  }
-
   /**
    * Produce the output manifest, only including prod dependencies
    */

package/support/bin/shell.ts

@@ -27,7 +27,7 @@ export const ShellCommands: Record<'win32' | 'posix', ShellCommandImpl> = {
     export: (key, value) => ['set', `${key}=${value}`],
     chdir: (dest) => ['cd', dest],
     comment: (message) => ['\nREM', stripAnsiCodes(message), '\n'],
-    echo: (message) => ['echo', `"${escape(stripAnsiCodes(message))}\n"`],
+    echo: (message) => ['echo', `"${escape(stripAnsiCodes(message))}"\n`],
     zip: (outputFile) => ['powershell', 'Compress-Archive', '-Path', '.', '-DestinationPath', outputFile]
   },
   posix: {
@@ -47,7 +47,7 @@ export const ShellCommands: Record<'win32' | 'posix', ShellCommandImpl> = {
     export: (key, value) => ['export', `${key}=${value}`],
     chdir: (dest) => ['cd', dest],
     comment: (message) => ['\n#', stripAnsiCodes(message), '\n'],
-    echo: (message) => ['echo', `"${escape(stripAnsiCodes(message))}\n"`],
+    echo: (message) => ['echo', `"${escape(stripAnsiCodes(message))}"\n`],
     zip: (outputFile) => ['zip', '-r', outputFile, '.']
   },
 };

package/support/bin/types.ts

@@ -1,12 +1,10 @@
-import { ListOptionConfig, OptionConfig } from '@travetto/cli';
-
 export type CommonPackConfig = {
   workspace: string;
   output: string;
   clean: boolean;
-  ejectFile: string;
+  ejectFile?: string;
   mainName: string;
-  mainScripts: boolean;
+  mainScripts?: boolean;
   module: string;
 
   // Bundle
@@ -17,40 +15,17 @@ export type CommonPackConfig = {
   includeSources: boolean;
 };
 
-export type CommonPackOptions = {
-  workspace: OptionConfig<string>;
-  output: OptionConfig<string>;
-  clean: OptionConfig<boolean>;
-  ejectFile: OptionConfig<string>;
-  mainName: OptionConfig<string>;
-  mainScripts: OptionConfig<boolean>;
-
-  // Bundle
-  entryPoint: OptionConfig<string>;
-  minify: OptionConfig<boolean>;
-  sourcemap: OptionConfig<boolean>;
-  includeSources: OptionConfig<boolean>;
-};
 
 export type DockerPackConfig = {
   dockerFactory: string;
   dockerImage: string;
   dockerName: string;
-  dockerTag: string[];
-  dockerPort: string[];
-  dockerPush: boolean;
-  dockerRegistry: string;
+  dockerTag?: string[];
+  dockerPort?: number[];
+  dockerPush?: boolean;
+  dockerRegistry?: string;
 } & CommonPackConfig;
 
-export type DockerPackOptions = {
-  dockerFactory: OptionConfig<string>;
-  dockerImage: OptionConfig<string>;
-  dockerName: OptionConfig<string>;
-  dockerTag: ListOptionConfig<string>;
-  dockerPort: ListOptionConfig<string>;
-  dockerPush: OptionConfig<boolean>;
-  dockerRegistry: OptionConfig<string>;
-} & CommonPackOptions;
 
 export type ShellCommandImpl = {
   var(name: string): string;

package/support/bin/util.ts

@@ -33,31 +33,33 @@ export class PackUtil {
   /**
    * Finalize eject output
    */
-  static async writeEjectOutput(
-    workspace: string,
-    module: string,
-    output: string[],
-    file: string
-  ): Promise<void> {
-    const vars = {
-      DIST: workspace,
-      TRV_OUT: RootIndex.outputRoot,
-      ROOT: path.cwd(),
-      MOD: module
-    };
-
-    const content = [
+  static async writeEjectOutput(workspace: string, module: string, output: AsyncIterable<string>, file: string): Promise<void> {
+    const vars = { DIST: workspace, TRV_OUT: RootIndex.outputRoot, ROOT: path.cwd(), MOD: module };
+
+    const replaceArgs = (text: string): string => Object.entries(vars)
+      .reduce((str, [k, v]) => str.replaceAll(v, ActiveShellCommand.var(k)), text);
+
+    const preamble = [
       ActiveShellCommand.scriptOpen(),
       ...Object.entries(vars).map(([k, v]) => ActiveShellCommand.export(k, v).join(' ')),
-      Object.entries(vars).reduce((text, [k, v]) => text.replaceAll(v, ActiveShellCommand.var(k)), output.join('\n')),
-      '', ''
     ].join('\n');
 
-    if (file === '-' || file === '/dev/stdout') {
-      console.log!(content);
-    } else {
+    let stream: fs.FileHandle | undefined;
+
+    if (!(file === '-' || file === '/dev/stdout')) {
       await fs.mkdir(path.dirname(file), { recursive: true });
-      await fs.writeFile(file, content, 'utf8');
+      await fs.truncate(file);
+      stream = await fs.open(file, 'utf8');
     }
+
+    const write = (text: string): Promise<unknown> | unknown => stream ? stream.write(`${text}\n`) : process.stdout.write(`${text}\n`);
+
+    await write(preamble);
+    for await (const line of output) {
+      await write(replaceArgs(line));
+    }
+    await write('\n');
+
+    await stream?.close();
   }
 }

package/support/cli.pack.ts

@@ -1,14 +1,9 @@
+import { CliCommand } from '@travetto/cli';
+
 import { BasePackCommand } from './pack.base';
-import { CommonPackConfig, CommonPackOptions } from './bin/types';
 
 /**
  * Standard pack support
  */
-export class PackCommand extends BasePackCommand<CommonPackOptions, CommonPackConfig> {
-
-  name = 'pack';
-
-  getOptions(): CommonPackOptions {
-    return this.getCommonOptions();
-  }
-}
+@CliCommand({ fields: ['module'] })
+export class PackCommand extends BasePackCommand { }

package/support/cli.pack_docker.ts

@@ -1,42 +1,38 @@
 import { path, RootIndex } from '@travetto/manifest';
+import { CliCommand, CliFlag, CliUtil } from '@travetto/cli';
 
-import { DockerPackConfig, DockerPackOptions } from './bin/types';
 import { DockerPackOperation } from './bin/docker-operation';
 import { BasePackCommand, PackOperationShape } from './pack.base';
 
-
 /**
  * Standard docker support for pack
  */
-export class PackDockerCommand extends BasePackCommand<DockerPackOptions, DockerPackConfig> {
-
-  name = 'pack:docker';
-
-  getOptions(): DockerPackOptions {
-    const opts = this.getCommonOptions();
-    return {
-      ...opts,
-      dockerFactory: this.option({ short: 'df', desc: 'Docker Factory source', def: '@travetto/pack/support/pack.dockerfile' }),
-      dockerImage: this.option({ short: 'di', desc: 'Docker Image to extend', def: 'node:18-alpine3.16' }),
-      dockerName: this.option({ short: 'dn', desc: 'Docker Image Name', def: this.monoRoot ? '<module>' : this.getSimpleModuleName() }),
-      dockerTag: this.listOption({ short: 'dt', desc: 'Docker Image Tag', def: ['latest'] }),
-      dockerPort: this.listOption({ short: 'dp', desc: 'Docker Image Port' }),
-      dockerPush: this.boolOption({ short: 'dx', desc: 'Docker Push Tags' }),
-      dockerRegistry: this.option({ short: 'dr', desc: 'Docker Registry' })
-    };
-  }
+@CliCommand({ fields: ['module'] })
+export class PackDockerCommand extends BasePackCommand {
+  @CliFlag({ desc: 'Docker Factory source ', short: 'df', envVars: ['PACK_DOCKER_FACTORY'] })
+  dockerFactory = '@travetto/pack/support/pack.dockerfile';
+  @CliFlag({ desc: 'Docker Image to extend ', short: 'di', envVars: ['PACK_DOCKER_IMAGE'] })
+  dockerImage = 'node:18-alpine3.16';
+  @CliFlag({ desc: 'Docker Image Name ', short: 'dn', envVars: ['PACK_DOCKER_IMAGE'] })
+  dockerName = CliUtil.monoRoot ? '<module>' : CliUtil.getSimpleModuleName();
+  @CliFlag({ desc: 'Docker Image Tag ', short: 'dt', envVars: ['PACK_DOCKER_TAGS'] })
+  dockerTag: string[] = ['latest'];
+  @CliFlag({ desc: 'Docker Image Port ', short: 'dp', envVars: ['PACK_DOCKER_PORT'] })
+  dockerPort: number[] = [];
+  @CliFlag({ desc: 'Docker Push Tags ', short: 'dx', envVars: ['PACK_DOCKER_PUSH'] })
+  dockerPush = false;
+  @CliFlag({ desc: 'Docker Registry ', short: 'dr', envVars: ['PACK_DOCKER_REGISTRY'] })
+  dockerRegistry?: string;
 
-  async buildConfig(): Promise<DockerPackConfig> {
-    const cfg = await super.buildConfig();
-    if (cfg.dockerFactory.startsWith('.')) {
-      cfg.dockerFactory = RootIndex.getFromSource(path.resolve(cfg.dockerFactory))?.import ?? cfg.dockerFactory;
+  finalize(unknownArgs: string[]): void {
+    super.finalize(unknownArgs);
+    if (this.dockerFactory.startsWith('.')) {
+      this.dockerFactory = RootIndex.getFromSource(path.resolve(this.dockerFactory))?.import ?? this.dockerFactory;
     }
-    cfg.dockerPort ??= [];
-    cfg.dockerTag ??= [];
-    return cfg;
+    this.dockerName = this.dockerName.replace('<module>', CliUtil.getSimpleModuleName(this.module ?? ''));
   }
 
-  getOperations(): PackOperationShape<DockerPackConfig>[] {
+  getOperations(): PackOperationShape<this>[] {
     return [
       ...super.getOperations(),
       DockerPackOperation.writeDockerFile,

package/support/cli.pack_zip.ts

@@ -1,21 +1,19 @@
-import { CommonPackConfig, CommonPackOptions } from './bin/types';
+import { CliCommand, CliUtil } from '@travetto/cli';
+
 import { PackOperation } from './bin/operation';
 import { BasePackCommand, PackOperationShape } from './pack.base';
 
 /**
  * Standard zip support for pack
  */
-export class PackZipCommand extends BasePackCommand<CommonPackOptions, CommonPackConfig> {
-
-  name = 'pack:zip';
+@CliCommand({ fields: ['module'] })
+export class PackZipCommand extends BasePackCommand {
 
-  getOptions(): CommonPackOptions {
-    const opts = this.getCommonOptions();
-    opts.output.def = this.monoRoot ? '<module>.zip' : `${this.getSimpleModuleName()}.zip`;
-    return opts;
+  initialize(): void {
+    this.output = CliUtil.monoRoot ? '<module>.zip' : `${CliUtil.getSimpleModuleName()}.zip`;
   }
 
-  getOperations(): PackOperationShape<CommonPackConfig>[] {
+  getOperations(): PackOperationShape<this>[] {
     return [
       ...super.getOperations(),
       PackOperation.compress

package/support/pack.base.ts

@@ -1,149 +1,117 @@
 import os from 'os';
 
-import { CliCommand, cliTpl } from '@travetto/cli';
+import { CliCommandShape, CliFlag, cliTpl, CliUtil } from '@travetto/cli';
 import { path, RootIndex } from '@travetto/manifest';
 import { TimeUtil } from '@travetto/base';
 import { GlobalTerminal } from '@travetto/terminal';
+import { Ignore, Required, Schema } from '@travetto/schema';
 
-import { CommonPackConfig, CommonPackOptions } from './bin/types';
 import { PackOperation } from './bin/operation';
 import { PackUtil } from './bin/util';
 
-export type PackOperationShape<T extends CommonPackConfig> = ((config: T) => AsyncIterable<string[]>);
+export type PackOperationShape<T> = ((config: T) => AsyncIterable<string[]>);
 
-const BASIC_OP_SET = [
-  PackOperation.clean,
-  PackOperation.writeEnv,
-  PackOperation.writePackageJson,
-  PackOperation.writeEntryScript,
-  PackOperation.copyResources,
-  PackOperation.primeAppCache,
-  PackOperation.writeManifest,
-  PackOperation.bundle,
-];
+@Schema()
+export abstract class BasePackCommand implements CliCommandShape {
 
-export abstract class BasePackCommand<T extends CommonPackOptions, S extends CommonPackConfig> extends CliCommand<{}> {
-
-  get monoRoot(): boolean {
-    return !!RootIndex.manifest.monoRepo && path.cwd() === RootIndex.manifest.workspacePath;
-  }
-
-  get entryPoints(): string[] {
+  static get entryPoints(): string[] {
     return RootIndex.findSupport({ filter: x => x.includes('entry.') })
       .map(x => x.import.replace(/[.][^.]+s$/, ''));
   }
 
-  getArgs(): string | undefined {
-    return this.monoRoot ? '<module> [args...]' : '[args...]';
-  }
+  #unknownArgs?: string[];
 
-  getCommonOptions(): CommonPackOptions {
-    const mainEntry = this.entryPoints.find(x => x.startsWith('@travetto/cli'))!;
-    return {
-      workspace: this.option({ short: 'w', desc: 'Workspace for building' }),
-      clean: this.boolOption({ short: 'c', desc: 'Clean workspace', def: true }),
-      output: this.option({ short: 'o', desc: 'Output location' }),
-      mainScripts: this.option({ short: 'es', desc: 'Create entry scripts' }),
-      mainName: this.option({ short: 'f', desc: 'Main name for build artifact' }),
-      entryPoint: this.option({ short: 'e', desc: 'Entry point', def: mainEntry }),
-      minify: this.boolOption({ short: 'm', desc: 'Minify output', def: true }),
-      sourcemap: this.boolOption({ short: 'sm', desc: 'Bundle source maps' }),
-      includeSources: this.boolOption({ short: 'is', desc: 'Include source with source maps' }),
-      ejectFile: this.option({ short: 'x', desc: 'Eject commands to file' }),
-    };
-  }
+  @CliFlag({ desc: 'Workspace for building', short: 'w' })
+  workspace: string = path.resolve(os.tmpdir(), RootIndex.mainModule.sourcePath.replace(/[\/\\: ]/g, '_'));
 
-  abstract getOptions(): T;
+  @CliFlag({ desc: 'Clean workspace' })
+  clean = true;
 
-  get cmd(): S {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return super.cmd as S;
-  }
+  @CliFlag({ desc: 'Output location', short: 'o' })
+  @Required(false)
+  output: string;
 
-  getSimpleModuleName(): string {
-    return RootIndex.mainPackage.name.replace(/[\/]/, '_').replace(/@/, '');
-  }
+  @CliFlag({ desc: 'Create entry scripts', short: 'es' })
+  mainScripts: boolean = true;
+
+  @CliFlag({ desc: 'Main name for build artifact', short: 'f' })
+  @Required(false)
+  mainName: string;
+
+  @CliFlag({ desc: 'Entry point', short: 'e' })
+  @Required(false)
+  entryPoint: string = '@travetto/cli/support/entry.cli';
 
-  getOperations(): PackOperationShape<S>[] {
-    return BASIC_OP_SET.slice(0);
+  @CliFlag({ desc: 'Minify output' })
+  minify = true;
+
+  @CliFlag({ desc: 'Bundle source maps', short: 'sm' })
+  sourcemap = false;
+
+  @CliFlag({ desc: 'Include source with source maps', short: 'is' })
+  includeSources = false;
+
+  @CliFlag({ desc: 'Eject commands to file', short: 'x' })
+  ejectFile?: string;
+
+  @Ignore()
+  module: string;
+
+  /** Entry arguments */
+  @Ignore()
+  entryArguments: string[] = [];
+
+  getOperations(): PackOperationShape<this>[] {
+    return [
+      PackOperation.clean,
+      PackOperation.writeEnv,
+      PackOperation.writePackageJson,
+      PackOperation.writeEntryScript,
+      PackOperation.copyResources,
+      PackOperation.writeManifest,
+      PackOperation.bundle,
+    ];
   }
 
   /**
    * Run all operations
    */
-  async * runOperations(cfg: S): AsyncIterable<string> {
+  async * runOperations(): AsyncIterable<string> {
     for (const op of this.getOperations()) {
-      for await (const msg of op(cfg)) {
+      for await (const msg of op(this)) {
         yield msg.join(' ');
       }
     }
   }
 
+  finalize(unknown: string[]): void {
+    this.#unknownArgs = unknown;
 
-  getModule(moduleName: string): string {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    let module = this.monoRoot ? moduleName : RootIndex.mainModule.name;
-    module = RootIndex.getModuleByFolder(module)?.name ?? module;
-
-    // Reinitialize for module
-    if (this.monoRoot) {
-      RootIndex.reinitForModule(module);
-    }
-
-    return module;
-  }
-
-  async buildConfig(): Promise<S> {
-    this.cmd.workspace ??= path.resolve(os.tmpdir(), RootIndex.mainModule.sourcePath.replace(/[\/\\: ]/g, '_'));
-    this.cmd.module = RootIndex.mainModule.name;
-    this.cmd.mainName ??= path.basename(this.cmd.entryPoint);
-    return this.cmd;
-  }
-
-  async action(module: string, args: string[]): Promise<void> {
-    if (Array.isArray(module)) {
-      args = module;
-      module = RootIndex.mainModule.name;
-    }
-    const start = Date.now();
-    if (!module && this.monoRoot) {
-      return this.showHelp(new Error('The module needs to specified when running from a monorepo root'));
-    }
-
-    module = this.getModule(module);
-
-    const cfg = await this.buildConfig();
-    cfg.entryArguments = Array.isArray(args) ? args : [];
-
-    for (const k in this.cmd) {
-      if (Object.hasOwn(this.cmd, k)) {
-        const v = this.cmd[k];
-        if (typeof v === 'string' && /<module>/.test(v)) {
-          // @ts-expect-error
-          this.cmd[k] = v.replace(/<module>/g, this.getSimpleModuleName());
-        }
-      }
-    }
+    this.output = this.output?.replace('<module>', CliUtil.getSimpleModuleName(this.module ?? ''));
 
     // Resolve all files to absolute paths
-    if (this.cmd.output) {
-      this.cmd.output = path.resolve(this.cmd.output);
+    if (this.output) {
+      this.output = path.resolve(this.output);
     }
-    if (this.cmd.ejectFile) {
-      this.cmd.ejectFile = path.resolve(this.cmd.ejectFile);
+    if (this.ejectFile) {
+      this.ejectFile = path.resolve(this.ejectFile);
     }
-    this.cmd.workspace = path.resolve(this.cmd.workspace);
+    this.workspace = path.resolve(this.workspace);
+  }
+
+  async main(args: string[] = []): Promise<void> {
+    this.entryArguments = [...args, ...this.#unknownArgs ?? []];
+    this.module ||= RootIndex.mainModule.name;
+    this.mainName ??= path.basename(this.module);
 
-    const stream = this.runOperations(cfg);
+    const stream = this.runOperations();
 
     // Eject to file
-    if (this.cmd.ejectFile) {
-      const output: string[] = [];
-      for await (const line of stream) {
-        output.push(line);
-      }
-      await PackUtil.writeEjectOutput(this.cmd.workspace, cfg.module, output, this.cmd.ejectFile);
+    if (this.ejectFile) {
+      await PackUtil.writeEjectOutput(this.workspace, this.module, stream, this.ejectFile);
     } else {
+      const start = Date.now();
+
       await GlobalTerminal.streamLinesWithWaiting(stream, {
         initialDelay: 0,
         cycleDelay: 100,
@@ -151,9 +119,9 @@ export abstract class BasePackCommand<T extends CommonPackOptions, S extends Com
         position: 'inline',
         committedPrefix: String.fromCharCode(171)
       });
-      let msg = cliTpl`${{ success: 'Success' }} (${{ identifier: TimeUtil.prettyDeltaSinceTime(start) }}) ${{ subtitle: 'module' }}=${{ param: this.cmd.module }}`;
-      if (this.cmd.output) {
-        msg = cliTpl`${msg} ${{ subtitle: 'output' }}=${{ path: this.cmd.output }}`;
+      let msg = cliTpl`${{ success: 'Success' }} (${{ identifier: TimeUtil.prettyDeltaSinceTime(start) }}) ${{ subtitle: 'module' }}=${{ param: this.module }}`;
+      if (this.output) {
+        msg = cliTpl`${msg} ${{ subtitle: 'output' }}=${{ path: this.output }}`;
       }
       await GlobalTerminal.writeLines(msg);
     }

package/support/pack.dockerfile.ts

@@ -4,6 +4,6 @@ export const factory: DockerPackFactory = cfg => `
 FROM ${cfg.dockerImage}
 WORKDIR /app
 COPY . .
-${cfg.dockerPort.map(port => `EXPOSE ${port}`).join('\n')}
+${cfg.dockerPort?.map(port => `EXPOSE ${port}`).join('\n') ?? ''}
 ENTRYPOINT ["/app/${cfg.mainName}.sh"]
 `;