@travetto/pack 3.0.0-rc.7 → 3.0.0-rc.9

package/__index__.ts

@@ -1,5 +1 @@
-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';
+export type { CommonPackConfig } from './support/bin/types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/pack",
-  "version": "3.0.0-rc.7",
+  "version": "3.0.0-rc.9",
   "description": "Code packing utilities",
   "keywords": [
     "travetto",
@@ -23,12 +23,16 @@
     "directory": "module/pack"
   },
   "dependencies": {
-    "@travetto/base": "^3.0.0-rc.7",
-    "@types/picomatch": "^2.3.0",
-    "picomatch": "^2.3.1"
+    "@rollup/plugin-commonjs": "^24.0.1",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-terser": "^0.4.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@travetto/base": "^3.0.0-rc.9",
+    "rollup": "^3.12.1",
+    "rollup-plugin-sourcemaps": "^0.6.3"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.0-rc.7"
+    "@travetto/cli": "^3.0.0-rc.10"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/support/bin/config.ts

@@ -0,0 +1,81 @@
+import type { OutputOptions } from 'rollup';
+import type terser from '@rollup/plugin-terser';
+
+import { Env } from '@travetto/base';
+import { ManifestModule, Package, path, RootIndex } from '@travetto/manifest';
+
+const INTRO = {
+  commonjs: `
+globalThis.crypto = require('crypto');
+try { require('./.env.js')} catch {}
+
+function __importStar(mod) { 
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+  result['default'] = mod;
+  return result;
+}
+`,
+  module: `
+globalThis.crypto = await import('crypto');
+try {await import('./.env.js')} catch {}
+`
+};
+
+function getFilesFromModule(m: ManifestModule): string[] {
+  return [
+    ...m.files.$index ?? [],
+    ...m.files.src ?? [],
+    ...m.files.bin ?? [],
+    ...(m.files.support ?? [])
+      .filter(f => !/support\/(test|doc)/.test(f[0]))
+  ]
+    .filter(([, t]) => t === 'ts' || t === 'js' || t === 'json')
+    .map(([f]) => path.resolve(m.outputFolder, f.replace(/[.]ts$/, '.js')));
+}
+
+export function getOutput(): OutputOptions {
+  const format: Package['type'] = Env.get('BUNDLE_FORMAT', 'commonjs');
+  return {
+    format,
+    intro: INTRO[format],
+    sourcemapPathTransform: (src, map): string =>
+      path.resolve(path.dirname(map), src).replace(`${RootIndex.manifest.workspacePath}/`, ''),
+    sourcemap:
+      Env.getBoolean('BUNDLE_SOURCEMAP') ?? false,
+    sourcemapExcludeSources:
+      !(Env.getBoolean('BUNDLE_SOURCES') ?? false),
+    compact:
+      Env.getBoolean('BUNDLE_COMPRESS') ?? true,
+    dir: Env.get('BUNDLE_OUTPUT')!,
+    ...(format === 'commonjs' ? {} : {
+      inlineDynamicImports: true
+    }),
+  };
+}
+
+export function getEntry(): string {
+  return Env.get('BUNDLE_ENTRY')!;
+}
+
+export function getFiles(): string[] {
+  return [...RootIndex.getModuleList('all')]
+    .map(x => RootIndex.manifest.modules[x])
+    .filter(m => m.profiles.includes('std'))
+    .flatMap(getFilesFromModule);
+}
+
+export function getTerserConfig(): Parameters<typeof terser>[0] {
+  return {
+    mangle: true,
+    keep_classnames: true,
+    keep_fnames: true,
+    ecma: 2020,
+    compress: {},
+    output: {
+      shebang: false,
+      comments: false,
+    }
+  };
+}

package/support/bin/docker-operation.ts

@@ -0,0 +1,88 @@
+import fs from 'fs/promises';
+
+import { path, RootIndex } from '@travetto/manifest';
+import { ExecUtil } from '@travetto/base';
+import { cliTpl } from '@travetto/cli';
+
+import { ActiveShellCommand } from './shell';
+import { DockerPackConfig, DockerPackFactoryModule } from './types';
+
+export class DockerPackOperation {
+
+  static getDockerTags(cfg: DockerPackConfig): string[] {
+    return (cfg.dockerTag ?? []).map(x => cfg.dockerRegistry ? `${cfg.dockerRegistry}/${cfg.dockerName}:${x}` : `${cfg.dockerName}:${x}`);
+  }
+
+  /**
+   * Write Docker File
+   */
+  static async* writeDockerFile(cfg: DockerPackConfig): AsyncIterable<string[]> {
+    const dockerFile = path.resolve(cfg.workspace, 'Dockerfile');
+    const title = cliTpl`${{ title: 'Generating Docker File' }} ${{ path: dockerFile }}`;
+    const mod: DockerPackFactoryModule = await import(RootIndex.getFromImport(cfg.dockerFactory)!.import);
+    const content = (await mod.factory(cfg)).trim();
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield* ActiveShellCommand.createFile(dockerFile, content.split(/\n/));
+    } else {
+      yield [title];
+      await fs.writeFile(dockerFile, content, 'utf8');
+    }
+  }
+
+  /**
+   * Pull Docker Base Image
+   */
+  static async* pullDockerBaseImage(cfg: DockerPackConfig): AsyncIterable<string[]> {
+    const title = cliTpl`${{ title: 'Pulling Docker Base Image' }} ${{ param: cfg.dockerImage }}`;
+
+    const command = ['docker', 'pull', cfg.dockerImage];
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield command;
+    } else {
+      yield [title];
+      await ExecUtil.spawn(command[0], command.slice(1), {}).result;
+    }
+  }
+
+  /**
+   * Building Docker Container
+   */
+  static async* buildDockerContainer(cfg: DockerPackConfig): AsyncIterable<string[]> {
+    const title = cliTpl`${{ title: 'Building Docker Container' }} ${{ param: cfg.dockerTag?.join(',') }}`;
+    const cmd = ['docker', 'build', ...DockerPackOperation.getDockerTags(cfg).flatMap(x => ['-t', x]), '.'];
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield ActiveShellCommand.chdir(cfg.workspace);
+      yield cmd;
+      yield ActiveShellCommand.chdir(path.cwd());
+    } else {
+      yield [title];
+      await ExecUtil.spawn(cmd[0], cmd.slice(1), { cwd: cfg.workspace, stdio: [0, 'pipe', 2] }).result;
+    }
+  }
+
+  /**
+   * Push Docker Container
+   */
+  static async* pushDockerContainer(cfg: DockerPackConfig): AsyncIterable<string[]> {
+    if (!cfg.dockerPush) {
+      return;
+    }
+    const tags = DockerPackOperation.getDockerTags(cfg);
+    const title = cliTpl`${{ title: 'Push Container to registry' }} ${{ param: cfg.dockerRegistry }}`;
+    const cmd = ['docker', 'image', 'push', ...tags];
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield cmd;
+    } else {
+      yield [title];
+      await ExecUtil.spawn(cmd[0], cmd.slice(1), { stdio: [0, 'pipe', 2] }).result;
+    }
+  }
+}

