Merge pull request #18 from crazy-max/fix-publish

chore: fix publish

.eslintignore

@@ -0,0 +1,4 @@
+/.yarn/**
+/lib/**
+/coverage/**
+/node_modules/**

.eslintrc.json

@@ -2,11 +2,15 @@
   "env": {
     "node": true,
     "es2021": true,
-    "jest/globals": true
+    "mocha": true,
+    "jest": true
   },
   "extends": [
     "eslint:recommended",
     "plugin:@typescript-eslint/recommended",
+    "plugin:import/errors",
+    "plugin:import/typescript", // this is needed to allow importing typescript files from JS
+    "plugin:import/warnings",
     "plugin:jest/recommended",
     "plugin:prettier/recommended"
   ],
@@ -19,5 +23,12 @@
     "@typescript-eslint",
     "jest",
     "prettier"
-  ]
+  ],
+  "rules": {
+    "import/no-unresolved": [
+      "error", {
+        "ignore": ["csv-parse/sync"]
+      }
+    ]
+  }
 }

.prettierignore

@@ -1,6 +1,9 @@
 # Dependency directories
-node_modules/
-jspm_packages/
+/node_modules/**
+/jspm_packages/**
 
 # yarn v2
-.yarn/
+/.yarn/**
+
+# build
+/lib/**

.yarnrc.yml

@@ -1,5 +1,14 @@
 nodeLinker: node-modules
 
+npmAuthToken: "${NODE_AUTH_TOKEN:-fallback}"
+
+logFilters:
+  # https://yarnpkg.com/advanced/error-codes
+  - code: YN0013
+    level: discard
+  - code: YN0076
+    level: discard
+
 plugins:
   - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
     spec: "@yarnpkg/plugin-interactive-tools"

__tests__/buildkit/buildkit.test.ts

@@ -14,37 +14,19 @@
  * limitations under the License.
  */
 
-import {describe, expect, it, jest, test, beforeEach, afterEach} from '@jest/globals';
-import * as fs from 'fs';
-import * as path from 'path';
-import rimraf from 'rimraf';
+import {beforeEach, describe, expect, it, jest, test} from '@jest/globals';
 import * as semver from 'semver';
 
-import {BuildKit} from '../src/buildkit';
-import {Builder, BuilderInfo} from '../src/builder';
-import {Context} from '../src/context';
+import {BuildKit} from '../../src/buildkit/buildkit';
+import {Builder} from '../../src/buildx/builder';
+import {Context} from '../../src/context';
 
-const tmpDir = path.join('/tmp/.docker-actions-toolkit-jest').split(path.sep).join(path.posix.sep);
-const tmpName = path.join(tmpDir, '.tmpname-jest').split(path.sep).join(path.posix.sep);
-
-jest.spyOn(Context.prototype as any, 'tmpDir').mockImplementation((): string => {
-  if (!fs.existsSync(tmpDir)) {
-    fs.mkdirSync(tmpDir, {recursive: true});
-  }
-  return tmpDir;
-});
-jest.spyOn(Context.prototype as any, 'tmpName').mockImplementation((): string => {
-  return tmpName;
-});
+import {BuilderInfo} from '../../src/types/builder';
 
 beforeEach(() => {
   jest.clearAllMocks();
 });
 
-afterEach(() => {
-  rimraf.sync(tmpDir);
-});
-
 jest.spyOn(Builder.prototype, 'inspect').mockImplementation(async (): Promise<BuilderInfo> => {
   return {
     name: 'builder2',
@@ -85,37 +67,3 @@ describe('satisfies', () => {
     expect(await buildkit.versionSatisfies(builderName, range)).toBe(expected);
   });
 });
-
-describe('generateConfig', () => {
-  test.each([
-    ['debug = true', false, 'debug = true', null],
-    [`notfound.toml`, true, '', new Error('config file notfound.toml not found')],
-    [
-      `${path.join(__dirname, 'fixtures', 'buildkitd.toml').split(path.sep).join(path.posix.sep)}`,
-      true,
-      `debug = true
-[registry."docker.io"]
-  mirrors = ["mirror.gcr.io"]
-`,
-      null
-    ]
-  ])('given %p config', async (val, file, exValue, error: Error) => {
-    try {
-      const buildkit = new BuildKit({
-        context: new Context()
-      });
-      let config: string;
-      if (file) {
-        config = buildkit.generateConfigFile(val);
-      } else {
-        config = buildkit.generateConfigInline(val);
-      }
-      expect(config).toEqual(tmpName);
-      const configValue = fs.readFileSync(tmpName, 'utf-8');
-      expect(configValue).toEqual(exValue);
-    } catch (e) {
-      // eslint-disable-next-line jest/no-conditional-expect
-      expect(e.message).toEqual(error?.message);
-    }
-  });
-});

__tests__/buildkit/config.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Copyright 2023 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {describe, expect, jest, test, beforeEach, afterEach} from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as rimraf from 'rimraf';
+
+import {BuildKit} from '../../src/buildkit/buildkit';
+import {Context} from '../../src/context';
+
+const fixturesDir = path.join(__dirname, '..', 'fixtures');
+// prettier-ignore
+const tmpDir = path.join(process.env.TEMP || '/tmp', 'buildkit-config-jest').split(path.sep).join(path.posix.sep);
+const tmpName = path.join(tmpDir, '.tmpname-jest').split(path.sep).join(path.posix.sep);
+
+jest.spyOn(Context.prototype, 'tmpDir').mockImplementation((): string => {
+  if (!fs.existsSync(tmpDir)) {
+    fs.mkdirSync(tmpDir, {recursive: true});
+  }
+  return tmpDir;
+});
+jest.spyOn(Context.prototype, 'tmpName').mockImplementation((): string => {
+  return tmpName;
+});
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+afterEach(() => {
+  rimraf.sync(tmpDir);
+});
+
+describe('generate', () => {
+  test.each([
+    ['debug = true', false, 'debug = true', null],
+    [`notfound.toml`, true, '', new Error('config file notfound.toml not found')],
+    [
+      `${path.join(fixturesDir, 'buildkitd.toml').split(path.sep).join(path.posix.sep)}`,
+      true,
+      `debug = true
+[registry."docker.io"]
+  mirrors = ["mirror.gcr.io"]
+`,
+      null
+    ]
+  ])('given %p config', async (val, file, exValue, error: Error) => {
+    try {
+      const buildkit = new BuildKit({
+        context: new Context()
+      });
+      let config: string;
+      if (file) {
+        config = buildkit.config.generateFromFile(val);
+      } else {
+        config = buildkit.config.generateFromString(val);
+      }
+      expect(config).toEqual(tmpName);
+      const configValue = fs.readFileSync(tmpName, 'utf-8');
+      expect(configValue).toEqual(exValue);
+    } catch (e) {
+      // eslint-disable-next-line jest/no-conditional-expect
+      expect(e.message).toEqual(error?.message);
+    }
+  });
+});

__tests__/buildx/builder.test.ts

@@ -18,8 +18,12 @@ import {beforeEach, describe, expect, it, jest, test} from '@jest/globals';
 import * as fs from 'fs';
 import * as path from 'path';
 
-import {Builder, BuilderInfo} from '../src/builder';
-import {Context} from '../src/context';
+import {Builder} from '../../src/buildx/builder';
+import {Context} from '../../src/context';
+
+import {BuilderInfo} from '../../src/types/builder';
+
+const fixturesDir = path.join(__dirname, '..', 'fixtures');
 
 beforeEach(() => {
   jest.clearAllMocks();
@@ -196,6 +200,6 @@ describe('parseInspect', () => {
      }
     ]
   ])('given %p', async (inspectFile, expected) => {
-    expect(await Builder.parseInspect(fs.readFileSync(path.join(__dirname, 'fixtures', inspectFile)).toString())).toEqual(expected);
+    expect(await Builder.parseInspect(fs.readFileSync(path.join(fixturesDir, inspectFile)).toString())).toEqual(expected);
   });
 });

