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

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/lib/types.ts

@@ -1,19 +0,0 @@
-export type CommonConfig = {
-  name?: string;
-  file?: string;
-  workspace: string;
-  active?: boolean;
-  postProcess?: { [key: string]: (<T extends CommonConfig>(cfg: T) => Promise<void>) }[];
-  preProcess?: { [key: string]: (<T extends CommonConfig>(cfg: T) => Promise<void>) }[];
-};
-
-export type PackOperation<T extends CommonConfig, K extends string> = {
-  key: K;
-  title: string;
-  defaults?: Partial<T>;
-  overrides?: Partial<T>;
-  extend?(src: Partial<T>, dest: Partial<T>): Partial<T>;
-  context(cfg: T): Promise<string> | string;
-  exec(cfg: T): AsyncGenerator<string>;
-  buildConfig(configs: Partial<T>[]): T;
-};

package/bin/lib/util.ts

@@ -1,175 +0,0 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
-
-// TODO: Get proper typings
-const glob = require('picomatch');
-
-import { FsUtil, PathUtil, ScanFs } from '@travetto/boot';
-import { SourceIndex } from '@travetto/boot/src/internal/source';
-import { color } from '@travetto/cli/src/color';
-
-import { CommonConfig, PackOperation } from './types';
-
-/**
- * Shared packing utils
- */
-export class PackUtil {
-
-  static #modes: Partial<CommonConfig>[];
-
-  /**
-   * Build configuration object for an operation with a set of configs
-   */
-  static buildConfig<T extends CommonConfig>(
-    op: { defaults?: Partial<T>, overrides?: Partial<T>, extend?(src: Partial<T>, dest: Partial<T>): Partial<T> },
-    configs: Partial<T>[]
-  ): T {
-    const inputs = [
-      op.defaults! ?? {},
-      ...configs,
-      op.overrides! ?? {}
-    ].filter(x => Object.keys(x).length > 0);
-
-    const res = inputs.reduce((out: Partial<T>, config: Partial<T>): Partial<T> => {
-      const final = {
-        active: config.active ?? out.active,
-        workspace: config.workspace ?? out.workspace,
-        preProcess: [...(config.preProcess! ?? []), ...(out.preProcess ?? [])],
-        postProcess: [...(config.postProcess! ?? []), ...(out.postProcess ?? [])],
-        ...op.extend?.(config, out)
-      };
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return final as Partial<T>;
-    }, {});
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return res as T;
-  }
-
-  /**
-   * Find pack modes with associated metadata
-   */
-  static async modeList(): Promise<Partial<CommonConfig>[]> {
-    if (!this.#modes) {
-      this.#modes = await Promise.all(
-        SourceIndex.find({ folder: 'support', filter: f => /\/pack[.].*[.]ts/.test(f) })
-          .map(async (x) => {
-            const req: Partial<CommonConfig> = (await import(x.file)).config;
-            req.file = x.module.replace(/^node_modules\//, '');
-            return req;
-          })
-      );
-    }
-    return this.#modes;
-  }
-
-
-  /**
-   * Build file include/exclude lists/checker
-   */
-  static excludeChecker(files: string[], base: string): (file: string) => boolean {
-    const all = files.map(x => {
-      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 });
-      Object.defineProperty(match, 'source', { value: x });
-      return [match, negate] as const;
-    });
-
-    return (f: string): boolean => {
-      let exclude = undefined;
-      f = PathUtil.resolveUnix(base, f);
-      for (const [match, n] of all) {
-        if ((n || exclude === undefined) && match(f)) {
-          if (n) { // Fast exit if negating
-            return false;
-          }
-          exclude = match;
-        }
-      }
-      return !!exclude;
-    };
-  }
-
-  /**
-   * Update .env.js with new env data
-   */
-  static async writeEnvJs(workspace: string, env: Record<string, string | undefined>): Promise<void> {
-    const out = `${workspace}/.env.js`;
-    let src = '';
-    if (!!(await FsUtil.exists(out))) {
-      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);
-      }
-    }
-  }
-
-  /**
-   * Run operation with logging
-   */
-  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
-
-    let i = 0;
-    function stdout(msg?: string): void {
-      if (i++ > 0) {
-        process.stdout.write(color`${spacer}${{ param: 'done' }}\n`);
-      }
-      if (msg) {
-        process.stdout.write(color`${spacer}${{ output: '᳁' }} ${{ path: msg.padEnd(width - 15) }} ... `);
-      }
-    }
-
-    async function runPhase(phase: 'preProcess' | 'postProcess'): Promise<void> {
-      for (const el of cfg[phase] ?? []) {
-        const [name, fn] = Object.entries(el)[0];
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        await stdout(name as string);
-        await fn(cfg);
-      }
-    }
-
-    let message: string | undefined;
-
-    process.stdout.write(`${spacer}${title}\n`);
-    process.stdout.write(`${spacer}${'-'.repeat(width)}\n`);
-
-    await runPhase('preProcess');
-
-    for await (const msg of op.exec(cfg)) {
-      if (msg.includes('Success')) { // We are done
-        message = msg;
-        break;
-      } else {
-        stdout(msg);
-      }
-    }
-
-    await runPhase('postProcess');
-
-    // Wrap up
-    stdout();
-
-    if (message !== undefined) {
-      process.stdout.write(`${spacer}${'-'.repeat(width)}\n`);
-      process.stdout.write(`${spacer}${message}\n`);
-    }
-  }
-}

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/bin/operation/docker.ts

