PR comments

src/index.ts

@@ -1,12 +1,12 @@
 import * as core from '@actions/core';
 import { Action, BuildParameters, Cache, Docker, ImageTag, Output, CloudRunner } from './model';
-import { CLI } from './model/cli/cli';
+import { Cli } from './model/cli/cli';
 import MacBuilder from './model/mac-builder';
 import PlatformSetup from './model/platform-setup';
 async function runMain() {
   try {
-    if (CLI.InitCliMode()) {
-      await CLI.RunCli();
+    if (Cli.InitCliMode()) {
+      await Cli.RunCli();
       return;
     }
     Action.checkCompatibility();

src/model/build-parameters.ts

@@ -8,7 +8,7 @@ import UnityVersioning from './unity-versioning';
 import Versioning from './versioning';
 import { GitRepoReader } from './input-readers/git-repo';
 import { GithubCliReader } from './input-readers/github-cli';
-import { CLI } from './cli/cli';
+import { Cli } from './cli/cli';
 
 class BuildParameters {
   public editorVersion!: string;
@@ -64,7 +64,7 @@ class BuildParameters {
   public cloudRunnerBranch!: string;
   public cloudRunnerIntegrationTests!: boolean;
   public cloudRunnerBuilderPlatform!: string | undefined;
-  public cliMode!: boolean;
+  public isCliMode!: boolean;
 
   static async create(): Promise<BuildParameters> {
     const buildFile = this.parseBuildFile(Input.buildName, Input.targetPlatform, Input.androidAppBundle);
@@ -76,7 +76,7 @@ class BuildParameters {
     // Todo - Don't use process.env directly, that's what the input model class is for.
     // ---
     let unitySerial = '';
-    if (!process.env.UNITY_SERIAL && Input.githubInputEnabled && CLI.options === undefined) {
+    if (!process.env.UNITY_SERIAL && Input.githubInputEnabled && Cli.options === undefined) {
       //No serial was present so it is a personal license that we need to convert
       if (!process.env.UNITY_LICENSE) {
         throw new Error(`Missing Unity License File and no Serial was found. If this
@@ -130,7 +130,7 @@ class BuildParameters {
       cloudRunnerBranch: Input.cloudRunnerBranch.split('/').reverse()[0],
       cloudRunnerIntegrationTests: Input.cloudRunnerTests,
       githubRepo: Input.githubRepo || (await GitRepoReader.GetRemote()) || 'game-ci/unity-builder',
-      cliMode: CLI.cliMode,
+      isCliMode: Cli.isCliMode,
       awsStackName: Input.awsBaseStackName,
       gitSha: Input.gitSha,
       logId: customAlphabet(CloudRunnerConstants.alphabet, 9)(),

src/model/cli/cli-functions-repository.ts

@@ -1,4 +1,4 @@
-export class CLIFunctionsRepository {
+export class CliFunctionsRepository {
   private static targets: any[] = [];
   public static PushCliFunction(
     target: any,
@@ -7,7 +7,7 @@ export class CLIFunctionsRepository {
     key: string,
     description: string,
   ) {
-    CLIFunctionsRepository.targets.push({
+    CliFunctionsRepository.targets.push({
       target,
       propertyKey,
       descriptor,
@@ -15,27 +15,30 @@ export class CLIFunctionsRepository {
       description,
     });
   }
+
   public static GetCliFunctions(key) {
-    const results = CLIFunctionsRepository.targets.find((x) => x.key === key);
+    const results = CliFunctionsRepository.targets.find((x) => x.key === key);
     if (results === undefined || results.length === 0) {
       throw new Error(`no CLI mode found for ${key}`);
     }
     return results;
   }
+
   public static GetAllCliModes() {
-    return CLIFunctionsRepository.targets.map((x) => {
+    return CliFunctionsRepository.targets.map((x) => {
       return {
         key: x.key,
         description: x.description,
       };
     });
   }
+
   // eslint-disable-next-line no-unused-vars
   public static PushCliFunctionSource(cliFunction: any) {}
 }
 
 export function CliFunction(key: string, description: string) {
   return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
-    CLIFunctionsRepository.PushCliFunction(target, propertyKey, descriptor, key, description);
+    CliFunctionsRepository.PushCliFunction(target, propertyKey, descriptor, key, description);
   };
 }

src/model/cli/cli.ts

@@ -4,32 +4,32 @@ import * as core from '@actions/core';
 import { ActionYamlReader } from '../input-readers/action-yaml';
 import CloudRunnerLogger from '../cloud-runner/services/cloud-runner-logger';
 import CloudRunnerQueryOverride from '../cloud-runner/services/cloud-runner-query-override';
-import { CliFunction, CLIFunctionsRepository } from './cli-functions-repository';
-import { AWSCLICommands } from '../cloud-runner/cloud-runner-providers/aws/commands/aws-cli-commands';
+import { CliFunction, CliFunctionsRepository } from './cli-functions-repository';
+import { AwsCliCommands } from '../cloud-runner/providers/aws/commands/aws-cli-commands';
 import { Caching } from '../cloud-runner/remote-client/caching';
-import { LFSHashing } from '../cloud-runner/services/lfs-hashing';
-import { SetupCloudRunnerRepository } from '../cloud-runner/remote-client/setup-cloud-runner-repository';
+import { LfsHashing } from '../cloud-runner/services/lfs-hashing';
+import { RemoteClient } from '../cloud-runner/remote-client';
 
-export class CLI {
+export class Cli {
   public static options;
-  static get cliMode() {
-    return CLI.options !== undefined && CLI.options.mode !== undefined && CLI.options.mode !== '';
+  static get isCliMode() {
+    return Cli.options !== undefined && Cli.options.mode !== undefined && Cli.options.mode !== '';
   }
   public static query(key, alternativeKey) {
-    if (CLI.options && CLI.options[key] !== undefined) {
-      return CLI.options[key];
+    if (Cli.options && Cli.options[key] !== undefined) {
+      return Cli.options[key];
     }
-    if (CLI.options && alternativeKey && CLI.options[alternativeKey] !== undefined) {
-      return CLI.options[alternativeKey];
+    if (Cli.options && alternativeKey && Cli.options[alternativeKey] !== undefined) {
+      return Cli.options[alternativeKey];
     }
     return;
   }
 
   public static InitCliMode() {
-    CLIFunctionsRepository.PushCliFunctionSource(AWSCLICommands);
-    CLIFunctionsRepository.PushCliFunctionSource(Caching);
-    CLIFunctionsRepository.PushCliFunctionSource(LFSHashing);
-    CLIFunctionsRepository.PushCliFunctionSource(SetupCloudRunnerRepository);
+    CliFunctionsRepository.PushCliFunctionSource(AwsCliCommands);
+    CliFunctionsRepository.PushCliFunctionSource(Caching);
+    CliFunctionsRepository.PushCliFunctionSource(LfsHashing);
+    CliFunctionsRepository.PushCliFunctionSource(RemoteClient);
     const program = new Command();
     program.version('0.0.1');
     const properties = Object.getOwnPropertyNames(Input);
@@ -39,7 +39,7 @@ export class CLI {
     }
     program.option(
       '-m, --mode <mode>',
-      CLIFunctionsRepository.GetAllCliModes()
+      CliFunctionsRepository.GetAllCliModes()
         .map((x) => `${x.key} (${x.description})`)
         .join(` | `),
     );
@@ -48,19 +48,19 @@ export class CLI {
     program.option('--cachePushTo <cachePushTo>', 'cache push to caching folder');
     program.option('--artifactName <artifactName>', 'caching artifact name');
     program.parse(process.argv);
-    CLI.options = program.opts();
-    return CLI.cliMode;
+    Cli.options = program.opts();
+    return Cli.isCliMode;
   }
 
   static async RunCli(): Promise<void> {
     Input.githubInputEnabled = false;
-    if (CLI.options['populateOverride'] === `true`) {
+    if (Cli.options['populateOverride'] === `true`) {
       await CloudRunnerQueryOverride.PopulateQueryOverrideInput();
     }
-    CLI.logInput();
-    const results = CLIFunctionsRepository.GetCliFunctions(CLI.options.mode);
+    Cli.logInput();
+    const results = CliFunctionsRepository.GetCliFunctions(Cli.options.mode);
     CloudRunnerLogger.log(`Entrypoint: ${results.key}`);
-    CLI.options.versioning = 'None';
+    Cli.options.versioning = 'None';
     return await results.target[results.propertyKey]();
   }
 

src/model/cloud-runner/cloud-runner.test.ts

@@ -4,7 +4,7 @@ import Input from '../input';
 import { CloudRunnerStatics } from './cloud-runner-statics';
 import { TaskParameterSerializer } from './services/task-parameter-serializer';
 import UnityVersioning from '../unity-versioning';
-import { CLI } from '../cli/cli';
+import { Cli } from '../cli/cli';
 import CloudRunnerLogger from './services/cloud-runner-logger';
 
 function guid() {
@@ -24,7 +24,7 @@ describe('Cloud Runner', () => {
   if (Input.cloudRunnerTests) {
     it('All build parameters sent to cloud runner as env vars', async () => {
       // build parameters
-      CLI.options = {
+      Cli.options = {
         versioning: 'None',
         projectPath: 'test-project',
         unityVersion: UnityVersioning.read('test-project'),
@@ -66,10 +66,10 @@ describe('Cloud Runner', () => {
           expect(newLinePurgedFile).toContain(`${element.name}=${element.value}`);
         }
       }
-      delete CLI.options;
+      delete Cli.options;
     }, 1000000);
     it('Run one build it should not use cache, run subsequent build which should use cache', async () => {
-      CLI.options = {
+      Cli.options = {
         versioning: 'None',
         projectPath: 'test-project',
         unityVersion: UnityVersioning.determineUnityVersion('test-project', UnityVersioning.read('test-project')),
@@ -92,12 +92,12 @@ describe('Cloud Runner', () => {
       expect(results2).toContain(buildSucceededString);
       expect(results2).toEqual(expect.not.stringContaining(libraryString));
       Input.githubInputEnabled = true;
-      delete CLI.options;
+      delete Cli.options;
     }, 1000000);
   }
   it('Local cloud runner returns commands', async () => {
     // build parameters
-    CLI.options = {
+    Cli.options = {
       versioning: 'None',
       projectPath: 'test-project',
       unityVersion: UnityVersioning.read('test-project'),
@@ -119,11 +119,11 @@ describe('Cloud Runner', () => {
     // run the job
     await expect(CloudRunner.run(buildParameter, baseImage.toString())).resolves.not.toThrow();
     Input.githubInputEnabled = true;
-    delete CLI.options;
+    delete Cli.options;
   }, 1000000);
   it('Test cloud runner returns commands', async () => {
     // build parameters
-    CLI.options = {
+    Cli.options = {
       versioning: 'None',
       projectPath: 'test-project',
       unityVersion: UnityVersioning.read('test-project'),
@@ -137,6 +137,6 @@ describe('Cloud Runner', () => {
     // run the job
     await expect(CloudRunner.run(buildParameter, baseImage.toString())).resolves.not.toThrow();
     Input.githubInputEnabled = true;
-    delete CLI.options;
+    delete Cli.options;
   }, 1000000);
 });

src/model/cloud-runner/cloud-runner.ts

@@ -1,6 +1,6 @@
-import AWSBuildPlatform from './cloud-runner-providers/aws';
+import AwsBuildPlatform from './providers/aws';
 import { BuildParameters, Input } from '..';
-import Kubernetes from './cloud-runner-providers/k8s';
+import Kubernetes from './providers/k8s';
 import CloudRunnerLogger from './services/cloud-runner-logger';
 import { CloudRunnerStepState } from './cloud-runner-step-state';
 import { WorkflowCompositionRoot } from './workflows/workflow-composition-root';
@@ -8,14 +8,14 @@ import { CloudRunnerError } from './error/cloud-runner-error';
 import { TaskParameterSerializer } from './services/task-parameter-serializer';
 import * as core from '@actions/core';
 import CloudRunnerSecret from './services/cloud-runner-secret';
-import { CloudRunnerProviderInterface } from './cloud-runner-providers/cloud-runner-provider-interface';
+import { ProviderInterface } from './providers/provider-interface';
 import CloudRunnerEnvironmentVariable from './services/cloud-runner-environment-variable';
-import TestCloudRunner from './cloud-runner-providers/test';
-import LocalCloudRunner from './cloud-runner-providers/local';
-import LocalDockerCloudRunner from './cloud-runner-providers/local-docker';
+import TestCloudRunner from './providers/test';
+import LocalCloudRunner from './providers/local';
+import LocalDockerCloudRunner from './providers/local-docker';
 
 class CloudRunner {
-  public static CloudRunnerProviderPlatform: CloudRunnerProviderInterface;
+  public static Provider: ProviderInterface;
   static buildParameters: BuildParameters;
   public static defaultSecrets: CloudRunnerSecret[];
   public static cloudRunnerEnvironmentVariables: CloudRunnerEnvironmentVariable[];
@@ -25,7 +25,7 @@ class CloudRunner {
     CloudRunner.setupBuildPlatform();
     CloudRunner.defaultSecrets = TaskParameterSerializer.readDefaultSecrets();
     CloudRunner.cloudRunnerEnvironmentVariables = TaskParameterSerializer.readBuildEnvironmentVariables();
-    if (!buildParameters.cliMode) {
+    if (!buildParameters.isCliMode) {
       const buildParameterPropertyNames = Object.getOwnPropertyNames(buildParameters);
       for (const element of CloudRunner.cloudRunnerEnvironmentVariables) {
         core.setOutput(Input.ToEnvVarFormat(element.name), element.value);
@@ -40,19 +40,19 @@ class CloudRunner {
     CloudRunnerLogger.log(`Cloud Runner platform selected ${CloudRunner.buildParameters.cloudRunnerCluster}`);
     switch (CloudRunner.buildParameters.cloudRunnerCluster) {
       case 'k8s':
-        CloudRunner.CloudRunnerProviderPlatform = new Kubernetes(CloudRunner.buildParameters);
+        CloudRunner.Provider = new Kubernetes(CloudRunner.buildParameters);
         break;
       case 'aws':
-        CloudRunner.CloudRunnerProviderPlatform = new AWSBuildPlatform(CloudRunner.buildParameters);
+        CloudRunner.Provider = new AwsBuildPlatform(CloudRunner.buildParameters);
         break;
       case 'test':
-        CloudRunner.CloudRunnerProviderPlatform = new TestCloudRunner();
+        CloudRunner.Provider = new TestCloudRunner();
         break;
       case 'local-system':
-        CloudRunner.CloudRunnerProviderPlatform = new LocalCloudRunner();
+        CloudRunner.Provider = new LocalCloudRunner();
         break;
       case 'local-docker':
-        CloudRunner.CloudRunnerProviderPlatform = new LocalDockerCloudRunner();
+        CloudRunner.Provider = new LocalDockerCloudRunner();
         break;
     }
   }
@@ -60,29 +60,29 @@ class CloudRunner {
   static async run(buildParameters: BuildParameters, baseImage: string) {
     CloudRunner.setup(buildParameters);
     try {
-      if (!CloudRunner.buildParameters.cliMode) core.startGroup('Setup shared cloud runner resources');
-      await CloudRunner.CloudRunnerProviderPlatform.setupSharedResources(
+      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('Setup shared cloud runner resources');
+      await CloudRunner.Provider.setup(
         CloudRunner.buildParameters.buildGuid,
         CloudRunner.buildParameters,
         CloudRunner.buildParameters.branch,
         CloudRunner.defaultSecrets,
       );
-      if (!CloudRunner.buildParameters.cliMode) core.endGroup();
+      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
       const output = await new WorkflowCompositionRoot().run(
         new CloudRunnerStepState(baseImage, CloudRunner.cloudRunnerEnvironmentVariables, CloudRunner.defaultSecrets),
       );
-      if (!CloudRunner.buildParameters.cliMode) core.startGroup('Cleanup shared cloud runner resources');
-      await CloudRunner.CloudRunnerProviderPlatform.cleanupSharedResources(
+      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('Cleanup shared cloud runner resources');
+      await CloudRunner.Provider.cleanup(
         CloudRunner.buildParameters.buildGuid,
         CloudRunner.buildParameters,
         CloudRunner.buildParameters.branch,
         CloudRunner.defaultSecrets,
       );
       CloudRunnerLogger.log(`Cleanup complete`);
-      if (!CloudRunner.buildParameters.cliMode) core.endGroup();
+      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
       return output;
     } catch (error) {
-      if (!CloudRunner.buildParameters.cliMode) core.endGroup();
+      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
       await CloudRunnerError.handleException(error);
       throw error;
     }

src/model/cloud-runner/error/cloud-runner-error.ts

@@ -6,7 +6,7 @@ export class CloudRunnerError {
   public static async handleException(error: unknown) {
     CloudRunnerLogger.error(JSON.stringify(error, undefined, 4));
     core.setFailed('Cloud Runner failed');
-    await CloudRunner.CloudRunnerProviderPlatform.cleanupSharedResources(
+    await CloudRunner.Provider.cleanup(
       CloudRunner.buildParameters.buildGuid,
       CloudRunner.buildParameters,
       CloudRunner.buildParameters.branch,

src/model/cloud-runner/providers/aws/commands/aws-cli-commands.ts

@@ -3,7 +3,7 @@ import { CliFunction } from '../../../../cli/cli-functions-repository';
 import Input from '../../../../input';
 import CloudRunnerLogger from '../../../services/cloud-runner-logger';
 
-export class AWSCLICommands {
+export class AwsCliCommands {
   @CliFunction(`aws-garbage-collect`, `garbage collect aws`)
   static async garbageCollectAws() {
     process.env.AWS_REGION = Input.region;

src/model/cloud-runner/providers/aws/index.ts

@@ -3,20 +3,20 @@ import CloudRunnerSecret from '../../services/cloud-runner-secret';
 import CloudRunnerEnvironmentVariable from '../../services/cloud-runner-environment-variable';
 import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
 import AWSTaskRunner from './aws-task-runner';
-import { CloudRunnerProviderInterface } from '../cloud-runner-provider-interface';
+import { ProviderInterface } from '../provider-interface';
 import BuildParameters from '../../../build-parameters';
 import CloudRunnerLogger from '../../services/cloud-runner-logger';
 import { AWSJobStack } from './aws-job-stack';
 import { AWSBaseStack } from './aws-base-stack';
 import { Input } from '../../..';
 
-class AWSBuildEnvironment implements CloudRunnerProviderInterface {
+class AWSBuildEnvironment implements ProviderInterface {
   private baseStackName: string;
 
   constructor(buildParameters: BuildParameters) {
     this.baseStackName = buildParameters.awsBaseStackName;
   }
-  async cleanupSharedResources(
+  async cleanup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars
@@ -26,7 +26,7 @@ class AWSBuildEnvironment implements CloudRunnerProviderInterface {
     // eslint-disable-next-line no-unused-vars
     defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
   ) {}
-  async setupSharedResources(
+  async setup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars

src/model/cloud-runner/providers/k8s/index.ts

@@ -1,7 +1,7 @@
 import * as k8s from '@kubernetes/client-node';
 import { BuildParameters, Output } from '../../..';
 import * as core from '@actions/core';
-import { CloudRunnerProviderInterface } from '../cloud-runner-provider-interface';
+import { ProviderInterface } from '../provider-interface';
 import CloudRunnerSecret from '../../services/cloud-runner-secret';
 import KubernetesStorage from './kubernetes-storage';
 import CloudRunnerEnvironmentVariable from '../../services/cloud-runner-environment-variable';
@@ -14,7 +14,7 @@ import CloudRunnerLogger from '../../services/cloud-runner-logger';
 import { CoreV1Api } from '@kubernetes/client-node';
 import DependencyOverrideService from '../../services/depdency-override-service';
 
-class Kubernetes implements CloudRunnerProviderInterface {
+class Kubernetes implements ProviderInterface {
   private kubeConfig: k8s.KubeConfig;
   private kubeClient: k8s.CoreV1Api;
   private kubeClientBatch: k8s.BatchV1Api;
@@ -39,7 +39,7 @@ class Kubernetes implements CloudRunnerProviderInterface {
     this.namespace = 'default';
     this.buildParameters = buildParameters;
   }
-  public async setupSharedResources(
+  public async setup(
     buildGuid: string,
     buildParameters: BuildParameters,
     // eslint-disable-next-line no-unused-vars
@@ -174,7 +174,7 @@ class Kubernetes implements CloudRunnerProviderInterface {
     } catch {}
   }
 
-  async cleanupSharedResources(
+  async cleanup(
     buildGuid: string,
     buildParameters: BuildParameters,
     // eslint-disable-next-line no-unused-vars

src/model/cloud-runner/providers/k8s/kubernetes-storage.ts

@@ -24,7 +24,7 @@ class KubernetesStorage {
     CloudRunnerLogger.log(JSON.stringify(pvcList, undefined, 4));
     if (pvcList.includes(pvcName)) {
       CloudRunnerLogger.log(`pvc ${pvcName} already exists`);
-      if (!buildParameters.cliMode) {
+      if (!buildParameters.isCliMode) {
         core.setOutput('volume', pvcName);
       }
       return;

src/model/cloud-runner/providers/local-docker/index.ts

@@ -2,11 +2,11 @@ import BuildParameters from '../../../build-parameters';
 import { CloudRunnerSystem } from '../../services/cloud-runner-system';
 import CloudRunnerEnvironmentVariable from '../../services/cloud-runner-environment-variable';
 import CloudRunnerLogger from '../../services/cloud-runner-logger';
-import { CloudRunnerProviderInterface } from '../cloud-runner-provider-interface';
+import { ProviderInterface } from '../provider-interface';
 import CloudRunnerSecret from '../../services/cloud-runner-secret';
 
-class LocalDockerCloudRunner implements CloudRunnerProviderInterface {
-  cleanupSharedResources(
+class LocalDockerCloudRunner implements ProviderInterface {
+  cleanup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars
@@ -16,7 +16,7 @@ class LocalDockerCloudRunner implements CloudRunnerProviderInterface {
     // eslint-disable-next-line no-unused-vars
     defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
   ) {}
-  setupSharedResources(
+  setup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars

src/model/cloud-runner/providers/local/index.ts

@@ -2,11 +2,11 @@ import BuildParameters from '../../../build-parameters';
 import { CloudRunnerSystem } from '../../services/cloud-runner-system';
 import CloudRunnerEnvironmentVariable from '../../services/cloud-runner-environment-variable';
 import CloudRunnerLogger from '../../services/cloud-runner-logger';
-import { CloudRunnerProviderInterface } from '../cloud-runner-provider-interface';
+import { ProviderInterface } from '../provider-interface';
 import CloudRunnerSecret from '../../services/cloud-runner-secret';
 
-class LocalCloudRunner implements CloudRunnerProviderInterface {
-  cleanupSharedResources(
+class LocalCloudRunner implements ProviderInterface {
+  cleanup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars
@@ -16,7 +16,7 @@ class LocalCloudRunner implements CloudRunnerProviderInterface {
     // eslint-disable-next-line no-unused-vars
     defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
   ) {}
-  public setupSharedResources(
+  public setup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars

src/model/cloud-runner/providers/provider-interface.ts

@@ -2,8 +2,8 @@ import BuildParameters from '../../build-parameters';
 import CloudRunnerEnvironmentVariable from '../services/cloud-runner-environment-variable';
 import CloudRunnerSecret from '../services/cloud-runner-secret';
 
-export interface CloudRunnerProviderInterface {
-  cleanupSharedResources(
+export interface ProviderInterface {
+  cleanup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars
@@ -13,7 +13,7 @@ export interface CloudRunnerProviderInterface {
     // eslint-disable-next-line no-unused-vars
     defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
   );
-  setupSharedResources(
+  setup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars

src/model/cloud-runner/providers/test/index.ts

@@ -1,11 +1,11 @@
 import BuildParameters from '../../../build-parameters';
 import CloudRunnerEnvironmentVariable from '../../services/cloud-runner-environment-variable';
 import CloudRunnerLogger from '../../services/cloud-runner-logger';
-import { CloudRunnerProviderInterface } from '../cloud-runner-provider-interface';
+import { ProviderInterface } from '../provider-interface';
 import CloudRunnerSecret from '../../services/cloud-runner-secret';
 
-class TestCloudRunner implements CloudRunnerProviderInterface {
-  cleanupSharedResources(
+class TestCloudRunner implements ProviderInterface {
+  cleanup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars
@@ -15,7 +15,7 @@ class TestCloudRunner implements CloudRunnerProviderInterface {
     // eslint-disable-next-line no-unused-vars
     defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
   ) {}
-  setupSharedResources(
+  setup(
     // eslint-disable-next-line no-unused-vars
     buildGuid: string,
     // eslint-disable-next-line no-unused-vars

src/model/cloud-runner/remote-client/caching.test.ts

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import BuildParameters from '../../build-parameters';
-import { CLI } from '../../cli/cli';
+import { Cli } from '../../cli/cli';
 import Input from '../../input';
 import UnityVersioning from '../../unity-versioning';
 import CloudRunner from '../cloud-runner';
@@ -22,7 +22,7 @@ describe('Cloud Runner Caching', () => {
 describe('Cloud Runner Caching', () => {
   if (process.platform === 'linux') {
     it('Simple caching works', async () => {
-      CLI.options = {
+      Cli.options = {
         versioning: 'None',
         projectPath: 'test-project',
         unityVersion: UnityVersioning.read('test-project'),
@@ -32,34 +32,39 @@ describe('Cloud Runner Caching', () => {
       Input.githubInputEnabled = false;
       const buildParameter = await BuildParameters.create();
       CloudRunner.buildParameters = buildParameter;
+
       // create test folder
-      const testFolder = path.resolve(__dirname, CLI.options.cacheKey);
+      const testFolder = path.resolve(__dirname, Cli.options.cacheKey);
       fs.mkdirSync(testFolder);
+
       // crate cache folder
-      const cacheFolder = path.resolve(__dirname, `cache-${CLI.options.cacheKey}`);
+      const cacheFolder = path.resolve(__dirname, `cache-${Cli.options.cacheKey}`);
       fs.mkdirSync(cacheFolder);
+
       // add test has file to test folders
-      fs.writeFileSync(path.resolve(testFolder, 'test.txt'), CLI.options.cacheKey);
-      await Caching.PushToCache(cacheFolder, testFolder, `${CLI.options.cacheKey}`);
+      fs.writeFileSync(path.resolve(testFolder, 'test.txt'), Cli.options.cacheKey);
+      await Caching.PushToCache(cacheFolder, testFolder, `${Cli.options.cacheKey}`);
+
       // delete test folder
       fs.rmdirSync(testFolder, { recursive: true });
       await Caching.PullFromCache(
         cacheFolder.replace(/\\/g, `/`),
         testFolder.replace(/\\/g, `/`),
-        `${CLI.options.cacheKey}`,
+        `${Cli.options.cacheKey}`,
       );
       await CloudRunnerSystem.Run(`du -h ${__dirname}`);
       await CloudRunnerSystem.Run(`tree ${testFolder}`);
       await CloudRunnerSystem.Run(`tree ${cacheFolder}`);
+
       // compare validity to original hash
       expect(fs.readFileSync(path.resolve(testFolder, 'test.txt'), { encoding: 'utf8' }).toString()).toContain(
-        CLI.options.cacheKey,
+        Cli.options.cacheKey,
       );
       fs.rmdirSync(testFolder, { recursive: true });
       fs.rmdirSync(cacheFolder, { recursive: true });
 
       Input.githubInputEnabled = true;
-      delete CLI.options;
+      delete Cli.options;
     }, 1000000);
   }
 });

src/model/cloud-runner/remote-client/caching.ts

@@ -5,9 +5,9 @@ import CloudRunner from '../cloud-runner';
 import CloudRunnerLogger from '../services/cloud-runner-logger';
 import { CloudRunnerFolders } from '../services/cloud-runner-folders';
 import { CloudRunnerSystem } from '../services/cloud-runner-system';
-import { LFSHashing } from '../services/lfs-hashing';
+import { LfsHashing } from '../services/lfs-hashing';
 import { RemoteClientLogger } from './remote-client-logger';
-import { CLI } from '../../cli/cli';
+import { Cli } from '../../cli/cli';
 import { CliFunction } from '../../cli/cli-functions-repository';
 
 export class Caching {
@@ -17,9 +17,9 @@ export class Caching {
       const buildParameter = JSON.parse(process.env.BUILD_PARAMETERS || '{}');
       CloudRunner.buildParameters = buildParameter;
       await Caching.PushToCache(
-        CLI.options['cachePushTo'],
-        CLI.options['cachePushFrom'],
-        CLI.options['artifactName'] || '',
+        Cli.options['cachePushTo'],
+        Cli.options['cachePushFrom'],
+        Cli.options['artifactName'] || '',
       );
     } catch (error: any) {
       CloudRunnerLogger.log(`${error}`);
@@ -32,9 +32,9 @@ export class Caching {
       const buildParameter = JSON.parse(process.env.BUILD_PARAMETERS || '{}');
       CloudRunner.buildParameters = buildParameter;
       await Caching.PullFromCache(
-        CLI.options['cachePushFrom'],
-        CLI.options['cachePushTo'],
-        CLI.options['artifactName'] || '',
+        Cli.options['cachePushFrom'],
+        Cli.options['cachePushTo'],
+        Cli.options['artifactName'] || '',
       );
     } catch (error: any) {
       CloudRunnerLogger.log(`${error}`);
@@ -45,14 +45,15 @@ export class Caching {
     cacheArtifactName = cacheArtifactName.replace(' ', '');
     const startPath = process.cwd();
     try {
-      if (!fs.existsSync(cacheFolder)) {
+      const cacheFolderStat = await fs.promises.stat(cacheFolder);
+      if (!cacheFolderStat.isDirectory()) {
         await CloudRunnerSystem.Run(`mkdir -p ${cacheFolder}`);
       }
       process.chdir(path.resolve(sourceFolder, '..'));
 
       if (CloudRunner.buildParameters.cloudRunnerIntegrationTests) {
         CloudRunnerLogger.log(
-          `Hashed cache folder ${await LFSHashing.hashAllFiles(sourceFolder)} ${sourceFolder} ${path.basename(
+          `Hashed cache folder ${await LfsHashing.hashAllFiles(sourceFolder)} ${sourceFolder} ${path.basename(
             sourceFolder,
           )}`,
         );
@@ -68,14 +69,17 @@ export class Caching {
         });
       };
       await CloudRunnerSystem.Run(`zip -q -r ${cacheArtifactName}.zip ${path.basename(sourceFolder)}`);
-      assert(fs.existsSync(`${cacheArtifactName}.zip`), 'cache zip exists');
-      assert(fs.existsSync(path.basename(sourceFolder)), 'source folder exists');
+      const cacheArtifactStatPreMove = await fs.promises.stat(`${cacheArtifactName}.zip`);
+      assert(cacheArtifactStatPreMove.isFile(), 'cache zip exists');
+      const sourceFolderStat = await fs.promises.stat(path.basename(sourceFolder));
+      assert(sourceFolderStat.isDirectory(), 'source folder exists');
       if (CloudRunner.buildParameters.cachePushOverrideCommand) {
         await CloudRunnerSystem.Run(formatFunction(CloudRunner.buildParameters.cachePushOverrideCommand));
       }
       await CloudRunnerSystem.Run(`mv ${cacheArtifactName}.zip ${cacheFolder}`);
       RemoteClientLogger.log(`moved ${cacheArtifactName}.zip to ${cacheFolder}`);
-      assert(fs.existsSync(`${path.join(cacheFolder, cacheArtifactName)}.zip`), 'cache zip exists inside cache folder');
+      const cacheArtifactStat = await fs.promises.stat(`${path.join(cacheFolder, cacheArtifactName)}.zip`);
+      assert(cacheArtifactStat.isFile(), 'cache zip exists inside cache folder');
     } catch (error) {
       process.chdir(`${startPath}`);
       throw error;
@@ -87,12 +91,15 @@ export class Caching {
     const startPath = process.cwd();
     RemoteClientLogger.log(`Caching for ${path.basename(destinationFolder)}`);
     try {
-      if (!fs.existsSync(cacheFolder)) {
-        fs.mkdirSync(cacheFolder);
+      const cacheFolderStat = await fs.promises.stat(cacheFolder);
+      if (!cacheFolderStat.isDirectory()) {
+        await fs.promises.mkdir(cacheFolder);
       }
 
-      if (!fs.existsSync(destinationFolder)) {
-        fs.mkdirSync(destinationFolder);
+      const destinationStat = await fs.promises.stat(destinationFolder);
+
+      if (!destinationStat.isDirectory()) {
+        await fs.promises.mkdir(destinationFolder);
       }
 
       const latestInBranch = await (await CloudRunnerSystem.Run(`ls -t "${cacheFolder}" | grep .zip$ | head -1`))
@@ -100,9 +107,10 @@ export class Caching {
         .replace('.zip', '');
 
       process.chdir(cacheFolder);
+      const cacheArtifactStat = await fs.promises.stat(`${cacheArtifactName}.zip`);
 
       const cacheSelection =
-        cacheArtifactName !== `` && fs.existsSync(`${cacheArtifactName}.zip`) ? cacheArtifactName : latestInBranch;
+        cacheArtifactName !== `` && cacheArtifactStat.isFile() ? cacheArtifactName : latestInBranch;
       await CloudRunnerLogger.log(`cache key ${cacheArtifactName} selection ${cacheSelection}`);
 
       // eslint-disable-next-line func-style
@@ -120,24 +128,29 @@ export class Caching {
         await CloudRunnerSystem.Run(formatFunction(CloudRunner.buildParameters.cachePullOverrideCommand));
       }
 
-      if (fs.existsSync(`${cacheSelection}.zip`)) {
+      const cacheSelectionExistsStat = await fs.promises.stat(`${cacheSelection}.zip`);
+      if (cacheSelectionExistsStat.isFile()) {
         const resultsFolder = `results${CloudRunner.buildParameters.buildGuid}`;
         await CloudRunnerSystem.Run(`mkdir -p ${resultsFolder}`);
         RemoteClientLogger.log(`cache item exists ${cacheFolder}/${cacheSelection}.zip`);
-        assert(`${fs.existsSync(destinationFolder)}`, `destination folder to pull into exists`);
         const fullResultsFolder = path.join(cacheFolder, resultsFolder);
         await CloudRunnerSystem.Run(`unzip -q ${cacheSelection}.zip -d ${path.basename(resultsFolder)}`);
         RemoteClientLogger.log(`cache item extracted to ${fullResultsFolder}`);
-        assert(`${fs.existsSync(fullResultsFolder)}`, `cache extraction results folder exists`);
+        const fullResultsFolderStat = await fs.promises.stat(fullResultsFolder);
+        assert(fullResultsFolderStat.isDirectory(), `cache extraction results folder exists`);
         const destinationParentFolder = path.resolve(destinationFolder, '..');
-        if (fs.existsSync(destinationFolder)) {
-          fs.rmdirSync(destinationFolder, { recursive: true });
+
+        const destinationFolderStat = await fs.promises.stat(destinationFolder);
+        if (destinationFolderStat.isDirectory()) {
+          await fs.promises.rmdir(destinationFolder, { recursive: true });
         }
         await CloudRunnerSystem.Run(
           `mv "${path.join(fullResultsFolder, path.basename(destinationFolder))}" "${destinationParentFolder}"`,
         );
         await CloudRunnerSystem.Run(`du -sh ${path.join(destinationParentFolder, path.basename(destinationFolder))}`);
-        const contents = fs.readdirSync(path.join(destinationParentFolder, path.basename(destinationFolder)));
+        const contents = await fs.promises.readdir(
+          path.join(destinationParentFolder, path.basename(destinationFolder)),
+        );
         CloudRunnerLogger.log(
           `There is ${contents.length} files/dir in the cache pulled contents for ${path.basename(destinationFolder)}`,
         );
@@ -155,10 +168,10 @@ export class Caching {
     process.chdir(`${startPath}`);
   }
 
-  public static handleCachePurging() {
+  public static async handleCachePurging() {
     if (process.env.PURGE_REMOTE_BUILDER_CACHE !== undefined) {
       RemoteClientLogger.log(`purging ${CloudRunnerFolders.purgeRemoteCaching}`);
-      fs.rmdirSync(CloudRunnerFolders.cacheFolder, { recursive: true });
+      fs.promises.rmdir(CloudRunnerFolders.cacheFolder, { recursive: true });
     }
   }
 }

src/model/cloud-runner/remote-client/index.ts

@@ -2,7 +2,7 @@ import fs from 'fs';
 import CloudRunner from '../cloud-runner';
 import { CloudRunnerFolders } from '../services/cloud-runner-folders';
 import { Caching } from './caching';
-import { LFSHashing } from '../services/lfs-hashing';
+import { LfsHashing } from '../services/lfs-hashing';
 import { RemoteClientLogger } from './remote-client-logger';
 import path from 'path';
 import { assert } from 'console';
@@ -10,35 +10,35 @@ import CloudRunnerLogger from '../services/cloud-runner-logger';
 import { CliFunction } from '../../cli/cli-functions-repository';
 import { CloudRunnerSystem } from '../services/cloud-runner-system';
 
-export class SetupCloudRunnerRepository {
-  public static async run() {
+export class RemoteClient {
+  public static async bootstrapRepository() {
     try {
-      await CloudRunnerSystem.Run(`mkdir -p ${CloudRunnerFolders.uniqueCloudRunnerJobFolderFull}`);
-      await CloudRunnerSystem.Run(`mkdir -p ${CloudRunnerFolders.repoPathFull}`);
+      await CloudRunnerSystem.Run(`mkdir -p ${CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute}`);
+      await CloudRunnerSystem.Run(`mkdir -p ${CloudRunnerFolders.repoPathAbsolute}`);
       await CloudRunnerSystem.Run(`mkdir -p ${CloudRunnerFolders.cacheFolderFull}`);
-      process.chdir(CloudRunnerFolders.repoPathFull);
-      await SetupCloudRunnerRepository.cloneRepoWithoutLFSFiles();
-      await SetupCloudRunnerRepository.sizeOfFolder('repo before lfs cache pull', CloudRunnerFolders.repoPathFull);
-      const lfsHashes = await LFSHashing.createLFSHashFiles();
-      if (fs.existsSync(CloudRunnerFolders.libraryFolderFull)) {
+      process.chdir(CloudRunnerFolders.repoPathAbsolute);
+      await RemoteClient.cloneRepoWithoutLFSFiles();
+      await RemoteClient.sizeOfFolder('repo before lfs cache pull', CloudRunnerFolders.repoPathAbsolute);
+      const lfsHashes = await LfsHashing.createLFSHashFiles();
+      if (fs.existsSync(CloudRunnerFolders.libraryFolderAbsolute)) {
         RemoteClientLogger.logWarning(`!Warning!: The Unity library was included in the git repository`);
       }
       await Caching.PullFromCache(
         CloudRunnerFolders.lfsCacheFolderFull,
-        CloudRunnerFolders.lfsDirectoryFull,
+        CloudRunnerFolders.lfsFolderAbsolute,
         `${lfsHashes.lfsGuidSum}`,
       );
-      await SetupCloudRunnerRepository.sizeOfFolder('repo after lfs cache pull', CloudRunnerFolders.repoPathFull);
-      await SetupCloudRunnerRepository.pullLatestLFS();
-      await SetupCloudRunnerRepository.sizeOfFolder('repo before lfs git pull', CloudRunnerFolders.repoPathFull);
+      await RemoteClient.sizeOfFolder('repo after lfs cache pull', CloudRunnerFolders.repoPathAbsolute);
+      await RemoteClient.pullLatestLFS();
+      await RemoteClient.sizeOfFolder('repo before lfs git pull', CloudRunnerFolders.repoPathAbsolute);
       await Caching.PushToCache(
         CloudRunnerFolders.lfsCacheFolderFull,
-        CloudRunnerFolders.lfsDirectoryFull,
+        CloudRunnerFolders.lfsFolderAbsolute,
         `${lfsHashes.lfsGuidSum}`,
       );
-      await Caching.PullFromCache(CloudRunnerFolders.libraryCacheFolderFull, CloudRunnerFolders.libraryFolderFull);
-      await SetupCloudRunnerRepository.sizeOfFolder('repo after library cache pull', CloudRunnerFolders.repoPathFull);
-      Caching.handleCachePurging();
+      await Caching.PullFromCache(CloudRunnerFolders.libraryCacheFolderFull, CloudRunnerFolders.libraryFolderAbsolute);
+      await RemoteClient.sizeOfFolder('repo after library cache pull', CloudRunnerFolders.repoPathAbsolute);
+      await Caching.handleCachePurging();
     } catch (error) {
       throw error;
     }
@@ -51,7 +51,7 @@ export class SetupCloudRunnerRepository {
 
   private static async cloneRepoWithoutLFSFiles() {
     try {
-      process.chdir(`${CloudRunnerFolders.repoPathFull}`);
+      process.chdir(`${CloudRunnerFolders.repoPathAbsolute}`);
       RemoteClientLogger.log(`Initializing source repository for cloning with caching of LFS files`);
       await CloudRunnerSystem.Run(`git config --global advice.detachedHead false`);
       RemoteClientLogger.log(`Cloning the repository being built:`);
@@ -60,7 +60,7 @@ export class SetupCloudRunnerRepository {
       await CloudRunnerSystem.Run(
         `git clone -q ${CloudRunnerFolders.targetBuildRepoUrl} ${path.resolve(
           `..`,
-          path.basename(CloudRunnerFolders.repoPathFull),
+          path.basename(CloudRunnerFolders.repoPathAbsolute),
         )}`,
       );
       await CloudRunnerSystem.Run(`git lfs install`);
@@ -75,12 +75,12 @@ export class SetupCloudRunnerRepository {
   }
 
   private static async pullLatestLFS() {
-    process.chdir(CloudRunnerFolders.repoPathFull);
+    process.chdir(CloudRunnerFolders.repoPathAbsolute);
     await CloudRunnerSystem.Run(`git config --global filter.lfs.smudge "git-lfs smudge -- %f"`);
     await CloudRunnerSystem.Run(`git config --global filter.lfs.process "git-lfs filter-process"`);
     await CloudRunnerSystem.Run(`git lfs pull`);
     RemoteClientLogger.log(`pulled latest LFS files`);
-    assert(fs.existsSync(CloudRunnerFolders.lfsDirectoryFull));
+    assert(fs.existsSync(CloudRunnerFolders.lfsFolderAbsolute));
   }
 
   @CliFunction(`remote-cli`, `sets up a repository, usually before a game-ci build`)
@@ -90,6 +90,6 @@ export class SetupCloudRunnerRepository {
       ${JSON.stringify(buildParameter, undefined, 4)}
     `);
     CloudRunner.buildParameters = buildParameter;
-    await SetupCloudRunnerRepository.run();
+    await RemoteClient.bootstrapRepository();
   }
 }

src/model/cloud-runner/services/cloud-runner-folders.ts

@@ -6,7 +6,7 @@ export class CloudRunnerFolders {
 
   // only the following paths that do not start a path.join with another "Full" suffixed property need to start with an absolute /
 
-  public static get uniqueCloudRunnerJobFolderFull(): string {
+  public static get uniqueCloudRunnerJobFolderAbsolute(): string {
     return path.join(`/`, CloudRunnerFolders.buildVolumeFolder, CloudRunner.buildParameters.buildGuid);
   }
 
@@ -19,28 +19,28 @@ export class CloudRunnerFolders {
     );
   }
 
-  public static get builderPathFull(): string {
-    return path.join(CloudRunnerFolders.uniqueCloudRunnerJobFolderFull, `builder`);
+  public static get builderPathAbsolute(): string {
+    return path.join(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute, `builder`);
   }
 
-  public static get repoPathFull(): string {
-    return path.join(CloudRunnerFolders.uniqueCloudRunnerJobFolderFull, CloudRunnerFolders.repositoryFolder);
+  public static get repoPathAbsolute(): string {
+    return path.join(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute, CloudRunnerFolders.repositoryFolder);
   }
 
-  public static get projectPathFull(): string {
-    return path.join(CloudRunnerFolders.repoPathFull, CloudRunner.buildParameters.projectPath);
+  public static get projectPathAbsolute(): string {
+    return path.join(CloudRunnerFolders.repoPathAbsolute, CloudRunner.buildParameters.projectPath);
   }
 
-  public static get libraryFolderFull(): string {
-    return path.join(CloudRunnerFolders.projectPathFull, `Library`);
+  public static get libraryFolderAbsolute(): string {
+    return path.join(CloudRunnerFolders.projectPathAbsolute, `Library`);
   }
 
-  public static get projectBuildFolderFull(): string {
-    return path.join(CloudRunnerFolders.repoPathFull, CloudRunner.buildParameters.buildPath);
+  public static get projectBuildFolderAbsolute(): string {
+    return path.join(CloudRunnerFolders.repoPathAbsolute, CloudRunner.buildParameters.buildPath);
   }
 
-  public static get lfsDirectoryFull(): string {
-    return path.join(CloudRunnerFolders.repoPathFull, `.git`, `lfs`);
+  public static get lfsFolderAbsolute(): string {
+    return path.join(CloudRunnerFolders.repoPathAbsolute, `.git`, `lfs`);
   }
 
   public static get purgeRemoteCaching(): boolean {

src/model/cloud-runner/services/cloud-runner-system.ts

@@ -1,5 +1,6 @@
 import { exec } from 'child_process';
 import { RemoteClientLogger } from '../remote-client/remote-client-logger';
+
 export class CloudRunnerSystem {
   public static async Run(command: string, suppressError = false, suppressLogs = false) {
     for (const element of command.split(`\n`)) {

src/model/cloud-runner/services/lfs-hashing.ts

@@ -3,10 +3,10 @@ import { CloudRunnerFolders } from './cloud-runner-folders';
 import { CloudRunnerSystem } from './cloud-runner-system';
 import fs from 'fs';
 import { assert } from 'console';
-import { CLI } from '../../cli/cli';
+import { Cli } from '../../cli/cli';
 import { CliFunction } from '../../cli/cli-functions-repository';
 
-export class LFSHashing {
+export class LfsHashing {
   public static async createLFSHashFiles() {
     try {
       await CloudRunnerSystem.Run(`git lfs ls-files -l | cut -d ' ' -f1 | sort > .lfs-assets-guid`);
@@ -15,10 +15,10 @@ export class LFSHashing {
       assert(fs.existsSync(`.lfs-assets-guid`));
       const lfsHashes = {
         lfsGuid: fs
-          .readFileSync(`${path.join(CloudRunnerFolders.repoPathFull, `.lfs-assets-guid`)}`, 'utf8')
+          .readFileSync(`${path.join(CloudRunnerFolders.repoPathAbsolute, `.lfs-assets-guid`)}`, 'utf8')
           .replace(/\n/g, ``),
         lfsGuidSum: fs
-          .readFileSync(`${path.join(CloudRunnerFolders.repoPathFull, `.lfs-assets-guid-sum`)}`, 'utf8')
+          .readFileSync(`${path.join(CloudRunnerFolders.repoPathAbsolute, `.lfs-assets-guid-sum`)}`, 'utf8')
           .replace('  .lfs-assets-guid', '')
           .replace(/\n/g, ``),
       };
@@ -39,7 +39,7 @@ export class LFSHashing {
 
   @CliFunction(`hash`, `hash all folder contents`)
   static async hash() {
-    const folder = CLI.options['cachePushFrom'];
-    LFSHashing.hashAllFiles(folder);
+    const folder = Cli.options['cachePushFrom'];
+    LfsHashing.hashAllFiles(folder);
   }
 }

src/model/cloud-runner/workflows/build-automation-workflow.ts

@@ -21,36 +21,36 @@ export class BuildAutomationWorkflow implements WorkflowInterface {
     try {
       CloudRunnerLogger.log(`Cloud Runner is running standard build automation`);
 
-      if (!CloudRunner.buildParameters.cliMode) core.startGroup('pre build steps');
+      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('pre build steps');
       let output = '';
       if (CloudRunner.buildParameters.preBuildSteps !== '') {
         output += await CustomWorkflow.runCustomJob(CloudRunner.buildParameters.preBuildSteps);
       }
-      if (!CloudRunner.buildParameters.cliMode) core.endGroup();
+      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
       CloudRunnerLogger.logWithTime('Configurable pre build step(s) time');
 
-      if (!CloudRunner.buildParameters.cliMode) core.startGroup('build');
+      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('build');
       CloudRunnerLogger.log(baseImage.toString());
       CloudRunnerLogger.logLine(` `);
       CloudRunnerLogger.logLine('Starting build automation job');
 
-      output += await CloudRunner.CloudRunnerProviderPlatform.runTask(
+      output += await CloudRunner.Provider.runTask(
         CloudRunner.buildParameters.buildGuid,
         baseImage.toString(),
-        BuildAutomationWorkflow.FullWorkflow,
+        BuildAutomationWorkflow.BuildWorkflow,
         `/${CloudRunnerFolders.buildVolumeFolder}`,
         `/${CloudRunnerFolders.buildVolumeFolder}/`,
         CloudRunner.cloudRunnerEnvironmentVariables,
         CloudRunner.defaultSecrets,
       );
-      if (!CloudRunner.buildParameters.cliMode) core.endGroup();
+      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
       CloudRunnerLogger.logWithTime('Build time');
 
-      if (!CloudRunner.buildParameters.cliMode) core.startGroup('post build steps');
+      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('post build steps');
       if (CloudRunner.buildParameters.postBuildSteps !== '') {
         output += await CustomWorkflow.runCustomJob(CloudRunner.buildParameters.postBuildSteps);
       }
-      if (!CloudRunner.buildParameters.cliMode) core.endGroup();
+      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
       CloudRunnerLogger.logWithTime('Configurable post build step(s) time');
 
       CloudRunnerLogger.log(`Cloud Runner finished running standard build automation`);
@@ -61,34 +61,34 @@ export class BuildAutomationWorkflow implements WorkflowInterface {
     }
   }
 
-  private static get FullWorkflow() {
+  private static get BuildWorkflow() {
     const setupHooks = CloudRunnerBuildCommandProcessor.getHooks(CloudRunner.buildParameters.customJobHooks).filter(
       (x) => x.step.includes(`setup`),
     );
     const buildHooks = CloudRunnerBuildCommandProcessor.getHooks(CloudRunner.buildParameters.customJobHooks).filter(
       (x) => x.step.includes(`build`),
     );
-    const builderPath = path.join(CloudRunnerFolders.builderPathFull, 'dist', `index.js`).replace(/\\/g, `/`);
+    const builderPath = path.join(CloudRunnerFolders.builderPathAbsolute, 'dist', `index.js`).replace(/\\/g, `/`);
     return `apt-get update > /dev/null
       apt-get install -y zip tree npm git-lfs jq unzip git > /dev/null
       npm install -g n > /dev/null
       n stable > /dev/null
       ${setupHooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
-      export GITHUB_WORKSPACE="${CloudRunnerFolders.repoPathFull.replace(/\\/g, `/`)}"
-      ${BuildAutomationWorkflow.SetupCommands(builderPath)}
+      export GITHUB_WORKSPACE="${CloudRunnerFolders.repoPathAbsolute.replace(/\\/g, `/`)}"
+      ${BuildAutomationWorkflow.setupCommands(builderPath)}
       ${setupHooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}
       ${buildHooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
       ${BuildAutomationWorkflow.BuildCommands(builderPath, CloudRunner.buildParameters.buildGuid)}
       ${buildHooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}`;
   }
 
-  private static SetupCommands(builderPath) {
+  private static setupCommands(builderPath) {
     return `export GIT_DISCOVERY_ACROSS_FILESYSTEM=1
     echo "game ci cloud runner clone"
-    mkdir -p ${CloudRunnerFolders.builderPathFull.replace(/\\/g, `/`)}
+    mkdir -p ${CloudRunnerFolders.builderPathAbsolute.replace(/\\/g, `/`)}
     git clone -q -b ${CloudRunner.buildParameters.cloudRunnerBranch} ${
       CloudRunnerFolders.unityBuilderRepoUrl
-    } "${CloudRunnerFolders.builderPathFull.replace(/\\/g, `/`)}"
+    } "${CloudRunnerFolders.builderPathAbsolute.replace(/\\/g, `/`)}"
     chmod +x ${builderPath}
     echo "game ci cloud runner bootstrap"
     node ${builderPath} -m remote-cli`;
@@ -96,11 +96,11 @@ export class BuildAutomationWorkflow implements WorkflowInterface {
 
   private static BuildCommands(builderPath, guid) {
     const linuxCacheFolder = CloudRunnerFolders.cacheFolderFull.replace(/\\/g, `/`);
-    const distFolder = path.join(CloudRunnerFolders.builderPathFull, 'dist');
-    const ubuntuPlatformsFolder = path.join(CloudRunnerFolders.builderPathFull, 'dist', 'platforms', 'ubuntu');
+    const distFolder = path.join(CloudRunnerFolders.builderPathAbsolute, 'dist');
+    const ubuntuPlatformsFolder = path.join(CloudRunnerFolders.builderPathAbsolute, 'dist', 'platforms', 'ubuntu');
     return `echo "game ci cloud runner init"
-    mkdir -p ${`${CloudRunnerFolders.projectBuildFolderFull}/build`.replace(/\\/g, `/`)}
-    cd ${CloudRunnerFolders.projectPathFull}
+    mkdir -p ${`${CloudRunnerFolders.projectBuildFolderAbsolute}/build`.replace(/\\/g, `/`)}
+    cd ${CloudRunnerFolders.projectPathAbsolute}
     cp -r "${path.join(distFolder, 'default-build-script').replace(/\\/g, `/`)}" "/UnityBuilderAction"
     cp -r "${path.join(ubuntuPlatformsFolder, 'entrypoint.sh').replace(/\\/g, `/`)}" "/entrypoint.sh"
     cp -r "${path.join(ubuntuPlatformsFolder, 'steps').replace(/\\/g, `/`)}" "/steps"
@@ -111,11 +111,11 @@ export class BuildAutomationWorkflow implements WorkflowInterface {
     echo "game ci cloud runner push library to cache"
     chmod +x ${builderPath}
     node ${builderPath} -m cache-push --cachePushFrom ${
-      CloudRunnerFolders.libraryFolderFull
+      CloudRunnerFolders.libraryFolderAbsolute
     } --artifactName lib-${guid} --cachePushTo ${linuxCacheFolder}/Library
     echo "game ci cloud runner push build to cache"
     node ${builderPath} -m cache-push --cachePushFrom ${
-      CloudRunnerFolders.projectBuildFolderFull
+      CloudRunnerFolders.projectBuildFolderAbsolute
     } --artifactName build-${guid} --cachePushTo ${`${linuxCacheFolder}/build`.replace(/\\/g, `/`)}`;
   }
 }

src/model/cloud-runner/workflows/custom-workflow.ts

@@ -27,7 +27,7 @@ export class CustomWorkflow {
           };
           return secret;
         });
-        output += await CloudRunner.CloudRunnerProviderPlatform.runTask(
+        output += await CloudRunner.Provider.runTask(
           CloudRunner.buildParameters.buildGuid,
           step['image'],
           step['commands'],

src/model/input.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { CLI } from './cli/cli';
+import { Cli } from './cli/cli';
 import CloudRunnerQueryOverride from './cloud-runner/services/cloud-runner-query-override';
 import Platform from './platform';
 
@@ -26,15 +26,18 @@ class Input {
     const alternativeQuery = Input.ToEnvVarFormat(query);
 
     // query input sources
-    if (CLI.query(query, alternativeQuery)) {
-      return CLI.query(query, alternativeQuery);
+    if (Cli.query(query, alternativeQuery)) {
+      return Cli.query(query, alternativeQuery);
     }
+
     if (CloudRunnerQueryOverride.query(query, alternativeQuery)) {
       return CloudRunnerQueryOverride.query(query, alternativeQuery);
     }
+
     if (process.env[query] !== undefined) {
       return process.env[query];
     }
+
     if (alternativeQuery !== query && process.env[alternativeQuery] !== undefined) {
       return process.env[alternativeQuery];
     }
@@ -222,7 +225,7 @@ class Input {
   }
 
   static get cloudRunnerCluster() {
-    if (CLI.cliMode) {
+    if (Cli.isCliMode) {
       return Input.getInput('cloudRunnerCluster') || 'aws';
     }
     return Input.getInput('cloudRunnerCluster') || 'local';