@travetto/pack 3.0.0-rc.2 → 3.0.0-rc.5

package/README.md

@@ -40,7 +40,7 @@ Assemble is the operation that stages the project's code for deployment.  The as
    
    1. Cleaning Workspace - Cleans workspace to start with an empty workspace
    1. Copying Dependencies - Computes the prod dependencies and copies them into the new workspace
-   1. Copying App Content - Copies over application content (src/resources/support/bin)
+   1. Copying App Content - Copies over application content (src/, resources/, support/, bin/)
    1. Excluding Pre-Compile Files - Any files that should be excluded pre-compilation, are removed
    1. Compiling - Compiles the code in the new workspace, isolating it from your local development
    1. Excluding Post-Compile Files - Removes any files that should be excluded, post compilation

package/__index__.ts

@@ -0,0 +1,5 @@
+export type { AllConfig, AllConfigPartial } from './support/bin/pack';
+export type { CommonConfig } from './support/bin/types';
+export type { AssembleConfig } from './support/bin/assemble/operation';
+export type { ZipConfig } from './support/bin/zip';
+export type { DockerConfig } from './support/bin/docker';

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@travetto/pack",
-  "displayName": "Pack",
-  "version": "3.0.0-rc.2",
+  "version": "3.0.0-rc.5",
   "description": "Code packing utilities",
   "keywords": [
     "travetto",
@@ -16,8 +15,7 @@
     "name": "Travetto Framework"
   },
   "files": [
-    "index.d.ts",
-    "bin",
+    "__index__.ts",
     "support"
   ],
   "repository": {
@@ -25,21 +23,23 @@
     "directory": "module/pack"
   },
   "dependencies": {
-    "@travetto/base": "^3.0.0-rc.2",
+    "@travetto/base": "^3.0.0-rc.5",
     "@types/picomatch": "^2.3.0",
     "picomatch": "^2.3.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.0-rc.2"
+    "@travetto/cli": "^3.0.0-rc.5"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {
       "optional": true
     }
   },
