@scandipwa/magento-scripts 2.0.0-alpha.9 → 2.0.1

package/lib/config/versions/magento-2.4.5.js

@@ -1,11 +1,16 @@
-const path = require('path');
 const { defaultMagentoConfig } = require('../magento-config');
-const sodium = require('../php/extensions/sodium');
+const sodium = require('../services/php/extensions/sodium');
 const { magento24PHPExtensionList } = require('../magento/required-php-extensions');
-const { php81 } = require('../php/versions');
-const { sslTerminator } = require('../ssl-terminator');
-const { varnish70 } = require('../varnish/varnish-7-0');
-const { repo } = require('../php/base-repo');
+const { php81 } = require('../services/php/versions');
+const { sslTerminator } = require('../services/ssl-terminator');
+const { varnish70 } = require('../services/varnish');
+const { repo } = require('../services/php/base-repo');
+const { nginx118 } = require('../services/nginx/versions');
+const { composer2 } = require('../services/composer/versions');
+const { maildev } = require('../services/maildev');
+const { redis62 } = require('../services/redis');
+const { mariadb104 } = require('../services/mariadb/versions');
+const { elasticsearch717 } = require('../services/elasticsearch/versions');
 
 module.exports = ({ templateDir } = {}) => ({
     magentoVersion: '2.4.5',
@@ -16,27 +21,17 @@ module.exports = ({ templateDir } = {}) => ({
             extensions: { ...magento24PHPExtensionList, sodium },
             baseImage: `${ repo }:php-8.1-magento-2.4`
         }),
-        nginx: {
-            version: '1.18.0',
-            configTemplate: path.join(templateDir || '', 'nginx.template.conf')
-        },
-        redis: {
-            version: '6.0'
-        },
+        nginx: nginx118({ templateDir }),
+        redis: redis62(),
         mysql: {
             version: '8.0'
         },
-        mariadb: {
-            version: '10.4'
-        },
-        elasticsearch: {
-            version: '7.17.5'
-        },
-        composer: {
-            version: '2'
-        },
+        mariadb: mariadb104(),
+        elasticsearch: elasticsearch717(),
+        composer: composer2(),
         varnish: varnish70({ templateDir }),
-        sslTerminator: sslTerminator({ templateDir })
+        sslTerminator: sslTerminator({ templateDir }),
+        maildev: maildev()
     },
     magento: defaultMagentoConfig,
     host: 'localhost',

package/lib/tasks/cli/create-bashrc-config.js

@@ -17,11 +17,13 @@ const createBashrcConfigFile = () => ({
                 overwrite: true,
                 templateArgs: {
                     php,
-                    varnishEnabled
+                    varnishEnabled,
+                    config: ctx.config,
+                    magentoVersion: ctx.magentoVersion
                 }
             });
         } catch (e) {
-            throw new UnknownError(`Unexpected error accrued during php.ini config creation\n\n${e}`);
+            throw new UnknownError(`Unexpected error accrued during .magentorc config creation\n\n${e}`);
         }
     }
 });

package/lib/tasks/composer/local-auth-json.js