package/support/bin/operation.ts

@@ -0,0 +1,255 @@
+import fs from 'fs/promises';
+
+import { path, RootIndex } from '@travetto/manifest';
+import { ExecUtil } from '@travetto/base';
+import { cliTpl } from '@travetto/cli';
+
+import { CommonPackConfig } from './types';
+import { PackUtil } from './util';
+import { ActiveShellCommand, ShellCommands } from './shell';
+
+async function writeRawFile(file: string, contents: string, mode?: string): Promise<void> {
+  await fs.writeFile(file, contents, { encoding: 'utf8', mode });
+}
+
+export class PackOperation {
+
+  static async * clean(cfg: CommonPackConfig): AsyncIterable<string[]> {
+    if (!cfg.clean) {
+      return;
+    }
+
+    const title = cliTpl`${{ title: 'Cleaning Output' }} ${{ path: cfg.workspace }}`;
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield ActiveShellCommand.rmRecursive(cfg.workspace);
+      if (cfg.output) {
+        yield ActiveShellCommand.rmRecursive(cfg.output);
+      }
+      yield ActiveShellCommand.mkdir(cfg.workspace);
+    } else {
+      yield [title];
+      await fs.rm(cfg.workspace, { recursive: true, force: true });
+      if (cfg.output) {
+        await fs.rm(cfg.output, { recursive: true, force: true });
+      }
+      await fs.mkdir(cfg.workspace, { recursive: true });
+    }
+  }
+
+  static async * bundle(cfg: CommonPackConfig): AsyncIterable<string[]> {
+    const cwd = RootIndex.outputRoot;
+
+    const bundleCommand = ['npx', 'rollup', '-c', 'node_modules/@travetto/pack/support/bin/rollup.js'];
+
+    const env = Object.fromEntries(([
+      ['BUNDLE_ENTRY', cfg.entryPoint],
+      ['BUNDLE_ENTRY_NAME', cfg.entryCommand],
+      ['BUNDLE_COMPRESS', cfg.minify],
+      ['BUNDLE_SOURCEMAP', cfg.sourcemap],
+      ['BUNDLE_SOURCES', cfg.includeSources],
+      ['BUNDLE_OUTPUT', cfg.workspace],
+      ['BUNDLE_FORMAT', RootIndex.manifest.moduleType],
+      ['TRV_MANIFEST', RootIndex.getModule(cfg.module)!.outputPath]
+    ] as const)
+      .filter(x => x[1] === false || x[1])
+      .map(x => [x[0], `${x[1]}`])
+    );
+
+    const props = (['minify', 'sourcemap', 'entryPoint'] as const)
+      .map(k => cliTpl`${{ subtitle: k }}=${{ param: cfg[k] }}`).join(' ');
+
+    const title = cliTpl`${{ title: 'Bundling Output' }} ${props}`;
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield* Object.entries(env).filter(x => !!x[1]).map(x =>
+        ActiveShellCommand.export(x[0], x[1])
+      );
+      yield ActiveShellCommand.chdir(cwd);
+      yield bundleCommand;
+      yield ActiveShellCommand.chdir(path.cwd());
+    } else {
+      yield [title];
+      await ExecUtil.spawn(bundleCommand[0], bundleCommand.slice(1), { cwd, env, stdio: ['inherit', 'pipe', 'pipe'] }).result;
+    }
+  }
+
+  static async * writePackageJson(cfg: CommonPackConfig): AsyncIterable<string[]> {
+    const file = 'package.json';
+    const title = cliTpl`${{ title: 'Writing' }} ${{ path: file }}`;
+    const pkg = { type: RootIndex.manifest.moduleType };
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield* ActiveShellCommand.createFile(
+        path.resolve(cfg.workspace, file),
+        [JSON.stringify(pkg)]
+      );
+    } else {
+      yield [title];
+      await writeRawFile(
+        path.resolve(cfg.workspace, file),
+        JSON.stringify(pkg, null, 2)
+      );
+    }
+  }
+
+  static async * writeEnv(cfg: CommonPackConfig): AsyncIterable<string[]> {
+    const file = '.env.js';
+    const title = cliTpl`${{ title: 'Writing' }} ${{ path: file }}`;
+    const env = {
+      TRV_MANIFEST: `node_modules/${cfg.module}`,
+      TRV_CLI_IPC: ''
+    };
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield* ActiveShellCommand.createFile(
+        path.resolve(cfg.workspace, file),
+        PackUtil.buildEnvJS(env)
+      );
+    } else {
+      yield [title];
+      await writeRawFile(
+        path.resolve(cfg.workspace, file),
+        PackUtil.buildEnvJS(env).join('\n')
+      );
+    }
+  }
+
+  static async * writeEntryScript(cfg: CommonPackConfig): AsyncIterable<string[]> {
+    const title = 'Writing entry scripts';
+
+    const files = ([['posix', 'sh'], ['win32', 'cmd']] as const)
+      .map(([type, ext]) => ({
+        fileTitle: cliTpl`${{ title }} ${{ path: `${cfg.entryCommand}.${ext}` }} args=(${{ param: cfg.entryArguments.join(' ') }})`,
+        file: `${cfg.entryCommand}.${ext}`,
+        text: [
+          ShellCommands[type].scriptOpen(),
+          ShellCommands[type].chdirScript(),
+          ShellCommands[type].callCommandWithAllArgs('node', cfg.entryCommand, ...cfg.entryArguments),
+        ].map(x => x.join(' '))
+      }));
+
+    if (cfg.ejectFile) {
+      for (const { fileTitle, text, file } of files) {
+        yield ActiveShellCommand.comment(fileTitle);
+        yield* ActiveShellCommand.createFile(path.resolve(cfg.workspace, file), text, '755');
+      }
+    } else {
+      for (const { fileTitle, text, file } of files) {
+        yield [fileTitle];
+        await writeRawFile(path.resolve(cfg.workspace, file), text.join('\n'), '755');
+      }
+    }
+  }
+
+  static async * copyResources(cfg: CommonPackConfig): AsyncIterable<string[]> {
+    const resources = {
+      count: RootIndex.mainModule.files.resources?.length ?? 0,
+      src: path.resolve(RootIndex.mainModule.sourcePath, 'resources'),
+      dest: path.resolve(cfg.workspace, 'resources')
+    };
+
+    const copyFiles = [
+      RootIndex.manifest.modules[RootIndex.mainModule.name],
+      RootIndex.manifest.modules['@travetto/manifest']
+    ].map(mod => ({
+      src: path.resolve(RootIndex.outputRoot, mod.outputFolder, 'package.json'),
+      dest: path.resolve(cfg.workspace, mod.outputFolder, 'package.json'),
+      destFolder: path.resolve(cfg.workspace, mod.outputFolder)
+    }));
+
+    const title = cliTpl`${{ title: 'Copying over resources' }}`;
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield* copyFiles.flatMap(mod => [
+        ActiveShellCommand.mkdir(path.dirname(mod.dest)),
+        ActiveShellCommand.copy(mod.src, mod.dest)
+      ]);
+      if (resources.count) {
+        yield ActiveShellCommand.copyRecursive(resources.src, path.resolve(cfg.workspace, 'resources'));
+      }
+    } else {
+      yield [title];
+
+      for (const { src, dest, destFolder } of copyFiles) {
+        await fs.mkdir(destFolder, { recursive: true });
+        await fs.copyFile(src, dest);
+      }
+
+      if (resources.count) {
+        await fs.mkdir(path.dirname(resources.dest), { recursive: true });
+        await PackUtil.copyRecursive(resources.src, resources.dest);
+      }
+    }
+  }
+
+  static async * primeAppCache(cfg: CommonPackConfig): AsyncIterable<string[]> {
+    const isCli = cfg.entryCommand === 'cli';
+    if (!isCli || !RootIndex.hasModule('@travetto/app')) {
+      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 title = cliTpl`${{ title: 'Generating App Cache' }} ${{ path: sub }}`;
+    const env = { DEBUG: '0', TRV_MODULE: cfg.module };
+    const appCache = path.resolve(cfg.workspace, sub);
+
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield ActiveShellCommand.mkdir(path.dirname(appCache));
+      yield [...Object.entries(env).map(x => `${x[0]}=${x[1]}`), ...appCacheCmd, '>', appCache];
+    } else {
+      yield [title];
+      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');
+    }
+  }
+
+  static async * writeManifest(cfg: CommonPackConfig): AsyncIterable<string[]> {
+    const out = path.resolve(cfg.workspace, 'node_modules', cfg.module);
+    const cmd = ['npx', 'trv', 'manifest', out, 'prod'];
+    const env = { TRV_MODULE: cfg.module };
+    const title = cliTpl`${{ title: 'Writing Manifest' }} ${{ path: path.join('node_modules', cfg.module) }}`;
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield [...Object.entries(env).map(([k, v]) => `${k}=${v}`), ...cmd];
+    } else {
+      yield [title];
+      await ExecUtil.spawn(cmd[0], cmd.slice(1), { env, stdio: ['inherit', 'ignore', 'inherit'] }).result;
+    }
+  }
+
+  static async * compress(cfg: CommonPackConfig): AsyncIterable<string[]> {
+    const title = cliTpl`${{ title: 'Compressing' }} ${{ path: cfg.output }}`;
+
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield ActiveShellCommand.chdir(cfg.workspace);
+      yield ActiveShellCommand.zip(cfg.output);
+      yield ActiveShellCommand.chdir(path.cwd());
+    } else {
+      yield [title];
+      const [cmd, ...args] = ActiveShellCommand.zip(cfg.output);
+      await ExecUtil.spawn(cmd, args, { cwd: cfg.workspace }).result;
+    }
+  }
+
+
+  static async * runOperations<S>(cfg: S, operations: ((config: S) => AsyncIterable<string[]>)[]): AsyncIterable<string> {
+    for (const op of operations) {
+      for await (const msg of op(cfg)) {
+        yield msg.join(' ');
+      }
+    }
+  }
+}