__tests__/buildx/buildx.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Copyright 2023 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {describe, expect, it, jest, test, beforeEach, afterEach} from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as rimraf from 'rimraf';
+import * as semver from 'semver';
+import * as exec from '@actions/exec';
+
+import {Buildx} from '../../src/buildx/buildx';
+import {Context} from '../../src/context';
+
+// prettier-ignore
+const tmpDir = path.join(process.env.TEMP || '/tmp', 'buildx-jest').split(path.sep).join(path.posix.sep);
+const tmpName = path.join(tmpDir, '.tmpname-jest').split(path.sep).join(path.posix.sep);
+
+jest.spyOn(Context.prototype, 'tmpDir').mockImplementation((): string => {
+  if (!fs.existsSync(tmpDir)) {
+    fs.mkdirSync(tmpDir, {recursive: true});
+  }
+  return tmpDir;
+});
+jest.spyOn(Context.prototype, 'tmpName').mockImplementation((): string => {
+  return tmpName;
+});
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+afterEach(() => {
+  rimraf.sync(tmpDir);
+});
+
+describe('isAvailable', () => {
+  it('docker cli', async () => {
+    const execSpy = jest.spyOn(exec, 'getExecOutput');
+    const buildx = new Buildx({
+      context: new Context(),
+      standalone: false
+    });
+    buildx.isAvailable().catch(() => {
+      // noop
+    });
+    // eslint-disable-next-line jest/no-standalone-expect
+    expect(execSpy).toHaveBeenCalledWith(`docker`, ['buildx'], {
+      silent: true,
+      ignoreReturnCode: true
+    });
+  });
+  it('standalone', async () => {
+    const execSpy = jest.spyOn(exec, 'getExecOutput');
+    const buildx = new Buildx({
+      context: new Context(),
+      standalone: true
+    });
+    buildx.isAvailable().catch(() => {
+      // noop
+    });
+    // eslint-disable-next-line jest/no-standalone-expect
+    expect(execSpy).toHaveBeenCalledWith(`buildx`, [], {
+      silent: true,
+      ignoreReturnCode: true
+    });
+  });
+});
+
+describe('printInspect', () => {
+  it('prints builder2 instance', () => {
+    const execSpy = jest.spyOn(exec, 'exec');
+    const buildx = new Buildx({
+      context: new Context(),
+      standalone: true
+    });
+    buildx.printInspect('builder2').catch(() => {
+      // noop
+    });
+    expect(execSpy).toHaveBeenCalledWith(`buildx`, ['inspect', 'builder2'], {
+      failOnStdErr: false
+    });
+  });
+});
+
+describe('printVersion', () => {
+  it('docker cli', () => {
+    const execSpy = jest.spyOn(exec, 'exec');
+    const buildx = new Buildx({
+      context: new Context(),
+      standalone: false
+    });
+    buildx.printVersion();
+    expect(execSpy).toHaveBeenCalledWith(`docker`, ['buildx', 'version'], {
+      failOnStdErr: false
+    });
+  });
+  it('standalone', () => {
+    const execSpy = jest.spyOn(exec, 'exec');
+    const buildx = new Buildx({
+      context: new Context(),
+      standalone: true
+    });
+    buildx.printVersion();
+    expect(execSpy).toHaveBeenCalledWith(`buildx`, ['version'], {
+      failOnStdErr: false
+    });
+  });
+});
+
+describe('version', () => {
+  it('valid', async () => {
+    const buildx = new Buildx({
+      context: new Context()
+    });
+    expect(semver.valid(await buildx.version)).not.toBeUndefined();
+  });
+});
+
+describe('parseVersion', () => {
+  test.each([
+    ['github.com/docker/buildx 0.4.1+azure bda4882a65349ca359216b135896bddc1d92461c', '0.4.1'],
+    ['github.com/docker/buildx v0.4.1 bda4882a65349ca359216b135896bddc1d92461c', '0.4.1'],
+    ['github.com/docker/buildx v0.4.2 fb7b670b764764dc4716df3eba07ffdae4cc47b2', '0.4.2'],
+    ['github.com/docker/buildx f117971 f11797113e5a9b86bd976329c5dbb8a8bfdfadfa', 'f117971']
+  ])('given %p', async (stdout, expected) => {
+    expect(Buildx.parseVersion(stdout)).toEqual(expected);
+  });
+});
+
+describe('versionSatisfies', () => {
+  test.each([
+    ['0.4.1', '>=0.3.2', true],
+    ['bda4882a65349ca359216b135896bddc1d92461c', '>0.1.0', false],
+    ['f117971', '>0.6.0', true]
+  ])('given %p', async (version, range, expected) => {
+    const buildx = new Buildx({
+      context: new Context()
+    });
+    expect(await buildx.versionSatisfies(range, version)).toBe(expected);
+  });
+});

__tests__/buildx/inputs.test.ts

@@ -14,30 +14,31 @@
  * limitations under the License.
  */
 
-import {describe, expect, it, jest, test, beforeEach, afterEach} from '@jest/globals';
+import {afterEach, beforeEach, describe, expect, it, jest, test} from '@jest/globals';
 import * as fs from 'fs';
 import * as path from 'path';
-import rimraf from 'rimraf';
-import * as semver from 'semver';
-import * as exec from '@actions/exec';
+import * as rimraf from 'rimraf';
 
-import {Buildx} from '../src/buildx';
-import {Context} from '../src/context';
+import {Context} from '../../src/context';
+import {Buildx} from '../../src/buildx/buildx';
+import {Inputs} from '../../src/buildx/inputs';
 
-const tmpDir = path.join('/tmp/.docker-actions-toolkit-jest').split(path.sep).join(path.posix.sep);
+const fixturesDir = path.join(__dirname, '..', 'fixtures');
+// prettier-ignore
+const tmpDir = path.join(process.env.TEMP || '/tmp', 'buildx-inputs-jest').split(path.sep).join(path.posix.sep);
 const tmpName = path.join(tmpDir, '.tmpname-jest').split(path.sep).join(path.posix.sep);
 const metadata = `{
   "containerimage.config.digest": "sha256:059b68a595b22564a1cbc167af369349fdc2ecc1f7bc092c2235cbf601a795fd",
   "containerimage.digest": "sha256:b09b9482c72371486bb2c1d2c2a2633ed1d0b8389e12c8d52b9e052725c0c83c"
 }`;
 
