@scandipwa/magento-scripts 2.0.0-alpha.2 → 2.0.0-alpha.21

package/lib/tasks/docker/api.d.ts

@@ -1,7 +1,6 @@
 import { ExecAsyncSpawnOptions } from '../../util/exec-async-command';
 
 export interface DockerVersionOptions<T extends boolean = false> {
-    format?: string
     format?: string
     formatToJSON?: T
 }
@@ -69,3 +68,28 @@ export function version(
     options: DockerVersionOptions<true>,
     execOptions?: ExecAsyncSpawnOptions<false>
 ): Promise<DockerVersionResult>
+
+export interface DockerContextOptions<T extends boolean = false> {
+    format?: string
+    formatToJSON?: T
+}
+
+export interface DockerContextResult {
+    Current: boolean
+    Description: string
+    DockerEndpoint: string
+    KubernetesEndpoint: string
+    ContextType: string
+    Name: string
+    StackOrchestrator: string
+}
+
+export function context(
+    options: DockerContextOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+
+export function context(
+    options: DockerContextOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<DockerContextResult[]>

package/lib/tasks/docker/api.js

@@ -25,6 +25,36 @@ const version = async (options, execOptions = {}) => {
     return execAsyncSpawn(`docker version ${args}`, execOptions);
 };
 
+/**
+ * @param {import('./api').DockerContextOptions} options
+ * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const context = async (options, execOptions = {}) => {
+    const {
+        format,
+        formatToJSON
+    } = options;
+
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+    const args = [
+        formatArg
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker context ls ${args}`, execOptions);
+        if (result.startsWith('[')) {
+            return JSON.parse(result);
+        }
+
+        return JSON.parse(`[${result.split('\n').join(', ')}]`);
+    }
+
+    return execAsyncSpawn(`docker context ls ${args}`, execOptions);
+};
+
 module.exports = {
-    version
+    version,
+    context
 };

package/lib/tasks/docker/containers/container-api.d.ts

@@ -69,6 +69,8 @@ export interface ContainerRunOptions {
      * Run container in background and print container ID
      */
     detach?: boolean
+
+    tty?: boolean
     /**
      * Publish or expose port [docs](https://docs.docker.com/engine/reference/commandline/run/#publish-or-expose-port--p---expose)
      */
@@ -126,3 +128,22 @@ export interface ContainerRunOptions {
 }
 
 export function run(containerOptions: ContainerRunOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<false>
+
+export function runCommand(options: ContainerRunOptions): string[]
+
+export interface ContainerLogsOptions<T = never> {
+    name: string
+    details?: boolean
+    follow?: boolean
+    since?: string
+    tail?: string
+    timestamps?: boolean
+    until?: string
+    parser?: (line: string) => T
+}
+
+export function logs(options?: ContainerLogsOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<string>
+export function logs<T>(options?: ContainerLogsOptions<T>, execOptions?: ExecAsyncSpawnOptions<false>): Promise<T[]>
+
+export function stop(containers: string[], execOptions: ExecAsyncSpawnOptions<false>): Promise<string>
+export function rm(containers: string[], execOptions: ExecAsyncSpawnOptions<false>): Promise<string>

package/lib/tasks/docker/containers/container-api.js

@@ -3,9 +3,9 @@ const { execAsyncSpawn } = require('../../../util/exec-async-command');
 
 /**
  * @param {import('./container-api').ContainerRunOptions} options
- * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ * @returns {string[]}
  */
-const run = (options, execOptions = {}) => {
+const runCommand = (options) => {
     const {
         addHost,
         ports = [],
@@ -24,32 +24,35 @@ const run = (options, execOptions = {}) => {
         expose = [],
         detach = true,
         rm = false,
+        tty = false,
         user
     } = options;
 
     const detachArg = detach && '-d';
     const rmArg = rm && '--rm';
+    const ttyArg = tty && '-it';
     const exposeArg = expose && expose.map((e) => `--expose=${ e }`);
-    const restartArg = !rm && restart && `--restart ${ restart }`;
-    const networkArg = network && `--network ${ network }`;
-    const portsArgs = ports.map((port) => `-p ${ port }`).join(' ');
-    const mountsArgs = mounts.map((mount) => `--mount ${ mount }`).join(' ');
-    const mountVolumesArgs = mountVolumes.map((mount) => `-v ${mount}`).join(' ');
-    const envArgs = !env ? '' : Object.entries(env).map(([key, value]) => `--env ${ key }='${ value }'`).join(' ');
-    const nameArg = name && `--name ${name}`;
-    const entrypointArg = entrypoint && `--entrypoint "${entrypoint}"`;
-    const healthCheckArg = healthCheck && Object.entries(healthCheck).map(([key, value]) => `--health-${key} '${value}'`).join(' ');
-    const securityArg = securityOptions.length > 0 && securityOptions.map((opt) => `--security-opt ${opt}`).join(' ');
-    const tmpfsArg = tmpfs.length > 0 && tmpfs.map((t) => `--tmpfs ${t}`).join(' ');
+    const restartArg = !rm && restart && `--restart=${ restart }`;
+    const networkArg = network && `--network=${ network }`;
+    const portsArgs = ports && ports.length > 0 && ports.map((port) => `-p=${ port }`);
+    const mountsArgs = mounts && mounts.map((mount) => `--mount=${ mount }`);
+    const mountVolumesArgs = mountVolumes && mountVolumes.map((mount) => `-v=${mount}`);
+    const envArgs = !env ? '' : Object.entries(env).map(([key, value]) => `--env=${ key }='${ value }'`);
+    const nameArg = name && `--name=${name}`;
+    const entrypointArg = entrypoint && `--entrypoint="${entrypoint}"`;
+    const healthCheckArg = healthCheck && Object.entries(healthCheck).map(([key, value]) => `--health-${key}='${value}'`);
+    const securityArg = securityOptions.length > 0 && securityOptions.map((opt) => `--security-opt=${opt}`);
+    const tmpfsArg = tmpfs.length > 0 && tmpfs.map((t) => `--tmpfs=${t}`);
     const userArg = user && `--user=${user}`;
     const addHostArg = addHost && `--add-host=${addHost}`;
 
     const dockerCommand = [
         'docker',
         'run',
+        nameArg,
+        ttyArg,
         detachArg,
         rmArg,
-        nameArg,
         networkArg,
         restartArg,
         portsArgs,
@@ -65,11 +68,17 @@ const run = (options, execOptions = {}) => {
         addHostArg,
         image,
         command
-    ].filter(Boolean).join(' ');
+    ].flat().filter(Boolean).filter((arg) => typeof arg === 'string');
 
-    return execAsyncSpawn(dockerCommand, execOptions);
+    return dockerCommand;
 };
 
+/**
+ * @param {import('./container-api').ContainerRunOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const run = (options, execOptions = {}) => execAsyncSpawn(runCommand(options).join(' '), execOptions);
+
 /**
  * @param {string} command
  * @param {string} container container id or name
@@ -140,14 +149,70 @@ const ls = async (options = {}, execOptions = {}) => {
 
     if (formatToJSON) {
         const result = await execAsyncSpawn(`docker container ls ${args}`, execOptions);
+        if (result.startsWith('[')) {
+            return JSON.parse(result);
+        }
+
         return JSON.parse(`[${result.split('\n').join(', ')}]`);
     }
 
     return execAsyncSpawn(`docker container ls ${args}`, execOptions);
 };
 
+/**
+ * @param {import('./container-api').ContainerLogsOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const logs = async (options = {}, execOptions = {}) => {
+    const {
+        name,
+        details = false,
+        follow = false,
+        since = '',
+        tail = '',
+        timestamps = false,
+        until = '',
+        parser
+    } = options;
+    const detailsArg = details && '--details';
+    const followArg = follow && '--follow';
+    const sinceArg = since && `--since=${since}`;
+    const tailArg = tail && `--tail=${tail}`;
+    const timestampsArg = timestamps && '--timestamps';
+    const untilArg = until && `--until=${until}`;
+
+    const logsCommand = [
+        'docker',
+        'container',
+        'logs',
+        detailsArg,
+        followArg,
+        sinceArg,
+        tailArg,
+        timestampsArg,
+        untilArg,
+        name
+    ].filter(Boolean).join(' ');
+
+    if (parser) {
+        const result = await execAsyncSpawn(logsCommand, execOptions);
+
+        return result.split('\n').map((line) => parser(line));
+    }
+
+    return execAsyncSpawn(logsCommand, execOptions);
+};
+
+const stop = (containers, execOptions = {}) => execAsyncSpawn(`docker container stop ${containers.join(' ')}`, execOptions);
+
+const rm = (containers, execOptions = {}) => execAsyncSpawn(`docker container rm ${containers.join(' ')}`, execOptions);
+
 module.exports = {
     run,
+    runCommand,
     exec,
-    ls
+    ls,
+    logs,
+    stop,
+    rm
 };

package/lib/tasks/docker/containers/tasks.js

@@ -6,9 +6,9 @@ const containerApi = require('./container-api');
 const { imageApi } = require('../image');
 const { execAsyncSpawn } = require('../../../util/exec-async-command');
 
-const stop = async (containers) => {
-    await execAsyncSpawn(`docker container stop ${containers.join(' ')}`);
-    await execAsyncSpawn(`docker container rm ${containers.join(' ')}`);
+const stopAndRemoveContainers = async (containers) => {
+    await containerApi.stop(containers);
+    await containerApi.rm(containers);
 };
 
 const pull = async (image) => execAsyncSpawn(`docker pull ${image}`);
@@ -26,8 +26,39 @@ const remoteImageReducer = (acc, val) => {
  */
 const pullImages = () => ({
     title: 'Pulling container images',
-    task: async ({ config: { docker } }, task) => {
+    task: async ({ config: { docker }, pullImages }, task) => {
         const containers = Object.values(docker.getContainers());
+
+        if (pullImages) {
+            return task.newListr(
+                containers
+                    .reduce(remoteImageReducer, [])
+                    .map((image) => {
+                        const [repo, tag = 'latest'] = image.split(':');
+
+                        return { repo, tag };
+                    })
+                    .reduce(
+                        (acc, val) => acc.concat(
+                            acc.some(
+                                (c) => c.repo === val.repo
+                                && c.tag === val.tag
+                            )
+                                ? []
+                                : val
+                        ),
+                        []
+                    )
+                    .map(({ repo, tag }) => ({
+                        title: `Pulling ${ logger.style.file(`${repo}:${tag}`) } image`,
+                        task: () => pull(`${repo}:${tag}`)
+                    })), {
+                    concurrent: true,
+                    exitOnError: true
+                }
+            );
+        }
+
         const imagesFilter = containers
             .reduce(remoteImageReducer, [])
             .map((image) => `reference='${image}'`);
@@ -85,10 +116,10 @@ const pullImages = () => ({
 const startContainers = () => ({
     title: 'Starting containers',
     task: async ({ ports, config: { docker }, debug }, task) => {
-        const containerList = (await execAsyncSpawn('docker container ls --all --format="{{.Names}}"')).split('\n');
+        const containerList = await containerApi.ls({ formatToJSON: true, all: true });
 
         const missingContainers = Object.values(docker.getContainers(ports)).filter(
-            ({ name }) => !containerList.includes(name)
+            ({ name }) => !containerList.some((c) => c.Names === name)
         );
 
         if (missingContainers.length === 0) {
@@ -129,22 +160,22 @@ const startContainers = () => ({
 const stopContainers = () => ({
     title: 'Stopping Docker containers',
     task: async ({ config: { baseConfig: { prefix } } }, task) => {
-        const containerList = (await execAsyncSpawn('docker container ls --all --format="{{.Names}}"')).split('\n');
+        const containerList = await containerApi.ls({ formatToJSON: true, all: true });
 
-        const runningContainers = containerList.filter((containerName) => containerName.startsWith(prefix));
+        const runningContainers = containerList.filter((containerName) => containerName.Names.startsWith(prefix));
 
         if (runningContainers.length === 0) {
             task.skip();
             return;
         }
 
-        await stop(runningContainers);
+        await stopAndRemoveContainers(runningContainers.map(({ Names }) => Names));
     }
 });
 
 const getContainerStatus = async (containerName) => {
     try {
-        return JSON.parse(await execAsyncSpawn(`docker inspect --format='{{json .State}}' ${containerName}`));
+        return JSON.parse(await execAsyncSpawn(`docker inspect --format='{{json .}}' ${containerName}`));
     } catch {
         return null;
     }
@@ -167,11 +198,11 @@ const checkContainersAreRunning = () => ({
                 }))
             );
 
-            if (containersWithStatus.some((c) => c.status.Status !== 'running')) {
+            if (containersWithStatus.some((c) => c.status.State.Status !== 'running')) {
                 if (tries === 2) {
-                    throw new KnownError(`${containersWithStatus.filter((c) => c.status.Status !== 'running').map((c) => c._).join(', ')} containers are not running! Please check container logs for more details!`);
+                    throw new KnownError(`${containersWithStatus.filter((c) => c.status.State.Status !== 'running').map((c) => c._).join(', ')} containers are not running! Please check container logs for more details!`);
                 } else {
-                    task.output = `${containersWithStatus.filter((c) => c.status.Status !== 'running').map((c) => c._).join(', ')} are not running, waiting if something will change...`;
+                    task.output = `${containersWithStatus.filter((c) => c.status.State.Status !== 'running').map((c) => c._).join(', ')} are not running, waiting if something will change...`;
                     await sleep(2000);
                     tries++;
                 }

package/lib/tasks/docker/convert-composer-home-to-composer-cache-volume.js

@@ -0,0 +1,52 @@
+const { containerApi } = require('./containers');
+const volumeApi = require('./volume/volume-api');
+
+const composeHomeDataVolumeName = 'composer_home-data';
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const convertComposerHomeToComposerCacheVolume = () => ({
+    skip: async () => {
+        const volumeList = await volumeApi.ls({
+            formatToJSON: true,
+            filter: `name=${ composeHomeDataVolumeName }`
+        });
+
+        return volumeList.length === 0;
+    },
+    task: async (ctx, task) => {
+        if (ctx.platform === 'linux' && !ctx.isDockerDesktop) {
+            await volumeApi.rm({ volumes: [composeHomeDataVolumeName] });
+            return;
+        }
+
+        const { composer_cache } = ctx.config.docker.volumes;
+        task.title = `Migrating from ${ composer_cache.name } volume to ${ composeHomeDataVolumeName }...`;
+        await containerApi.run({
+            rm: true,
+            detach: false,
+            mountVolumes: [
+                `${ composeHomeDataVolumeName }:/from:ro`,
+                `${ composer_cache.name }:/to`
+            ],
+            image: 'alpine',
+            command: 'ash -c "cd /from/cache; cp -av . /to"'
+        });
+
+        const runningContainers = await volumeApi.inspect({ volume: composeHomeDataVolumeName, formatToJSON: true });
+
+        if (runningContainers.Containers && Object.entries(runningContainers.Containers).length > 0) {
+            await Promise.all(Object.values(runningContainers.Containers).map(async (c) => {
+                await containerApi.stop([c.Name]);
+                await containerApi.rm([c.Name]);
+            }));
+        }
+
+        await volumeApi.rm({ volumes: [composeHomeDataVolumeName] });
+    }
+});
+
+module.exports = {
+    convertComposerHomeToComposerCacheVolume
+};

package/lib/tasks/docker/convert-mysql-to-mariadb.js

@@ -5,7 +5,6 @@ const { volumeApi, createVolumes } = require('./volume');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
 const { containerApi, stopContainers, pullImages } = require('./containers');
 const { importDumpToDatabase, connectToDatabase } = require('../database');
-const { setPrefix } = require('../prefix');
 const getProjectConfiguration = require('../../config/get-project-configuration');
 const { getAvailablePorts, getCachedPorts } = require('../../config/get-port-config');
 const { saveConfiguration } = require('../../config/save-config');
@@ -21,6 +20,7 @@ const KnownError = require('../../errors/known-error');
 const { createCacheFolder } = require('../cache');
 const { getSystemConfigTask } = require('../../config/system-config');
 const sleep = require('../../util/sleep');
+const { setProjectConfigTask } = require('../project-config');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -203,7 +203,7 @@ Please wait, this will take some time and do not restart the MySQL container unt
                     getSystemConfigTask(),
                     getCachedPorts(),
                     stopContainers(),
-                    setPrefix(),
+                    setProjectConfigTask(),
                     getProjectConfiguration(),
                     // get fresh ports
                     getAvailablePorts(),

package/lib/tasks/docker/image/image-api.d.ts

@@ -32,3 +32,47 @@ export function ls(
     options?: ImagesLsOptions<true>,
     execOptions?: ExecAsyncSpawnOptions<false>
 ): Promise<ImagesLsResult[]>
+
+export interface ImagesInspectOptions<T extends boolean = false> {
+    image: string
+    format?: string
+    formatToJSON?: T
+}
+
+export interface ImagesInspectResult {
+    Id: string
+    RepoTags: string[]
+    RepoDigests: string[]
+    Parent: string
+    Comment: string
+    Created: string
+    Container: string
+    ContainerConfig: unknown
+    DockerVersion: string
+    Author: string
+    Config: {
+        Env: string[],
+        Cmd: string[]
+        WorkingDir: string
+        Entrypoint: string[]
+        StopSignal: string
+    }
+    Architecture: string
+    Os: string
+    Size: number
+    VirtualSize: number
+    GraphDriver: unknown
+    RootFs: unknown
+    Metadata: Record<string, unknown>
+    CreatedTime: number
+    Container: Record<string, unknown>
+}
+
+export function inspect(
+    options?: ImagesInspectOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+export function inspect(
+    options?: ImagesInspectOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<ImagesInspectResult>

package/lib/tasks/docker/image/image-api.js

@@ -1,7 +1,6 @@
 const { execAsyncSpawn } = require('../../../util/exec-async-command');
 
 /**
- *
  * @param {import('./image-api').ImagesLsOptions} options
  * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
  */
@@ -44,6 +43,35 @@ const ls = async (options, execOptions = {}) => {
     return execAsyncSpawn(`docker image ls ${args}`, execOptions);
 };
 
+/**
+ * @param {import('./image-api').ImagesInspectOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const inspect = async (options, execOptions = {}) => {
+    const {
+        image,
+        format,
+        formatToJSON = false
+    } = options;
+
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+
+    const args = [
+        formatArg,
+        image
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker image inspect ${args}`, execOptions);
+        return JSON.parse(result);
+    }
+
+    return execAsyncSpawn(`docker image inspect ${args}`, execOptions);
+};
+
 module.exports = {
-    ls
+    ls,
+    inspect
 };

package/lib/tasks/docker/index.js

@@ -1,5 +1,7 @@
 const containers = require('./containers');
 const network = require('./network');
+const volume = require('./volume');
+const dockerApi = require('./api');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -19,13 +21,16 @@ const startServices = () => ({
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const stopServices = () => ({
+    title: 'Stopping Docker services',
     task: (ctx, task) => task.newListr([
         containers.stopContainers(),
+        volume.removeLocalVolumes(),
         network.tasks.removeNetwork()
     ])
 });
 
 module.exports = {
     startServices,
-    stopServices
+    stopServices,
+    dockerApi
 };

package/lib/tasks/docker/project-image-builder.js

@@ -1,8 +1,10 @@
+const path = require('path');
+const os = require('os');
 const { DockerFileBuilder } = require('../../util/dockerfile-builder');
-const semver = require('semver');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
 const KnownError = require('../../errors/known-error');
 const { runContainerImage } = require('../../util/run-container-image');
+const { imageApi } = require('./image');
 
 /**
  * Get enabled extensions list with versions
@@ -27,15 +29,15 @@ const getEnabledExtensionsFromImage = async (imageWithTag) => {
         .reduce((acc, [name, version]) => ({ ...acc, [name]: version }), {});
 };
 
-const addExtensionToBuilder = (builder, ctx) => ([extensionName, extensionInstructions]) => {
+const addExtensionToBuilder = (builder, ctx) => async ([extensionName, extensionInstructions]) => {
     const { command, ...extensionInstructionsWithoutCommand } = extensionInstructions;
     let runCommand = '';
     if (typeof command === 'string') {
         runCommand += ` ${command}`;
-    } else if (typeof command === 'function') {
-        runCommand += ` ${command({ ...extensionInstructionsWithoutCommand, ctx })}`;
+    } else if (typeof command === 'function' || command instanceof Promise) {
+        runCommand += ` ${await Promise.resolve(command({ ...extensionInstructionsWithoutCommand, ctx }))}`;
     } else {
-        runCommand += ` docker-php-ext-install ${extensionInstructionsWithoutCommand.name}`;
+        runCommand += ` docker-php-ext-install ${extensionInstructionsWithoutCommand.name || extensionName}`;
     }
     builder
         .comment(`extension ${extensionName} installation command`)
@@ -49,6 +51,7 @@ const addExtensionToBuilder = (builder, ctx) => ([extensionName, extensionInstru
 const buildDockerFileInstructions = async (ctx, { image, tag }) => {
     const { composer } = ctx.config.overridenConfiguration.configuration;
     const existingPHPExtensions = await getEnabledExtensionsFromImage(`${image}:${tag}`);
+    const imageDetails = await imageApi.inspect({ image: `${image}:${tag}`, formatToJSON: true });
 
     const missingExtensions = Object.entries(
         ctx.config.overridenConfiguration.configuration.php.extensions
@@ -68,10 +71,6 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
         .comment('project image')
         .from({ image, tag });
 
-    // install bash in image
-    dockerFileInstructions
-        .run('apk add --no-cache bash');
-
     if (missingExtensions.length > 0) {
         const allDependencies = missingExtensions.map(
             ([_extensionName, extensionInstructions]) => (extensionInstructions.dependencies || [])
@@ -79,7 +78,9 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
             .reduce((acc, val) => acc.concat(val.filter((ex) => !acc.includes(ex))), []);
 
         dockerFileInstructions.run(`apk add --no-cache ${allDependencies.join(' ')}`);
-        missingExtensions.forEach(addExtensionToBuilder(dockerFileInstructions, ctx));
+        for (const missingExtensionInstructions of missingExtensions) {
+            await addExtensionToBuilder(dockerFileInstructions, ctx)(missingExtensionInstructions);
+        }
     }
 
     const composerVersion = /^\d$/.test(composer.version)
@@ -92,17 +93,39 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
         .comment('make composer executable')
         .run('chmod +x ./composer')
         .comment('move composer to bin directory')
-        .run('mv composer /usr/local/bin/composer');
+        .run('mv composer /usr/local/bin/composer')
+        .run('mkdir -p /composer/home/cache')
+        .env({
+            COMPOSER_HOME: '/composer/home',
+            COMPOSER_CACHE_DIR: '/composer/home/cache'
+        });
+
+    if (composer.plugins && Object.values(composer.plugins).length > 0) {
+        for (const [pluginName, pluginOptions] of Object.entries(composer.plugins)) {
+            if (pluginOptions.enabled) {
+                dockerFileInstructions
+                    .comment(`install ${pluginName} composer global package`)
+                    // eslint-disable-next-line max-len
+                    .run(`composer global require ${pluginName}${ pluginOptions.options ? ` ${pluginOptions.options}` : '' }${ pluginOptions.options ? ` ${pluginOptions.options}` : ''}`);
+            }
+        }
+    }
 
-    if (semver.satisfies(composer.version, '^1')) {
+    if (!ctx.isDockerDesktop) {
         dockerFileInstructions
-            .comment('install prestissimo composer plugin')
-            .run('composer global require hirak/prestissimo');
+            .run(`chown -R ${os.userInfo().uid}:${os.userInfo().gid} /composer/home`);
     }
 
     dockerFileInstructions
         .workDir(ctx.config.baseConfig.containerMagentoDir);
 
+    const imagePathEnv = imageDetails.Config.Env.find((env) => env.startsWith('PATH'));
+
+    dockerFileInstructions
+        .env({
+            PATH: `${ imagePathEnv.split('=').pop() }:${ path.join(ctx.config.baseConfig.containerMagentoDir, 'bin') }`
+        });
+
     return dockerFileInstructions;
 };
 

package/lib/tasks/docker/system/index.js

@@ -0,0 +1,5 @@
+const systemApi = require('./system-api');
+
+module.exports = {
+    systemApi
+};