package/support/bin/rollup-esm-dynamic-import.ts

@@ -0,0 +1,55 @@
+import { AcornNode, Plugin } from 'rollup';
+import { walk } from 'estree-walker';
+import MagicString from 'magic-string';
+
+const BRAND = '__imp';
+
+const DYNAMIC_IMPORT = (imports: string[]): string => `
+function ${BRAND}(path) { 
+  switch (path) {
+    ${imports.map(p => `  case '${p}': return import('${p}');`).join('\n')}
+    default: return import(path); // Fall back for built-ins
+  } 
+}
+globalThis.${BRAND} = ${BRAND}`;
+
+export function travettoImportPlugin(entry: string, files: string[]): Plugin {
+  const imports = files
+    .map(x => x.split('node_modules/').pop()!)
+    .flatMap(x => x.endsWith('__index__.js') ? [x.replace('__index__.js', ''), x] : [x]);
+
+  const out: Plugin = {
+    name: 'travetto-import',
+    transform(code, id) {
+      const parsed = this.parse(code);
+
+      let ms: MagicString | undefined;
+
+      if (id.includes(entry)) {
+        (ms ??= new MagicString(code).append(DYNAMIC_IMPORT(imports)));
+      }
+
+      walk(parsed, {
+        enter: (node) => {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          const impNode = node as AcornNode & { source?: { type: string } };
+          if (impNode.type !== 'ImportExpression' || impNode.source?.type === 'Literal') {
+            return;
+          }
+          (ms ??= new MagicString(code)).overwrite(impNode.start, impNode.start + 6, BRAND);
+        }
+      });
+
+      if (ms !== undefined) {
+        return {
+          code: ms.toString(),
+          map: ms.generateMap({ file: id, includeContent: true, hires: true })
+        };
+      } else {
+        return null;
+      }
+    }
+  };
+
+  return out;
+}