-jest.spyOn(Context.prototype as any, 'tmpDir').mockImplementation((): string => {
+jest.spyOn(Context.prototype, 'tmpDir').mockImplementation((): string => {
   if (!fs.existsSync(tmpDir)) {
     fs.mkdirSync(tmpDir, {recursive: true});
   }
   return tmpDir;
 });
-jest.spyOn(Context.prototype as any, 'tmpName').mockImplementation((): string => {
+jest.spyOn(Context.prototype, 'tmpName').mockImplementation((): string => {
   return tmpName;
 });
 
@@ -49,122 +50,15 @@ afterEach(() => {
   rimraf.sync(tmpDir);
 });
 
-describe('isAvailable', () => {
-  it('docker cli', async () => {
-    const execSpy = jest.spyOn(exec, 'getExecOutput');
-    const buildx = new Buildx({
-      context: new Context(),
-      standalone: false
-    });
-    buildx.isAvailable().catch(() => {
-      // noop
-    });
-    // eslint-disable-next-line jest/no-standalone-expect
-    expect(execSpy).toHaveBeenCalledWith(`docker`, ['buildx'], {
-      silent: true,
-      ignoreReturnCode: true
-    });
-  });
-  it('standalone', async () => {
-    const execSpy = jest.spyOn(exec, 'getExecOutput');
-    const buildx = new Buildx({
-      context: new Context(),
-      standalone: true
-    });
-    buildx.isAvailable().catch(() => {
-      // noop
-    });
-    // eslint-disable-next-line jest/no-standalone-expect
-    expect(execSpy).toHaveBeenCalledWith(`buildx`, [], {
-      silent: true,
-      ignoreReturnCode: true
-    });
-  });
-});
-
-describe('printInspect', () => {
-  it('prints builder2 instance', () => {
-    const execSpy = jest.spyOn(exec, 'exec');
-    const buildx = new Buildx({
-      context: new Context(),
-      standalone: true
-    });
-    buildx.printInspect('builder2').catch(() => {
-      // noop
-    });
-    expect(execSpy).toHaveBeenCalledWith(`buildx`, ['inspect', 'builder2'], {
-      failOnStdErr: false
-    });
-  });
-});
-
-describe('printVersion', () => {
-  it('docker cli', () => {
-    const execSpy = jest.spyOn(exec, 'exec');
-    const buildx = new Buildx({
-      context: new Context(),
-      standalone: false
-    });
-    buildx.printVersion();
-    expect(execSpy).toHaveBeenCalledWith(`docker`, ['buildx', 'version'], {
-      failOnStdErr: false
-    });
-  });
-  it('standalone', () => {
-    const execSpy = jest.spyOn(exec, 'exec');
-    const buildx = new Buildx({
-      context: new Context(),
-      standalone: true
-    });
-    buildx.printVersion();
-    expect(execSpy).toHaveBeenCalledWith(`buildx`, ['version'], {
-      failOnStdErr: false
-    });
-  });
-});
-
-describe('version', () => {
-  it('valid', async () => {
-    const buildx = new Buildx({
-      context: new Context()
-    });
-    expect(semver.valid(await buildx.version)).not.toBeUndefined();
-  });
-});
-
-describe('parseVersion', () => {
-  test.each([
-    ['github.com/docker/buildx 0.4.1+azure bda4882a65349ca359216b135896bddc1d92461c', '0.4.1'],
-    ['github.com/docker/buildx v0.4.1 bda4882a65349ca359216b135896bddc1d92461c', '0.4.1'],
-    ['github.com/docker/buildx v0.4.2 fb7b670b764764dc4716df3eba07ffdae4cc47b2', '0.4.2'],
-    ['github.com/docker/buildx f117971 f11797113e5a9b86bd976329c5dbb8a8bfdfadfa', 'f117971']
-  ])('given %p', async (stdout, expected) => {
-    expect(Buildx.parseVersion(stdout)).toEqual(expected);
-  });
-});
-
-describe('versionSatisfies', () => {
-  test.each([
-    ['0.4.1', '>=0.3.2', true],
-    ['bda4882a65349ca359216b135896bddc1d92461c', '>0.1.0', false],
-    ['f117971', '>0.6.0', true]
-  ])('given %p', async (version, range, expected) => {
-    const buildx = new Buildx({
-      context: new Context()
-    });
-    expect(await buildx.versionSatisfies(range, version)).toBe(expected);
-  });
-});
-
 describe('getBuildImageID', () => {
   it('matches', async () => {
     const buildx = new Buildx({
       context: new Context()
     });
     const imageID = 'sha256:bfb45ab72e46908183546477a08f8867fc40cebadd00af54b071b097aed127a9';
-    const imageIDFile = buildx.getBuildImageIDFilePath();
+    const imageIDFile = buildx.inputs.getBuildImageIDFilePath();
     await fs.writeFileSync(imageIDFile, imageID);
-    const expected = buildx.getBuildImageID();
+    const expected = buildx.inputs.getBuildImageID();
     expect(expected).toEqual(imageID);
   });
 });
@@ -174,9 +68,9 @@ describe('getBuildMetadata', () => {
     const buildx = new Buildx({
       context: new Context()
     });
-    const metadataFile = buildx.getBuildMetadataFilePath();
+    const metadataFile = buildx.inputs.getBuildMetadataFilePath();
     await fs.writeFileSync(metadataFile, metadata);
-    const expected = buildx.getBuildMetadata();
+    const expected = buildx.inputs.getBuildMetadata();
     expect(expected).toEqual(metadata);
   });
 });
@@ -186,9 +80,9 @@ describe('getDigest', () => {
     const buildx = new Buildx({
       context: new Context()
     });
-    const metadataFile = buildx.getBuildMetadataFilePath();
+    const metadataFile = buildx.inputs.getBuildMetadataFilePath();
     await fs.writeFileSync(metadataFile, metadata);
-    const expected = buildx.getDigest();
+    const expected = buildx.inputs.getDigest();
     expect(expected).toEqual('sha256:b09b9482c72371486bb2c1d2c2a2633ed1d0b8389e12c8d52b9e052725c0c83c');
   });
 });
@@ -238,7 +132,7 @@ describe('getProvenanceInput', () => {
     const buildx = new Buildx({
       context: new Context()
     });
-    expect(buildx.getProvenanceInput('provenance')).toEqual(expected);
+    expect(buildx.inputs.getProvenanceInput('provenance')).toEqual(expected);
   });
 });
 
@@ -269,35 +163,7 @@ describe('getProvenanceAttrs', () => {
     const buildx = new Buildx({
       context: new Context()
     });
-    expect(buildx.getProvenanceAttrs(input)).toEqual(expected);
-  });
-});
-
-describe('getRelease', () => {
-  it('returns latest buildx GitHub release', async () => {
-    const release = await Buildx.getRelease('latest');
-    expect(release).not.toBeNull();
-    expect(release?.tag_name).not.toEqual('');
-  });
-
-  it('returns v0.10.1 buildx GitHub release', async () => {
-    const release = await Buildx.getRelease('v0.10.1');
-    expect(release).not.toBeNull();
-    expect(release?.id).toEqual(90346950);
-    expect(release?.tag_name).toEqual('v0.10.1');
-    expect(release?.html_url).toEqual('https://github.com/docker/buildx/releases/tag/v0.10.1');
-  });
-
-  it('returns v0.2.2 buildx GitHub release', async () => {
-    const release = await Buildx.getRelease('v0.2.2');
-    expect(release).not.toBeNull();
-    expect(release?.id).toEqual(17671545);
-    expect(release?.tag_name).toEqual('v0.2.2');
-    expect(release?.html_url).toEqual('https://github.com/docker/buildx/releases/tag/v0.2.2');
-  });
-
-  it('unknown release', async () => {
-    await expect(Buildx.getRelease('foo')).rejects.toThrowError(new Error('Cannot find Buildx release foo in https://raw.githubusercontent.com/docker/buildx/master/.github/releases.json'));
+    expect(buildx.inputs.getProvenanceAttrs(input)).toEqual(expected);
   });
 });
 