@@ -1,96 +0,0 @@
-import { promises as fs } from 'fs';
-
-import { ExecUtil, Package, PathUtil } from '@travetto/boot';
-import { color } from '@travetto/cli/src/color';
-import { CliUtil } from '@travetto/cli/src/util';
-
-import { CommonConfig, PackOperation } from '../lib/types';
-import { PackUtil } from '../lib/util';
-
-export interface DockerConfig extends CommonConfig {
-  image: string;
-  tag: string[];
-  name?: string;
-  app?: string;
-  port?: (string | number)[];
-  env: Record<string, string | number | boolean>;
-  builder?: (cfg: DockerConfig) => string;
-  registry?: string;
-  push?: boolean;
-}
-
-const dockerFileBuilder = ({ image, port, app = 'rest', env }: DockerConfig): string => `
-FROM ${image}
-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}"]
-`;
-
-export const Docker: PackOperation<DockerConfig, 'docker'> = {
-  key: 'docker',
-  title: 'Docker-izing',
-  context(cfg: DockerConfig) {
-    return `[image=${cfg.image}, port=${cfg.port}]`;
-  },
-  defaults: {
-    name: Package.name.replace('@', ''),
-    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
-  },
-  extend(src: Partial<DockerConfig>, dest: Partial<DockerConfig>): Partial<DockerConfig> {
-    return {
-      image: src.image ?? dest.image,
-      app: src.app ?? dest.app,
-      name: src.name ?? dest.name,
-      builder: src.builder ?? dest.builder,
-      tag: src.tag ?? dest.tag,
-      port: src.port ?? dest.port,
-      registry: src.registry ?? dest.registry,
-      env: { ...(src.env ?? {}), ...(dest.env ?? {}) },
-      push: src.push ?? dest.push
-    };
-  },
-  buildConfig(configs: Partial<DockerConfig>[]): DockerConfig {
-    return PackUtil.buildConfig(this, configs);
-  },
-  /**
-  * Dockerize workspace with flags
-  */
-  async* exec(cfg: DockerConfig) {
-    const { builder, workspace, push, image, tag, name, registry } = cfg;
-
-    const ws = PathUtil.resolveUnix(workspace);
-
-    yield 'Building Dockerfile';
-
-    await fs.writeFile(PathUtil.resolveUnix(ws, 'Dockerfile'), builder!(cfg), { encoding: 'utf8' });
-
-    yield 'Pulling Base Image';
-    await ExecUtil.spawn('docker', ['pull', image]).result;
-
-    yield 'Building Docker Container';
-    const tags = tag.map(x => registry ? `${registry}/${name}:${x}` : `${name}:${x}`);
-    const args = ['build', ...tags.flatMap(x => ['-t', x]), '.'];
-
-    await ExecUtil.spawn('docker', args, { cwd: ws, stdio: [0, 'pipe', 2] }).result;
-
-    if (push) {
-      yield 'Pushing Tags';
-      await ExecUtil.spawn('docker', ['image', 'push', ...tags]).result;
-    }
-
-    yield color`${{ success: 'Successfully' }} containerized project`;
-  }
-};

package/bin/operation/pack.ts

@@ -1,69 +0,0 @@
-import { color } from '@travetto/cli/src/color';
-
-import { CommonConfig, PackOperation } from '../lib/types';
-import { PackUtil } from '../lib/util';
-import { Assemble, AssembleConfig } from './assemble';
-import { Docker, DockerConfig } from './docker';
-import { Zip, ZipConfig } from './zip';
-
-type DeepPartial<T> = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [P in keyof T]?: (T[P] extends (number | string | boolean | undefined | RegExp | ((...args: any[]) => any)) ?
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (T[P] | undefined) : (T[P] extends any[] ? DeepPartial<T[P][number]>[] : DeepPartial<T[P]>));
-};
-
-const ops = {
-  [Assemble.key]: Assemble,
-  [Zip.key]: Zip,
-  [Docker.key]: Docker
-} as const;
-
-export type AllConfig = CommonConfig &
-{ assemble: AssembleConfig } &
-{ zip: ZipConfig } &
-{ docker: DockerConfig };
-
-export type AllConfigPartial = DeepPartial<AllConfig>;
-
-type DefaultOpType = ['assemble', typeof Assemble];
-
-export const Pack: PackOperation<AllConfig, ''> = {
-  key: '',
-  title: 'Packing',
-  buildConfig(configs: Partial<AllConfig>[]): AllConfig {
-    const ret: Partial<AllConfig> = {
-      workspace: configs[0].workspace,
-    };
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    for (const [k, op] of (Object.entries(ops) as DefaultOpType[])) {
-      ret[k] = op.buildConfig(configs.map(config => config[k] ?? {}));
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return ret as AllConfig;
-  },
-  async context(cfg: AllConfig) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return `[ ${(Object.entries(ops) as DefaultOpType[])
-      .filter(x => cfg[x[0]].active)
-      .map(x => x[0])
-      .join(', ')} ]`;
-  },
-  async * exec(cfg: AllConfig) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const steps = (Object.entries(ops) as DefaultOpType[])
-      .filter(x => cfg[x[0]].active);
-
-    if (!steps.length) {
-      throw new Error('Pack operation has zero active steps');
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    for (const [step, op] of steps as DefaultOpType[]) {
-      process.stdout.write('\n');
-      cfg[step].workspace = cfg.workspace;
-      await PackUtil.runOperation(op, cfg[step], 2);
-    }
-    process.stdout.write('\n');
-    yield color`${{ success: 'Successfully' }} packed project`;
-  }
-};