package/support/bin/rollup.ts

@@ -0,0 +1,36 @@
+import commonjsRequire from '@rollup/plugin-commonjs';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import terser from '@rollup/plugin-terser';
+import jsonImport from '@rollup/plugin-json';
+import sourceMaps from 'rollup-plugin-sourcemaps';
+import type { RollupOptions } from 'rollup';
+
+import { RootIndex } from '@travetto/manifest';
+
+import { getEntry, getOutput, getTerserConfig, getFiles } from './config';
+import { travettoImportPlugin } from './rollup-esm-dynamic-import';
+
+const NEVER_INCLUDE = new Set(['node-forge', '@parcel/watcher']);
+
+export default function buildConfig(): RollupOptions {
+  const output = getOutput();
+  const entry = getEntry();
+  const files = getFiles();
+
+  return {
+    input: [entry],
+    output,
+    plugins: [
+      jsonImport(),
+      commonjsRequire({
+        ignore: id => NEVER_INCLUDE.has(id),
+        dynamicRequireRoot: RootIndex.manifest.workspacePath,
+        dynamicRequireTargets: (output.format === 'commonjs' ? files : [])
+      }),
+      ...(output.format === 'module' ? [travettoImportPlugin(entry, files)] : []),
+      nodeResolve({ preferBuiltins: true }),
+      ...(output.sourcemap !== 'hidden' && output.sourcemap !== false ? [sourceMaps({})] : []),
+      ...(output.compact ? [terser(getTerserConfig())] : [])
+    ]
+  };
+}