@@ -309,7 +175,7 @@ describe('generateBuildSecret', () => {
     ['aaaaaaaa', false, '', '', new Error('aaaaaaaa is not a valid secret')],
     ['aaaaaaaa=', false, '', '', new Error('aaaaaaaa= is not a valid secret')],
     ['=bbbbbbb', false, '', '', new Error('=bbbbbbb is not a valid secret')],
-    [`foo=${path.join(__dirname, 'fixtures', 'secret.txt').split(path.sep).join(path.posix.sep)}`, true, 'foo', 'bar', null],
+    [`foo=${path.join(fixturesDir, 'secret.txt').split(path.sep).join(path.posix.sep)}`, true, 'foo', 'bar', null],
     [`notfound=secret`, true, '', '', new Error('secret file secret not found')]
   ])('given %p key and %p secret', async (kvp: string, file: boolean, exKey: string, exValue: string, error: Error) => {
     try {
@@ -318,9 +184,9 @@ describe('generateBuildSecret', () => {
       });
       let secret: string;
       if (file) {
-        secret = buildx.generateBuildSecretFile(kvp);
+        secret = buildx.inputs.generateBuildSecretFile(kvp);
       } else {
-        secret = buildx.generateBuildSecretString(kvp);
+        secret = buildx.inputs.generateBuildSecretString(kvp);
       }
       expect(secret).toEqual(`id=${exKey},src=${tmpName}`);
       expect(fs.readFileSync(tmpName, 'utf-8')).toEqual(exValue);
@@ -343,7 +209,7 @@ describe('hasLocalExporter', () => {
     [['" type= local" , dest=./release-out'], true],
     [['.'], true]
   ])('given %p returns %p', async (exporters: Array<string>, expected: boolean) => {
-    expect(Buildx.hasLocalExporter(exporters)).toEqual(expected);
+    expect(Inputs.hasLocalExporter(exporters)).toEqual(expected);
   });
 });
 
@@ -359,7 +225,7 @@ describe('hasTarExporter', () => {
     [['" type= local" , dest=./release-out'], false],
     [['.'], false]
   ])('given %p returns %p', async (exporters: Array<string>, expected: boolean) => {
-    expect(Buildx.hasTarExporter(exporters)).toEqual(expected);
+    expect(Inputs.hasTarExporter(exporters)).toEqual(expected);
   });
 });
 
@@ -375,7 +241,7 @@ describe('hasDockerExporter', () => {
     [['" type= local" , dest=./release-out'], false, undefined],
     [['.'], true, true],
   ])('given %p returns %p', async (exporters: Array<string>, expected: boolean, load: boolean | undefined) => {
-    expect(Buildx.hasDockerExporter(exporters, load)).toEqual(expected);
+    expect(Inputs.hasDockerExporter(exporters, load)).toEqual(expected);
   });
 });
 
@@ -385,7 +251,7 @@ describe('hasGitAuthTokenSecret', () => {
     [['A_SECRET=abcdef0123456789'], false],
     [['GIT_AUTH_TOKEN=abcdefghijklmno=0123456789'], true],
   ])('given %p secret', async (kvp: Array<string>, expected: boolean) => {
-    expect(Buildx.hasGitAuthTokenSecret(kvp)).toBe(expected);
+    expect(Inputs.hasGitAuthTokenSecret(kvp)).toBe(expected);
   });
 });
 

__tests__/buildx/install.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Copyright 2023 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {describe, expect, it, jest, test, beforeEach} from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import osm = require('os');
+
+import {Install} from '../../src/buildx/install';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('install', () => {
+  // prettier-ignore
+  const tmpDir = path.join(process.env.TEMP || '/tmp', 'buildx-install-jest').split(path.sep).join(path.posix.sep);
+
+  // prettier-ignore
+  test.each([
+    ['v0.4.1', false],
+    ['latest', false],
+    ['v0.4.1', true],
+    ['latest', true]
+  ])(
+  'acquires %p of buildx (standalone: %p)', async (version, standalone) => {
+      const install = new Install({standalone: standalone});
+      const buildxBin = await install.install(version, tmpDir);
+      expect(fs.existsSync(buildxBin)).toBe(true);
+    },
+    100000
+  );
+
+  // TODO: add tests for arm
+  // prettier-ignore
+  test.each([
+    ['win32', 'x64'],
+    ['win32', 'arm64'],
+    ['darwin', 'x64'],
+    ['darwin', 'arm64'],
+    ['linux', 'x64'],
+    ['linux', 'arm64'],
+    ['linux', 'ppc64'],
+    ['linux', 's390x'],
+  ])(
+  'acquires buildx for %s/%s', async (os, arch) => {
+      jest.spyOn(osm, 'platform').mockImplementation(() => os);
+      jest.spyOn(osm, 'arch').mockImplementation(() => arch);
+      const install = new Install();
+      const buildxBin = await install.install('latest', tmpDir);
+      expect(fs.existsSync(buildxBin)).toBe(true);
+    },
+    100000
+  );
+
+  it('returns latest buildx GitHub release', async () => {
+    const release = await Install.getRelease('latest');
+    expect(release).not.toBeNull();
+    expect(release?.tag_name).not.toEqual('');
+  });
+});
+
+describe('getRelease', () => {
+  it('returns latest buildx GitHub release', async () => {
+    const release = await Install.getRelease('latest');
+    expect(release).not.toBeNull();
+    expect(release?.tag_name).not.toEqual('');
+  });
+
+  it('returns v0.10.1 buildx GitHub release', async () => {
+    const release = await Install.getRelease('v0.10.1');
+    expect(release).not.toBeNull();
+    expect(release?.id).toEqual(90346950);
+    expect(release?.tag_name).toEqual('v0.10.1');
+    expect(release?.html_url).toEqual('https://github.com/docker/buildx/releases/tag/v0.10.1');
+  });
+
+  it('returns v0.2.2 buildx GitHub release', async () => {
+    const release = await Install.getRelease('v0.2.2');
+    expect(release).not.toBeNull();
+    expect(release?.id).toEqual(17671545);
+    expect(release?.tag_name).toEqual('v0.2.2');
+    expect(release?.html_url).toEqual('https://github.com/docker/buildx/releases/tag/v0.2.2');
+  });
+
+  it('unknown release', async () => {
+    await expect(Install.getRelease('foo')).rejects.toThrowError(new Error('Cannot find Buildx release foo in https://raw.githubusercontent.com/docker/buildx/master/.github/releases.json'));
+  });
+});

__tests__/context.test.ts

@@ -14,14 +14,15 @@
  * limitations under the License.
  */
 
-import fs from 'fs';
-import path from 'path';
-import rimraf from 'rimraf';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as rimraf from 'rimraf';
 import {describe, expect, jest, it, beforeEach, afterEach} from '@jest/globals';
 
 import {Context} from '../src/context';
 