package/bin/operation/zip.ts

@@ -1,51 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs/promises';
-
-import { ExecUtil, FsUtil, PathUtil } from '@travetto/boot';
-import { color } from '@travetto/cli/src/color';
-
-import { CommonConfig, PackOperation } from '../lib/types';
-import { PackUtil } from '../lib/util';
-
-export interface ZipConfig extends CommonConfig {
-  output: string;
-}
-
-export const Zip: PackOperation<ZipConfig, 'zip'> = {
-  key: 'zip',
-  title: 'Zipping',
-  context(cfg: ZipConfig) {
-    return `[output=${cfg.output}]`;
-  },
-  overrides: {
-    output: process.env.PACK_ZIP_OUTPUT || undefined
-  },
-  extend(src: Partial<ZipConfig>, dest: Partial<ZipConfig>): Partial<ZipConfig> {
-    return { output: src.output ?? dest.output };
-  },
-  buildConfig(configs: Partial<ZipConfig>[]): ZipConfig {
-    return PackUtil.buildConfig(this, configs);
-  },
-  /**
-  * Zip workspace with flags
-  */
-  async * exec({ workspace, output }: ZipConfig) {
-    const ws = PathUtil.resolveUnix(workspace);
-    const zipFile = PathUtil.resolveUnix(output);
-
-    yield 'Preparing Target';
-    await fs.mkdir(path.dirname(zipFile), { recursive: true });
-    if (await FsUtil.exists(zipFile)) {
-      await fs.unlink(zipFile); // Unlink
-    }
-
-    yield 'Compressing';
-    if (/win/i.test(process.platform)) {
-      await ExecUtil.spawn('powershell', ['Compress-Archive', '-Path', '.', '-DestinationPath', zipFile], { cwd: ws }).result;
-    } else {
-      await ExecUtil.spawn('zip', ['-r', zipFile, '.'], { cwd: ws }).result;
-    }
-
-    yield color`${{ success: 'Successfully' }} archived project to ${{ path: zipFile.replace(PathUtil.cwd, '.') }}`;
-  }
-};

package/bin/pack-base.ts

@@ -1,100 +0,0 @@
-import * as 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 { PackUtil } from './lib/util';
-import { CommonConfig, PackOperation } from './lib/types';
-
-const packName = `pack_${Package.name}`
-  .toLowerCase()
-  .replace(/[^a-z]+/g, '_')
-  .replace(/_+/g, '_');
-
-export type BaseOptions = {
-  workspace: OptionConfig<string>;
-};
-
-function getConfigFromOperationOrGlobal<C extends CommonConfig, K extends string>(key: K, config: Partial<C> | Record<K, Partial<C>> | undefined): Partial<C> | undefined {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !config ? config : (key && key in config ? (config as Record<K, C>)[key] : config) as C;
-}
-
-/**
- * Supports packing a project into a directory, ready for archiving
- */
-export abstract class BasePackCommand<V extends BaseOptions, C extends CommonConfig, K extends string> extends CliCommand<V> {
-
-  /**
-   * Package stage name
-   */
-  abstract get operation(): PackOperation<C, K>;
-
-  get cmdOptions(): Partial<C> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return this.cmd as Partial<C>;
-  }
-
-  get name(): string {
-    return this.operation.key ? `pack:${this.operation.key}` : 'pack';
-  }
-
-  commonOptions(): BaseOptions {
-    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');
-
-    const configs = [
-      { workspace: PathUtil.resolveUnix(os.tmpdir(), packName) },
-      def,
-      cfg,
-      this.cmdOptions,
-      { active: true }
-    ]
-      .map(x => getConfigFromOperationOrGlobal(this.operation.key, x))
-      .filter((x): x is C => x !== undefined);
-
-    return this.operation.buildConfig(configs);
-  }
-
-  getArgs(): string {
-    return '[mode]';
-  }
-
-  async help(): Promise<string> {
-    const lines = await PackUtil.modeList();
-
-    const out: string[] = [];
-    if (lines.length) {
-      out.push('', color`${{ title: 'Available Pack Modes:' }}`);
-      for (const { name, file } of lines) {
-        out.push(color`  * ${{ 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'))) {
-      throw new Error('Refusing to use workspace with a .git directory');
-    }
-    return PackUtil.runOperation(this.operation, resolved);
-  }
-}