@@ -27,7 +27,7 @@ const localAuthJson = () => ({
                 throw new KnownError(`Your ./auth.json file does not contain the ${ logger.style.misc("{ 'http-basic': { 'repo.magento.com': <> } }") } field.`);
             }
 
-            process.env.COMPOSER_AUTH = localAuthJson;
+            process.env.COMPOSER_AUTH = JSON.stringify(JSON.parse(localAuthJson), null, 0);
         }
     },
     options: {

package/lib/tasks/database/connect-to-database.js

@@ -3,6 +3,8 @@ const UnknownError = require('../../errors/unknown-error');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
 const sleep = require('../../util/sleep');
 const { createMagentoDatabase } = require('./create-magento-database');
+const { createMagentoUser } = require('./create-magento-user');
+const defaultMagentoUser = require('./default-magento-user');
 
 /**
  * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -60,9 +62,9 @@ const gettingDatabaseConnection = () => ({
                 const connection = await mysql2.createConnection({
                     host: '127.0.0.1',
                     port: ports.mariadb,
-                    user: mariadb.env.MARIADB_USER,
-                    password: mariadb.env.MARIADB_PASSWORD,
-                    database: mariadb.env.MARIADB_DATABASE
+                    user: defaultMagentoUser.user,
+                    password: defaultMagentoUser.password,
+                    database: 'magento'
                 });
 
                 ctx.databaseConnection = connection;
@@ -101,6 +103,7 @@ const connectToDatabase = () => ({
     task: (ctx, task) => task.newListr([
         waitForDatabaseInitialization(),
         createMagentoDatabase(),
+        createMagentoUser(),
         terminatingExistingConnection(),
         gettingDatabaseConnection()
     ], {

package/lib/tasks/database/create-magento-database.js

@@ -1,4 +1,4 @@
-const { execAsyncSpawn } = require('../../util/exec-async-command');
+const { containerApi } = require('../docker/containers');
 
 /**
  * Will create database 'magento' in MariaDB if it does not exist for some reason
@@ -9,7 +9,10 @@ const createMagentoDatabase = () => ({
     task: async (ctx, task) => {
         const { mariadb } = ctx.config.docker.getContainers();
         task.title = `Creating Magento database in ${ mariadb._ }`;
-        await execAsyncSpawn(`docker exec ${mariadb.name} mysql -umagento -pmagento -h 127.0.0.1 -e "CREATE DATABASE IF NOT EXISTS magento;"`);
+        await containerApi.exec(
+            `mysql -uroot -p${ mariadb.env.MARIADB_ROOT_PASSWORD } -h 127.0.0.1 -e "CREATE DATABASE IF NOT EXISTS magento;"`,
+            mariadb.name
+        );
     }
 });
 

package/lib/tasks/database/create-magento-user.js

@@ -0,0 +1,50 @@
+const mysql2 = require('mysql2/promise');
+const defaultMagentoUser = require('./default-magento-user');
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const createMagentoUser = () => ({
+    title: 'Creating Magento user',
+    task: async (ctx, task) => {
+        const { mariadb } = ctx.config.docker.getContainers();
+        const connection = await mysql2.createConnection({
+            host: '127.0.0.1',
+            port: ctx.ports.mariadb,
+            user: 'root',
+            password: mariadb.env.MARIADB_ROOT_PASSWORD
+        });
+
+        const result = await connection.query('select Host, User from mysql.user;');
+
+        if (result.length === 0) {
+            task.skip();
+            return;
+        }
+
+        const [users] = result;
+
+        if (users.some((user) => user.User === defaultMagentoUser.user && user.Host === '%')) {
+            task.skip();
+            return;
+        }
+
+        if (users.some((user) => user.User === defaultMagentoUser.user)) {
+            const magentoUser = users.find((user) => user.User === defaultMagentoUser.user);
+
+            await connection.query(`DROP USER '${ magentoUser.User }'@'${ magentoUser.Host }'`);
+        }
+
+        await connection.query(
+            `CREATE USER '${ defaultMagentoUser.user }'@'${ defaultMagentoUser.host }' IDENTIFIED BY '${ defaultMagentoUser.password }';`
+        );
+        await connection.query(`GRANT ALL PRIVILEGES ON *.* TO '${ defaultMagentoUser.user }'@'${ defaultMagentoUser.host }' WITH GRANT OPTION;`);
+        await connection.query('FLUSH PRIVILEGES;');
+
+        await connection.destroy();
+    }
+});
+
+module.exports = {
+    createMagentoUser
+};

package/lib/tasks/database/default-magento-database.js

@@ -0,0 +1,3 @@
+module.exports = {
+    defaultMagentoDatabase: 'magento'
+};

package/lib/tasks/database/default-magento-user.js

@@ -0,0 +1,7 @@
+const defaultMagentoUser = {
+    user: 'magento',
+    password: 'magento',
+    host: '%'
+};
+
+module.exports = defaultMagentoUser;

package/lib/tasks/database/import-dump-to-database.js

@@ -5,6 +5,7 @@ const UnknownError = require('../../errors/unknown-error');
 const { execAsyncSpawn, execCommandTask } = require('../../util/exec-async-command');
 const pathExists = require('../../util/path-exists');
 const connectToDatabase = require('./connect-to-database');
+const defaultMagentoUser = require('./default-magento-user');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -88,8 +89,8 @@ const executeImportDumpSQL = () => ({
                     message: `root (${logger.style.command('Probably safest option')})`
                 },
                 {
-                    name: `--user=${mariadb.env.MARIADB_USER} --password=${mariadb.env.MARIADB_PASSWORD}`,
-                    message: `${mariadb.env.MARIADB_USER}`
+                    name: `--user=${defaultMagentoUser.user} --password=${defaultMagentoUser.password}`,
+                    message: `${defaultMagentoUser.user}`
                 }
             ]
         });

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

@@ -130,3 +130,20 @@ 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

@@ -34,15 +34,15 @@ const runCommand = (options) => {
     const exposeArg = expose && expose.map((e) => `--expose=${ e }`);
     const restartArg = !rm && restart && `--restart=${ restart }`;
     const networkArg = network && `--network=${ network }`;
-    const portsArgs = ports && ports.length > 0 && ports.map((port) => `-p=${ port }`).join(' ');
-    const mountsArgs = mounts && mounts.map((mount) => `--mount=${ mount }`).join(' ');
-    const mountVolumesArgs = mountVolumes && mountVolumes.map((mount) => `-v=${mount}`).join(' ');
-    const envArgs = !env ? '' : Object.entries(env).map(([key, value]) => `--env=${ key }='${ value }'`).join(' ');
+    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}'`).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 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}`;
 
@@ -68,7 +68,7 @@ const runCommand = (options) => {
         addHostArg,
         image,
         command
-    ].filter(Boolean).filter((arg) => typeof arg === 'string');
+    ].flat().filter(Boolean).filter((arg) => typeof arg === 'string');
 
     return dockerCommand;
 };
@@ -149,15 +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>