-const tmpDir = path.join('/tmp/.docker-actions-toolkit-jest').split(path.sep).join(path.posix.sep);
+// prettier-ignore
+const tmpDir = path.join(process.env.TEMP || '/tmp', 'context-jest').split(path.sep).join(path.posix.sep);
 const tmpName = path.join(tmpDir, '.tmpname-jest').split(path.sep).join(path.posix.sep);
 
 jest.spyOn(Context.prototype, 'tmpDir').mockImplementation((): string => {

__tests__/docker.test.ts

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 
-import {beforeEach, describe, expect, it, jest} from '@jest/globals';
+import {afterEach, beforeEach, describe, expect, it, jest} from '@jest/globals';
 import * as exec from '@actions/exec';
+import path from 'path';
+import osm = require('os');
 
 import {Docker} from '../src/docker';
 
@@ -23,10 +25,32 @@ beforeEach(() => {
   jest.clearAllMocks();
 });
 
+describe('configDir', () => {
+  const originalEnv = process.env;
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = {
+      ...originalEnv,
+      DOCKER_CONFIG: '/var/docker/config'
+    };
+  });
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+  it('returns default', async () => {
+    process.env.DOCKER_CONFIG = '';
+    jest.spyOn(osm, 'homedir').mockImplementation(() => path.join('/tmp', 'home'));
+    expect(Docker.configDir).toEqual(path.join('/tmp', 'home', '.docker'));
+  });
+  it('returns from env', async () => {
+    expect(Docker.configDir).toEqual('/var/docker/config');
+  });
+});
+
 describe('isAvailable', () => {
   it('cli', () => {
     const execSpy = jest.spyOn(exec, 'getExecOutput');
-    Docker.isAvailable();
+    Docker.isAvailable;
     // eslint-disable-next-line jest/no-standalone-expect
     expect(execSpy).toHaveBeenCalledWith(`docker`, undefined, {
       silent: true,

__tests__/github.test.ts

@@ -18,25 +18,31 @@ import {describe, expect, jest, it, beforeEach, afterEach} from '@jest/globals';
 import * as fs from 'fs';
 import * as path from 'path';
 
-import {GitHub, GitHubRepo} from '../src/github';
+import {GitHub} from '../src/github';
+import {GitHubRepo} from '../src/types/github';
 
 beforeEach(() => {
   jest.clearAllMocks();
 });
 
-import * as repoFixture from './fixtures/repo.json';
+import repoFixture from './fixtures/repo.json';
 jest.spyOn(GitHub.prototype, 'repoData').mockImplementation((): Promise<GitHubRepo> => {
   return <Promise<GitHubRepo>>(repoFixture as unknown);
 });
 
+describe('repoData', () => {
+  it('returns GitHub repository', async () => {
+    const github = new GitHub();
+    expect((await github.repoData()).name).toEqual('Hello-World');
+  });
+});
+
 describe('context', () => {
   it('returns repository name from payload', async () => {
-    const github = new GitHub();
-    expect(github.context.payload.repository?.name).toEqual('test-docker-action');
+    expect(GitHub.context.payload.repository?.name).toEqual('test-docker-action');
   });
   it('is repository private', async () => {
-    const github = new GitHub();
-    expect(github.context.payload.repository?.private).toEqual(true);
+    expect(GitHub.context.payload.repository?.private).toEqual(true);
   });
 });
 
@@ -54,12 +60,31 @@ describe('serverURL', () => {
   });
   it('returns default', async () => {
     process.env.GITHUB_SERVER_URL = '';
-    const github = new GitHub();
-    expect(github.serverURL).toEqual('https://github.com');
+    expect(GitHub.serverURL).toEqual('https://github.com');
   });
   it('returns from env', async () => {
-    const github = new GitHub();
-    expect(github.serverURL).toEqual('https://foo.github.com');
+    expect(GitHub.serverURL).toEqual('https://foo.github.com');
+  });
+});
+
+describe('apiURL', () => {
+  const originalEnv = process.env;
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = {
+      ...originalEnv,
+      GITHUB_API_URL: 'https://bar.github.com'
+    };
+  });
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+  it('returns default', async () => {
+    process.env.GITHUB_API_URL = '';
+    expect(GitHub.apiURL).toEqual('https://api.github.com');
+  });
+  it('returns from env', async () => {
+    expect(GitHub.apiURL).toEqual('https://bar.github.com');
   });
 });
 
@@ -76,21 +101,12 @@ describe('actionsRuntimeToken', () => {
   });
   it('empty', async () => {
     process.env.ACTIONS_RUNTIME_TOKEN = '';
-    const github = new GitHub();
-    expect(github.actionsRuntimeToken).toEqual({});
+    expect(GitHub.actionsRuntimeToken).toEqual({});
   });
   it('fixture', async () => {
     process.env.ACTIONS_RUNTIME_TOKEN = fs.readFileSync(path.join(__dirname, 'fixtures', 'runtimeToken.txt')).toString().trim();
-    const github = new GitHub();
-    const runtimeToken = github.actionsRuntimeToken;
+    const runtimeToken = GitHub.actionsRuntimeToken;
     expect(runtimeToken.ac).toEqual('[{"Scope":"refs/heads/master","Permission":3}]');
     expect(runtimeToken.iss).toEqual('vstoken.actions.githubusercontent.com');
   });
 });
-
-describe('repoData', () => {
-  it('returns GitHub repository', async () => {
-    const github = new GitHub();
-    expect((await github.repoData()).name).toEqual('Hello-World');
-  });
-});

jest.config.ts

@@ -14,10 +14,17 @@
  * limitations under the License.
  */
 
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'docker-actions-toolkit-')).split(path.sep).join(path.posix.sep);
+
 process.env = Object.assign({}, process.env, {
+  TEMP: tmpDir,
   GITHUB_REPOSITORY: 'docker/actions-toolkit',
-  RUNNER_TEMP: '/tmp/github_runner',
-  RUNNER_TOOL_CACHE: '/tmp/github_tool_cache'
+  RUNNER_TEMP: path.join(tmpDir, 'runner-temp').split(path.sep).join(path.posix.sep),
+  RUNNER_TOOL_CACHE: path.join(tmpDir, 'runner-tool-cache').split(path.sep).join(path.posix.sep)
 }) as {
   [key: string]: string;
 };

package.json

@@ -3,8 +3,12 @@
   "description": "Toolkit for Docker (GitHub) Actions",
   "scripts": {
     "build": "tsc",
-    "lint": "eslint src/**/*.ts __tests__/**/*.ts",
-    "format": "eslint --fix src/**/*.ts __tests__/**/*.ts",
+    "lint": "yarn run prettier && yarn run eslint",
+    "format": "yarn run prettier:fix && yarn run eslint:fix",
+    "eslint": "eslint --max-warnings=0 .",
+    "eslint:fix": "eslint --fix .",
+    "prettier": "prettier --check \"./**/*.ts\"",
+    "prettier:fix": "prettier --write \"./**/*.ts\"",
     "test": "jest",
     "test-coverage": "jest --coverage"
   },
@@ -41,7 +45,8 @@
     "@actions/exec": "^1.1.1",
     "@actions/github": "^5.1.1",
     "@actions/http-client": "^2.0.1",
-    "csv-parse": "^5.3.3",
+    "@actions/tool-cache": "^2.0.1",
+    "csv-parse": "^5.3.4",
     "jwt-decode": "^3.1.2",
     "semver": "^7.3.8",
     "tmp": "^0.2.1"
@@ -57,6 +62,7 @@
     "dotenv": "^16.0.3",
     "eslint": "^8.33.0",
     "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-jest": "^26.9.0",
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^27.5.1",

src/buildkit/buildkit.ts

@@ -14,14 +14,16 @@
  * limitations under the License.
  */
 
