@elementor/wp-lite-env 0.0.16 → 0.0.18

package/dist/{chunk-UBXF6D42.js → chunk-FNPCY3S6.js}

@@ -17,100 +17,108 @@ var getConfig = (configFilePath) => {
     mappings: {},
     config: {}
   };
-  return {
-    core: configFile.core || defaultConfig.core,
-    phpVersion: configFile.phpVersion || defaultConfig.phpVersion,
-    plugins: configFile.plugins || defaultConfig.plugins,
-    themes: configFile.themes || defaultConfig.themes,
-    mappings: configFile.mappings || defaultConfig.mappings,
-    config: configFile.config || defaultConfig.config
-  };
+  return Object.assign({}, defaultConfig, configFile);
 };
 
 // src/run.ts
-import fs2 from "fs";
+import fs2 from "fs/promises";
 
 // src/templates.ts
 import path from "path";
-var generateDockerComposeYmlTemplate = (config, basePath, port, configPath) => {
+import { dump } from "js-yaml";
+var generateVolumeMapping = (basePath, configPath, config) => {
   const mappingsStringArray = Object.keys(config.mappings).map((key) => {
     const value = config.mappings[key];
-    return `      - >-
-        ${path.resolve(basePath, value)}:/var/www/html/${key}
-`;
+    return `${path.resolve(basePath, value)}:/var/www/html/${key}`;
   });
   const pluginsStringArray = Object.keys(config.plugins).map((key) => {
     const value = config.plugins[key];
-    return `      - >-
-        ${path.resolve(basePath, value)}:/var/www/html/wp-content/plugins/${key}
-`;
+    return `${path.resolve(basePath, value)}:/var/www/html/wp-content/plugins/${key}`;
   });
   const themesStringArray = Object.keys(config.themes).map((key) => {
     const value = config.themes[key];
-    return `      - >-
-        ${path.resolve(basePath, value)}:/var/www/html/wp-content/themes/${key}
-`;
+    return `${path.resolve(basePath, value)}:/var/www/html/wp-content/themes/${key}`;
   });
-  const wpContent = `      - >-
-        wpcontent:/var/www/html
-`;
-  const wpConfig = `      - >-
-        ${configPath}:/var/www/html/wp-config
-`;
-  const volumes = mappingsStringArray.concat(pluginsStringArray).concat(themesStringArray).concat([wpContent, wpConfig]).join("");
-  return `services:
-  mysql:
-    image: 'mariadb:lts'
-    ports:
-      - '\${WP_ENV_MYSQL_PORT:-}:3306'
-    environment:
-      MYSQL_ROOT_HOST: '%'
-      MYSQL_ROOT_PASSWORD: password
-      MYSQL_DATABASE: wordpress
-    volumes:
-      - 'mysql:/var/lib/mysql'
-  wordpress:
-    depends_on:
-      - mysql
-    build:
-      context: .
-      dockerfile: WordPress.Dockerfile
-      no_cache: true
-      args: &ref_0
-        HOST_USERNAME: yotams
-        HOST_UID: '502'
-        HOST_GID: '20'
-    ports:
-      - '\${WP_ENV_PORT:-${port}}:80'
-    environment:
-      APACHE_RUN_USER: '#502'
-      APACHE_RUN_GROUP: '#20'
-      WORDPRESS_DB_USER: root
-      WORDPRESS_DB_PASSWORD: password
-      WORDPRESS_DB_NAME: wordpress
-    volumes: &ref_1
-${volumes}
-    extra_hosts:
-      - 'host.docker.internal:host-gateway'
-  cli:
-    depends_on:
-      - wordpress
-    build:
-      context: .
-      dockerfile: CLI.Dockerfile
-      args: *ref_0
-    volumes: *ref_1
-    user: '502:20'
-    environment:
-      WORDPRESS_DB_USER: root
-      WORDPRESS_DB_PASSWORD: password
-      WORDPRESS_DB_NAME: wordpress
-    extra_hosts:
-      - 'host.docker.internal:host-gateway'
-volumes:
-  mysql: {}
-  wpcontent: {}
-`;
+  const wpContent = `wpcontent:/var/www/html`;
+  const wpConfig = `${configPath}:/var/www/html/wp-config`;
+  return mappingsStringArray.concat(pluginsStringArray).concat(themesStringArray).concat([wpContent, wpConfig]);
+};
+var generateDockerComposeYmlTemplate = (config, basePath, port, configPath) => {
+  const hostUid = "502";
+  const hostGid = "20";
+  const wordpressDbUser = "root";
+  const wordpressDbPassword = "password";
+  const wordpressDbName = "wordpress";
+  const args = {
+    HOST_USERNAME: "someuser",
+    HOST_UID: hostUid,
+    HOST_GID: hostGid
+  };
+  const volumes = generateVolumeMapping(basePath, configPath, config);
+  const compose = {
+    services: {
+      mysql: {
+        image: "mariadb:lts",
+        ports: [
+          "${WP_ENV_MYSQL_PORT:-}:3306"
+        ],
+        environment: {
+          MYSQL_ROOT_HOST: "%",
+          MYSQL_ROOT_PASSWORD: "password",
+          MYSQL_DATABASE: "wordpress"
+        },
+        volumes: [
+          "mysql:/var/lib/mysql"
+        ]
+      },
+      wordpress: {
+        depends_on: ["mysql"],
+        build: {
+          context: ".",
+          dockerfile: "WordPress.Dockerfile",
+          no_cache: true,
+          args
+        },
+        ports: [
+          `\${WP_ENV_PORT:-${port}}:80`
+        ],
+        environment: {
+          APACHE_RUN_USER: `#${hostUid}`,
+          APACHE_RUN_GROUP: `#${hostGid}`,
+          WORDPRESS_DB_USER: wordpressDbUser,
+          WORDPRESS_DB_PASSWORD: wordpressDbPassword,
+          WORDPRESS_DB_NAME: wordpressDbName
+        },
+        volumes,
+        extra_hosts: [
+          "host.docker.internal:host-gateway"
+        ]
+      },
+      cli: {
+        depends_on: ["wordpress"],
+        build: {
+          context: ".",
+          dockerfile: "CLI.Dockerfile",
+          args
+        },
+        volumes,
+        user: `${hostUid}:${hostGid}`,
+        environment: {
+          WORDPRESS_DB_USER: wordpressDbUser,
+          WORDPRESS_DB_PASSWORD: wordpressDbPassword,
+          WORDPRESS_DB_NAME: wordpressDbName
+        },
+        extra_hosts: [
+          "host.docker.internal:host-gateway"
+        ]
+      }
+    },
+    volumes: {
+      mysql: {},
+      wpcontent: {}
+    }
+  };
+  return dump(compose);
 };
 var generateWordPressDockerfileTemplate = (config) => {
   return `FROM wordpress:${config.core}-php${config.phpVersion}
@@ -152,22 +160,28 @@ set -eox pipefail
 import { createHash } from "crypto";
 import os from "node:os";
 var waitForServer = async (url, timeoutMs) => {
-  const startTime = Date.now();
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-  while (startTime + timeoutMs > Date.now()) {
+  const pollEveryMs = 100;
+  let retries = timeoutMs / pollEveryMs;
+  while (retries > 0) {
     try {
       const response = await fetch(url);
-      if (response.ok && (200 === response.status || 302 === response.status)) {
+      if (200 === response.status || 302 === response.status) {
         return true;
       }
     } catch (e) {
-    } finally {
-      await sleep(100);
+      if ("ECONNREFUSED" !== e.cause?.code) {
+        console.warn(`Encountered an error while waiting for server to start: ${e.message}
+Trying to reach server again.`);
+      }
     }
+    await sleep(pollEveryMs);
+    retries--;
   }
+  console.error(`Server did not start within ${timeoutMs}ms`);
   return false;
 };
-var getRunPath = (port) => path2.resolve(os.tmpdir(), port);
+var getRunPath = (port) => path2.resolve(os.tmpdir(), `${port}`);
 var start = async (port) => {
   const runPath = getRunPath(port);
   await upAll({
@@ -176,7 +190,7 @@ var start = async (port) => {
     cwd: runPath,
     log: true
   });
-  await waitForServer(`http://localhost:${port}`, 1e4);
+  await waitForServer(`http://0.0.0.0:${port}`, 1e4);
   await cli(port, "bash wp-config/configure-wp.sh");
 };
 var stop = async (port) => {
@@ -187,7 +201,7 @@ var stop = async (port) => {
     composeOptions: ["-p", `port${port}`],
     log: true
   });
-  cleanup(port);
+  await cleanup(port);
 };
 var cli = async (port, command) => {
   const runPath = getRunPath(port);
@@ -203,52 +217,30 @@ var commandMap = {
   stop,
   cli
 };
-var getWpConfigPath = (port) => path2.resolve(process.cwd(), port);
-var generateFiles = (port, configFilePath) => {
+var getWpConfigPath = (port) => path2.resolve(process.cwd(), `${port}`);
+var generateFiles = async (port, configFilePath) => {
   const config = getConfig(configFilePath);
   const wpConfigPath = getWpConfigPath(port);
-  if (!fs2.existsSync(wpConfigPath)) {
-    fs2.mkdirSync(wpConfigPath, { recursive: true });
-  }
+  await fs2.mkdir(wpConfigPath, { recursive: true });
   const wpConfig = generateConfiguration(config, port);
-  fs2.writeFileSync(path2.resolve(wpConfigPath, "configure-wp.sh"), wpConfig);
+  await fs2.writeFile(path2.resolve(wpConfigPath, "configure-wp.sh"), wpConfig);
   const dockerComposeYmlTemplate = generateDockerComposeYmlTemplate(config, process.cwd(), port, wpConfigPath);
   const wordPressDockerfileTemplate = generateWordPressDockerfileTemplate(config);
   const cliDockerfileTemplate = generateCliDockerfileTemplate(config);
   const hash = createHash("sha256");
   hash.update(dockerComposeYmlTemplate + wordPressDockerfileTemplate + cliDockerfileTemplate + port);
   const runPath = getRunPath(port);
-  if (!fs2.existsSync(runPath)) {
-    fs2.mkdirSync(runPath);
-  }
+  await fs2.mkdir(runPath, { recursive: true });
   console.log(`writing files to run path: ${runPath}`);
-  fs2.writeFileSync(path2.resolve(runPath, "docker-compose.yml"), dockerComposeYmlTemplate);
-  fs2.writeFileSync(path2.resolve(runPath, "WordPress.Dockerfile"), wordPressDockerfileTemplate);
-  fs2.writeFileSync(path2.resolve(runPath, "CLI.Dockerfile"), cliDockerfileTemplate);
+  await fs2.writeFile(path2.resolve(runPath, "docker-compose.yml"), dockerComposeYmlTemplate);
+  await fs2.writeFile(path2.resolve(runPath, "WordPress.Dockerfile"), wordPressDockerfileTemplate);
+  await fs2.writeFile(path2.resolve(runPath, "CLI.Dockerfile"), cliDockerfileTemplate);
   return runPath;
 };
-var getArgument = (argumentKey, processArgs) => {
-  for (let i = 3; i < processArgs.length; i++) {
-    const argument = processArgs[i];
-    if (argument.startsWith(`${argumentKey}=`)) {
-      return argument.substring(argumentKey.length + 1);
-    }
-  }
-  return void 0;
-};
-var getConfigFilePath = (processArgs) => {
-  return path2.resolve(getArgument("config", processArgs));
-};
-var getCliCommand = (processArgs) => {
-  return getArgument("command", processArgs);
-};
-var getPort = (processArgs) => {
-  return getArgument("port", processArgs) || "8888";
-};
-var cleanup = (port) => {
+var cleanup = async (port) => {
   const runPath = getRunPath(port);
-  fs2.rmSync(getWpConfigPath(port), { recursive: true, force: true });
-  fs2.rmSync(runPath, { recursive: true, force: true });
+  await fs2.rm(getWpConfigPath(port), { recursive: true, force: true });
+  await fs2.rm(runPath, { recursive: true, force: true });
 };
 
 export {
@@ -256,9 +248,6 @@ export {
   stop,
   cli,
   commandMap,
-  generateFiles,
-  getConfigFilePath,
-  getCliCommand,
-  getPort
+  generateFiles
 };
-//# sourceMappingURL=chunk-UBXF6D42.js.map
+//# sourceMappingURL=chunk-FNPCY3S6.js.map

package/dist/index.cjs

@@ -38,25 +38,36 @@ module.exports = __toCommonJS(src_exports);
 // src/run.ts
 var import_docker_compose = require("docker-compose");
 var import_path = __toESM(require("path"), 1);
-var import_fs = __toESM(require("fs"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+
+// src/templates.ts
+var import_js_yaml = require("js-yaml");
+
+// src/run.ts
 var import_node_os = __toESM(require("os"), 1);
 var waitForServer = async (url, timeoutMs) => {
-  const startTime = Date.now();
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-  while (startTime + timeoutMs > Date.now()) {
+  const pollEveryMs = 100;
+  let retries = timeoutMs / pollEveryMs;
+  while (retries > 0) {
     try {
       const response = await fetch(url);
-      if (response.ok && (200 === response.status || 302 === response.status)) {
+      if (200 === response.status || 302 === response.status) {
         return true;
       }
     } catch (e) {
-    } finally {
-      await sleep(100);
+      if ("ECONNREFUSED" !== e.cause?.code) {
+        console.warn(`Encountered an error while waiting for server to start: ${e.message}
+Trying to reach server again.`);
+      }
     }
+    await sleep(pollEveryMs);
+    retries--;
   }
+  console.error(`Server did not start within ${timeoutMs}ms`);
   return false;
 };
-var getRunPath = (port) => import_path.default.resolve(import_node_os.default.tmpdir(), port);
+var getRunPath = (port) => import_path.default.resolve(import_node_os.default.tmpdir(), `${port}`);
 var start = async (port) => {
   const runPath = getRunPath(port);
   await (0, import_docker_compose.upAll)({
@@ -65,7 +76,7 @@ var start = async (port) => {
     cwd: runPath,
     log: true
   });
-  await waitForServer(`http://localhost:${port}`, 1e4);
+  await waitForServer(`http://0.0.0.0:${port}`, 1e4);
   await cli(port, "bash wp-config/configure-wp.sh");
 };
 var stop = async (port) => {
@@ -76,7 +87,7 @@ var stop = async (port) => {
     composeOptions: ["-p", `port${port}`],
     log: true
   });
-  cleanup(port);
+  await cleanup(port);
 };
 var cli = async (port, command) => {
   const runPath = getRunPath(port);
@@ -87,11 +98,11 @@ var cli = async (port, command) => {
     log: true
   });
 };
-var getWpConfigPath = (port) => import_path.default.resolve(process.cwd(), port);
-var cleanup = (port) => {
+var getWpConfigPath = (port) => import_path.default.resolve(process.cwd(), `${port}`);
+var cleanup = async (port) => {
   const runPath = getRunPath(port);
-  import_fs.default.rmSync(getWpConfigPath(port), { recursive: true, force: true });
-  import_fs.default.rmSync(runPath, { recursive: true, force: true });
+  await import_promises.default.rm(getWpConfigPath(port), { recursive: true, force: true });
+  await import_promises.default.rm(runPath, { recursive: true, force: true });
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-declare const start: (port: string) => Promise<void>;
-declare const stop: (port: string) => Promise<void>;
-declare const cli: (port: string, command: string) => Promise<void>;
+declare const start: (port: number) => Promise<void>;
+declare const stop: (port: number) => Promise<void>;
+declare const cli: (port: number, command: string) => Promise<void>;
 
 export { cli, start, stop };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-declare const start: (port: string) => Promise<void>;
-declare const stop: (port: string) => Promise<void>;
-declare const cli: (port: string, command: string) => Promise<void>;
+declare const start: (port: number) => Promise<void>;
+declare const stop: (port: number) => Promise<void>;
+declare const cli: (port: number, command: string) => Promise<void>;
 
 export { cli, start, stop };

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   cli,
   start,
   stop
-} from "./chunk-UBXF6D42.js";
+} from "./chunk-FNPCY3S6.js";
 export {
   cli,
   start,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elementor/wp-lite-env",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "private": false,
   "description": "A simple, lightweight, docker-based WordPress environment",
   "main": "dist/index.cjs",
@@ -31,13 +31,17 @@
   },
   "homepage": "https://github.com/elementor/wp-lite-env#readme",
   "dependencies": {
-    "docker-compose": "^1.1.0"
+    "command-line-args": "^6.0.1",
+    "docker-compose": "^1.1.0",
+    "js-yaml": "^4.1.0"
   },
   "devDependencies": {
     "@changesets/cli": "^2.27.9",
     "@eslint/js": "^9.15.0",
     "@jest/globals": "^29.7.0",
+    "@types/command-line-args": "^5.2.3",
     "@types/eslint__js": "^8.42.3",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.10.0",
     "eslint": "~9.14.0",
     "jest": "^29.7.0",

package/src/bin.ts

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 
-import {commandMap, generateFiles, getCliCommand, getConfigFilePath, getPort} from './run';
+import commandLineArgs from 'command-line-args';
+import {commandMap, generateFiles} from './run';
 
-const command = process.argv[ 2 ];
-if ( ! commandMap[ command ] ) {
-	console.log( `Valid commands: ${ Object.keys( commandMap ).join( ', ' ) }. You used ${ command }` );
-}
+const cliOptionDefinitions = [
+	{ name: 'cmd', type: String, defaultOption: true, description: 'The command to run. Can be one of "start", "stop" or "cli"' },
+	{ name: 'config', type: String, description: "Path to the configuration file defining the WordPress environment." },
+	{ name: 'port', type: Number, description: "Port to run the WordPress environment on" },
+	{ name: 'command', type: String, defaultValue: '', description: "The command to run by the WP CLI" },
+];
+const cliOptions = commandLineArgs(cliOptionDefinitions);
 
-const port = getPort( process.argv );
-const configFilePath = getConfigFilePath( process.argv )
-const cliCommand = getCliCommand( process.argv );
-generateFiles( port, configFilePath );
-
-commandMap[command](port, cliCommand);
+const command = cliOptions.cmd;
+const port = cliOptions.port;
+const configFilePath = cliOptions.config;
+const cliCommand = cliOptions.command;
+generateFiles( port, configFilePath ).then( () => commandMap[command](port, cliCommand) );

package/src/config.ts

@@ -24,12 +24,5 @@ export const getConfig = ( configFilePath?: string ): Config => {
 		config: {},
 	};
 
-	return {
-		core: configFile.core || defaultConfig.core,
-		phpVersion: configFile.phpVersion || defaultConfig.phpVersion,
-		plugins: configFile.plugins || defaultConfig.plugins,
-		themes: configFile.themes || defaultConfig.themes,
-		mappings: configFile.mappings || defaultConfig.mappings,
-		config: configFile.config || defaultConfig.config,
-	};
+	return Object.assign({}, defaultConfig, configFile);
 };

package/src/run.ts

@@ -1,7 +1,7 @@
 import {downAll, run, upAll} from "docker-compose";
 import path from "path";
 import {getConfig} from "./config";
-import fs from "fs";
+import fs from "fs/promises";
 import {
     generateCliDockerfileTemplate,
     generateConfiguration,
@@ -12,27 +12,32 @@ import {createHash} from "crypto";
 import os from "node:os";
 
 const waitForServer = async ( url: string, timeoutMs: number ) => {
-    const startTime = Date.now();
     const sleep = ( ms: number ) => new Promise( ( r ) => setTimeout( r, ms ) );
 
-    while ( startTime + timeoutMs > Date.now() ) {
+    const pollEveryMs = 100;
+    let retries = timeoutMs / pollEveryMs;
+
+    while (retries > 0) {
         try {
             const response = await fetch( url );
-            if ( response.ok && ( 200 === response.status || 302 === response.status ) ) {
+            if ( 200 === response.status || 302 === response.status ) {
                 return true;
             }
-        } catch ( e ) { // eslint-disable-line @typescript-eslint/no-unused-vars
-            // Ignore
-        } finally {
-            await sleep( 100 );
+        } catch ( e ) {
+            if ( 'ECONNREFUSED' !== e.cause?.code ) {
+                console.warn( `Encountered an error while waiting for server to start: ${ e.message }\nTrying to reach server again.` );
+            }
         }
+        await sleep (pollEveryMs);
+        retries--;
     }
+    console.error( `Server did not start within ${ timeoutMs }ms` );
     return false;
 };
 
-const getRunPath = ( port: string ) => path.resolve( os.tmpdir(), port );
+const getRunPath = ( port: number ) => path.resolve( os.tmpdir(), `${port}` );
 
-export const start = async ( port: string ) => {
+export const start = async ( port: number ) => {
     const runPath = getRunPath( port );
     await upAll( {
         commandOptions: [ '--build' ],
@@ -40,11 +45,11 @@ export const start = async ( port: string ) => {
         cwd: runPath,
         log: true,
     } );
-    await waitForServer( `http://localhost:${ port }`, 10000 );
+    await waitForServer( `http://0.0.0.0:${ port }`, 10000 );
     await cli( port, 'bash wp-config/configure-wp.sh' );
 };
 
-export const stop = async ( port: string ) => {
+export const stop = async ( port: number ) => {
     const runPath = getRunPath( port );
     await downAll( {
         cwd: runPath,
@@ -52,10 +57,10 @@ export const stop = async ( port: string ) => {
         composeOptions: [ '-p', `port${ port }` ],
         log: true,
     } );
-    cleanup( port );
+    await cleanup( port );
 };
 
-export const cli = async ( port: string, command: string ) => {
+export const cli = async ( port: number, command: string ) => {
     const runPath = getRunPath( port );
     await run( 'cli', command, {
         cwd: runPath,
@@ -65,25 +70,23 @@ export const cli = async ( port: string, command: string ) => {
     } );
 };
 
-export const commandMap: { [key: string]: ( ( port: string ) => Promise<void> ) | ( ( port: string, command: string ) => Promise<void> ) } = {
+export const commandMap: { [key: string]: ( ( port: number ) => Promise<void> ) | ( ( port: number, command: string ) => Promise<void> ) } = {
     start,
     stop,
     cli,
 };
 
-const getWpConfigPath = ( port: string ) => path.resolve( process.cwd(), port );
+const getWpConfigPath = ( port: number ) => path.resolve( process.cwd(), `${port}` );
 
-export const generateFiles = ( port: string, configFilePath: string ) => {
+export const generateFiles = async ( port: number, configFilePath: string ) => {
     const config = getConfig( configFilePath );
 
     // Using a local path since Docker Compose cannot access /tmp
     // See: https://github.com/docker/compose/issues/1153
     const wpConfigPath = getWpConfigPath( port );
-    if ( ! fs.existsSync( wpConfigPath ) ) {
-        fs.mkdirSync( wpConfigPath, { recursive: true } );
-    }
+    await fs.mkdir( wpConfigPath, { recursive: true } );
     const wpConfig = generateConfiguration( config, port );
-    fs.writeFileSync( path.resolve( wpConfigPath, 'configure-wp.sh' ), wpConfig );
+    await fs.writeFile( path.resolve( wpConfigPath, 'configure-wp.sh' ), wpConfig );
 
     const dockerComposeYmlTemplate = generateDockerComposeYmlTemplate( config, process.cwd(), port, wpConfigPath );
     const wordPressDockerfileTemplate = generateWordPressDockerfileTemplate( config );
@@ -91,14 +94,12 @@ export const generateFiles = ( port: string, configFilePath: string ) => {
     const hash = createHash( 'sha256' );
     hash.update( dockerComposeYmlTemplate + wordPressDockerfileTemplate + cliDockerfileTemplate + port );
     const runPath = getRunPath( port );
-    if ( ! fs.existsSync( runPath ) ) {
-        fs.mkdirSync( runPath );
-    }
+    await fs.mkdir( runPath, { recursive: true } );
 
     console.log( `writing files to run path: ${ runPath }` );
-    fs.writeFileSync( path.resolve( runPath, 'docker-compose.yml' ), dockerComposeYmlTemplate );
-    fs.writeFileSync( path.resolve( runPath, 'WordPress.Dockerfile' ), wordPressDockerfileTemplate );
-    fs.writeFileSync( path.resolve( runPath, 'CLI.Dockerfile' ), cliDockerfileTemplate );
+    await fs.writeFile( path.resolve( runPath, 'docker-compose.yml' ), dockerComposeYmlTemplate );
+    await fs.writeFile( path.resolve( runPath, 'WordPress.Dockerfile' ), wordPressDockerfileTemplate );
+    await fs.writeFile( path.resolve( runPath, 'CLI.Dockerfile' ), cliDockerfileTemplate );
 
     return runPath;
 };
@@ -117,16 +118,8 @@ export const getConfigFilePath = ( processArgs: string[] ) => {
     return path.resolve(getArgument( 'config', processArgs ));
 };
 
-export const getCliCommand = ( processArgs: string[] ) => {
-    return getArgument( 'command', processArgs );
-};
-
-export const getPort = ( processArgs: string[] ) => {
-    return getArgument( 'port', processArgs ) || '8888';
-};
-
-const cleanup = ( port: string ) => {
+const cleanup = async ( port: number ) => {
     const runPath = getRunPath( port );
-    fs.rmSync( getWpConfigPath( port ), { recursive: true, force: true } );
-    fs.rmSync( runPath, { recursive: true, force: true } );
+    await fs.rm( getWpConfigPath( port ), { recursive: true, force: true } );
+    await fs.rm( runPath, { recursive: true, force: true } );
 }