@docker/actions-toolkit 0.76.0 → 0.77.0

package/lib/docker/install.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2023 actions-toolkit authors
  *
@@ -14,74 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Install = void 0;
-const child_process = __importStar(require("child_process"));
-const fs_1 = __importDefault(require("fs"));
-const promises_1 = __importDefault(require("fs/promises"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-const async_retry_1 = __importDefault(require("async-retry"));
-const handlebars = __importStar(require("handlebars"));
-const core = __importStar(require("@actions/core"));
-const io = __importStar(require("@actions/io"));
-const tc = __importStar(require("@actions/tool-cache"));
-const context_1 = require("../context");
-const docker_1 = require("./docker");
-const exec_1 = require("../exec");
-const github_1 = require("../github");
-const regctl_1 = require("../regclient/regctl");
-const undock_1 = require("../undock/undock");
-const util_1 = require("../util");
-const assets_1 = require("./assets");
-class Install {
+import * as child_process from 'child_process';
+import fs from 'fs';
+import fsp from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import retry from 'async-retry';
+import * as handlebars from 'handlebars';
+import * as core from '@actions/core';
+import * as io from '@actions/io';
+import * as tc from '@actions/tool-cache';
+import { Context } from '../context.js';
+import { Docker } from './docker.js';
+import { Exec } from '../exec.js';
+import { GitHub } from '../github/github.js';
+import { Regctl } from '../regclient/regctl.js';
+import { Undock } from '../undock/undock.js';
+import { Util } from '../util.js';
+import { limaYamlData, dockerServiceLogsPs1, setupDockerWinPs1 } from './assets.js';
+export class Install {
+    runDir;
+    source;
+    contextName;
+    daemonConfig;
+    rootless;
+    localTCPPort;
+    regctl;
+    undock;
+    githubToken;
+    _version;
+    _toolDir;
+    gitCommit;
+    limaInstanceName = 'docker-actions-toolkit';
     constructor(opts) {
-        this.limaInstanceName = 'docker-actions-toolkit';
         this.runDir = opts.runDir;
         this.source = opts.source || {
             type: 'archive',
@@ -92,462 +56,438 @@ class Install {
         this.daemonConfig = opts.daemonConfig;
         this.rootless = opts.rootless || false;
         this.localTCPPort = opts.localTCPPort;
-        this.regctl = opts.regctl || new regctl_1.Regctl();
-        this.undock = opts.undock || new undock_1.Undock();
+        this.regctl = opts.regctl || new Regctl();
+        this.undock = opts.undock || new Undock();
         this.githubToken = opts.githubToken || process.env.GITHUB_TOKEN;
     }
     get toolDir() {
-        return this._toolDir || context_1.Context.tmpDir();
+        return this._toolDir || Context.tmpDir();
     }
-    download() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let extractFolder;
-            let cacheKey;
-            const platform = os_1.default.platform();
-            switch (this.source.type) {
-                case 'image': {
-                    this._version = this.source.tag;
-                    cacheKey = `docker-image`;
-                    extractFolder = yield this.downloadSourceImage(platform);
-                    break;
-                }
-                case 'archive': {
-                    const version = this.source.version;
-                    const channel = this.source.channel;
-                    cacheKey = `docker-archive-${channel}`;
-                    this._version = version;
-                    core.info(`Downloading Docker ${version} from ${this.source.channel} at download.docker.com`);
-                    extractFolder = yield this.downloadSourceArchive('docker', this.source);
-                    if (this.rootless) {
-                        core.info(`Downloading Docker rootless extras ${version} from ${this.source.channel} at download.docker.com`);
-                        const extrasFolder = yield this.downloadSourceArchive('docker-rootless-extras', this.source);
-                        fs_1.default.readdirSync(extrasFolder).forEach(file => {
-                            const src = path_1.default.join(extrasFolder, file);
-                            const dest = path_1.default.join(extractFolder, file);
-                            fs_1.default.copyFileSync(src, dest);
-                        });
-                    }
-                    break;
+    async download() {
+        let extractFolder;
+        let cacheKey;
+        const platform = os.platform();
+        switch (this.source.type) {
+            case 'image': {
+                this._version = this.source.tag;
+                cacheKey = `docker-image`;
+                extractFolder = await this.downloadSourceImage(platform);
+                break;
+            }
+            case 'archive': {
+                const version = this.source.version;
+                const channel = this.source.channel;
+                cacheKey = `docker-archive-${channel}`;
+                this._version = version;
+                core.info(`Downloading Docker ${version} from ${this.source.channel} at download.docker.com`);
+                extractFolder = await this.downloadSourceArchive('docker', this.source);
+                if (this.rootless) {
+                    core.info(`Downloading Docker rootless extras ${version} from ${this.source.channel} at download.docker.com`);
+                    const extrasFolder = await this.downloadSourceArchive('docker-rootless-extras', this.source);
+                    fs.readdirSync(extrasFolder).forEach(file => {
+                        const src = path.join(extrasFolder, file);
+                        const dest = path.join(extractFolder, file);
+                        fs.copyFileSync(src, dest);
+                    });
                 }
+                break;
             }
-            core.info('Fixing perms');
-            fs_1.default.readdir(path_1.default.join(extractFolder), function (err, files) {
-                if (err) {
-                    throw err;
+        }
+        core.info('Fixing perms');
+        fs.readdir(path.join(extractFolder), function (err, files) {
+            if (err) {
+                throw err;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            files.forEach(function (file, index) {
+                if (!Util.isDirectory(path.join(extractFolder, file))) {
+                    fs.chmodSync(path.join(extractFolder, file), '0755');
                 }
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                files.forEach(function (file, index) {
-                    if (!util_1.Util.isDirectory(path_1.default.join(extractFolder, file))) {
-                        fs_1.default.chmodSync(path_1.default.join(extractFolder, file), '0755');
-                    }
-                });
             });
-            const tooldir = yield tc.cacheDir(extractFolder, cacheKey, this._version.replace(/(0+)([1-9]+)/, '$2'));
-            core.addPath(tooldir);
-            core.info('Added Docker to PATH');
-            this._toolDir = tooldir;
-            return tooldir;
         });
+        const tooldir = await tc.cacheDir(extractFolder, cacheKey, this._version.replace(/(0+)([1-9]+)/, '$2'));
+        core.addPath(tooldir);
+        core.info('Added Docker to PATH');
+        this._toolDir = tooldir;
+        return tooldir;
     }
-    downloadSourceImage(platform) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const dest = path_1.default.join(context_1.Context.tmpDir(), 'docker-install-image');
-            const cliImage = `dockereng/cli-bin:${this._version}`;
-            const engineImage = `moby/moby-bin:${this._version}`;
-            core.info(`Downloading Docker CLI from ${cliImage}`);
-            yield this.undock.run({
-                source: cliImage,
+    async downloadSourceImage(platform) {
+        const dest = path.join(Context.tmpDir(), 'docker-install-image');
+        const cliImage = `dockereng/cli-bin:${this._version}`;
+        const engineImage = `moby/moby-bin:${this._version}`;
+        core.info(`Downloading Docker CLI from ${cliImage}`);
+        await this.undock.run({
+            source: cliImage,
+            dist: dest
+        });
+        if (['win32', 'linux'].includes(platform)) {
+            core.info(`Downloading Docker engine from ${engineImage}`);
+            await this.undock.run({
+                source: engineImage,
                 dist: dest
             });
-            if (['win32', 'linux'].includes(platform)) {
-                core.info(`Downloading Docker engine from ${engineImage}`);
-                yield this.undock.run({
-                    source: engineImage,
-                    dist: dest
-                });
-            }
-            else if (platform == 'darwin') {
-                // On macOS, the docker daemon binary will be downloaded inside the lima VM.
-                // However, we will get the exact git revision from the image config
-                // to get the matching systemd unit files. There's no macOS image for
-                // moby/moby-bin - a linux daemon is run inside lima.
-                try {
-                    const engineImageConfig = yield this.imageConfig(engineImage, 'linux/arm64');
-                    core.debug(`docker.Install.downloadSourceImage engineImageConfig: ${JSON.stringify(engineImageConfig)}`);
-                    this.gitCommit = (_b = (_a = engineImageConfig.config) === null || _a === void 0 ? void 0 : _a.Labels) === null || _b === void 0 ? void 0 : _b['org.opencontainers.image.revision'];
-                    if (!this.gitCommit) {
-                        throw new Error(`No git revision can be determined from the image`);
-                    }
-                }
-                catch (e) {
-                    core.warning(e);
-                    this.gitCommit = 'master';
+        }
+        else if (platform == 'darwin') {
+            // On macOS, the docker daemon binary will be downloaded inside the lima VM.
+            // However, we will get the exact git revision from the image config
+            // to get the matching systemd unit files. There's no macOS image for
+            // moby/moby-bin - a linux daemon is run inside lima.
+            try {
+                const engineImageConfig = await this.imageConfig(engineImage, 'linux/arm64');
+                core.debug(`docker.Install.downloadSourceImage engineImageConfig: ${JSON.stringify(engineImageConfig)}`);
+                this.gitCommit = engineImageConfig.config?.Labels?.['org.opencontainers.image.revision'];
+                if (!this.gitCommit) {
+                    throw new Error(`No git revision can be determined from the image`);
                 }
-                core.debug(`docker.Install.downloadSourceImage gitCommit: ${this.gitCommit}`);
             }
-            else {
-                core.warning(`Docker engine not supported on ${platform}, only the Docker cli will be available`);
+            catch (e) {
+                core.warning(e);
+                this.gitCommit = 'master';
             }
-            return dest;
-        });
+            core.debug(`docker.Install.downloadSourceImage gitCommit: ${this.gitCommit}`);
+        }
+        else {
+            core.warning(`Docker engine not supported on ${platform}, only the Docker cli will be available`);
+        }
+        return dest;
+    }
+    async downloadSourceArchive(component, src) {
+        const release = await Install.getRelease(src.version, this.githubToken);
+        this._version = release.tag_name.replace(/^(docker-)?v+/, '');
+        core.debug(`docker.Install.downloadSourceArchive version: ${this._version}`);
+        const downloadURL = this.downloadURL(component, this._version, src.channel);
+        core.info(`Downloading ${downloadURL}`);
+        const downloadPath = await tc.downloadTool(downloadURL);
+        core.debug(`docker.Install.downloadSourceArchive downloadPath: ${downloadPath}`);
+        let extractFolder;
+        if (os.platform() == 'win32') {
+            extractFolder = await tc.extractZip(downloadPath, extractFolder);
+        }
+        else {
+            extractFolder = await tc.extractTar(downloadPath, extractFolder);
+        }
+        if (Util.isDirectory(path.join(extractFolder, component))) {
+            extractFolder = path.join(extractFolder, component);
+        }
+        core.debug(`docker.Install.downloadSourceArchive extractFolder: ${extractFolder}`);
+        return extractFolder;
     }
-    downloadSourceArchive(component, src) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const release = yield Install.getRelease(src.version, this.githubToken);
-            this._version = release.tag_name.replace(/^(docker-)?v+/, '');
-            core.debug(`docker.Install.downloadSourceArchive version: ${this._version}`);
-            const downloadURL = this.downloadURL(component, this._version, src.channel);
-            core.info(`Downloading ${downloadURL}`);
-            const downloadPath = yield tc.downloadTool(downloadURL);
-            core.debug(`docker.Install.downloadSourceArchive downloadPath: ${downloadPath}`);
-            let extractFolder;
-            if (os_1.default.platform() == 'win32') {
-                extractFolder = yield tc.extractZip(downloadPath, extractFolder);
+    async install() {
+        if (!this.toolDir) {
+            throw new Error('toolDir must be set. Run download first.');
+        }
+        if (!this.runDir) {
+            throw new Error('runDir must be set');
+        }
+        const platform = os.platform();
+        if (this.rootless && platform != 'linux') {
+            // TODO: Support on macOS (via lima)
+            throw new Error(`rootless is only supported on linux`);
+        }
+        switch (platform) {
+            case 'darwin': {
+                return await this.installDarwin();
             }
-            else {
-                extractFolder = yield tc.extractTar(downloadPath, extractFolder);
+            case 'linux': {
+                return await this.installLinux();
             }
-            if (util_1.Util.isDirectory(path_1.default.join(extractFolder, component))) {
-                extractFolder = path_1.default.join(extractFolder, component);
+            case 'win32': {
+                return await this.installWindows();
             }
-            core.debug(`docker.Install.downloadSourceArchive extractFolder: ${extractFolder}`);
-            return extractFolder;
-        });
+            default: {
+                throw new Error(`Unsupported platform: ${os.platform()}`);
+            }
+        }
     }
-    install() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.toolDir) {
-                throw new Error('toolDir must be set. Run download first.');
-            }
-            if (!this.runDir) {
-                throw new Error('runDir must be set');
-            }
-            const platform = os_1.default.platform();
-            if (this.rootless && platform != 'linux') {
-                // TODO: Support on macOS (via lima)
-                throw new Error(`rootless is only supported on linux`);
-            }
-            switch (platform) {
-                case 'darwin': {
-                    return yield this.installDarwin();
-                }
-                case 'linux': {
-                    return yield this.installLinux();
-                }
-                case 'win32': {
-                    return yield this.installWindows();
-                }
-                default: {
-                    throw new Error(`Unsupported platform: ${os_1.default.platform()}`);
-                }
+    async installDarwin() {
+        if (this.source.type == 'image' && !this.gitCommit) {
+            throw new Error('gitCommit must be set. Run download first.');
+        }
+        const src = this.source;
+        const limaDir = path.join(os.homedir(), '.lima', this.limaInstanceName);
+        await io.mkdirP(limaDir);
+        const dockerHost = `unix://${limaDir}/docker.sock`;
+        if (!(await Install.limaInstalled())) {
+            await this.brewInstall('lima');
+        }
+        await core.group('Lima version', async () => {
+            await Exec.exec('lima', ['--version']);
+        });
+        await core.group('Creating lima config', async () => {
+            let limaDaemonConfig = {};
+            if (this.daemonConfig) {
+                limaDaemonConfig = JSON.parse(this.daemonConfig);
             }
+            handlebars.registerHelper('stringify', function (obj) {
+                return new handlebars.SafeString(JSON.stringify(obj));
+            });
+            const srcArchive = src;
+            const limaCfg = handlebars.compile(limaYamlData)({
+                customImages: Install.limaCustomImages(),
+                daemonConfig: limaDaemonConfig,
+                dockerSock: `${limaDir}/docker.sock`,
+                localTCPPort: this.localTCPPort,
+                gitCommit: this.gitCommit,
+                srcType: src.type,
+                srcArchiveVersion: this._version, // Use the resolved version (e.g. latest -> 27.4.0)
+                srcArchiveChannel: srcArchive.channel,
+                srcImageTag: src.tag
+            });
+            core.info(`Writing lima config to ${path.join(limaDir, 'lima.yaml')}`);
+            fs.writeFileSync(path.join(limaDir, 'lima.yaml'), limaCfg);
+            core.info(limaCfg);
         });
-    }
-    installDarwin() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.source.type == 'image' && !this.gitCommit) {
-                throw new Error('gitCommit must be set. Run download first.');
-            }
-            const src = this.source;
-            const limaDir = path_1.default.join(os_1.default.homedir(), '.lima', this.limaInstanceName);
-            yield io.mkdirP(limaDir);
-            const dockerHost = `unix://${limaDir}/docker.sock`;
-            if (!(yield Install.limaInstalled())) {
-                yield this.brewInstall('lima');
-            }
-            yield core.group('Lima version', () => __awaiter(this, void 0, void 0, function* () {
-                yield exec_1.Exec.exec('lima', ['--version']);
-            }));
-            yield core.group('Creating lima config', () => __awaiter(this, void 0, void 0, function* () {
-                let limaDaemonConfig = {};
-                if (this.daemonConfig) {
-                    limaDaemonConfig = JSON.parse(this.daemonConfig);
-                }
-                handlebars.registerHelper('stringify', function (obj) {
-                    return new handlebars.SafeString(JSON.stringify(obj));
-                });
-                const srcArchive = src;
-                const limaCfg = handlebars.compile(assets_1.limaYamlData)({
-                    customImages: Install.limaCustomImages(),
-                    daemonConfig: limaDaemonConfig,
-                    dockerSock: `${limaDir}/docker.sock`,
-                    localTCPPort: this.localTCPPort,
-                    gitCommit: this.gitCommit,
-                    srcType: src.type,
-                    srcArchiveVersion: this._version, // Use the resolved version (e.g. latest -> 27.4.0)
-                    srcArchiveChannel: srcArchive.channel,
-                    srcImageTag: src.tag
+        if (!(await Install.qemuInstalled())) {
+            await this.brewInstall('qemu');
+        }
+        const qemuBin = await Install.qemuBin();
+        await core.group('QEMU version', async () => {
+            await Exec.exec(qemuBin, ['--version']);
+        });
+        // lima might already be started on the runner so env var added in download
+        // method is not expanded to the running process.
+        const envs = Object.assign({}, process.env, {
+            PATH: `${this.toolDir}:${process.env.PATH}`
+        });
+        await core.group('Starting lima instance', async () => {
+            const limaStartArgs = ['start', `--name=${this.limaInstanceName}`, `--timeout=${process.env.LIMA_START_TIMEOUT ?? '15m'}`];
+            if (process.env.LIMA_START_ARGS) {
+                limaStartArgs.push(process.env.LIMA_START_ARGS);
+            }
+            try {
+                await Exec.exec(`limactl ${limaStartArgs.join(' ')}`, [], { env: envs });
+            }
+            catch (e) {
+                fsp
+                    .readdir(limaDir)
+                    .then(files => {
+                    files
+                        .filter(f => path.extname(f) === '.log')
+                        .forEach(f => {
+                        const logfile = path.join(limaDir, f);
+                        const logcontent = fs.readFileSync(logfile, { encoding: 'utf8' }).trim();
+                        if (logcontent.length > 0) {
+                            core.info(`### ${logfile}:\n${logcontent}`);
+                        }
+                    });
+                })
+                    .catch(() => {
+                    // ignore
                 });
-                core.info(`Writing lima config to ${path_1.default.join(limaDir, 'lima.yaml')}`);
-                fs_1.default.writeFileSync(path_1.default.join(limaDir, 'lima.yaml'), limaCfg);
-                core.info(limaCfg);
-            }));
-            if (!(yield Install.qemuInstalled())) {
-                yield this.brewInstall('qemu');
-            }
-            const qemuBin = yield Install.qemuBin();
-            yield core.group('QEMU version', () => __awaiter(this, void 0, void 0, function* () {
-                yield exec_1.Exec.exec(qemuBin, ['--version']);
-            }));
-            // lima might already be started on the runner so env var added in download
-            // method is not expanded to the running process.
-            const envs = Object.assign({}, process.env, {
-                PATH: `${this.toolDir}:${process.env.PATH}`
+                throw e;
+            }
+        });
+        await core.group('Create Docker context', async () => {
+            await Docker.exec(['context', 'create', this.contextName, '--docker', `host=${dockerHost}`]);
+            await Docker.exec(['context', 'use', this.contextName]);
+        });
+        return dockerHost;
+    }
+    async installLinux() {
+        const dockerHost = `unix://${path.join(this.runDir, 'docker.sock')}`;
+        await io.mkdirP(this.runDir);
+        const daemonConfigPath = path.join(this.runDir, 'daemon.json');
+        await fs.writeFileSync(daemonConfigPath, '{}');
+        let daemonConfig = undefined;
+        const daemonConfigDefaultPath = '/etc/docker/daemon.json';
+        if (fs.existsSync(daemonConfigDefaultPath)) {
+            await core.group('Default Docker daemon config found', async () => {
+                core.info(JSON.stringify(JSON.parse(fs.readFileSync(daemonConfigDefaultPath, { encoding: 'utf8' })), null, 2));
+            });
+            daemonConfig = JSON.parse(fs.readFileSync(daemonConfigDefaultPath, { encoding: 'utf8' }));
+        }
+        if (this.daemonConfig) {
+            daemonConfig = Object.assign(daemonConfig || {}, JSON.parse(this.daemonConfig));
+        }
+        if (daemonConfig) {
+            const daemonConfigStr = JSON.stringify(daemonConfig, null, 2);
+            await core.group('Writing Docker daemon config', async () => {
+                fs.writeFileSync(daemonConfigPath, daemonConfigStr);
+                core.info(daemonConfigStr);
             });
-            yield core.group('Starting lima instance', () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const limaStartArgs = ['start', `--name=${this.limaInstanceName}`, `--timeout=${(_a = process.env.LIMA_START_TIMEOUT) !== null && _a !== void 0 ? _a : '15m'}`];
-                if (process.env.LIMA_START_ARGS) {
-                    limaStartArgs.push(process.env.LIMA_START_ARGS);
+        }
+        const envs = Object.assign({}, process.env, {
+            PATH: `${this.toolDir}:${process.env.PATH}`,
+            XDG_RUNTIME_DIR: (this.rootless && this.runDir) || undefined
+        });
+        await core.group('Start Docker daemon', async () => {
+            const bashPath = await io.which('bash', true);
+            let dockerPath = `${this.toolDir}/dockerd`;
+            if (this.rootless) {
+                dockerPath = `${this.toolDir}/dockerd-rootless.sh`;
+                if (fs.existsSync('/proc/sys/kernel/apparmor_restrict_unprivileged_userns')) {
+                    await Exec.exec('sudo', ['sh', '-c', 'echo 0 > /proc/sys/kernel/apparmor_restrict_unprivileged_userns']);
                 }
+            }
+            let cmd = `${dockerPath} --host="${dockerHost}" --config-file="${daemonConfigPath}" --exec-root="${this.runDir}/execroot" --data-root="${this.runDir}/data" --pidfile="${this.runDir}/docker.pid"`;
+            if (this.localTCPPort) {
+                cmd += ` --host="tcp://127.0.0.1:${this.localTCPPort}"`;
+            }
+            core.info(`[command] ${cmd}`); // https://github.com/actions/toolkit/blob/3d652d3133965f63309e4b2e1c8852cdbdcb3833/packages/exec/src/toolrunner.ts#L47
+            let sudo = 'sudo';
+            if (this.rootless) {
+                sudo += ' -u \\#1001';
+            }
+            const proc = await child_process.spawn(
+            // We can't use Exec.exec here because we need to detach the process to
+            // avoid killing it when the action finishes running. Even if detached,
+            // we also need to run dockerd in a subshell and unref the process so
+            // GitHub Action doesn't wait for it to finish.
+            `${sudo} env "PATH=$PATH" "XDG_RUNTIME_DIR=$XDG_RUNTIME_DIR" ${bashPath} << EOF
+( ${cmd} 2>&1 | tee "${this.runDir}/dockerd.log" ) &
+EOF`, [], {
+                env: envs,
+                detached: true,
+                shell: true,
+                stdio: ['ignore', process.stdout, process.stderr]
+            });
+            proc.unref();
+            await Util.sleep(3);
+            const retries = 10;
+            await retry(async (bail) => {
                 try {
-                    yield exec_1.Exec.exec(`limactl ${limaStartArgs.join(' ')}`, [], { env: envs });
+                    await Exec.getExecOutput(`docker version`, undefined, {
+                        silent: true,
+                        env: Object.assign({}, envs, {
+                            DOCKER_HOST: dockerHost,
+                            DOCKER_CONTENT_TRUST: 'false'
+                        })
+                    });
                 }
                 catch (e) {
-                    promises_1.default
-                        .readdir(limaDir)
-                        .then(files => {
-                        files
-                            .filter(f => path_1.default.extname(f) === '.log')
-                            .forEach(f => {
-                            const logfile = path_1.default.join(limaDir, f);
-                            const logcontent = fs_1.default.readFileSync(logfile, { encoding: 'utf8' }).trim();
-                            if (logcontent.length > 0) {
-                                core.info(`### ${logfile}:\n${logcontent}`);
-                            }
-                        });
-                    })
-                        .catch(() => {
-                        // ignore
-                    });
-                    throw e;
+                    bail(e);
+                }
+            }, {
+                retries: retries,
+                minTimeout: 1000,
+                onRetry: (err, i) => {
+                    core.info(`${err}. Retrying (${i}/${retries})...`);
                 }
-            }));
-            yield core.group('Create Docker context', () => __awaiter(this, void 0, void 0, function* () {
-                yield docker_1.Docker.exec(['context', 'create', this.contextName, '--docker', `host=${dockerHost}`]);
-                yield docker_1.Docker.exec(['context', 'use', this.contextName]);
-            }));
-            return dockerHost;
+            });
+            core.info(`Docker daemon started started successfully`);
+        });
+        await core.group('Create Docker context', async () => {
+            await Docker.exec(['context', 'create', this.contextName, '--docker', `host=${dockerHost}`]);
+            await Docker.exec(['context', 'use', this.contextName]);
         });
+        return dockerHost;
     }
-    installLinux() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dockerHost = `unix://${path_1.default.join(this.runDir, 'docker.sock')}`;
-            yield io.mkdirP(this.runDir);
-            const daemonConfigPath = path_1.default.join(this.runDir, 'daemon.json');
-            yield fs_1.default.writeFileSync(daemonConfigPath, '{}');
-            let daemonConfig = undefined;
-            const daemonConfigDefaultPath = '/etc/docker/daemon.json';
-            if (fs_1.default.existsSync(daemonConfigDefaultPath)) {
-                yield core.group('Default Docker daemon config found', () => __awaiter(this, void 0, void 0, function* () {
-                    core.info(JSON.stringify(JSON.parse(fs_1.default.readFileSync(daemonConfigDefaultPath, { encoding: 'utf8' })), null, 2));
-                }));
-                daemonConfig = JSON.parse(fs_1.default.readFileSync(daemonConfigDefaultPath, { encoding: 'utf8' }));
-            }
-            if (this.daemonConfig) {
-                daemonConfig = Object.assign(daemonConfig || {}, JSON.parse(this.daemonConfig));
-            }
-            if (daemonConfig) {
-                const daemonConfigStr = JSON.stringify(daemonConfig, null, 2);
-                yield core.group('Writing Docker daemon config', () => __awaiter(this, void 0, void 0, function* () {
-                    fs_1.default.writeFileSync(daemonConfigPath, daemonConfigStr);
-                    core.info(daemonConfigStr);
-                }));
-            }
-            const envs = Object.assign({}, process.env, {
-                PATH: `${this.toolDir}:${process.env.PATH}`,
-                XDG_RUNTIME_DIR: (this.rootless && this.runDir) || undefined
+    async installWindows() {
+        const dockerHostSocket = 'npipe:////./pipe/setup_docker_action';
+        let daemonConfig = undefined;
+        const daemonConfigPath = path.join(this.runDir, 'daemon.json');
+        if (fs.existsSync(daemonConfigPath)) {
+            await core.group('Default Docker daemon config found', async () => {
+                core.info(JSON.stringify(JSON.parse(fs.readFileSync(daemonConfigPath, { encoding: 'utf8' })), null, 2));
             });
-            yield core.group('Start Docker daemon', () => __awaiter(this, void 0, void 0, function* () {
-                const bashPath = yield io.which('bash', true);
-                let dockerPath = `${this.toolDir}/dockerd`;
-                if (this.rootless) {
-                    dockerPath = `${this.toolDir}/dockerd-rootless.sh`;
-                    if (fs_1.default.existsSync('/proc/sys/kernel/apparmor_restrict_unprivileged_userns')) {
-                        yield exec_1.Exec.exec('sudo', ['sh', '-c', 'echo 0 > /proc/sys/kernel/apparmor_restrict_unprivileged_userns']);
-                    }
-                }
-                let cmd = `${dockerPath} --host="${dockerHost}" --config-file="${daemonConfigPath}" --exec-root="${this.runDir}/execroot" --data-root="${this.runDir}/data" --pidfile="${this.runDir}/docker.pid"`;
-                if (this.localTCPPort) {
-                    cmd += ` --host="tcp://127.0.0.1:${this.localTCPPort}"`;
-                }
-                core.info(`[command] ${cmd}`); // https://github.com/actions/toolkit/blob/3d652d3133965f63309e4b2e1c8852cdbdcb3833/packages/exec/src/toolrunner.ts#L47
-                let sudo = 'sudo';
-                if (this.rootless) {
-                    sudo += ' -u \\#1001';
-                }
-                const proc = yield child_process.spawn(
-                // We can't use Exec.exec here because we need to detach the process to
-                // avoid killing it when the action finishes running. Even if detached,
-                // we also need to run dockerd in a subshell and unref the process so
-                // GitHub Action doesn't wait for it to finish.
-                `${sudo} env "PATH=$PATH" "XDG_RUNTIME_DIR=$XDG_RUNTIME_DIR" ${bashPath} << EOF
-( ${cmd} 2>&1 | tee "${this.runDir}/dockerd.log" ) &
-EOF`, [], {
-                    env: envs,
-                    detached: true,
-                    shell: true,
-                    stdio: ['ignore', process.stdout, process.stderr]
-                });
-                proc.unref();
-                yield util_1.Util.sleep(3);
-                const retries = 10;
-                yield (0, async_retry_1.default)((bail) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        yield exec_1.Exec.getExecOutput(`docker version`, undefined, {
-                            silent: true,
-                            env: Object.assign({}, envs, {
-                                DOCKER_HOST: dockerHost,
-                                DOCKER_CONTENT_TRUST: 'false'
-                            })
-                        });
-                    }
-                    catch (e) {
-                        bail(e);
-                    }
-                }), {
-                    retries: retries,
-                    minTimeout: 1000,
-                    onRetry: (err, i) => {
-                        core.info(`${err}. Retrying (${i}/${retries})...`);
-                    }
-                });
-                core.info(`Docker daemon started started successfully`);
-            }));
-            yield core.group('Create Docker context', () => __awaiter(this, void 0, void 0, function* () {
-                yield docker_1.Docker.exec(['context', 'create', this.contextName, '--docker', `host=${dockerHost}`]);
-                yield docker_1.Docker.exec(['context', 'use', this.contextName]);
-            }));
-            return dockerHost;
+            daemonConfig = JSON.parse(fs.readFileSync(daemonConfigPath, { encoding: 'utf8' }));
+        }
+        if (this.daemonConfig) {
+            daemonConfig = Object.assign(daemonConfig || {}, JSON.parse(this.daemonConfig));
+        }
+        let daemonConfigStr = '{}';
+        if (daemonConfig) {
+            daemonConfigStr = JSON.stringify(daemonConfig, null, 2);
+            await core.group('Docker daemon config', async () => {
+                core.info(daemonConfigStr);
+            });
+        }
+        const params = {
+            ToolDir: this.toolDir,
+            RunDir: this.runDir,
+            DockerHostSocket: dockerHostSocket,
+            DaemonConfig: daemonConfigStr
+        };
+        if (this.localTCPPort) {
+            params['DockerHostTCP'] = `tcp://127.0.0.1:${this.localTCPPort}`;
+        }
+        await core.group('Install Docker daemon service', async () => {
+            const setupCmd = await Util.powershellCommand(setupDockerWinPs1(), params);
+            await Exec.exec(setupCmd.command, setupCmd.args);
+            const logCmd = await Util.powershellCommand(dockerServiceLogsPs1());
+            await Exec.exec(logCmd.command, logCmd.args);
         });
-    }
-    installWindows() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dockerHostSocket = 'npipe:////./pipe/setup_docker_action';
-            let daemonConfig = undefined;
-            const daemonConfigPath = path_1.default.join(this.runDir, 'daemon.json');
-            if (fs_1.default.existsSync(daemonConfigPath)) {
-                yield core.group('Default Docker daemon config found', () => __awaiter(this, void 0, void 0, function* () {
-                    core.info(JSON.stringify(JSON.parse(fs_1.default.readFileSync(daemonConfigPath, { encoding: 'utf8' })), null, 2));
-                }));
-                daemonConfig = JSON.parse(fs_1.default.readFileSync(daemonConfigPath, { encoding: 'utf8' }));
-            }
-            if (this.daemonConfig) {
-                daemonConfig = Object.assign(daemonConfig || {}, JSON.parse(this.daemonConfig));
-            }
-            let daemonConfigStr = '{}';
-            if (daemonConfig) {
-                daemonConfigStr = JSON.stringify(daemonConfig, null, 2);
-                yield core.group('Docker daemon config', () => __awaiter(this, void 0, void 0, function* () {
-                    core.info(daemonConfigStr);
-                }));
-            }
-            const params = {
-                ToolDir: this.toolDir,
-                RunDir: this.runDir,
-                DockerHostSocket: dockerHostSocket,
-                DaemonConfig: daemonConfigStr
-            };
-            if (this.localTCPPort) {
-                params['DockerHostTCP'] = `tcp://127.0.0.1:${this.localTCPPort}`;
-            }
-            yield core.group('Install Docker daemon service', () => __awaiter(this, void 0, void 0, function* () {
-                const setupCmd = yield util_1.Util.powershellCommand((0, assets_1.setupDockerWinPs1)(), params);
-                yield exec_1.Exec.exec(setupCmd.command, setupCmd.args);
-                const logCmd = yield util_1.Util.powershellCommand((0, assets_1.dockerServiceLogsPs1)());
-                yield exec_1.Exec.exec(logCmd.command, logCmd.args);
-            }));
-            yield core.group('Create Docker context', () => __awaiter(this, void 0, void 0, function* () {
-                yield docker_1.Docker.exec(['context', 'create', this.contextName, '--docker', `host=${dockerHostSocket}`]);
-                yield docker_1.Docker.exec(['context', 'use', this.contextName]);
-            }));
-            return dockerHostSocket;
+        await core.group('Create Docker context', async () => {
+            await Docker.exec(['context', 'create', this.contextName, '--docker', `host=${dockerHostSocket}`]);
+            await Docker.exec(['context', 'use', this.contextName]);
         });
+        return dockerHostSocket;
     }
-    tearDown() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.runDir) {
-                throw new Error('runDir must be set');
-            }
-            switch (os_1.default.platform()) {
-                case 'darwin': {
-                    yield this.tearDownDarwin();
-                    break;
-                }
-                case 'linux': {
-                    yield this.tearDownLinux();
-                    break;
-                }
-                case 'win32': {
-                    yield this.tearDownWindows();
-                    break;
-                }
-                default: {
-                    throw new Error(`Unsupported platform: ${os_1.default.platform()}`);
-                }
+    async tearDown() {
+        if (!this.runDir) {
+            throw new Error('runDir must be set');
+        }
+        switch (os.platform()) {
+            case 'darwin': {
+                await this.tearDownDarwin();
+                break;
             }
-            yield core.group(`Cleaning up toolDir`, () => __awaiter(this, void 0, void 0, function* () {
-                if (!this._toolDir) {
-                    return;
-                }
-                fs_1.default.rmSync(this._toolDir, { recursive: true, force: true });
-            }));
+            case 'linux': {
+                await this.tearDownLinux();
+                break;
+            }
+            case 'win32': {
+                await this.tearDownWindows();
+                break;
+            }
+            default: {
+                throw new Error(`Unsupported platform: ${os.platform()}`);
+            }
+        }
+        await core.group(`Cleaning up toolDir`, async () => {
+            if (!this._toolDir) {
+                return;
+            }
+            fs.rmSync(this._toolDir, { recursive: true, force: true });
         });
     }
-    tearDownDarwin() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield core.group('Docker daemon logs', () => __awaiter(this, void 0, void 0, function* () {
-                yield exec_1.Exec.exec('limactl', ['shell', '--tty=false', this.limaInstanceName, 'sudo', 'journalctl', '-u', 'docker.service', '-l', '--no-pager']).catch(() => {
-                    core.warning(`Failed to get Docker daemon logs`);
-                });
-            }));
-            yield core.group('Stopping lima instance', () => __awaiter(this, void 0, void 0, function* () {
-                yield exec_1.Exec.exec('limactl', ['stop', '--tty=false', this.limaInstanceName, '--force']);
-            }));
-            yield core.group('Removing lima instance', () => __awaiter(this, void 0, void 0, function* () {
-                yield exec_1.Exec.exec('limactl', ['delete', '--tty=false', this.limaInstanceName, '--force']);
-            }));
-            yield core.group('Removing Docker context', () => __awaiter(this, void 0, void 0, function* () {
-                yield docker_1.Docker.exec(['context', 'rm', '-f', this.contextName]);
-            }));
-            yield core.group(`Cleaning up runDir`, () => __awaiter(this, void 0, void 0, function* () {
-                yield exec_1.Exec.exec('sudo', ['rm', '-rf', this.runDir]);
-            }));
+    async tearDownDarwin() {
+        await core.group('Docker daemon logs', async () => {
+            await Exec.exec('limactl', ['shell', '--tty=false', this.limaInstanceName, 'sudo', 'journalctl', '-u', 'docker.service', '-l', '--no-pager']).catch(() => {
+                core.warning(`Failed to get Docker daemon logs`);
+            });
+        });
+        await core.group('Stopping lima instance', async () => {
+            await Exec.exec('limactl', ['stop', '--tty=false', this.limaInstanceName, '--force']);
+        });
+        await core.group('Removing lima instance', async () => {
+            await Exec.exec('limactl', ['delete', '--tty=false', this.limaInstanceName, '--force']);
+        });
+        await core.group('Removing Docker context', async () => {
+            await Docker.exec(['context', 'rm', '-f', this.contextName]);
+        });
+        await core.group(`Cleaning up runDir`, async () => {
+            await Exec.exec('sudo', ['rm', '-rf', this.runDir]);
         });
     }
-    tearDownLinux() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield core.group('Docker daemon logs', () => __awaiter(this, void 0, void 0, function* () {
-                core.info(fs_1.default.readFileSync(path_1.default.join(this.runDir, 'dockerd.log'), { encoding: 'utf8' }));
-            }));
-            yield core.group('Stopping Docker daemon', () => __awaiter(this, void 0, void 0, function* () {
-                yield exec_1.Exec.exec('sudo', ['kill', '-s', 'SIGTERM', fs_1.default.readFileSync(path_1.default.join(this.runDir, 'docker.pid')).toString().trim()]);
-                yield util_1.Util.sleep(5);
-            }));
-            yield core.group('Removing Docker context', () => __awaiter(this, void 0, void 0, function* () {
-                yield docker_1.Docker.exec(['context', 'rm', '-f', this.contextName]);
-            }));
-            yield core.group(`Cleaning up runDir`, () => __awaiter(this, void 0, void 0, function* () {
-                yield exec_1.Exec.exec('sudo', ['rm', '-rf', this.runDir], {
-                    ignoreReturnCode: true,
-                    failOnStdErr: false
-                });
-            }));
+    async tearDownLinux() {
+        await core.group('Docker daemon logs', async () => {
+            core.info(fs.readFileSync(path.join(this.runDir, 'dockerd.log'), { encoding: 'utf8' }));
+        });
+        await core.group('Stopping Docker daemon', async () => {
+            await Exec.exec('sudo', ['kill', '-s', 'SIGTERM', fs.readFileSync(path.join(this.runDir, 'docker.pid')).toString().trim()]);
+            await Util.sleep(5);
+        });
+        await core.group('Removing Docker context', async () => {
+            await Docker.exec(['context', 'rm', '-f', this.contextName]);
+        });
+        await core.group(`Cleaning up runDir`, async () => {
+            await Exec.exec('sudo', ['rm', '-rf', this.runDir], {
+                ignoreReturnCode: true,
+                failOnStdErr: false
+            });
         });
     }
-    tearDownWindows() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield core.group('Docker daemon logs', () => __awaiter(this, void 0, void 0, function* () {
-                const logCmd = yield util_1.Util.powershellCommand((0, assets_1.dockerServiceLogsPs1)());
-                yield exec_1.Exec.exec(logCmd.command, logCmd.args);
-            }));
-            yield core.group('Removing Docker context', () => __awaiter(this, void 0, void 0, function* () {
-                yield docker_1.Docker.exec(['context', 'rm', '-f', this.contextName]);
-            }));
-            yield core.group('Stopping Docker daemon service', () => __awaiter(this, void 0, void 0, function* () {
-                yield exec_1.Exec.exec('powershell', ['-Command', `Stop-Service -Name docker -Force`]);
-            }));
+    async tearDownWindows() {
+        await core.group('Docker daemon logs', async () => {
+            const logCmd = await Util.powershellCommand(dockerServiceLogsPs1());
+            await Exec.exec(logCmd.command, logCmd.args);
+        });
+        await core.group('Removing Docker context', async () => {
+            await Docker.exec(['context', 'rm', '-f', this.contextName]);
+        });
+        await core.group('Stopping Docker daemon service', async () => {
+            await Exec.exec('powershell', ['-Command', `Stop-Service -Name docker -Force`]);
         });
     }
     downloadURL(component, version, channel) {
@@ -557,7 +497,7 @@ EOF`, [], {
         return `https://download.docker.com/${platformOS}/static/${channel}/${platformArch}/${component}-${version}${ext}`;
     }
     static platformOS() {
-        switch (os_1.default.platform()) {
+        switch (os.platform()) {
             case 'darwin': {
                 return 'mac';
             }
@@ -568,12 +508,12 @@ EOF`, [], {
                 return 'win';
             }
             default: {
-                return os_1.default.platform();
+                return os.platform();
             }
         }
     }
     static platformArch() {
-        switch (os_1.default.arch()) {
+        switch (os.arch()) {
             case 'x64': {
                 return 'x86_64';
             }
@@ -599,70 +539,62 @@ EOF`, [], {
                 }
             }
             default: {
-                return os_1.default.arch();
+                return os.arch();
             }
         }
     }
-    static limaInstalled() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield io
-                .which('lima', true)
-                .then(res => {
-                core.debug(`docker.Install.limaInstalled ok: ${res}`);
-                return true;
-            })
-                .catch(error => {
-                core.debug(`docker.Install.limaInstalled error: ${error}`);
-                return false;
-            });
+    static async limaInstalled() {
+        return await io
+            .which('lima', true)
+            .then(res => {
+            core.debug(`docker.Install.limaInstalled ok: ${res}`);
+            return true;
+        })
+            .catch(error => {
+            core.debug(`docker.Install.limaInstalled error: ${error}`);
+            return false;
         });
     }
-    static qemuBin() {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (os_1.default.arch()) {
-                case 'x64': {
-                    return `qemu-system-x86_64`;
-                }
-                case 'arm64': {
-                    return `qemu-system-aarch64`;
-                }
-                default: {
-                    return `qemu-system-${os_1.default.arch()}`;
-                }
+    static async qemuBin() {
+        switch (os.arch()) {
+            case 'x64': {
+                return `qemu-system-x86_64`;
             }
-        });
+            case 'arm64': {
+                return `qemu-system-aarch64`;
+            }
+            default: {
+                return `qemu-system-${os.arch()}`;
+            }
+        }
     }
-    static qemuInstalled() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield io
-                .which(yield Install.qemuBin(), true)
-                .then(res => {
-                core.debug(`docker.Install.qemuInstalled ok: ${res}`);
-                return true;
-            })
-                .catch(error => {
-                core.debug(`docker.Install.qemuInstalled error: ${error}`);
-                return false;
-            });
+    static async qemuInstalled() {
+        return await io
+            .which(await Install.qemuBin(), true)
+            .then(res => {
+            core.debug(`docker.Install.qemuInstalled ok: ${res}`);
+            return true;
+        })
+            .catch(error => {
+            core.debug(`docker.Install.qemuInstalled error: ${error}`);
+            return false;
         });
     }
-    static getRelease(version, githubToken) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const github = new github_1.GitHub({ token: githubToken });
-            const releases = yield github.releases('Docker', {
-                owner: 'docker',
-                repo: 'actions-toolkit',
-                ref: 'main',
-                path: '.github/docker-releases.json'
-            });
-            if (!releases[version]) {
-                if (!releases['v' + version]) {
-                    throw new Error(`Cannot find Docker release ${version} in releases JSON`);
-                }
-                return releases['v' + version];
-            }
-            return releases[version];
+    static async getRelease(version, githubToken) {
+        const github = new GitHub({ token: githubToken });
+        const releases = await github.releases('Docker', {
+            owner: 'docker',
+            repo: 'actions-toolkit',
+            ref: 'main',
+            path: '.github/docker-releases.json'
         });
+        if (!releases[version]) {
+            if (!releases['v' + version]) {
+                throw new Error(`Cannot find Docker release ${version} in releases JSON`);
+            }
+            return releases['v' + version];
+        }
+        return releases[version];
     }
     static limaCustomImages() {
         const res = [];
@@ -670,7 +602,7 @@ EOF`, [], {
         if (!env) {
             return res;
         }
-        for (const input of util_1.Util.getList(env, { ignoreComma: true, comment: '#' })) {
+        for (const input of Util.getList(env, { ignoreComma: true, comment: '#' })) {
             const archIndex = input.indexOf(':');
             const arch = input.substring(0, archIndex).trim();
             const digestIndex = input.indexOf('@');
@@ -684,91 +616,85 @@ EOF`, [], {
         }
         return res;
     }
-    imageConfig(image, platform) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const manifest = yield this.regctl.manifestGet({
-                image: image,
-                platform: platform
-            });
-            const configDigest = (_a = manifest === null || manifest === void 0 ? void 0 : manifest.config) === null || _a === void 0 ? void 0 : _a.digest;
-            if (!configDigest) {
-                throw new Error(`No config digest found for image ${image}`);
-            }
-            const blob = yield this.regctl.blobGet({
-                repository: image,
-                digest: configDigest
-            });
-            return JSON.parse(blob);
+    async imageConfig(image, platform) {
+        const manifest = await this.regctl.manifestGet({
+            image: image,
+            platform: platform
         });
+        const configDigest = manifest?.config?.digest;
+        if (!configDigest) {
+            throw new Error(`No config digest found for image ${image}`);
+        }
+        const blob = await this.regctl.blobGet({
+            repository: image,
+            digest: configDigest
+        });
+        return JSON.parse(blob);
     }
-    brewInstall(packageName, revision) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // avoid brew to auto update and upgrade unrelated packages.
-            const envs = Object.assign({}, process.env, {
-                HOMEBREW_NO_AUTO_UPDATE: '1',
-                HOMEBREW_NO_INSTALL_UPGRADE: '1',
-                HOMEBREW_NO_INSTALL_CLEANUP: '1'
-            });
-            yield core.group(`Installing ${packageName}`, () => __awaiter(this, void 0, void 0, function* () {
-                if (!revision) {
-                    yield exec_1.Exec.exec('brew', ['install', packageName]);
-                }
-                else {
-                    const dockerTap = 'docker-actions-toolkit/tap';
-                    const hasDockerTap = yield exec_1.Exec.getExecOutput('brew', ['tap'], {
-                        ignoreReturnCode: true,
-                        silent: true,
-                        env: envs
-                    }).then(res => {
-                        if (res.stderr.length > 0 && res.exitCode != 0) {
-                            throw new Error(res.stderr);
-                        }
-                        for (const line of res.stdout.trim().split('\n')) {
-                            if (line.includes(dockerTap)) {
-                                return true;
-                            }
-                        }
-                        return false;
-                    });
-                    if (!hasDockerTap) {
-                        yield exec_1.Exec.exec('brew', ['tap-new', dockerTap], { env: envs });
+    async brewInstall(packageName, revision) {
+        // avoid brew to auto update and upgrade unrelated packages.
+        const envs = Object.assign({}, process.env, {
+            HOMEBREW_NO_AUTO_UPDATE: '1',
+            HOMEBREW_NO_INSTALL_UPGRADE: '1',
+            HOMEBREW_NO_INSTALL_CLEANUP: '1'
+        });
+        await core.group(`Installing ${packageName}`, async () => {
+            if (!revision) {
+                await Exec.exec('brew', ['install', packageName]);
+            }
+            else {
+                const dockerTap = 'docker-actions-toolkit/tap';
+                const hasDockerTap = await Exec.getExecOutput('brew', ['tap'], {
+                    ignoreReturnCode: true,
+                    silent: true,
+                    env: envs
+                }).then(res => {
+                    if (res.stderr.length > 0 && res.exitCode != 0) {
+                        throw new Error(res.stderr);
                     }
-                    const brewRepoTapPath = yield exec_1.Exec.getExecOutput('brew', ['--repo', dockerTap], {
-                        ignoreReturnCode: true,
-                        silent: true,
-                        env: envs
-                    }).then(res => {
-                        if (res.stderr.length > 0 && res.exitCode != 0) {
-                            throw new Error(res.stderr);
+                    for (const line of res.stdout.trim().split('\n')) {
+                        if (line.includes(dockerTap)) {
+                            return true;
                         }
-                        return res.stdout.trim();
-                    });
-                    const formulaURL = `https://raw.githubusercontent.com/Homebrew/homebrew-core/${revision}/Formula/${packageName.charAt(0)}/${packageName}.rb`;
-                    yield tc.downloadTool(formulaURL, path_1.default.join(brewRepoTapPath, 'Formula', `${packageName}.rb`));
-                    const hasFormulaInstalled = yield exec_1.Exec.getExecOutput('brew', ['ls', '-1'], {
-                        ignoreReturnCode: true,
-                        silent: true,
-                        env: envs
-                    }).then(res => {
-                        if (res.stderr.length > 0 && res.exitCode != 0) {
-                            throw new Error(res.stderr);
-                        }
-                        for (const line of res.stdout.trim().split('\n')) {
-                            if (line.trim() == packageName) {
-                                return true;
-                            }
+                    }
+                    return false;
+                });
+                if (!hasDockerTap) {
+                    await Exec.exec('brew', ['tap-new', dockerTap], { env: envs });
+                }
+                const brewRepoTapPath = await Exec.getExecOutput('brew', ['--repo', dockerTap], {
+                    ignoreReturnCode: true,
+                    silent: true,
+                    env: envs
+                }).then(res => {
+                    if (res.stderr.length > 0 && res.exitCode != 0) {
+                        throw new Error(res.stderr);
+                    }
+                    return res.stdout.trim();
+                });
+                const formulaURL = `https://raw.githubusercontent.com/Homebrew/homebrew-core/${revision}/Formula/${packageName.charAt(0)}/${packageName}.rb`;
+                await tc.downloadTool(formulaURL, path.join(brewRepoTapPath, 'Formula', `${packageName}.rb`));
+                const hasFormulaInstalled = await Exec.getExecOutput('brew', ['ls', '-1'], {
+                    ignoreReturnCode: true,
+                    silent: true,
+                    env: envs
+                }).then(res => {
+                    if (res.stderr.length > 0 && res.exitCode != 0) {
+                        throw new Error(res.stderr);
+                    }
+                    for (const line of res.stdout.trim().split('\n')) {
+                        if (line.trim() == packageName) {
+                            return true;
                         }
-                        return false;
-                    });
-                    if (hasFormulaInstalled) {
-                        yield exec_1.Exec.exec('brew', ['uninstall', packageName, '--ignore-dependencies'], { env: envs });
                     }
-                    yield exec_1.Exec.exec('brew', ['install', `${dockerTap}/${packageName}`], { env: envs });
+                    return false;
+                });
+                if (hasFormulaInstalled) {
+                    await Exec.exec('brew', ['uninstall', packageName, '--ignore-dependencies'], { env: envs });
                 }
-            }));
+                await Exec.exec('brew', ['install', `${dockerTap}/${packageName}`], { env: envs });
+            }
         });
     }
 }
-exports.Install = Install;
 //# sourceMappingURL=install.js.map