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

package/support/bin/types.ts

@@ -0,0 +1,70 @@
+import { ListOptionConfig, OptionConfig } from '@travetto/cli';
+
+export type CommonPackConfig = {
+  workspace: string;
+  output: string;
+  clean: boolean;
+  ejectFile: string;
+  module: string;
+
+  // Bundle
+  entryPoint: string;
+  entryCommand: string;
+  entryArguments: string[];
+  minify: boolean;
+  sourcemap: boolean;
+  includeSources: boolean;
+};
+
+export type CommonPackOptions = {
+  workspace: OptionConfig<string>;
+  output: OptionConfig<string>;
+  clean: OptionConfig<boolean>;
+  ejectFile: OptionConfig<string>;
+
+  // Bundle
+  entryPoint: OptionConfig<string>;
+  entryCommand: 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;
+} & 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;
+  createFile(file: string, text: string[], mode?: string): string[][];
+  scriptOpen(): string[];
+  chdirScript(): string[];
+  callCommandWithAllArgs(cmd: string, ...args: string[]): string[];
+  copy(src: string, dest: string): string[];
+  copyRecursive(src: string, dest: string): string[];
+  rmRecursive(dest: string): string[];
+  mkdir(dest: string): string[];
+  export(key: string, value: string): string[];
+  chdir(dest: string): string[];
+  comment(message: string): string[];
+  zip(output: string): string[];
+};
+
+export type DockerPackFactory = (cfg: DockerPackConfig) => (string | Promise<string>);
+export type DockerPackFactoryModule = { factory: DockerPackFactory };

package/support/bin/util.ts