package/support/bin/shell.ts

@@ -0,0 +1,53 @@
+import { path } from '@travetto/manifest';
+import { stripAnsiCodes } from '@travetto/terminal';
+
+import { ShellCommandImpl } from './types';
+
+const escape = (text: string): string =>
+  text
+    .replaceAll('"', '\\"')
+    .replaceAll('$', '\\$');
+
+export const ShellCommands: Record<'win32' | 'posix', ShellCommandImpl> = {
+  win32: {
+    var: (name: string) => `%${name}%`,
+    scriptOpen: () => [],
+    chdirScript: () => ['cd', '%~p0'],
+    callCommandWithAllArgs: (cmd, ...args) => [cmd, ...args, '%*'],
+    createFile: (file, text) => [
+      ['@echo', 'off'],
+      ...text.map((line, i) =>
+        ['echo', `"${escape(line)}"`, i === 0 ? '>' : '>>', file]
+      )
+    ],
+    copy: (src, dest) => ['copy', src, dest],
+    copyRecursive: (src, dest) => ['xcopy', '/y', '/h', '/s', path.toNative(src), path.toNative(dest)],
+    rmRecursive: (dest) => ['rmdir', '/Q', '/S', dest],
+    mkdir: (dest) => ['md', dest],
+    export: (key, value) => ['set', `${key}=${value}`],
+    chdir: (dest) => ['cd', dest],
+    comment: (message) => ['\nREM', stripAnsiCodes(message), '\n'],
+    zip: (outputFile) => ['powershell', 'Compress-Archive', '-Path', '.', '-DestinationPath', outputFile]
+  },
+  posix: {
+    var: (name: string) => `$${name}`,
+    scriptOpen: () => ['#!/bin/sh'],
+    chdirScript: () => ['cd', '$(dirname "$0")'],
+    callCommandWithAllArgs: (cmd, ...args) => [cmd, ...args, '$@'],
+    createFile: (file, text, mode) => [
+      ...text.map((line, i) =>
+        ['echo', `"${escape(line)}"`, i === 0 ? '>' : '>>', file]),
+      ...(mode ? [['chmod', mode, file]] : [])
+    ],
+    copy: (src, dest) => ['cp', src, dest],
+    copyRecursive: (src, dest) => ['cp', '-r', '-p', src, dest],
+    rmRecursive: (dest) => ['rm', '-rf', dest],
+    mkdir: (dest) => ['mkdir', '-p', dest],
+    export: (key, value) => ['export', `${key}=${value}`],
+    chdir: (dest) => ['cd', dest],
+    comment: (message) => ['\n#', stripAnsiCodes(message), '\n'],
+    zip: (outputFile) => ['zip', '-r', outputFile, '.']
+  },
+};
+
+export const ActiveShellCommand = ShellCommands[process.platform === 'win32' ? 'win32' : 'posix'];