-import fs from 'fs';
 import * as core from '@actions/core';
 import * as exec from '@actions/exec';
 import * as semver from 'semver';
 
-import {Context} from './context';
-import {Buildx} from './buildx';
-import {Builder, BuilderInfo} from './builder';
+import {Context} from '../context';
+import {Buildx} from '../buildx/buildx';
+import {Builder} from '../buildx/builder';
+import {Config} from './config';
+
+import {BuilderInfo} from '../types/builder';
 
 export interface BuildKitOpts {
   context: Context;
@@ -33,8 +35,11 @@ export class BuildKit {
   private readonly buildx: Buildx;
   private containerNamePrefix = 'buildx_buildkit_';
 
+  public readonly config: Config;
+
   constructor(opts: BuildKitOpts) {
     this.context = opts.context;
+    this.config = new Config(this.context);
     this.buildx =
       opts?.buildx ||
       new Buildx({
@@ -42,14 +47,6 @@ export class BuildKit {
       });
   }
 
-  private async getBuilderInfo(name: string): Promise<BuilderInfo> {
-    const builder = new Builder({
-      context: this.context,
-      buildx: this.buildx
-    });
-    return builder.inspect(name);
-  }
-
   public async getVersion(builderName: string): Promise<string | undefined> {
     const builderInfo = await this.getBuilderInfo(builderName);
     if (builderInfo.nodes.length == 0) {
@@ -118,23 +115,11 @@ export class BuildKit {
     return true;
   }
 
-  public generateConfigInline(s: string): string {
-    return this.generateConfig(s, false);
-  }
-
-  public generateConfigFile(s: string): string {
-    return this.generateConfig(s, true);
-  }
-
-  private generateConfig(s: string, file: boolean): string {
-    if (file) {
-      if (!fs.existsSync(s)) {
-        throw new Error(`config file ${s} not found`);
-      }
-      s = fs.readFileSync(s, {encoding: 'utf-8'});
-    }
-    const configFile = this.context.tmpName({tmpdir: this.context.tmpDir()});
-    fs.writeFileSync(configFile, s);
-    return configFile;
+  private async getBuilderInfo(name: string): Promise<BuilderInfo> {
+    const builder = new Builder({
+      context: this.context,
+      buildx: this.buildx
+    });
+    return builder.inspect(name);
   }
 }

src/buildkit/config.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright 2023 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import fs from 'fs';
+
+import {Context} from '../context';
+
+export class Config {
+  private readonly context: Context;
+
+  constructor(context: Context) {
+    this.context = context;
+  }
+
+  public generateFromString(s: string): string {
+    return this.generate(s, false);
+  }
+
+  public generateFromFile(s: string): string {
+    return this.generate(s, true);
+  }
+
+  private generate(s: string, file: boolean): string {
+    if (file) {
+      if (!fs.existsSync(s)) {
+        throw new Error(`config file ${s} not found`);
+      }
+      s = fs.readFileSync(s, {encoding: 'utf-8'});
+    }
+    const configFile = this.context.tmpName({tmpdir: this.context.tmpDir()});
+    fs.writeFileSync(configFile, s);
+    return configFile;
+  }
+}

src/buildx/builder.ts

@@ -17,24 +17,9 @@
 import * as exec from '@actions/exec';
 
 import {Buildx} from './buildx';
-import {Context} from './context';
+import {Context} from '../context';
 
-export interface BuilderInfo {
-  name?: string;
-  driver?: string;
-  lastActivity?: Date;
-  nodes: NodeInfo[];
-}
-
-export interface NodeInfo {
-  name?: string;
-  endpoint?: string;
-  driverOpts?: Array<string>;
-  status?: string;
-  buildkitdFlags?: string;
-  buildkitVersion?: string;
-  platforms?: string;
-}
+import {BuilderInfo, NodeInfo} from '../types/builder';
 
 export interface BuilderOpts {
   context: Context;

src/buildx/buildx.ts

@@ -0,0 +1,120 @@
+/**
+ * Copyright 2023 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as exec from '@actions/exec';
+import * as semver from 'semver';
+
+import {Docker} from '../docker';
+import {Context} from '../context';
+import {Inputs} from './inputs';
+import {Install} from './install';
+
+export interface BuildxOpts {
+  context: Context;
+  standalone?: boolean;
+}
+
+export class Buildx {
+  private readonly context: Context;
+  private _version: string | undefined;
+
+  public readonly inputs: Inputs;
+  public readonly install: Install;
+  public readonly standalone: boolean;
+
+  constructor(opts: BuildxOpts) {
+    this.context = opts.context;
+    this.inputs = new Inputs(this.context);
+    this.install = new Install({standalone: opts.standalone});
+    this.standalone = opts?.standalone ?? !Docker.isAvailable;
+  }
+
+  public getCommand(args: Array<string>) {
+    return {
+      command: this.standalone ? 'buildx' : 'docker',
+      args: this.standalone ? args : ['buildx', ...args]
+    };
+  }
+
+  public async isAvailable(): Promise<boolean> {
+    const cmd = this.getCommand([]);
+    return await exec
+      .getExecOutput(cmd.command, cmd.args, {
+        ignoreReturnCode: true,
+        silent: true
+      })
+      .then(res => {
+        if (res.stderr.length > 0 && res.exitCode != 0) {
+          return false;
+        }
+        return res.exitCode == 0;
+      })
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      .catch(error => {
+        return false;
+      });
+  }
+
+  public async printInspect(name: string): Promise<void> {
+    const cmd = this.getCommand(['inspect', name]);
+    await exec.exec(cmd.command, cmd.args, {
+      failOnStdErr: false
+    });
+  }
+
+  get version() {
+    return (async () => {
+      if (!this._version) {
+        const cmd = this.getCommand(['version']);
+        this._version = await exec
+          .getExecOutput(cmd.command, cmd.args, {
+            ignoreReturnCode: true,
+            silent: true
+          })
+          .then(res => {
+            if (res.stderr.length > 0 && res.exitCode != 0) {
+              throw new Error(res.stderr.trim());
+            }
+            return Buildx.parseVersion(res.stdout.trim());
+          });
+      }
+      return this._version;
+    })();
+  }
+
+  public async printVersion() {
+    const cmd = this.getCommand(['version']);
+    await exec.exec(cmd.command, cmd.args, {
+      failOnStdErr: false
+    });
+  }
+
+  public static parseVersion(stdout: string): string {
+    const matches = /\sv?([0-9a-f]{7}|[0-9.]+)/.exec(stdout);
+    if (!matches) {
+      throw new Error(`Cannot parse buildx version`);
+    }
+    return matches[1];
+  }
+
+  public async versionSatisfies(range: string, version?: string): Promise<boolean> {
+    const ver = version ?? (await this.version);
+    if (!ver) {
+      return false;
+    }
+    return semver.satisfies(ver, range) || /^[0-9a-f]{7}$/.exec(ver) !== null;
+  }
+}

src/buildx/inputs.ts

@@ -17,111 +17,15 @@
 import fs from 'fs';
 import path from 'path';
 import * as core from '@actions/core';
-import * as exec from '@actions/exec';
-import * as httpm from '@actions/http-client';
 import {parse} from 'csv-parse/sync';
-import * as semver from 'semver';
 
-import {Docker} from './docker';
-import {Context} from './context';
+import {Context} from '../context';
 
-export interface GitHubRelease {
-  id: number;
-  tag_name: string;
-  html_url: string;
-  assets: Array<string>;
-}
-
-export interface BuildxOpts {
-  context: Context;
-  standalone?: boolean;
-}
-
-export class Buildx {
+export class Inputs {
   private readonly context: Context;
-  private _version: string | undefined;
 
-  public standalone: boolean;
-
-  constructor(opts: BuildxOpts) {
-    this.context = opts.context;
-    this.standalone = opts?.standalone ?? !Docker.isAvailable();
-  }
-
-  public getCommand(args: Array<string>) {
-    return {
-      command: this.standalone ? 'buildx' : 'docker',
-      args: this.standalone ? args : ['buildx', ...args]
-    };
-  }
-
-  public async isAvailable(): Promise<boolean> {
-    const cmd = this.getCommand([]);
-    return await exec
-      .getExecOutput(cmd.command, cmd.args, {
-        ignoreReturnCode: true,
-        silent: true
-      })
-      .then(res => {
-        if (res.stderr.length > 0 && res.exitCode != 0) {
-          return false;
-        }
-        return res.exitCode == 0;
-      })
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      .catch(error => {
-        return false;
-      });
-  }
-
-  public async printInspect(name: string): Promise<void> {
-    const cmd = this.getCommand(['inspect', name]);
-    await exec.exec(cmd.command, cmd.args, {
-      failOnStdErr: false
-    });
-  }
-
-  get version() {
-    return (async () => {
-      if (!this._version) {
-        const cmd = this.getCommand(['version']);
-        this._version = await exec
-          .getExecOutput(cmd.command, cmd.args, {
-            ignoreReturnCode: true,
-            silent: true
-          })
-          .then(res => {
-            if (res.stderr.length > 0 && res.exitCode != 0) {
-              throw new Error(res.stderr.trim());
-            }
-            return Buildx.parseVersion(res.stdout.trim());
-          });
-      }
-      return this._version;
-    })();
-  }
-
-  public async printVersion() {
-    const cmd = this.getCommand(['version']);
-    await exec.exec(cmd.command, cmd.args, {
-      failOnStdErr: false
-    });
-  }
-
-  public static parseVersion(stdout: string): string {
-    const matches = /\sv?([0-9a-f]{7}|[0-9.]+)/.exec(stdout);
-    if (!matches) {
-      throw new Error(`Cannot parse buildx version`);
-    }
-    return matches[1];
-  }
-
-  public async versionSatisfies(range: string, version?: string): Promise<boolean> {
-    const ver = version ?? (await this.version);
-    if (!ver) {
-      return false;
-    }
-    return semver.satisfies(ver, range) || /^[0-9a-f]{7}$/.exec(ver) !== null;
+  constructor(context: Context) {
+    this.context = context;
   }
 
   public getBuildImageIDFilePath(): string {
@@ -228,33 +132,16 @@ export class Buildx {
     return `${input},builder-id=${this.context.provenanceBuilderID}`;
   }
 
-  public static async getRelease(version: string): Promise<GitHubRelease> {
-    // FIXME: Use https://raw.githubusercontent.com/docker/actions-toolkit/main/.github/buildx-releases.json when repo public
-    const url = `https://raw.githubusercontent.com/docker/buildx/master/.github/releases.json`;
-    const http: httpm.HttpClient = new httpm.HttpClient('docker-actions-toolkit');
-    const resp: httpm.HttpClientResponse = await http.get(url);
-    const body = await resp.readBody();
-    const statusCode = resp.message.statusCode || 500;
-    if (statusCode >= 400) {
-      throw new Error(`Failed to get Buildx release ${version} from ${url} with status code ${statusCode}: ${body}`);
-    }
-    const releases = <Record<string, GitHubRelease>>JSON.parse(body);
-    if (!releases[version]) {
-      throw new Error(`Cannot find Buildx release ${version} in ${url}`);
-    }
-    return releases[version];
-  }
-
   public static hasLocalExporter(exporters: string[]): boolean {
-    return Buildx.hasExporterType('local', exporters);
+    return Inputs.hasExporterType('local', exporters);
   }
 
   public static hasTarExporter(exporters: string[]): boolean {
-    return Buildx.hasExporterType('tar', exporters);
+    return Inputs.hasExporterType('tar', exporters);
   }
 
   public static hasDockerExporter(exporters: string[], load?: boolean): boolean {
-    return load ?? Buildx.hasExporterType('docker', exporters);
+    return load ?? Inputs.hasExporterType('docker', exporters);
   }
 
   public static hasExporterType(name: string, exporters: string[]): boolean {

src/buildx/install.ts

@@ -0,0 +1,142 @@
+/**
+ * Copyright 2023 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import * as core from '@actions/core';
+import * as httpm from '@actions/http-client';
+import * as tc from '@actions/tool-cache';
+import * as semver from 'semver';
+import * as util from 'util';
+
+import {GitHubRelease} from '../types/github';
+
+export interface InstallOpts {
+  standalone?: boolean;
+}
+
+export class Install {
+  private readonly opts: InstallOpts;
+
+  constructor(opts?: InstallOpts) {
+    this.opts = opts || {};
+  }
+
+  public async install(version: string, dest: string): Promise<string> {
+    const release: GitHubRelease = await Install.getRelease(version);
+    const fversion = release.tag_name.replace(/^v+|v+$/g, '');
+    let toolPath: string;
+    toolPath = tc.find('buildx', fversion, this.platform());
+    if (!toolPath) {
+      const c = semver.clean(fversion) || '';
+      if (!semver.valid(c)) {
+        throw new Error(`Invalid Buildx version "${fversion}".`);
+      }
+      toolPath = await this.download(fversion);
+    }
+    if (this.opts.standalone) {
+      return this.setStandalone(toolPath, dest);
+    }
+    return this.setPlugin(toolPath, dest);
+  }
+
+  public async setStandalone(toolPath: string, dest: string): Promise<string> {
+    const toolBinPath = path.join(toolPath, os.platform() == 'win32' ? 'docker-buildx.exe' : 'docker-buildx');
+    const binDir = path.join(dest, 'bin');
+    if (!fs.existsSync(binDir)) {
+      fs.mkdirSync(binDir, {recursive: true});
+    }
+    const filename: string = os.platform() == 'win32' ? 'buildx.exe' : 'buildx';
+    const buildxPath: string = path.join(binDir, filename);
+    fs.copyFileSync(toolBinPath, buildxPath);
+    fs.chmodSync(buildxPath, '0755');
+    core.addPath(binDir);
+    return buildxPath;
+  }
+
+  public async setPlugin(toolPath: string, dest: string): Promise<string> {
+    const toolBinPath = path.join(toolPath, os.platform() == 'win32' ? 'docker-buildx.exe' : 'docker-buildx');
+    const pluginsDir: string = path.join(dest, 'cli-plugins');
+    if (!fs.existsSync(pluginsDir)) {
+      fs.mkdirSync(pluginsDir, {recursive: true});
+    }
+    const filename: string = os.platform() == 'win32' ? 'docker-buildx.exe' : 'docker-buildx';
+    const pluginPath: string = path.join(pluginsDir, filename);
+    fs.copyFileSync(toolBinPath, pluginPath);
+    fs.chmodSync(pluginPath, '0755');
+    return pluginPath;
+  }
+
+  private async download(version: string): Promise<string> {
+    const targetFile: string = os.platform() == 'win32' ? 'docker-buildx.exe' : 'docker-buildx';
+    const downloadURL = util.format('https://github.com/docker/buildx/releases/download/v%s/%s', version, this.filename(version));
+    const downloadPath = await tc.downloadTool(downloadURL);
+    core.debug(`downloadURL: ${downloadURL}`);
+    core.debug(`downloadPath: ${downloadPath}`);
+    return await tc.cacheFile(downloadPath, targetFile, 'buildx', version);
+  }
+
+  private platform(): string {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const arm_version = (process.config.variables as any).arm_version;
+    return `${os.platform()}-${os.arch()}${arm_version ? 'v' + arm_version : ''}`;
+  }
+
+  private filename(version: string): string {
+    let arch: string;
+    switch (os.arch()) {
+      case 'x64': {
+        arch = 'amd64';
+        break;
+      }
+      case 'ppc64': {
+        arch = 'ppc64le';
+        break;
+      }
+      case 'arm': {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const arm_version = (process.config.variables as any).arm_version;
+        arch = arm_version ? 'arm-v' + arm_version : 'arm';
+        break;
+      }
+      default: {
+        arch = os.arch();
+        break;
+      }
+    }
+    const platform: string = os.platform() == 'win32' ? 'windows' : os.platform();
+    const ext: string = os.platform() == 'win32' ? '.exe' : '';
+    return util.format('buildx-v%s.%s-%s%s', version, platform, arch, ext);
+  }
+
+  public static async getRelease(version: string): Promise<GitHubRelease> {
+    // FIXME: Use https://raw.githubusercontent.com/docker/actions-toolkit/main/.github/buildx-releases.json when repo public
+    const url = `https://raw.githubusercontent.com/docker/buildx/master/.github/releases.json`;
+    const http: httpm.HttpClient = new httpm.HttpClient('docker-actions-toolkit');
+    const resp: httpm.HttpClientResponse = await http.get(url);
+    const body = await resp.readBody();
+    const statusCode = resp.message.statusCode || 500;
+    if (statusCode >= 400) {
+      throw new Error(`Failed to get Buildx release ${version} from ${url} with status code ${statusCode}: ${body}`);
+    }
+    const releases = <Record<string, GitHubRelease>>JSON.parse(body);
+    if (!releases[version]) {
+      throw new Error(`Cannot find Buildx release ${version} in ${url}`);
+    }
+    return releases[version];
+  }
+}

src/docker.ts

@@ -14,10 +14,16 @@
  * limitations under the License.
  */
 
+import os from 'os';
+import path from 'path';
 import * as exec from '@actions/exec';
 
 export class Docker {
-  public static isAvailable(): boolean {
+  static get configDir(): string {
+    return process.env.DOCKER_CONFIG || path.join(os.homedir(), '.docker');
+  }
+
+  static get isAvailable(): boolean {
     let dockerAvailable = false;
     exec
       .getExecOutput('docker', undefined, {
@@ -39,7 +45,7 @@ export class Docker {
   }
 
   public static async printVersion(standalone?: boolean) {
-    const noDocker = standalone ?? !Docker.isAvailable();
+    const noDocker = standalone ?? !Docker.isAvailable;
     if (noDocker) {
       return;
     }
@@ -49,7 +55,7 @@ export class Docker {
   }
 
   public static async printInfo(standalone?: boolean) {
-    const noDocker = standalone ?? !Docker.isAvailable();
+    const noDocker = standalone ?? !Docker.isAvailable;
     if (noDocker) {
       return;
     }

src/github.ts

@@ -16,42 +16,40 @@
 
 import {GitHub as Octokit} from '@actions/github/lib/utils';
 import * as github from '@actions/github';
-import {components as OctoOpenApiTypes} from '@octokit/openapi-types';
-import jwt_decode, {JwtPayload} from 'jwt-decode';
 import {Context} from '@actions/github/lib/context';
+import jwt_decode from 'jwt-decode';
 
-export type GitHubRepo = OctoOpenApiTypes['schemas']['repository'];
-
-export interface GitHubActionsRuntimeToken extends JwtPayload {
-  ac?: string;
-}
+import {GitHubActionsRuntimeToken, GitHubRepo} from './types/github';
 
 export interface GitHubOpts {
   token?: string;
 }
 
 export class GitHub {
-  public static readonly serverURL: string = process.env.GITHUB_SERVER_URL || 'https://github.com';
   public readonly octokit: InstanceType<typeof Octokit>;
 
   constructor(opts?: GitHubOpts) {
     this.octokit = github.getOctokit(`${opts?.token}`);
   }
 
-  get context(): Context {
-    return github.context;
-  }
-
-  get serverURL(): string {
-    return process.env.GITHUB_SERVER_URL || 'https://github.com';
-  }
-
-  get actionsRuntimeToken(): GitHubActionsRuntimeToken {
-    const token = process.env['ACTIONS_RUNTIME_TOKEN'] || '';
-    return token ? jwt_decode<GitHubActionsRuntimeToken>(token) : {};
-  }
-
   public repoData(): Promise<GitHubRepo> {
     return this.octokit.rest.repos.get({...github.context.repo}).then(response => response.data as GitHubRepo);
   }
+
+  static get context(): Context {
+    return github.context;
+  }
+
+  static get serverURL(): string {
+    return process.env.GITHUB_SERVER_URL || 'https://github.com';
+  }
+
+  static get apiURL(): string {
+    return process.env.GITHUB_API_URL || 'https://api.github.com';
+  }
+
+  static get actionsRuntimeToken(): GitHubActionsRuntimeToken {
+    const token = process.env['ACTIONS_RUNTIME_TOKEN'] || '';
+    return token ? jwt_decode<GitHubActionsRuntimeToken>(token) : {};
+  }
 }

src/toolkit.ts

@@ -15,19 +15,10 @@
  */
 
 import {Context} from './context';
-import {Buildx} from './buildx';
-import {BuildKit} from './buildkit';
+import {Buildx} from './buildx/buildx';
+import {BuildKit} from './buildkit/buildkit';
 import {GitHub} from './github';
 
-export {Builder, BuilderOpts, BuilderInfo, NodeInfo} from './builder';
-export {BuildKit, BuildKitOpts} from './buildkit';
-export {Buildx, BuildxOpts} from './buildx';
-export {Context} from './context';
-export {Docker} from './docker';
-export {Git} from './git';
-export {GitHub, GitHubRepo, GitHubActionsRuntimeToken} from './github';
-export {Util} from './util';
-
 export interface ToolkitOpts {
   /**
    * GitHub token to use for authentication.

src/types/builder.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2023 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface BuilderInfo {
+  name?: string;
+  driver?: string;
+  lastActivity?: Date;
+  nodes: NodeInfo[];
+}
+
+export interface NodeInfo {
+  name?: string;
+  endpoint?: string;
+  driverOpts?: Array<string>;
+  status?: string;
+  buildkitdFlags?: string;
+  buildkitVersion?: string;
+  platforms?: string;
+}

src/types/github.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2023 actions-toolkit authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {components as OctoOpenApiTypes} from '@octokit/openapi-types';
+import {JwtPayload} from 'jwt-decode';
+
+export interface GitHubRelease {
+  id: number;
+  tag_name: string;
+  html_url: string;
+  assets: Array<string>;
+}
+
+export type GitHubRepo = OctoOpenApiTypes['schemas']['repository'];
+
+export interface GitHubActionsRuntimeToken extends JwtPayload {
+  ac?: string;
+}