@@ -0,0 +1,63 @@
+import fs from 'fs/promises';
+
+import { path, RootIndex } from '@travetto/manifest';
+import { ExecUtil } from '@travetto/base';
+
+import { ActiveShellCommand } from './shell';
+
+export class PackUtil {
+  /**
+   * Generate env.js
+   */
+  static buildEnvJS(env: Record<string, string | number | boolean | undefined>): string[] {
+    const entries = Object.entries(env)
+      .filter(([k, v]) => (v !== undefined))
+      .map(([k, v]) => [k, `${v}`]);
+    return entries.map(([k, v]) => `process.env.${k} = '${v}';`);
+  }
+
+  /**
+   * 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] = ActiveShellCommand.copyRecursive(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}`);
+    }
+  }
+
+  /**
+   * 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 = [
+      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 {
+      await fs.mkdir(path.dirname(file), { recursive: true });
+      await fs.writeFile(file, content, 'utf8');
+    }
+  }
+}

package/support/cli.pack.ts

@@ -0,0 +1,14 @@
+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();
+  }
+}

package/support/cli.pack_docker.ts

@@ -0,0 +1,48 @@
+import { path, RootIndex } from '@travetto/manifest';
+
+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' })
+    };
+  }
+
+  async buildConfig(): Promise<DockerPackConfig> {
+    const cfg = await super.buildConfig();
+    if (cfg.dockerFactory.startsWith('.')) {
+      cfg.dockerFactory = RootIndex.getFromSource(path.resolve(cfg.dockerFactory))?.import ?? cfg.dockerFactory;
+    }
+    cfg.dockerPort ??= [];
+    cfg.dockerTag ??= [];
+    return cfg;
+  }
+
+  getOperations(): PackOperationShape<DockerPackConfig>[] {
+    return [
+      ...super.getOperations(),
+      DockerPackOperation.writeDockerFile,
+      DockerPackOperation.pullDockerBaseImage,
+      DockerPackOperation.buildDockerContainer,
+      DockerPackOperation.pushDockerContainer
+    ];
+  }
+}

package/support/cli.pack_zip.ts

@@ -0,0 +1,24 @@
+import { CommonPackConfig, CommonPackOptions } from './bin/types';
+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';
+
+  getOptions(): CommonPackOptions {
+    const opts = this.getCommonOptions();
+    opts.output.def = this.monoRoot ? '<module>.zip' : `${this.getSimpleModuleName()}.zip`;
+    return opts;
+  }
+
+  getOperations(): PackOperationShape<CommonPackConfig>[] {
+    return [
+      ...super.getOperations(),
+      PackOperation.compress
+    ];
+  }
+}

package/support/pack.base.ts

@@ -0,0 +1,150 @@
+import os from 'os';
+
+import { CliCommand, cliTpl } from '@travetto/cli';
+import { path, RootIndex } from '@travetto/manifest';
+import { TimeUtil } from '@travetto/base';
+import { GlobalTerminal } from '@travetto/terminal';
+
+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[]>);
+
+const BASIC_OP_SET = [
+  PackOperation.clean,
+  PackOperation.writeEnv,
+  PackOperation.writePackageJson,
+  PackOperation.writeEntryScript,
+  PackOperation.copyResources,
+  PackOperation.primeAppCache,
+  PackOperation.writeManifest,
+  PackOperation.bundle,
+];
+
+export abstract class BasePackCommand<T extends CommonPackOptions, S extends CommonPackConfig> extends CliCommand<{}> {
+
+  get monoRoot(): boolean {
+    return !!RootIndex.manifest.monoRepo && path.cwd() === RootIndex.manifest.workspacePath;
+  }
+
+  getArgs(): string | undefined {
+    return this.monoRoot ? '<module> [args...]' : '[args...]';
+  }
+
+  getCommonOptions(): CommonPackOptions {
+    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' }),
+
+      entryPoint: this.option({ short: 'e', desc: 'Entry point', def: 'node_modules/@travetto/cli/support/cli.js' }),
+      entryCommand: this.option({ short: 'ec', desc: 'Entry command' }),
+      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' }),
+    };
+  }
+
+  abstract getOptions(): T;
+
+  get cmd(): S {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return super.cmd as S;
+  }
+
+  getSimpleModuleName(): string {
+    return RootIndex.mainPackage.name.replace(/[\/]/, '_').replace(/@/, '');
+  }
+
+  getOperations(): PackOperationShape<S>[] {
+    return BASIC_OP_SET.slice(0);
+  }
+
+  /**
+   * Run all operations
+   */
+  async * runOperations(cfg: S): AsyncIterable<string> {
+    for (const op of this.getOperations()) {
+      for await (const msg of op(cfg)) {
+        yield msg.join(' ');
+      }
+    }
+  }
+
+
+  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.entryCommand ??= path.basename(this.cmd.entryPoint).replace(/[.][tj]s$/, '');
+    this.cmd.module = RootIndex.mainModule.name;
+    return this.cmd;
+  }
+
+  async action(module: string, args: string[]): Promise<void> {
+    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());
+        }
+      }
+    }
+
+    // Resolve all files to absolute paths
+    if (this.cmd.output) {
+      this.cmd.output = path.resolve(this.cmd.output);
+    }
+    if (this.cmd.ejectFile) {
+      this.cmd.ejectFile = path.resolve(this.cmd.ejectFile);
+    }
+    this.cmd.workspace = path.resolve(this.cmd.workspace);
+
+    const stream = this.runOperations(cfg);
+
+    // 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);
+    } else {
+      await GlobalTerminal.streamLinesWithWaiting(stream, {
+        initialDelay: 0,
+        cycleDelay: 100,
+        end: true,
+        commitedPrefix: 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 }}`;
+      }
+      await GlobalTerminal.writeLines(msg);
+    }
+  }
+}

package/support/pack.dockerfile.ts

@@ -0,0 +1,9 @@
+import { DockerPackFactory } from './bin/types';
+
+export const factory: DockerPackFactory = cfg => `
+FROM ${cfg.dockerImage}
+WORKDIR /app
+COPY . .
+${cfg.dockerPort.map(port => `EXPOSE ${port}`).join('\n')}
+ENTRYPOINT ["/app/${cfg.entryCommand}.sh"]
+`;

package/bin/cli-pack.ts

@@ -1,10 +0,0 @@
-import { BaseOptions, BasePackCommand } from './pack-base';
-import { Pack, AllConfig } from './operation/pack';
-
-export class PackCommand extends BasePackCommand<BaseOptions, AllConfig> {
-  operation = Pack;
-
-  getOptions(): BaseOptions {
-    return this.commonOptions();
-  }
-}

package/bin/cli-pack_assemble.ts

@@ -1,21 +0,0 @@
-import { OptionConfig } from '@travetto/cli/src/command';
-
-import { BaseOptions, BasePackCommand } from './pack-base';
-import { Assemble, AssembleConfig } from './operation/assemble';
-
-type Options = BaseOptions & {
-  keepSource: OptionConfig<boolean>;
-  readonly: OptionConfig<boolean>;
-};
-
-export class PackAssembleCommand extends BasePackCommand<Options, AssembleConfig> {
-  operation = Assemble;
-
-  getOptions(): Options {
-    return {
-      ...this.commonOptions(),
-      keepSource: this.boolOption({ desc: 'Should source be preserved' }),
-      readonly: this.boolOption({ desc: 'Build a readonly deployable' })
-    };
-  }
-}

package/bin/cli-pack_docker-export.ts

@@ -1,54 +0,0 @@
-import * as fs from 'fs/promises';
-
-import { FsUtil, PathUtil } from '@travetto/boot';
-import { CliCommand, OptionConfig, ListOptionConfig } from '@travetto/cli/src/command';
-
-type Options = {
-  app: OptionConfig<string>;
-  image: OptionConfig<string>;
-  port: OptionConfig<number>;
-  add: ListOptionConfig<string>;
-  output: OptionConfig<string>;
-};
-
-export class PackDockerExportCommand extends CliCommand<Options> {
-
-  name = 'pack:docker-export';
-
-  getOptions(): Options {
-    return {
-      app: this.option({ desc: 'The application target to run', def: 'rest' }),
-      image: this.option({ desc: 'Docker image to extend', def: 'node:16-alpine' }),
-      port: this.intOption({ desc: 'Expose port', def: 3000 }),
-      add: this.listOption({ desc: 'Files to include' }),
-      output: this.option({ desc: 'Docker file name', def: 'Dockerfile' })
-    };
-  }
-
-  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 content = `
-FROM ${this.cmd.image} as build
-WORKDIR /build
-${files.map(x => `COPY ${x} ${x}`).join('\n')}
-ENV NODE_OPTIONS "--no-deprecation"
-RUN npm ci
-RUN npx trv pack:assemble -w /app
-
-FROM ${this.cmd.image} as scratch
-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}"]
-`;
-
-    if (this.cmd.output === '-' || this.cmd.output === '/dev/stdout' || !this.cmd.output) {
-      console.log(content);
-    } else {
-      await fs.writeFile(this.cmd.output, content, { encoding: 'utf8' });
-    }
-  }
-}

package/bin/cli-pack_docker.ts

@@ -1,29 +0,0 @@
-import { OptionConfig, ListOptionConfig } from '@travetto/cli/src/command';
-
-import { BaseOptions, BasePackCommand } from './pack-base';
-import { Docker, DockerConfig } from './operation/docker';
-
-type Options = BaseOptions & {
-  image: OptionConfig<string>;
-  name: OptionConfig<string>;
-  tag: ListOptionConfig<string>;
-  port: ListOptionConfig<string>;
-  push: OptionConfig<boolean>;
-  registry: OptionConfig<string>;
-};
-
-export class PackDockerCommand extends BasePackCommand<Options, DockerConfig> {
-  operation = Docker;
-
-  getOptions(): Options {
-    return {
-      ...this.commonOptions(),
-      image: this.option({ desc: 'Docker Image to extend' }),
-      name: this.option({ desc: 'Image Name' }),
-      tag: this.listOption({ desc: 'Image Tag' }),
-      port: this.listOption({ desc: 'Image Port' }),
-      push: this.boolOption({ short: 'x', desc: 'Push Tags' }),
-      registry: this.option({ desc: 'Registry' })
-    };
-  }
-}

package/bin/cli-pack_zip.ts

@@ -1,19 +0,0 @@
-import { OptionConfig } from '@travetto/cli/src/command';
-
-import { BaseOptions, BasePackCommand } from './pack-base';
-import { Zip, ZipConfig } from './operation/zip';
-
-type Options = BaseOptions & {
-  output: OptionConfig<string>;
-};
-
-export class PackZipCommand extends BasePackCommand<Options, ZipConfig> {
-  operation = Zip;
-
-  getOptions(): Options {
-    return {
-      ...this.commonOptions(),
-      output: this.option({ desc: 'Output File' })
-    };
-  }
-}

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);
-        }
-      }
-    }
-  }
-}