-  "docDependencies": {
-    "@travetto/rest": true,
-    "@travetto/rest-aws-lambda": true
+  "travetto": {
+    "displayName": "Pack",
+    "profiles": [
+      "build"
+    ]
   },
   "publishConfig": {
     "access": "public"

package/support/bin/assemble/operation.ts

@@ -0,0 +1,59 @@
+import fs from 'fs/promises';
+
+import { path } from '@travetto/manifest';
+import { cliTpl } from '@travetto/cli';
+import { Env } from '@travetto/base';
+
+import { PackUtil } from '../util';
+import { CommonConfig, PackOperation } from '../types';
+import { AssembleUtil } from './util';
+export interface AssembleConfig extends CommonConfig {
+  keepSource: boolean;
+  readonly: boolean;
+  add: Record<string, string>[];
+  exclude: string[];
+  env: Record<string, string | undefined>;
+}
+
+/**
+ * Utils for packing source code and minimizing space usage
+ */
+export const Assemble: PackOperation<AssembleConfig, 'assemble'> = {
+  key: 'assemble',
+  title: 'Assembling',
+  context(cfg: AssembleConfig) {
+    return `[readonly=${cfg.readonly},source=${cfg.keepSource}]`;
+  },
+  overrides: {
+    keepSource: Env.getBoolean('PACK_ASSEMBLE_KEEP_SOURCE'),
+    readonly: Env.getBoolean('PACK_ASSEMBLE_READONLY')
+  },
+  extend(src: Partial<AssembleConfig>, dest: Partial<AssembleConfig>): Partial<AssembleConfig> {
+    return {
+      keepSource: src.keepSource ?? dest.keepSource,
+      readonly: src.readonly ?? dest.readonly,
+      add: [...(src.add ?? []), ...(dest.add ?? [])],
+      exclude: [...(src.exclude ?? []), ...(dest.exclude ?? [])],
+      env: { ...(src.env ?? {}), ...(dest.env ?? {}) },
+    };
+  },
+  buildConfig(configs: Partial<AssembleConfig>[]): AssembleConfig {
+    return PackUtil.buildConfig(this, configs);
+  },
+  /**
+   * Assemble the project into a workspace directory, optimized for space and runtime
+   */
+  async * exec({ workspace, add, exclude, env, keepSource }: AssembleConfig) {
+    const ws = path.resolve(workspace!);
+    yield 'Cleaning Workspace'; {
+      await fs.rm(ws, { recursive: true, force: true }).catch(() => { });
+      await fs.mkdir(ws);
+    }
+    yield 'Create Entrypoint'; await AssembleUtil.copyEntryPoint(ws);
+    yield 'Copying Prod Dependencies'; await AssembleUtil.copyProdDependencies(ws, keepSource);
+    yield 'Excluding Files'; await AssembleUtil.excludeFiles(ws, exclude);
+    yield 'Copying Added Content'; await AssembleUtil.copyAddedContent(ws, add);
+    yield 'Removing Empty Folders'; await AssembleUtil.removeEmptyFolders(ws);
+    yield cliTpl`${{ success: 'Successfully' }} assembled project at ${{ path: workspace }}`;
+  }
+};

package/support/bin/assemble/util.ts

@@ -0,0 +1,139 @@
+import fs from 'fs/promises';
+
+import { IndexedModule, Package, PackageUtil, path, RootIndex } from '@travetto/manifest';
+import { FileQueryProvider, TypedObject } from '@travetto/base';
+
+import { PackUtil } from '../util';
+
+/**
+ * Utils for assembling
+ */
+export class AssembleUtil {
+
+  /**
+   * Purge workspace using file rules
+   */
+  static async excludeFiles(root: string, files: string[]): Promise<void> {
+    const filter = PackUtil.excludeChecker(files, root);
+    for await (const el of FileQueryProvider.query({ paths: [root], filter, hidden: true })) {
+      try {
+        await fs.unlink(el);
+      } catch { }
+    }
+  }
+
+  /**
+   * Copy over added content
+   */
+  static async copyAddedContent(workspace: string, files: Record<string, string>[]): Promise<void> {
+    for (const a of files) {
+      let [src, dest] = Object.entries(a)[0];
+      [src, dest] = [path.resolve(src), path.resolve(workspace, dest)];
+      const stat = await fs.stat(src).catch(() => { });
+      if (stat) {
+        if (stat.isFile()) {
+          await fs.mkdir(path.dirname(dest), { recursive: true });
+          await fs.copyFile(src, dest);
+        } else {
+          await fs.mkdir(path.dirname(dest), { recursive: true });
+          await PackUtil.copyRecursive(src, dest);
+        }
+      }
+    }
+  }
+
+  static async copyModule(workspace: string, module: IndexedModule, keepSource?: boolean): Promise<void> {
+    const toCopy: Promise<void>[] = [];
+    for (const [key, files] of TypedObject.entries(module.files)) {
+      switch (key) {
+        case '$index':
+        case '$root':
+        case '$package':
+        case 'src':
+        case 'support':
+        case 'resources':
+        case 'bin': {
+          for (const file of files) {
+            const targetPartial = file.output.split(RootIndex.manifest.outputFolder)[1];
+            const target = path.join(workspace, targetPartial);
+            const src = await fs.stat(file.output).then(() => file.output, () => file.source);
+            toCopy.push((async (): Promise<void> => {
+              await fs.mkdir(path.dirname(target), { recursive: true });
+              await fs.copyFile(src, target);
+
+              if (file.type === 'ts' || file.type === 'js') {
+                if (keepSource) {
+                  await fs.copyFile(`${src}.map`, `${target}.map`).catch(() => { });
+                } else {
+                  await fs.writeFile(target, (await fs.readFile(target, 'utf8')).replace(/\/\/# sourceMap.*/g, ''));
+                }
+              }
+            })());
+          }
+          break;
+        }
+      }
+    }
+    await Promise.all(toCopy);
+  }
+
+  /**
+   * Copy over all prod dependencies
+   */
+  static async copyProdDependencies(workspace: string, keepSource?: boolean): Promise<void> {
+    const pkgs = await PackageUtil.visitPackages<{ pkg: Package, src: string }>(RootIndex.mainModule.source, {
+      valid: req =>
+        (req.rel === 'prod' || req.rel === 'opt' || req.rel === 'root') &&
+        !req.pkg.name.startsWith('@types/'),
+      create: req => ({ pkg: req.pkg, src: req.sourcePath }),
+    });
+    await fs.mkdir(path.resolve(workspace, 'node_modules'), { recursive: true });
+    for (const { pkg, src } of pkgs) {
+      if (RootIndex.hasModule(pkg.name)) {
+        await this.copyModule(workspace, RootIndex.getModule(pkg.name)!, keepSource);
+      } else {
+        const folder = path.dirname(path.resolve(workspace, 'node_modules', src.replace(/^.*?node_modules\//, '')));
+        await PackUtil.copyRecursive(src, folder);
+      }
+    }
+  }
+
+  /**
+   * Copy over entry point
+   */
+  static async copyEntryPoint(workspace: string): Promise<void> {
+    // Faux-package.json
+    await fs.writeFile(path.resolve(workspace, 'package.json'), JSON.stringify({
+      name: '@entry/main',
+      version: RootIndex.mainPackage.version,
+      dependencies: { [RootIndex.mainPackage.name]: '*', }
+    }, null, 2), 'utf8');
+
+    const manifest = structuredClone(RootIndex.manifest);
+    for (const [name, mod] of TypedObject.entries(manifest.modules)) {
+      if (!mod.profiles.includes('std')) {
+        delete manifest.modules[name];
+      }
+    }
+
+    manifest.manifestFile = 'manifest.json';
+    manifest.mainPath = RootIndex.manifest.modules[RootIndex.mainPackage.name].output;
+
+    await fs.writeFile(path.resolve(workspace, 'manifest.json'), JSON.stringify(manifest), 'utf8');
+
+    const output = path.resolve(RootIndex.manifest.workspacePath, RootIndex.manifest.outputFolder);
+    for (const file of [
+      path.resolve(output, 'trv'), // Entry points
+      path.resolve(output, 'trv.cmd')
+    ]) {
+      await fs.copyFile(file, path.resolve(workspace, path.basename(file)));
+    }
+  }
+
+  /**
+   * Delete all empty folders
+   */
+  static async removeEmptyFolders(root: string): Promise<void> {
+    // Remove
+  }
+}

package/{bin/operation → support/bin}/docker.ts

@@ -1,11 +1,11 @@
-import { promises as fs } from 'fs';
+import fs from 'fs/promises';
 
-import { ExecUtil, Package, PathUtil } from '@travetto/boot';
-import { color } from '@travetto/cli/src/color';
-import { CliUtil } from '@travetto/cli/src/util';
+import { path, RootIndex } from '@travetto/manifest';
+import { Env, ExecUtil } from '@travetto/base';
+import { cliTpl } from '@travetto/cli';
 
-import { CommonConfig, PackOperation } from '../lib/types';
-import { PackUtil } from '../lib/util';
+import { CommonConfig, PackOperation } from './types';
+import { PackUtil } from './util';
 
 export interface DockerConfig extends CommonConfig {
   image: string;
@@ -25,7 +25,7 @@ WORKDIR /app
 COPY . .
 ${Object.entries(env).map(([k, v]) => `ENV ${k} "${v}"`).join('\n')}
 ${(port ?? []).map(x => `EXPOSE ${x}`).join('\n')}
-CMD ["node", "./node_modules/@travetto/cli/bin/trv", "run", "${app}"]
+CMD ["./trv", "run", "${app}"]
 `;
 
 export const Docker: PackOperation<DockerConfig, 'docker'> = {
@@ -35,19 +35,20 @@ export const Docker: PackOperation<DockerConfig, 'docker'> = {
     return `[image=${cfg.image}, port=${cfg.port}]`;
   },
   defaults: {
-    name: Package.name.replace('@', ''),
+    name: RootIndex.mainPackage.name.replace('@', ''),
+    image: 'node:18-alpine3.16',
     builder: dockerFileBuilder,
     port: [],
     tag: ['latest']
   },
   overrides: {
-    image: process.env.PACK_DOCKER_IMAGE || undefined,
-    name: process.env.PACK_DOCKER_NAME || undefined,
-    app: process.env.PACK_DOCKER_APP || undefined,
-    port: process.env.PACK_DOCKER_PORT ? [process.env.PACK_DOCKER_PORT] : undefined,
-    registry: process.env.PACK_DOCKER_REGISTRY || undefined,
-    push: CliUtil.toBool(process.env.PACK_DOCKER_PUSH),
-    tag: process.env.PACK_DOCKER_TAG ? [process.env.PACK_DOCKER_TAG] : undefined
+    image: Env.get('PACK_DOCKER_IMAGE') || undefined,
+    name: Env.get('PACK_DOCKER_NAME') || undefined,
+    app: Env.get('PACK_DOCKER_APP') || undefined,
+    registry: Env.get('PACK_DOCKER_REGISTRY') || undefined,
+    push: Env.getBoolean('PACK_DOCKER_PUSH'),
+    port: Env.getList('PACK_DOCKER_PORT'),
+    tag: Env.getList('PACK_DOCKER_TAG')
   },
   extend(src: Partial<DockerConfig>, dest: Partial<DockerConfig>): Partial<DockerConfig> {
     return {
@@ -71,11 +72,11 @@ export const Docker: PackOperation<DockerConfig, 'docker'> = {
   async* exec(cfg: DockerConfig) {
     const { builder, workspace, push, image, tag, name, registry } = cfg;
 
-    const ws = PathUtil.resolveUnix(workspace);
+    const ws = path.resolve(workspace);
 
     yield 'Building Dockerfile';
 
-    await fs.writeFile(PathUtil.resolveUnix(ws, 'Dockerfile'), builder!(cfg), { encoding: 'utf8' });
+    await fs.writeFile(path.resolve(ws, 'Dockerfile'), builder!(cfg), { encoding: 'utf8' });
 
     yield 'Pulling Base Image';
     await ExecUtil.spawn('docker', ['pull', image]).result;
@@ -91,6 +92,6 @@ export const Docker: PackOperation<DockerConfig, 'docker'> = {
       await ExecUtil.spawn('docker', ['image', 'push', ...tags]).result;
     }
 
-    yield color`${{ success: 'Successfully' }} containerized project`;
+    yield cliTpl`${{ success: 'Successfully' }} containerized project`;
   }
 };

package/{bin/operation → support/bin}/pack.ts

@@ -1,8 +1,8 @@
-import { color } from '@travetto/cli/src/color';
+import { cliTpl } from '@travetto/cli';
 
-import { CommonConfig, PackOperation } from '../lib/types';
-import { PackUtil } from '../lib/util';
-import { Assemble, AssembleConfig } from './assemble';
+import { CommonConfig, PackOperation } from './types';
+import { PackUtil } from './util';
+import { Assemble, AssembleConfig } from './assemble/operation';
 import { Docker, DockerConfig } from './docker';
 import { Zip, ZipConfig } from './zip';
 
@@ -64,6 +64,6 @@ export const Pack: PackOperation<AllConfig, ''> = {
       await PackUtil.runOperation(op, cfg[step], 2);
     }
     process.stdout.write('\n');
-    yield color`${{ success: 'Successfully' }} packed project`;
+    yield cliTpl`${{ success: 'Successfully' }} packed project`;
   }
 };

package/{bin/lib → support/bin}/util.ts

@@ -1,12 +1,11 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
+import fs from 'fs/promises';
 
-// TODO: Get proper typings
-const glob = require('picomatch');
+import glob from 'picomatch';
 
-import { FsUtil, PathUtil, ScanFs } from '@travetto/boot';
-import { SourceIndex } from '@travetto/boot/src/internal/source';
-import { color } from '@travetto/cli/src/color';
+import { path, RootIndex } from '@travetto/manifest';
+import { cliTpl } from '@travetto/cli';
+import { ExecUtil } from '@travetto/base';
+import { stripAnsiCodes } from '@travetto/terminal';
 
 import { CommonConfig, PackOperation } from './types';
 
@@ -51,10 +50,10 @@ export class PackUtil {
   static async modeList(): Promise<Partial<CommonConfig>[]> {
     if (!this.#modes) {
       this.#modes = await Promise.all(
-        SourceIndex.find({ folder: 'support', filter: f => /\/pack[.].*[.]ts/.test(f) })
+        RootIndex.findSupport({ filter: f => /\/pack[.].*[.]/.test(f) })
           .map(async (x) => {
-            const req: Partial<CommonConfig> = (await import(x.file)).config;
-            req.file = x.module.replace(/^node_modules\//, '');
+            const req: Partial<CommonConfig> = (await import(x.output)).config;
+            req.file = x.import.replace(/^node_modules\//, '');
             return req;
           })
       );
@@ -71,14 +70,14 @@ export class PackUtil {
       const negate = x.startsWith('!') || x.startsWith('^');
       x = negate ? x.substring(1) : x;
       x = x.replace(/^[.][/]/g, `${base}/`);
-      const match: (f: string) => boolean = glob(x, { nocase: true, dot: true, basename: base, contains: true });
+      const match: (f: string) => boolean = glob(x, { nocase: true, dot: true, basename: true, contains: true, cwd: base });
       Object.defineProperty(match, 'source', { value: x });
       return [match, negate] as const;
     });
 
     return (f: string): boolean => {
       let exclude = undefined;
-      f = PathUtil.resolveUnix(base, f);
+      f = path.resolve(base, f);
       for (const [match, n] of all) {
         if ((n || exclude === undefined) && match(f)) {
           if (n) { // Fast exit if negating
@@ -95,27 +94,14 @@ export class PackUtil {
    * Update .env.js with new env data
    */
   static async writeEnvJs(workspace: string, env: Record<string, string | undefined>): Promise<void> {
-    const out = `${workspace}/.env.js`;
+    const out = path.resolve(workspace, '.env.js');
     let src = '';
-    if (!!(await FsUtil.exists(out))) {
+    if (!!(await fs.stat(out).catch(() => { }))) {
       src = await fs.readFile(out, 'utf8');
     }
     const lines = Object.entries(env).map(([k, v]) => v ? `process.env['${k}'] = \`${v.replace(/`/g, '\\`')}\`;` : '');
     const content = `${src}\n${lines.join('\n')}`;
-    await fs.writeFile(PathUtil.resolveUnix(workspace, '.env.js'), content, { encoding: 'utf8' });
-  }
-
-  /**
-   * Delete all empty folders
-   */
-  static async removeEmptyFolders(root: string): Promise<void> {
-    for (const el of await ScanFs.scanDir({ testDir: x => true, testFile: x => false, withHidden: true }, root)) {
-      let dir = el.file;
-      while ((await fs.readdir(dir)).length === 0) { // empty
-        await fs.rmdir(dir);
-        dir = path.dirname(dir);
-      }
-    }
+    await fs.writeFile(out, content, { encoding: 'utf8' });
   }
 
   /**
@@ -124,16 +110,16 @@ export class PackUtil {
   static async runOperation<T extends CommonConfig>(op: PackOperation<T, string>, cfg: T, indent = 0): Promise<void> {
     const spacer = ' '.repeat(indent);
     const ctx = await op.context(cfg);
-    const title = color`${{ title: op.title }} ${ctx}`;
-    const width = Math.max(title.replace(/\x1b\[\d+m/g, '').length, 50); // eslint-disable-line
+    const title = cliTpl`${{ title: op.title }} ${ctx}`;
+    const width = Math.max(stripAnsiCodes(title).length, 50); // eslint-disable-line
 
     let i = 0;
     function stdout(msg?: string): void {
       if (i++ > 0) {
-        process.stdout.write(color`${spacer}${{ param: 'done' }}\n`);
+        process.stdout.write(cliTpl`${spacer}${{ param: 'done' }}\n`);
       }
       if (msg) {
-        process.stdout.write(color`${spacer}${{ output: '᳁' }} ${{ path: msg.padEnd(width - 15) }} ... `);
+        process.stdout.write(cliTpl`${spacer}${{ output: '᳁' }} ${{ path: msg.padEnd(width - 15) }} ... `);
       }
     }
 
@@ -172,4 +158,21 @@ export class PackUtil {
       process.stdout.write(`${spacer}${message}\n`);
     }
   }
+
+  /**
+   * Remove directory, determine if errors should be ignored
+   * @param src The folder to copy
+   * @param dest The folder to copy to
+   * @param ignore Should errors be ignored
+   */
+  static async copyRecursive(src: string, dest: string, ignore = false): Promise<void> {
+    const [cmd, args] = process.platform === 'win32' ?
+      ['xcopy', ['/y', '/h', '/s', path.toNative(src), path.toNative(dest)]] :
+      ['cp', ['-r', '-p', src, dest]];
+
+    const res = await ExecUtil.spawn(cmd, args, { catchAsResult: true }).result;
+    if (res.code && !ignore) {
+      throw new Error(`Failed to copy ${src} to ${dest}`);
+    }
+  }
 }

package/{bin/operation → support/bin}/zip.ts

@@ -1,11 +1,11 @@
-import * as path from 'path';
-import * as fs from 'fs/promises';
+import fs from 'fs/promises';
 
-import { ExecUtil, FsUtil, PathUtil } from '@travetto/boot';
-import { color } from '@travetto/cli/src/color';
+import { path } from '@travetto/manifest';
+import { ExecUtil } from '@travetto/base';
+import { cliTpl } from '@travetto/cli';
 
-import { CommonConfig, PackOperation } from '../lib/types';
-import { PackUtil } from '../lib/util';
+import { CommonConfig, PackOperation } from './types';
+import { PackUtil } from './util';
 
 export interface ZipConfig extends CommonConfig {
   output: string;
@@ -30,12 +30,12 @@ export const Zip: PackOperation<ZipConfig, 'zip'> = {
   * Zip workspace with flags
   */
   async * exec({ workspace, output }: ZipConfig) {
-    const ws = PathUtil.resolveUnix(workspace);
-    const zipFile = PathUtil.resolveUnix(output);
+    const ws = path.resolve(workspace);
+    const zipFile = path.resolve(output);
 
     yield 'Preparing Target';
     await fs.mkdir(path.dirname(zipFile), { recursive: true });
-    if (await FsUtil.exists(zipFile)) {
+    if (await fs.stat(zipFile).catch(() => { })) {
       await fs.unlink(zipFile); // Unlink
     }
 
@@ -46,6 +46,6 @@ export const Zip: PackOperation<ZipConfig, 'zip'> = {
       await ExecUtil.spawn('zip', ['-r', zipFile, '.'], { cwd: ws }).result;
     }
 
-    yield color`${{ success: 'Successfully' }} archived project to ${{ path: zipFile.replace(PathUtil.cwd, '.') }}`;
+    yield cliTpl`${{ success: 'Successfully' }} archived project to ${{ path: zipFile.replace(path.cwd(), '.') }}`;
   }
 };

package/{bin/pack-base.ts → support/cli.pack-base.ts}

@@ -1,13 +1,12 @@
-import * as os from 'os';
+import os from 'os';
 
-import { CliCommand, OptionConfig } from '@travetto/cli/src/command';
-import { color } from '@travetto/cli/src/color';
-import { PathUtil, Package, FsUtil } from '@travetto/boot';
+import { path, RootIndex } from '@travetto/manifest';
+import { CliCommand, CliScmUtil, cliTpl, OptionConfig } from '@travetto/cli';
 
-import { PackUtil } from './lib/util';
-import { CommonConfig, PackOperation } from './lib/types';
+import { PackUtil } from './bin/util';
+import { CommonConfig, PackOperation } from './bin/types';
 
-const packName = `pack_${Package.name}`
+const packName = `pack_${RootIndex.mainPackage.name}`
   .toLowerCase()
   .replace(/[^a-z]+/g, '_')
   .replace(/_+/g, '_');
@@ -44,19 +43,9 @@ export abstract class BasePackCommand<V extends BaseOptions, C extends CommonCon
     return { workspace: this.option({ desc: 'Working directory' }) } as const;
   }
 
-  async resolveConfigs(): Promise<C> {
-    const list = (await PackUtil.modeList());
-    if (!this.args[0]) {
-      this.showHelp('Missing config mode');
-    }
-    const cfg = list.find(c => c.name === this.args[0]);
-    if (!cfg) {
-      this.showHelp(`Unknown config mode: ${this.args[0]}`);
-    }
-    const def = list.find(c => c.name === 'default');
-
+  async resolveConfigs(cfg: Partial<CommonConfig>, def?: Partial<CommonConfig>): Promise<C> {
     const configs = [
-      { workspace: PathUtil.resolveUnix(os.tmpdir(), packName) },
+      { workspace: path.resolve(os.tmpdir(), packName) },
       def,
       cfg,
       this.cmdOptions,
@@ -77,22 +66,30 @@ export abstract class BasePackCommand<V extends BaseOptions, C extends CommonCon
 
     const out: string[] = [];
     if (lines.length) {
-      out.push('', color`${{ title: 'Available Pack Modes:' }}`);
+      out.push('', cliTpl`${{ title: 'Available Pack Modes:' }}`);
       for (const { name, file } of lines) {
-        out.push(color`  * ${{ input: `${name}` }} [${{ path: file }}]`);
+        out.push(cliTpl`  * ${{ input: `${name}` }} [${{ path: file }}]`);
       }
       out.push('');
     }
     return out.join('\n');
   }
 
-  override async complete(): Promise<Record<string, string[]>> {
-    return { '': (await PackUtil.modeList()).map(x => x.name!) };
-  }
-
   async action(): Promise<void> {
-    const resolved = await this.resolveConfigs();
-    if (await FsUtil.exists(PathUtil.resolveUnix(resolved.workspace, '.git'))) {
+    if (!this.args[0]) {
+      return this.showHelp('Missing config mode');
+    }
+
+    const list = (await PackUtil.modeList());
+    const cfg = list.find(c => c.name === this.args[0]);
+    if (!cfg) {
+      return this.showHelp(`Unknown config mode: ${this.args[0]}`);
+    }
+
+    const def = list.find(c => c.name === 'default');
+
+    const resolved = await this.resolveConfigs(cfg, def);
+    if (await CliScmUtil.isRepoRoot(resolved.workspace)) {
       throw new Error('Refusing to use workspace with a .git directory');
     }
     return PackUtil.runOperation(this.operation, resolved);

package/{bin/cli-pack.ts → support/cli.pack.ts}

@@ -1,7 +1,7 @@
-import { BaseOptions, BasePackCommand } from './pack-base';
-import { Pack, AllConfig } from './operation/pack';
+import { BaseOptions, BasePackCommand } from './cli.pack-base';
+import { Pack, AllConfig } from './bin/pack';
 
-export class PackCommand extends BasePackCommand<BaseOptions, AllConfig> {
+export class PackCommand extends BasePackCommand<BaseOptions, AllConfig, ''> {
   operation = Pack;
 
   getOptions(): BaseOptions {

package/{bin/cli-pack_assemble.ts → support/cli.pack_assemble.ts}

@@ -1,14 +1,14 @@
-import { OptionConfig } from '@travetto/cli/src/command';
+import { OptionConfig } from '@travetto/cli';
 
-import { BaseOptions, BasePackCommand } from './pack-base';
-import { Assemble, AssembleConfig } from './operation/assemble';
+import { BaseOptions, BasePackCommand } from './cli.pack-base';
+import { Assemble, AssembleConfig } from './bin/assemble/operation';
 
 type Options = BaseOptions & {
   keepSource: OptionConfig<boolean>;
   readonly: OptionConfig<boolean>;
 };
 
-export class PackAssembleCommand extends BasePackCommand<Options, AssembleConfig> {
+export class PackAssembleCommand extends BasePackCommand<Options, AssembleConfig, 'assemble'> {
   operation = Assemble;
 
   getOptions(): Options {

package/{bin/cli-pack_docker-export.ts → support/cli.pack_docker-export.ts}

@@ -1,7 +1,8 @@
-import * as fs from 'fs/promises';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
 
-import { FsUtil, PathUtil } from '@travetto/boot';
-import { CliCommand, OptionConfig, ListOptionConfig } from '@travetto/cli/src/command';
+import { path } from '@travetto/manifest';
+import { CliCommand, OptionConfig, ListOptionConfig } from '@travetto/cli';
 
 type Options = {
   app: OptionConfig<string>;
@@ -26,8 +27,8 @@ export class PackDockerExportCommand extends CliCommand<Options> {
   }
 
   async action(...args: unknown[]): Promise<void> {
-    const files = ['src', 'bin', 'support', 'resources', 'package.json', 'package-lock.json', ...this.cmd.add]
-      .filter(x => FsUtil.existsSync(PathUtil.resolveUnix(x)));
+    const files = ['src', 'bin', 'support', 'resource', 'package.json', 'package-lock.json', ...this.cmd.add]
+      .filter(x => existsSync(path.resolve(x)));
 
     const content = `
 FROM ${this.cmd.image} as build
@@ -42,7 +43,7 @@ COPY --from=build /app /app
 EXPOSE ${this.cmd.port}
 WORKDIR  /app
 ENV NODE_OPTIONS "--no-deprecation"
-CMD ["node", "./node_modules/@travetto/cli/bin/trv", "run", "${this.cmd.app}"]
+CMD ["./trv", "run", "${this.cmd.app}"]
 `;
 
     if (this.cmd.output === '-' || this.cmd.output === '/dev/stdout' || !this.cmd.output) {

package/{bin/cli-pack_docker.ts → support/cli.pack_docker.ts}

@@ -1,7 +1,7 @@
-import { OptionConfig, ListOptionConfig } from '@travetto/cli/src/command';
+import { OptionConfig, ListOptionConfig } from '@travetto/cli';
 
-import { BaseOptions, BasePackCommand } from './pack-base';
-import { Docker, DockerConfig } from './operation/docker';
+import { BaseOptions, BasePackCommand } from './cli.pack-base';
+import { Docker, DockerConfig } from './bin/docker';
 
 type Options = BaseOptions & {
   image: OptionConfig<string>;
@@ -12,7 +12,7 @@ type Options = BaseOptions & {
   registry: OptionConfig<string>;
 };
 
-export class PackDockerCommand extends BasePackCommand<Options, DockerConfig> {
+export class PackDockerCommand extends BasePackCommand<Options, DockerConfig, 'docker'> {
   operation = Docker;
 
   getOptions(): Options {

package/{bin/cli-pack_zip.ts → support/cli.pack_zip.ts}

@@ -1,13 +1,13 @@
-import { OptionConfig } from '@travetto/cli/src/command';
+import { OptionConfig } from '@travetto/cli';
 
-import { BaseOptions, BasePackCommand } from './pack-base';
-import { Zip, ZipConfig } from './operation/zip';
+import { BaseOptions, BasePackCommand } from './cli.pack-base';
+import { Zip, ZipConfig } from './bin/zip';
 
 type Options = BaseOptions & {
   output: OptionConfig<string>;
 };
 
-export class PackZipCommand extends BasePackCommand<Options, ZipConfig> {
+export class PackZipCommand extends BasePackCommand<Options, ZipConfig, 'zip'> {
   operation = Zip;
 
   getOptions(): Options {

package/support/pack.config.ts

@@ -1,4 +1,4 @@
-import { AllConfigPartial } from '../bin/operation/pack';
+import { AllConfigPartial } from './bin/pack';
 
 const mod = (f: string): string => `node_modules/${f}`;
 
@@ -6,7 +6,6 @@ export const config: AllConfigPartial = {
   name: 'default',
   assemble: {
     active: true,
-    cacheDir: 'cache',
     keepSource: true,
     readonly: true,
     env: {
@@ -16,11 +15,6 @@ export const config: AllConfigPartial = {
       { [mod('@travetto/cli/bin/trv.js')]: mod('.bin/trv') },
       { [mod('lodash/lodash.min.js')]: mod('lodash/lodash.js') },
     ],
-    excludeCompile: [
-      mod('@travetto/*/doc/'),
-      mod('@travetto/*/e2e/'),
-      mod('@travetto/*/test/'),
-    ],
     exclude: [
       'bower.json',
       'LICENSE',
@@ -50,7 +44,7 @@ export const config: AllConfigPartial = {
       mod('typescript/'),
       mod('@types/'),
       `^./${mod('@travetto/**/*.ts')}`,
-      `^./${mod('@travetto/boot/tsconfig.trv.json')}`,
+      `^./${mod('@travetto/compiler/tsconfig.trv.json')}`,
       '^./resources/',
       '^./src/',
     ]

package/bin/lib/assemble.ts

@@ -1,151 +0,0 @@
-import * as path from 'path';
-import { promises as fs } from 'fs';
-
-import { ExecUtil, PathUtil, ScanFs, FsUtil } from '@travetto/boot';
-
-import { DependenciesUtil, DepType } from './dependencies';
-import { PackUtil } from './util';
-
-const MODULE_DIRS = ['src', 'bin', 'support', 'resources', 'index.ts', 'package.json', 'tsconfig.trv.json'];
-
-/**
- * Utils for assembling
- */
-export class AssembleUtil {
-
-  /**
-   * Minimize cached source files, by removing source mapping info
-   */
-  static async cleanCache(cache: string): Promise<void> {
-    for (const el of await fs.readdir(cache)) {
-      if (el.endsWith('.ts') || el.endsWith('.js')) {
-        const content = (await fs.readFile(`${cache}/${el}`, 'utf8')).replace(/\/\/# sourceMap.*/g, '');
-        await fs.writeFile(`${cache}/${el}`, content);
-      }
-    }
-  }
-
-  /**
-   * Minimize cached source files, by removing source mapping info
-   */
-  static async cleanBoot(ws: string): Promise<void> {
-    for (const el of await ScanFs.scanDir({
-      testFile: f => f.endsWith('.js') || f.endsWith('.d.ts'),
-      testDir: x => true
-    }, `${ws}/node_modules/@travetto/boot`)) {
-      if (el.file.endsWith('.d.ts')) {
-        await fs.writeFile(el.file, '');
-      } else if (el.file.endsWith('.js')) {
-        const content = (await fs.readFile(el.file, 'utf8')).replace(/\/\/# sourceMap.*/g, '');
-        await fs.writeFile(el.file, content);
-      }
-    }
-  }
-
-  /**
-   * Truncate all app source files, and framework source files
-   */
-  static async purgeSource(folders: string[]): Promise<void> {
-    for (const sub of folders) {
-      for (const f of await ScanFs.scanDir({ testFile: x => x.endsWith('.ts'), testDir: x => true }, sub)) {
-        if (f.stats?.isFile() && !f.module.startsWith('cli/')) {
-          await fs.writeFile(f.file, '');
-        }
-      }
-    }
-  }
-
-  /**
-   * Copy a module
-   */
-  static async copyModule(root: string, target: string): Promise<void> {
-    for (const f of MODULE_DIRS) {
-      const sourceFile = PathUtil.resolveUnix(root, f);
-      const targetFile = PathUtil.resolveUnix(target, f);
-      const found = await FsUtil.exists(sourceFile);
-      if (found) {
-        if (found.isFile()) {
-          await fs.copyFile(sourceFile, targetFile);
-        } else {
-          await fs.mkdir(targetFile, { recursive: true });
-          await FsUtil.copyRecursive(`${sourceFile}/*`, targetFile);
-        }
-      }
-    }
-  }
-
-  /**
-   * Purge workspace using file rules
-   */
-  static async excludeFiles(root: string, files: string[]): Promise<void> {
-    const checker = PackUtil.excludeChecker(files, root);
-    for (const el of await ScanFs.scanDir({ testDir: x => true, testFile: checker, withHidden: true }, root)) {
-      if (!el.stats || !el.stats.isFile()) { continue; }
-      try {
-        await fs.unlink(el.file);
-      } catch { }
-    }
-  }
-
-  /**
-   * Copy over all prod dependencies
-   */
-  static async copyDependencies(workspace: string, types: DepType[] = ['prod', 'opt', 'peer']): Promise<void> {
-
-    for (const el of await DependenciesUtil.resolveDependencies({ types })) {
-      const sub = PathUtil.normalizeFrameworkPath(el.file, 'node_modules/')
-        .replace(/.*?node_modules/, 'node_modules');
-
-      const tgt = PathUtil.resolveUnix(workspace, sub);
-      await fs.mkdir(path.dirname(tgt), { recursive: true });
-
-      if (el.dep.startsWith('@travetto')) {
-        await this.copyModule(el.file, tgt);
-      } else {
-        if (!(await FsUtil.exists(tgt))) {
-          await FsUtil.copyRecursive(el.file, tgt);
-        }
-      }
-    }
-    await FsUtil.copyRecursive(
-      PathUtil.resolveUnix(path.dirname(require.resolve('@travetto/boot/bin/main.js'))),
-      PathUtil.resolveUnix(workspace, 'node_modules/@travetto/boot/bin')
-    );
-    await FsUtil.copyRecursive(
-      PathUtil.resolveUnix(path.dirname(require.resolve('@travetto/base/bin/main.js'))),
-      PathUtil.resolveUnix(workspace, 'node_modules/@travetto/base/bin')
-    );
-  }
-
-  /**
-   * Compile workspace
-   */
-  static async buildWorkspace(root: string, cacheDir: string): Promise<void> {
-    await ExecUtil.spawn('node', ['./node_modules/@travetto/cli/bin/trv.js', 'build'],
-      {
-        cwd: root, isolatedEnv: true,
-        env: { TRV_ENV: 'prod', TRV_READONLY: '0', TRV_CACHE: cacheDir, TRV_NODE_VERSION: process.env.TRV_NODE_VERSION },
-        stdio: ['pipe', 'pipe', 2]
-      }).result;
-  }
-
-  /**
-   * Copy over added content
-   */
-  static async copyAddedContent(workspace: string, files: Record<string, string>[]): Promise<void> {
-    for (const a of files) {
-      let [src, dest] = Object.entries(a)[0];
-      [src, dest] = [PathUtil.resolveUnix(src), PathUtil.resolveUnix(workspace, dest)];
-      const stat = await FsUtil.exists(src);
-      if (stat) {
-        if (stat.isFile()) {
-          await fs.mkdir(path.dirname(dest), { recursive: true });
-          await fs.copyFile(src, dest);
-        } else {
-          await fs.mkdir(path.dirname(dest), { recursive: true });
-          await FsUtil.copyRecursive(src, dest);
-        }
-      }
-    }
-  }
-}

package/bin/lib/dependencies.ts

@@ -1,103 +0,0 @@
-import * as path from 'path';
-
-import { FsUtil, PathUtil } from '@travetto/boot';
-
-export type ResolvedDep = { file: string, type: DepType, dep: string, version: string };
-export type DepType = 'prod' | 'dev' | 'opt' | 'peer';
-
-type DepResolveConfig = { root?: string, types?: DepType[] | (readonly DepType[]), maxDepth?: number };
-
-const DEP_MAPPING = {
-  prod: 'dependencies',
-  dev: 'devDependencies',
-  opt: 'optionalDependencies',
-  peer: 'peerDependencies',
-} as const;
-
-type PackageShape = {
-  name: string;
-} & {
-  [key: string]: {
-    [key: string]: string;
-  };
-};
-
-/**
- * Utilities for processing the package.json dependencies
- */
-export class DependenciesUtil {
-
-  /**
-   * Find the dependency's package.json file
-   * @param dep
-   * @param root
-   */
-  static resolveDependencyPackageJson(dep: string, root: string): string {
-    const paths = [root, ...(require.resolve.paths(root) || [])];
-    let folder: string;
-    try {
-      folder = require.resolve(`${dep}/package.json`, { paths });
-      folder = path.dirname(PathUtil.resolveUnix(root, folder));
-    } catch {
-      folder = require.resolve(dep, { paths });
-      folder = path.dirname(PathUtil.resolveUnix(root, folder));
-      while (!FsUtil.existsSync(`${folder}/package.json`)) {
-        const next = path.dirname(folder);
-        if (folder === next) {
-          throw new Error(`Unable to resolve dependency: ${dep}`);
-        }
-        folder = next;
-      }
-    }
-    return folder;
-  }
-
-  /**
-   * Get list of all production dependencies and their folders, for a given package
-   */
-  static async resolveDependencies({
-    root = PathUtil.cwd,
-    types = ['prod'],
-    maxDepth = Number.MAX_SAFE_INTEGER
-  }: DepResolveConfig): Promise<ResolvedDep[]> {
-    const pending: [string, number][] = [[root, 0]];
-    const foundSet = new Set<string>();
-    const found: ResolvedDep[] = [];
-    while (pending.length) {
-      const [top, depth] = pending.shift()!;
-      if (depth > maxDepth) { // Ignore if greater than valid max depth
-        continue;
-      }
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const p = await import(`${top}/package.json`) as PackageShape;
-      const deps: (readonly [name: string, type: DepType, version: string])[] = [];
-      for (const type of types) {
-        if (
-          type !== 'dev' ||
-          maxDepth === 0
-        ) {
-          deps.push(...Object
-            .entries<Record<string, string>>(p[DEP_MAPPING[type]] ?? {})
-            .map(([name, version]) => [name, type, version] as const)
-          );
-        }
-      }
-      for (const [dep, type, version] of deps) {
-        try {
-          const resolved = this.resolveDependencyPackageJson(dep, top);
-
-          if (!foundSet.has(resolved)) {
-            foundSet.add(resolved);
-            found.push({ file: resolved, type, dep, version });
-            pending.push([resolved, depth + 1]);
-          }
-        } catch {
-          if (!dep.startsWith('@types') && type !== 'opt' && type !== 'peer') {
-            console.error('Unable to resolve', { type, dependency: dep });
-          }
-        }
-      }
-    }
-    return found;
-  }
-}

package/bin/operation/assemble.ts

@@ -1,75 +0,0 @@
-import { FsUtil, PathUtil } from '@travetto/boot';
-import { color } from '@travetto/cli/src/color';
-import { CliUtil } from '@travetto/cli/src/util';
-
-import { PackUtil } from '../lib/util';
-import { CommonConfig, PackOperation } from '../lib/types';
-import { AssembleUtil } from '../lib/assemble';
-
-export interface AssembleConfig extends CommonConfig {
-  keepSource: boolean;
-  readonly: boolean;
-  cacheDir: string;
-  add: Record<string, string>[];
-  exclude: string[];
-  excludeCompile: string[];
-  env: Record<string, string | undefined>;
-}
-
-/**
- * Utils for packing source code and minimizing space usage
- */
-export const Assemble: PackOperation<AssembleConfig, 'assemble'> = {
-  key: 'assemble',
-  title: 'Assembling',
-  context(cfg: AssembleConfig) {
-    return `[readonly=${cfg.readonly},cache=${cfg.cacheDir},source=${cfg.keepSource}]`;
-  },
-  overrides: {
-    keepSource: CliUtil.toBool(process.env.PACK_ASSEMBLE_KEEP_SOURCE),
-    readonly: CliUtil.toBool(process.env.PACK_ASSEMBLE_READONLY)
-  },
-  extend(src: Partial<AssembleConfig>, dest: Partial<AssembleConfig>): Partial<AssembleConfig> {
-    return {
-      keepSource: src.keepSource ?? dest.keepSource,
-      readonly: src.readonly ?? dest.readonly,
-      cacheDir: src.cacheDir ?? dest.cacheDir,
-      add: [...(src.add ?? []), ...(dest.add ?? [])],
-      exclude: [...(src.exclude ?? []), ...(dest.exclude ?? [])],
-      excludeCompile: [...(src.excludeCompile ?? []), ...(dest.excludeCompile ?? [])],
-      env: { ...(src.env ?? {}), ...(dest.env ?? {}) },
-    };
-  },
-  buildConfig(configs: Partial<AssembleConfig>[]): AssembleConfig {
-    return PackUtil.buildConfig(this, configs);
-  },
-  /**
-   * Assemble the project into a workspace directory, optimized for space and runtime
-   */
-  async * exec({ workspace, cacheDir, add, exclude, excludeCompile, env, keepSource, readonly }: AssembleConfig) {
-    const fullCacheDir = PathUtil.resolveUnix(workspace!, cacheDir);
-    const ws = PathUtil.resolveUnix(workspace!);
-
-    yield 'Cleaning Workspace'; await FsUtil.unlinkRecursive(ws).then(() => { });
-    yield 'Copying Dependencies'; await AssembleUtil.copyDependencies(ws);
-    yield 'Copying App Content'; await AssembleUtil.copyModule(PathUtil.cwd, ws);
-    yield 'Excluding Pre-Compile Files'; await AssembleUtil.excludeFiles(ws, excludeCompile);
-    yield 'Building'; await AssembleUtil.buildWorkspace(ws, cacheDir);
-    yield 'Excluding Post-Compile Files'; await AssembleUtil.excludeFiles(ws, exclude);
-    yield 'Copying Added Content'; await AssembleUtil.copyAddedContent(ws, add);
-    yield 'Removing Empty Folders'; await PackUtil.removeEmptyFolders(ws);
-    yield 'Writing Env.js'; await PackUtil.writeEnvJs(ws, {
-      ...env,
-      TRV_CACHE: `\${__dirname}/${cacheDir}`,
-      ...(readonly ? { TRV_READONLY: '1' } : {})
-    });
-
-    if (!keepSource) {
-      yield 'Clean Boot'; await AssembleUtil.cleanBoot(ws);
-      yield 'Remove Source Maps'; await AssembleUtil.cleanCache(fullCacheDir);
-      yield 'Emptying .ts Files'; await AssembleUtil.purgeSource([`${ws}/node_modules/@travetto`, `${ws}/src`]);
-    }
-
-    yield color`${{ success: 'Successfully' }} assembled project at ${{ path: workspace }}`;
-  }
-};

package/index.d.ts

@@ -1,5 +0,0 @@
-export { AllConfig, AllConfigPartial } from './bin/operation/pack';
-export { CommonConfig } from './bin/lib/types';
-export { AssembleConfig } from './bin/operation/assemble';
-export { ZipConfig } from './bin/operation/zip';
-export { DockerConfig } from './bin/operation/docker';