fix: replace orchestrator-develop branch references with main

The orchestrator-develop branch no longer exists. Update all fallback
clone commands and test fixtures to use main instead.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.eslintrc.json

@@ -78,5 +78,13 @@
     "unicorn/prefer-spread": "off",
     // Temp disable to prevent mixing changes with other PRs
     "i18n-text/no-en": "off"
-  }
+  },
+  "overrides": [
+    {
+      "files": ["jest.setup.js"],
+      "rules": {
+        "import/no-commonjs": "off"
+      }
+    }
+  ]
 }

.github/workflows/cleanup.yml

@@ -1,37 +0,0 @@
-name: Cleanup (cron)
-on:
-  schedule:
-    - cron: '30 10 * * SUN' # every sunday at 10:30
-
-jobs:
-  deleteArtifacts:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Delete old artifacts
-        uses: kolpav/purge-artifacts-action@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          expire-in: 21 days
-  cleanupCloudRunner:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        if: github.event.event_type != 'pull_request_target'
-        with:
-          lfs: true
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-      - run: yarn
-      - run: yarn run cli --help
-        env:
-          AWS_REGION: eu-west-2
-          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          AWS_DEFAULT_REGION: eu-west-2
-      - run: yarn run cli -m list-resources
-        env:
-          AWS_REGION: eu-west-2
-          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          AWS_DEFAULT_REGION: eu-west-2

.github/workflows/cloud-runner-ci-pipeline.yml

@@ -1,231 +0,0 @@
-name: Cloud Runner CI Pipeline
-
-on:
-  push: { branches: [cloud-runner-develop, cloud-runner-preview, main] }
-  workflow_dispatch:
-    inputs:
-      runGithubIntegrationTests:
-        description: 'Run GitHub Checks integration tests'
-        required: false
-        default: 'false'
-
-permissions:
-  checks: write
-  contents: read
-  actions: write
-
-env:
-  GKE_ZONE: 'us-central1'
-  GKE_REGION: 'us-central1'
-  GKE_PROJECT: 'unitykubernetesbuilder'
-  GKE_CLUSTER: 'game-ci-github-pipelines'
-  GCP_LOGGING: true
-  GCP_PROJECT: unitykubernetesbuilder
-  GCP_LOG_FILE: ${{ github.workspace }}/cloud-runner-logs.txt
-  AWS_REGION: eu-west-2
-  AWS_DEFAULT_REGION: eu-west-2
-  AWS_STACK_NAME: game-ci-team-pipelines
-  CLOUD_RUNNER_BRANCH: ${{ github.ref }}
-  DEBUG: true
-  UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
-  UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
-  UNITY_SERIAL: ${{ secrets.UNITY_SERIAL }}
-  PROJECT_PATH: test-project
-  UNITY_VERSION: 2019.3.15f1
-  USE_IL2CPP: false
-  USE_GKE_GCLOUD_AUTH_PLUGIN: true
-
-jobs:
-  tests:
-    name: Tests
-    if: github.event.event_type != 'pull_request_target'
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        test:
-          - 'cloud-runner-end2end-locking'
-          - 'cloud-runner-end2end-caching'
-          - 'cloud-runner-end2end-retaining'
-          - 'cloud-runner-caching'
-          - 'cloud-runner-environment'
-          - 'cloud-runner-image'
-          - 'cloud-runner-hooks'
-          - 'cloud-runner-local-persistence'
-          - 'cloud-runner-locking-core'
-          - 'cloud-runner-locking-get-locked'
-    steps:
-      - name: Checkout (default)
-        uses: actions/checkout@v4
-        with:
-          lfs: false
-      - name: Configure AWS Credentials
-        uses: aws-actions/configure-aws-credentials@v1
-        with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: eu-west-2
-      - run: yarn
-      - run: yarn run test "${{ matrix.test }}" --detectOpenHandles --forceExit --runInBand
-        timeout-minutes: 60
-        env:
-          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
-          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
-          UNITY_SERIAL: ${{ secrets.UNITY_SERIAL }}
-          PROJECT_PATH: test-project
-          TARGET_PLATFORM: StandaloneWindows64
-          cloudRunnerTests: true
-          versioning: None
-          KUBE_STORAGE_CLASS: local-path
-          PROVIDER_STRATEGY: local-docker
-          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          GIT_PRIVATE_TOKEN: ${{ secrets.GIT_PRIVATE_TOKEN }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  k8sTests:
-    name: K8s Tests
-    if: github.event.event_type != 'pull_request_target'
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        test:
-          # - 'cloud-runner-async-workflow'
-          - 'cloud-runner-end2end-locking'
-          - 'cloud-runner-end2end-caching'
-          - 'cloud-runner-end2end-retaining'
-          - 'cloud-runner-kubernetes'
-          - 'cloud-runner-environment'
-          - 'cloud-runner-github-checks'
-    steps:
-      - name: Checkout (default)
-        uses: actions/checkout@v2
-        with:
-          lfs: false
-      - run: yarn
-      - name: actions-k3s
-        uses: debianmaster/actions-k3s@v1.0.5
-        with:
-          version: 'latest'
-      - run: yarn run test "${{ matrix.test }}" --detectOpenHandles --forceExit --runInBand
-        timeout-minutes: 60
-        env:
-          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
-          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
-          UNITY_SERIAL: ${{ secrets.UNITY_SERIAL }}
-          PROJECT_PATH: test-project
-          TARGET_PLATFORM: StandaloneWindows64
-          cloudRunnerTests: true
-          versioning: None
-          KUBE_STORAGE_CLASS: local-path
-          PROVIDER_STRATEGY: k8s
-          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          GIT_PRIVATE_TOKEN: ${{ secrets.GIT_PRIVATE_TOKEN }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  awsTests:
-    name: AWS Tests
-    if: github.event.event_type != 'pull_request_target'
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        test:
-          - 'cloud-runner-end2end-locking'
-          - 'cloud-runner-end2end-caching'
-          - 'cloud-runner-end2end-retaining'
-          - 'cloud-runner-environment'
-          - 'cloud-runner-s3-steps'
-    steps:
-      - name: Checkout (default)
-        uses: actions/checkout@v2
-        with:
-          lfs: false
-      - name: Configure AWS Credentials
-        uses: aws-actions/configure-aws-credentials@v1
-        with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: eu-west-2
-      - run: yarn
-      - run: yarn run test "${{ matrix.test }}" --detectOpenHandles --forceExit --runInBand
-        timeout-minutes: 60
-        env:
-          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
-          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
-          UNITY_SERIAL: ${{ secrets.UNITY_SERIAL }}
-          PROJECT_PATH: test-project
-          TARGET_PLATFORM: StandaloneWindows64
-          cloudRunnerTests: true
-          versioning: None
-          KUBE_STORAGE_CLASS: local-path
-          PROVIDER_STRATEGY: aws
-          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          GIT_PRIVATE_TOKEN: ${{ secrets.GIT_PRIVATE_TOKEN }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  buildTargetTests:
-    name: Local Build Target Tests
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        providerStrategy:
-          #- aws
-          - local-docker
-          #- k8s
-        targetPlatform:
-          - StandaloneOSX # Build a macOS standalone (Intel 64-bit).
-          - StandaloneWindows64 # Build a Windows 64-bit standalone.
-          - StandaloneLinux64 # Build a Linux 64-bit standalone.
-          - WebGL # WebGL.
-          - iOS # Build an iOS player.
-          # - Android # Build an Android .apk.
-    steps:
-      - name: Checkout (default)
-        uses: actions/checkout@v4
-        with:
-          lfs: false
-      - run: yarn
-      - uses: ./
-        id: unity-build
-        timeout-minutes: 30
-        env:
-          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
-          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
-          UNITY_SERIAL: ${{ secrets.UNITY_SERIAL }}
-
-          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          GIT_PRIVATE_TOKEN: ${{ secrets.GIT_PRIVATE_TOKEN }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          cloudRunnerTests: true
-          versioning: None
-          targetPlatform: ${{ matrix.targetPlatform }}
-          providerStrategy: ${{ matrix.providerStrategy }}
-      - run: |
-          cp ./cloud-runner-cache/cache/${{ steps.unity-build.outputs.CACHE_KEY }}/build/${{ steps.unity-build.outputs.BUILD_ARTIFACT }} ${{ steps.unity-build.outputs.BUILD_ARTIFACT }}
-      - uses: actions/upload-artifact@v4
-        with:
-          name: ${{ matrix.providerStrategy }} Build (${{ matrix.targetPlatform }})
-          path: ${{ steps.unity-build.outputs.BUILD_ARTIFACT }}
-          retention-days: 14
-
-  githubChecksIntegration:
-    name: GitHub Checks Integration
-    runs-on: ubuntu-latest
-    if: github.event_name == 'workflow_dispatch' && github.event.inputs.runGithubIntegrationTests == 'true'
-    env:
-      RUN_GITHUB_INTEGRATION_TESTS: true
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: 'yarn'
-      - run: yarn install --frozen-lockfile
-      - run: yarn test cloud-runner-github-checks-integration-test --detectOpenHandles --forceExit --runInBand
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/integrity-check.yml

@@ -4,6 +4,11 @@ on:
   push: { branches: [main] }
   pull_request: {}
 
+permissions:
+  contents: read
+  checks: write
+  statuses: write
+
 env:
   CODECOV_TOKEN: '2f2eb890-30e2-4724-83eb-7633832cf0de'
 
@@ -22,7 +27,12 @@ jobs:
           node-version: '18'
       - run: yarn
       - run: yarn lint
-      - run: yarn test --coverage
+      - run: yarn test:ci --coverage
       - run: bash <(curl -s https://codecov.io/bash)
       - run: yarn build || { echo "build command should always succeed" ; exit 61; }
-#      - run: yarn build --quiet && git diff --quiet dist || { echo "dist should be auto generated" ; git diff dist ; exit 62; }
+  #      - run: yarn build --quiet && git diff --quiet dist || { echo "dist should be auto generated" ; git diff dist ; exit 62; }
+
+  orchestrator:
+    name: Orchestrator Integrity
+    uses: ./.github/workflows/orchestrator-integrity.yml
+    secrets: inherit

.github/workflows/orchestrator-async-checks.yml

@@ -18,15 +18,16 @@ env:
   GKE_CLUSTER: 'game-ci-github-pipelines'
   GCP_LOGGING: true
   GCP_PROJECT: unitykubernetesbuilder
-  GCP_LOG_FILE: ${{ github.workspace }}/cloud-runner-logs.txt
-  AWS_REGION: eu-west-2
-  AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-  AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-  AWS_DEFAULT_REGION: eu-west-2
-  AWS_STACK_NAME: game-ci-github-pipelines
-  CLOUD_RUNNER_BRANCH: ${{ github.ref }}
-  CLOUD_RUNNER_DEBUG: true
-  CLOUD_RUNNER_DEBUG_TREE: true
+  GCP_LOG_FILE: ${{ github.workspace }}/orchestrator-logs.txt
+  # Commented out: Using LocalStack tests instead of real AWS
+  # AWS_REGION: eu-west-2
+  # AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+  # AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+  # AWS_DEFAULT_REGION: eu-west-2
+  # AWS_STACK_NAME: game-ci-github-pipelines
+  ORCHESTRATOR_BRANCH: ${{ github.ref }}
+  ORCHESTRATOR_DEBUG: true
+  ORCHESTRATOR_DEBUG_TREE: true
   DEBUG: true
   UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
   PROJECT_PATH: test-project
@@ -46,13 +47,14 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           GIT_PRIVATE_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           TARGET_PLATFORM: StandaloneWindows64
-          cloudRunnerTests: true
+          orchestratorTests: true
           versioning: None
-          CLOUD_RUNNER_CLUSTER: local-docker
-          AWS_STACK_NAME: game-ci-github-pipelines
+          ORCHESTRATOR_CLUSTER: local-docker
+          # Commented out: Using LocalStack tests instead of real AWS
+          # AWS_STACK_NAME: game-ci-github-pipelines
           CHECKS_UPDATE: ${{ github.event.inputs.checksObject }}
         run: |
-          git clone -b cloud-runner-develop https://github.com/game-ci/unity-builder
+          git clone -b main https://github.com/game-ci/unity-builder
           cd unity-builder
           yarn
           ls

.github/workflows/release-cli.yml

@@ -0,0 +1,170 @@
+name: Release CLI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Release tag to build (e.g., v2.0.0). Uses latest release if empty.'
+        required: false
+        type: string
+      publish-npm:
+        description: 'Publish to npm'
+        required: false
+        default: false
+        type: boolean
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.release.tag_name || inputs.tag || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build-binaries:
+    name: Build ${{ matrix.target }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: linux-x64
+            os: ubuntu-latest
+            pkg-target: node20-linux-x64
+            binary-name: game-ci-linux-x64
+          - target: linux-arm64
+            os: ubuntu-latest
+            pkg-target: node20-linux-arm64
+            binary-name: game-ci-linux-arm64
+          - target: macos-x64
+            os: macos-latest
+            pkg-target: node20-macos-x64
+            binary-name: game-ci-macos-x64
+          - target: macos-arm64
+            os: macos-latest
+            pkg-target: node20-macos-arm64
+            binary-name: game-ci-macos-arm64
+          - target: windows-x64
+            os: windows-latest
+            pkg-target: node20-win-x64
+            binary-name: game-ci-windows-x64.exe
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.release.tag_name || inputs.tag || github.ref }}
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile
+
+      - name: Build TypeScript
+        run: yarn build
+
+      - name: Verify CLI before packaging
+        run: node lib/cli.js version
+
+      - name: Build standalone binary
+        run: npx pkg lib/cli.js --target ${{ matrix.pkg-target }} --output ${{ matrix.binary-name }} --compress GZip
+
+      - name: Verify standalone binary (non-cross-compiled)
+        if: |
+          (matrix.target == 'linux-x64' && runner.os == 'Linux') ||
+          (matrix.target == 'macos-arm64' && runner.os == 'macOS' && runner.arch == 'ARM64') ||
+          (matrix.target == 'macos-x64' && runner.os == 'macOS' && runner.arch == 'X64') ||
+          (matrix.target == 'windows-x64' && runner.os == 'Windows')
+        run: ./${{ matrix.binary-name }} version
+        shell: bash
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: binary-${{ matrix.target }}
+          path: ${{ matrix.binary-name }}
+          retention-days: 5
+
+  create-checksums-and-upload:
+    name: Checksums and release upload
+    needs: build-binaries
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: binaries
+          pattern: binary-*
+          merge-multiple: true
+
+      - name: List binaries
+        run: ls -la binaries/
+
+      - name: Generate SHA256 checksums
+        run: |
+          cd binaries
+          sha256sum game-ci-* > checksums.txt
+          echo "=== checksums.txt ==="
+          cat checksums.txt
+
+      - name: Determine release tag
+        id: tag
+        run: |
+          if [ "${{ github.event_name }}" = "release" ]; then
+            echo "tag=${{ github.event.release.tag_name }}" >> "$GITHUB_OUTPUT"
+          elif [ -n "${{ inputs.tag }}" ]; then
+            echo "tag=${{ inputs.tag }}" >> "$GITHUB_OUTPUT"
+          else
+            echo "No release tag available. Skipping upload."
+            echo "tag=" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Upload binaries to release
+        if: steps.tag.outputs.tag != ''
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          cd binaries
+          for f in game-ci-* checksums.txt; do
+            echo "Uploading $f..."
+            gh release upload "${{ steps.tag.outputs.tag }}" "$f" \
+              --repo "${{ github.repository }}" \
+              --clobber
+          done
+
+  publish-npm:
+    name: Publish to npm
+    needs: build-binaries
+    runs-on: ubuntu-latest
+    if: >-
+      (github.event_name == 'release') || (github.event_name == 'workflow_dispatch' && inputs.publish-npm)
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.release.tag_name || inputs.tag || github.ref }}
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile
+
+      - name: Build
+        run: yarn build
+
+      - name: Run tests
+        run: yarn test
+
+      - name: Verify CLI
+        run: |
+          node lib/cli.js version
+          node lib/cli.js --help
+
+      - name: Publish to npm
+        run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.gitignore

@@ -5,3 +5,5 @@ lib/
 .vsconfig
 yarn-error.log
 .orig
+$LOG_FILE
+temp/

action.yml

@@ -104,11 +104,11 @@ inputs:
   gitPrivateToken:
     required: false
     default: ''
-    description: '[CloudRunner] Github private token to pull from github'
+    description: '[Orchestrator] Github private token to pull from github'
   githubOwner:
     required: false
     default: ''
-    description: '[CloudRunner] GitHub owner name or organization/team name'
+    description: '[Orchestrator] GitHub owner name or organization/team name'
   runAsHostUser:
     required: false
     default: 'false'
@@ -149,97 +149,101 @@ inputs:
   allowDirtyBuild:
     required: false
     default: ''
-    description: '[CloudRunner] Allows the branch of the build to be dirty, and still generate the build.'
+    description: '[Orchestrator] Allows the branch of the build to be dirty, and still generate the build.'
   postBuildSteps:
     required: false
     default: ''
     description:
-      '[CloudRunner] run a post build job in yaml format with the keys image, secrets (name, value object array),
+      '[Orchestrator] run a post build job in yaml format with the keys image, secrets (name, value object array),
       command string'
   preBuildSteps:
     required: false
     default: ''
     description:
-      '[CloudRunner] Run a pre build job after the repository setup but before the build job (in yaml format with the
+      '[Orchestrator] Run a pre build job after the repository setup but before the build job (in yaml format with the
       keys image, secrets (name, value object array), command line string)'
   containerHookFiles:
     required: false
     default: ''
     description:
-      '[CloudRunner] Specify the names (by file name) of custom steps to run before or after cloud runner jobs, must
+      '[Orchestrator] Specify the names (by file name) of custom steps to run before or after orchestrator jobs, must
       match a yaml step file inside your repo in the folder .game-ci/steps/'
   customHookFiles:
     required: false
     default: ''
     description:
-      '[CloudRunner] Specify the names (by file name) of custom hooks to run before or after cloud runner jobs, must
+      '[Orchestrator] Specify the names (by file name) of custom hooks to run before or after orchestrator jobs, must
       match a yaml step file inside your repo in the folder .game-ci/hooks/'
   customCommandHooks:
     required: false
     default: ''
-    description: '[CloudRunner] Specify custom commands and trigger hooks (injects commands into jobs)'
+    description: '[Orchestrator] Specify custom commands and trigger hooks (injects commands into jobs)'
   customJob:
     required: false
     default: ''
     description:
-      '[CloudRunner] Run a custom job instead of the standard build automation for cloud runner (in yaml format with the
+      '[Orchestrator] Run a custom job instead of the standard build automation for orchestrator (in yaml format with the
       keys image, secrets (name, value object array), command line string)'
   awsStackName:
     default: 'game-ci'
     required: false
-    description: '[CloudRunner] The Cloud Formation stack name that must be setup before using this option.'
+    description: '[Orchestrator] The Cloud Formation stack name that must be setup before using this option.'
   providerStrategy:
     default: 'local'
     required: false
     description:
-      '[CloudRunner] Either local, k8s or aws can be used to run builds on a remote cluster. Additional parameters must
+      '[Orchestrator] Either local, k8s or aws can be used to run builds on a remote cluster. Additional parameters must
       be configured.'
+  resourceTracking:
+    default: 'false'
+    required: false
+    description: '[Orchestrator] Enable resource tracking logs for disk usage and allocation summaries.'
   containerCpu:
     default: ''
     required: false
-    description: '[CloudRunner] Amount of CPU time to assign the remote build container'
+    description: '[Orchestrator] Amount of CPU time to assign the remote build container'
   containerMemory:
     default: ''
     required: false
-    description: '[CloudRunner] Amount of memory to assign the remote build container'
+    description: '[Orchestrator] Amount of memory to assign the remote build container'
   readInputFromOverrideList:
     default: ''
     required: false
-    description: '[CloudRunner] Comma separated list of input value names to read from "input override command"'
+    description: '[Orchestrator] Comma separated list of input value names to read from "input override command"'
   readInputOverrideCommand:
     default: ''
     required: false
     description:
-      '[CloudRunner] Extend game ci by specifying a command to execute to pull input from external source e.g cloud
+      '[Orchestrator] Extend game ci by specifying a command to execute to pull input from external source e.g cloud
       provider secret managers'
   kubeConfig:
     default: ''
     required: false
     description:
-      '[CloudRunner] Supply a base64 encoded kubernetes config to run builds on kubernetes and stream logs until
+      '[Orchestrator] Supply a base64 encoded kubernetes config to run builds on kubernetes and stream logs until
       completion.'
   kubeVolume:
     default: ''
     required: false
-    description: '[CloudRunner] Supply a Persistent Volume Claim name to use for the Unity build.'
+    description: '[Orchestrator] Supply a Persistent Volume Claim name to use for the Unity build.'
   kubeStorageClass:
     default: ''
     required: false
     description:
-      '[CloudRunner] Kubernetes storage class to use for cloud runner jobs, leave empty to install rook cluster.'
+      '[Orchestrator] Kubernetes storage class to use for orchestrator jobs, leave empty to install rook cluster.'
   kubeVolumeSize:
     default: '5Gi'
     required: false
-    description: '[CloudRunner] Amount of disc space to assign the Kubernetes Persistent Volume'
+    description: '[Orchestrator] Amount of disc space to assign the Kubernetes Persistent Volume'
   cacheKey:
     default: ''
     required: false
-    description: '[CloudRunner] Cache key to indicate bucket for cache'
+    description: '[Orchestrator] Cache key to indicate bucket for cache'
   watchToEnd:
     default: 'true'
     required: false
     description:
-      '[CloudRunner] Whether or not to watch the build to the end. Can be used for especially long running jobs e.g
+      '[Orchestrator] Whether or not to watch the build to the end. Can be used for especially long running jobs e.g
       imports or self-hosted ephemeral runners.'
   cacheUnityInstallationOnMac:
     default: 'false'
@@ -265,6 +269,16 @@ inputs:
     default: 'false'
     required: false
     description: 'Skip the activation/deactivation of Unity. This assumes Unity is already activated.'
+  cloneDepth:
+    default: '50'
+    required: false
+    description: '[Orchestrator] Specifies the depth of the git clone for the repository. Use 0 for full clone.'
+  orchestratorRepoName:
+    default: 'game-ci/unity-builder'
+    required: false
+    description:
+      '[Orchestrator] Specifies the repo for the unity builder. Useful if you forked the repo for testing, features, or
+      fixes.'
 
 outputs:
   volume:

dist/default-build-script/Assets/Editor/UnityBuilderAction/Builder.cs

@@ -66,10 +66,6 @@ namespace UnityBuilderAction
         var buildProfile = AssetDatabase.LoadAssetAtPath<BuildProfile>(buildProfilePath)
                            ?? throw new Exception("Build profile file not found at path: " + buildProfilePath);
 
-#if !BUILD_PROFILE_LOADED
-        throw new Exception("Build profile's define symbol not present before script execution; shouldn't happen");
-#endif // BUILD_PROFILE_LOADED
-
         // no need to set active profile, as already set by `-activeBuildProfile` CLI argument
         // BuildProfile.SetActiveBuildProfile(buildProfile);
         Debug.Log($"build profile: {buildProfile.name}");

dist/licenses.txt

@@ -13750,210 +13750,6 @@ Apache License
    See the License for the specific language governing permissions and
    limitations under the License.
 
-@smithy/util-body-length-browser
-Apache-2.0
-Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2018-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-
-   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.
-
 @smithy/util-body-length-node
 Apache-2.0
 Apache License
@@ -19616,6 +19412,33 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 
+shell-quote
+MIT
+The MIT License
+
+Copyright (c) 2013 James Halliday (mail@substack.net)
+
+Permission is hereby granted, free of charge, 
+to any person obtaining a copy of this software and 
+associated documentation files (the "Software"), to 
+deal in the Software without restriction, including 
+without limitation the rights to use, copy, modify, 
+merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom 
+the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice 
+shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 shelljs
 BSD-3-Clause
 Copyright (c) 2012, Artur Adib <arturadib@gmail.com>

install.ps1

@@ -0,0 +1,122 @@
+# game-ci CLI installer for Windows
+# Usage: irm https://raw.githubusercontent.com/game-ci/unity-builder/main/install.ps1 | iex
+#
+# Environment variables:
+#   GAME_CI_VERSION   - Install a specific version (e.g., v2.0.0). Defaults to latest.
+#   GAME_CI_INSTALL   - Installation directory. Defaults to $HOME\.game-ci\bin.
+
+$ErrorActionPreference = 'Stop'
+
+$Repo = "game-ci/unity-builder"
+$InstallDir = if ($env:GAME_CI_INSTALL) { $env:GAME_CI_INSTALL } else { Join-Path $env:USERPROFILE ".game-ci\bin" }
+$AssetName = "game-ci-windows-x64.exe"
+$BinaryName = "game-ci.exe"
+
+function Write-Info($Message) {
+    Write-Host "info: " -ForegroundColor Green -NoNewline
+    Write-Host $Message
+}
+
+function Write-Warn($Message) {
+    Write-Host "warn: " -ForegroundColor Yellow -NoNewline
+    Write-Host $Message
+}
+
+# Determine version
+if ($env:GAME_CI_VERSION) {
+    $Version = $env:GAME_CI_VERSION
+    Write-Info "Using specified version: $Version"
+} else {
+    Write-Info "Fetching latest release..."
+    try {
+        $Release = Invoke-RestMethod "https://api.github.com/repos/$Repo/releases/latest"
+        $Version = $Release.tag_name
+    } catch {
+        Write-Host "error: Could not determine latest version. Check https://github.com/$Repo/releases" -ForegroundColor Red
+        exit 1
+    }
+}
+
+$DownloadUrl = "https://github.com/$Repo/releases/download/$Version/$AssetName"
+$ChecksumUrl = "https://github.com/$Repo/releases/download/$Version/checksums.txt"
+$BinaryPath = Join-Path $InstallDir $BinaryName
+
+Write-Host ""
+Write-Info "Installing game-ci $Version (windows-x64)"
+Write-Info "  from: $DownloadUrl"
+Write-Info "  to:   $BinaryPath"
+Write-Host ""
+
+# Create install directory
+if (-not (Test-Path $InstallDir)) {
+    New-Item -ItemType Directory -Force -Path $InstallDir | Out-Null
+}
+
+# Download binary
+try {
+    Invoke-WebRequest -Uri $DownloadUrl -OutFile $BinaryPath -UseBasicParsing
+} catch {
+    if ($_.Exception.Response.StatusCode -eq 404) {
+        Write-Host "error: Release asset not found: $AssetName ($Version)" -ForegroundColor Red
+        Write-Host "       Check available assets at https://github.com/$Repo/releases/tag/$Version" -ForegroundColor Red
+    } else {
+        Write-Host "error: Download failed: $_" -ForegroundColor Red
+    }
+    exit 1
+}
+
+# Verify checksum
+try {
+    $Checksums = Invoke-WebRequest -Uri $ChecksumUrl -UseBasicParsing | Select-Object -ExpandProperty Content
+    $ExpectedLine = $Checksums -split "`n" | Where-Object { $_ -match $AssetName } | Select-Object -First 1
+    if ($ExpectedLine) {
+        $ExpectedHash = ($ExpectedLine -split '\s+')[0]
+        $ActualHash = (Get-FileHash -Path $BinaryPath -Algorithm SHA256).Hash.ToLower()
+        if ($ExpectedHash -eq $ActualHash) {
+            Write-Info "Checksum verified (SHA256)"
+        } else {
+            Write-Host "error: Checksum verification failed!" -ForegroundColor Red
+            Write-Host "  Expected: $ExpectedHash" -ForegroundColor Red
+            Write-Host "  Got:      $ActualHash" -ForegroundColor Red
+            Remove-Item $BinaryPath -Force
+            exit 1
+        }
+    }
+} catch {
+    # Checksums not available for this release; continue without verification
+}
+
+# Verify the binary works
+try {
+    $VersionOutput = & $BinaryPath version 2>&1
+    Write-Info "Verified: $($VersionOutput | Select-Object -First 1)"
+} catch {
+    Write-Warn "Binary downloaded but could not verify. It may still work."
+}
+
+Write-Host ""
+Write-Host "game-ci installed successfully!" -ForegroundColor Green -BackgroundColor Black
+Write-Host ""
+
+# Check PATH and offer to add
+$UserPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+if ($UserPath -notlike "*$InstallDir*") {
+    Write-Warn "game-ci is not in your PATH."
+    Write-Host ""
+    Write-Host "To add it permanently, run:" -ForegroundColor Yellow
+    Write-Host ""
+    Write-Host "  [Environment]::SetEnvironmentVariable('PATH', ""$InstallDir;"" + [Environment]::GetEnvironmentVariable('PATH', 'User'), 'User')"
+    Write-Host ""
+    Write-Info "Then restart your terminal."
+
+    # Offer to add automatically
+    Write-Host ""
+    $AddToPath = Read-Host "Add to PATH now? (Y/n)"
+    if ($AddToPath -ne 'n' -and $AddToPath -ne 'N') {
+        [Environment]::SetEnvironmentVariable('PATH', "$InstallDir;$UserPath", 'User')
+        $env:PATH = "$InstallDir;$env:PATH"
+        Write-Info "Added to PATH. You can now run: game-ci --help"
+    }
+} else {
+    Write-Info "game-ci is already in your PATH. Run: game-ci --help"
+}

install.sh

@@ -0,0 +1,196 @@
+#!/bin/sh
+# game-ci CLI installer
+# Usage: curl -fsSL https://raw.githubusercontent.com/game-ci/unity-builder/main/install.sh | sh
+#
+# Environment variables:
+#   GAME_CI_VERSION   - Install a specific version (e.g., v2.0.0). Defaults to latest.
+#   GAME_CI_INSTALL   - Installation directory. Defaults to ~/.game-ci/bin.
+
+set -e
+
+REPO="game-ci/unity-builder"
+INSTALL_DIR="${GAME_CI_INSTALL:-$HOME/.game-ci/bin}"
+BINARY_NAME="game-ci"
+
+# Colors (disabled if not a terminal)
+if [ -t 1 ]; then
+  BOLD='\033[1m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[0;33m'
+  RED='\033[0;31m'
+  RESET='\033[0m'
+else
+  BOLD=''
+  GREEN=''
+  YELLOW=''
+  RED=''
+  RESET=''
+fi
+
+info() {
+  printf "${GREEN}info${RESET}: %s\n" "$1"
+}
+
+warn() {
+  printf "${YELLOW}warn${RESET}: %s\n" "$1"
+}
+
+error() {
+  printf "${RED}error${RESET}: %s\n" "$1" >&2
+  exit 1
+}
+
+# Detect OS and architecture
+detect_platform() {
+  OS="$(uname -s)"
+  ARCH="$(uname -m)"
+
+  case "$OS" in
+    Linux*)  PLATFORM="linux" ;;
+    Darwin*) PLATFORM="macos" ;;
+    MINGW*|MSYS*|CYGWIN*)
+      PLATFORM="windows"
+      warn "For Windows, consider using install.ps1 instead:"
+      warn "  irm https://raw.githubusercontent.com/game-ci/unity-builder/main/install.ps1 | iex"
+      ;;
+    *) error "Unsupported operating system: $OS" ;;
+  esac
+
+  case "$ARCH" in
+    x86_64|amd64)  ARCH="x64" ;;
+    aarch64|arm64) ARCH="arm64" ;;
+    *) error "Unsupported architecture: $ARCH" ;;
+  esac
+
+  ASSET_NAME="game-ci-${PLATFORM}-${ARCH}"
+  if [ "$PLATFORM" = "windows" ]; then
+    ASSET_NAME="${ASSET_NAME}.exe"
+    BINARY_NAME="game-ci.exe"
+  fi
+}
+
+# Get latest release tag from GitHub API
+get_latest_version() {
+  if [ -n "$GAME_CI_VERSION" ]; then
+    VERSION="$GAME_CI_VERSION"
+    info "Using specified version: $VERSION"
+    return
+  fi
+
+  info "Fetching latest release..."
+
+  if command -v curl > /dev/null 2>&1; then
+    VERSION=$(curl -fsSL "https://api.github.com/repos/${REPO}/releases/latest" | grep '"tag_name"' | sed -E 's/.*"([^"]+)".*/\1/')
+  elif command -v wget > /dev/null 2>&1; then
+    VERSION=$(wget -qO- "https://api.github.com/repos/${REPO}/releases/latest" | grep '"tag_name"' | sed -E 's/.*"([^"]+)".*/\1/')
+  else
+    error "Neither curl nor wget found. Please install one of them."
+  fi
+
+  if [ -z "$VERSION" ]; then
+    error "Could not determine latest version. Check https://github.com/${REPO}/releases"
+  fi
+}
+
+# Download and install the binary
+install() {
+  DOWNLOAD_URL="https://github.com/${REPO}/releases/download/${VERSION}/${ASSET_NAME}"
+
+  printf "\n"
+  info "Installing game-ci ${VERSION} (${PLATFORM}-${ARCH})"
+  info "  from: ${DOWNLOAD_URL}"
+  info "  to:   ${INSTALL_DIR}/${BINARY_NAME}"
+  printf "\n"
+
+  mkdir -p "$INSTALL_DIR"
+
+  # Download with progress
+  if command -v curl > /dev/null 2>&1; then
+    HTTP_CODE=$(curl -fSL "$DOWNLOAD_URL" -o "${INSTALL_DIR}/${BINARY_NAME}" -w "%{http_code}" 2>/dev/null) || true
+    if [ "$HTTP_CODE" = "404" ]; then
+      error "Release asset not found: ${ASSET_NAME} (${VERSION}). Check available assets at https://github.com/${REPO}/releases/tag/${VERSION}"
+    elif [ ! -f "${INSTALL_DIR}/${BINARY_NAME}" ]; then
+      error "Download failed. URL: ${DOWNLOAD_URL}"
+    fi
+  elif command -v wget > /dev/null 2>&1; then
+    wget -q "$DOWNLOAD_URL" -O "${INSTALL_DIR}/${BINARY_NAME}" || error "Download failed. URL: ${DOWNLOAD_URL}"
+  fi
+
+  chmod +x "${INSTALL_DIR}/${BINARY_NAME}"
+
+  # Verify the binary works
+  if "${INSTALL_DIR}/${BINARY_NAME}" version > /dev/null 2>&1; then
+    INSTALLED_VERSION=$("${INSTALL_DIR}/${BINARY_NAME}" version 2>&1 | head -1)
+    info "Verified: ${INSTALLED_VERSION}"
+  else
+    warn "Binary downloaded but could not verify. It may still work."
+  fi
+
+  printf "\n"
+  printf "${BOLD}game-ci installed successfully!${RESET}\n"
+  printf "\n"
+
+  # Check if install dir is in PATH
+  case ":$PATH:" in
+    *":${INSTALL_DIR}:"*)
+      info "game-ci is already in your PATH. Run: game-ci --help"
+      ;;
+    *)
+      SHELL_NAME=$(basename "$SHELL" 2>/dev/null || echo "sh")
+      case "$SHELL_NAME" in
+        zsh)  PROFILE="~/.zshrc" ;;
+        bash) PROFILE="~/.bashrc" ;;
+        fish) PROFILE="~/.config/fish/config.fish" ;;
+        *)    PROFILE="~/.profile" ;;
+      esac
+
+      printf "${YELLOW}Add game-ci to your PATH by adding this to ${PROFILE}:${RESET}\n"
+      printf "\n"
+      if [ "$SHELL_NAME" = "fish" ]; then
+        printf "  set -gx PATH \"%s\" \$PATH\n" "$INSTALL_DIR"
+      else
+        printf "  export PATH=\"%s:\$PATH\"\n" "$INSTALL_DIR"
+      fi
+      printf "\n"
+      info "Then restart your shell or run: source ${PROFILE}"
+      ;;
+  esac
+}
+
+# Verify checksum if checksums.txt is available
+verify_checksum() {
+  if ! command -v sha256sum > /dev/null 2>&1; then
+    return 0
+  fi
+
+  CHECKSUM_URL="https://github.com/${REPO}/releases/download/${VERSION}/checksums.txt"
+
+  CHECKSUMS=""
+  if command -v curl > /dev/null 2>&1; then
+    CHECKSUMS=$(curl -fsSL "$CHECKSUM_URL" 2>/dev/null) || return 0
+  elif command -v wget > /dev/null 2>&1; then
+    CHECKSUMS=$(wget -qO- "$CHECKSUM_URL" 2>/dev/null) || return 0
+  fi
+
+  if [ -z "$CHECKSUMS" ]; then
+    return 0
+  fi
+
+  EXPECTED=$(echo "$CHECKSUMS" | grep "$ASSET_NAME" | awk '{print $1}')
+  if [ -z "$EXPECTED" ]; then
+    return 0
+  fi
+
+  ACTUAL=$(sha256sum "${INSTALL_DIR}/${BINARY_NAME}" | awk '{print $1}')
+  if [ "$EXPECTED" != "$ACTUAL" ]; then
+    error "Checksum verification failed!\n  Expected: ${EXPECTED}\n  Got:      ${ACTUAL}"
+  fi
+
+  info "Checksum verified (SHA256)"
+}
+
+# Main
+detect_platform
+get_latest_version
+install
+verify_checksum

jest.ci.config.js

@@ -0,0 +1,11 @@
+const base = require('./jest.config.js');
+
+module.exports = {
+  ...base,
+  forceExit: true,
+  detectOpenHandles: true,
+  testTimeout: 120000,
+  maxWorkers: 1,
+};
+
+

jest.config.js

@@ -25,8 +25,6 @@ module.exports = {
   // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
   modulePathIgnorePatterns: ['<rootDir>/lib/', '<rootDir>/dist/'],
 
-  // Files that will be run before Jest is loaded to set globals like fetch
-  setupFiles: ['<rootDir>/src/jest.globals.ts'],
-  // A list of paths to modules that run some code to configure or set up the testing framework after the environment is ready
-  setupFilesAfterEnv: ['<rootDir>/src/jest.setup.ts'],
+  // Use jest.setup.js to polyfill fetch for all tests
+  setupFiles: ['<rootDir>/jest.setup.js'],
 };

jest.setup.js

@@ -0,0 +1,2 @@
+const fetch = require('node-fetch');
+global.fetch = fetch;

package.json

@@ -3,6 +3,24 @@
   "version": "3.0.0",
   "description": "Build Unity projects for different platforms.",
   "main": "dist/index.js",
+  "bin": {
+    "game-ci": "./lib/cli.js"
+  },
+  "pkg": {
+    "scripts": "lib/**/*.js",
+    "assets": [
+      "lib/**/*.json",
+      "package.json"
+    ],
+    "targets": [
+      "node20-linux-x64",
+      "node20-linux-arm64",
+      "node20-macos-x64",
+      "node20-macos-arm64",
+      "node20-win-x64"
+    ],
+    "outputPath": "dist-binaries"
+  },
   "repository": "git@github.com:game-ci/unity-builder.git",
   "author": "Webber <webber@takken.io>",
   "license": "MIT",
@@ -12,17 +30,19 @@
     "lint": "prettier --check \"src/**/*.{js,ts}\" && eslint src/**/*.ts",
     "format": "prettier --write \"src/**/*.{js,ts}\"",
     "cli": "yarn ts-node src/index.ts -m cli",
-    "gcp-secrets-tests": "cross-env providerStrategy=aws cloudRunnerTests=true inputPullCommand=\"gcp-secret-manager\" populateOverride=true pullInputList=UNITY_EMAIL,UNITY_SERIAL,UNITY_PASSWORD yarn test -i -t \"cloud runner\"",
-    "gcp-secrets-cli": "cross-env cloudRunnerTests=true USE_IL2CPP=false inputPullCommand=\"gcp-secret-manager\" yarn ts-node src/index.ts -m cli --populateOverride true --pullInputList UNITY_EMAIL,UNITY_SERIAL,UNITY_PASSWORD",
-    "aws-secrets-cli": "cross-env cloudRunnerTests=true inputPullCommand=\"aws-secret-manager\" yarn ts-node src/index.ts -m cli --populateOverride true --pullInputList UNITY_EMAIL,UNITY_SERIAL,UNITY_PASSWORD",
+    "game-ci": "ts-node src/cli.ts",
+    "gcp-secrets-tests": "cross-env providerStrategy=aws orchestratorTests=true inputPullCommand=\"gcp-secret-manager\" populateOverride=true pullInputList=UNITY_EMAIL,UNITY_SERIAL,UNITY_PASSWORD yarn test -i -t \"orchestrator\"",
+    "gcp-secrets-cli": "cross-env orchestratorTests=true USE_IL2CPP=false inputPullCommand=\"gcp-secret-manager\" yarn ts-node src/index.ts -m cli --populateOverride true --pullInputList UNITY_EMAIL,UNITY_SERIAL,UNITY_PASSWORD",
+    "aws-secrets-cli": "cross-env orchestratorTests=true inputPullCommand=\"aws-secret-manager\" yarn ts-node src/index.ts -m cli --populateOverride true --pullInputList UNITY_EMAIL,UNITY_SERIAL,UNITY_PASSWORD",
     "cli-aws": "cross-env providerStrategy=aws yarn run test-cli",
     "cli-k8s": "cross-env providerStrategy=k8s yarn run test-cli",
-    "test-cli": "cross-env cloudRunnerTests=true yarn ts-node src/index.ts -m cli --projectPath test-project",
+    "test-cli": "cross-env orchestratorTests=true yarn ts-node src/index.ts -m cli --projectPath test-project",
     "test": "jest",
-    "test-i": "cross-env cloudRunnerTests=true yarn test -i -t \"cloud runner\"",
+    "test:ci": "jest --config=jest.ci.config.js --runInBand",
+    "test-i": "cross-env orchestratorTests=true yarn test -i -t \"orchestrator\"",
     "test-i-*": "yarn run test-i-aws && yarn run test-i-k8s",
-    "test-i-aws": "cross-env cloudRunnerTests=true providerStrategy=aws yarn test -i -t \"cloud runner\"",
-    "test-i-k8s": "cross-env cloudRunnerTests=true providerStrategy=k8s yarn test -i -t \"cloud runner\""
+    "test-i-aws": "cross-env orchestratorTests=true providerStrategy=aws yarn test -i -t \"orchestrator\"",
+    "test-i-k8s": "cross-env orchestratorTests=true providerStrategy=k8s yarn test -i -t \"orchestrator\""
   },
   "engines": {
     "node": ">=18.x"
@@ -49,10 +69,12 @@
     "nanoid": "^3.3.1",
     "reflect-metadata": "^0.1.13",
     "semver": "^7.5.2",
+    "shell-quote": "^1.8.3",
     "ts-md5": "^1.3.1",
     "unity-changeset": "^3.1.0",
     "uuid": "^9.0.0",
-    "yaml": "^2.2.2"
+    "yaml": "^2.2.2",
+    "yargs": "^17.7.2"
   },
   "devDependencies": {
     "@types/base-64": "^1.0.0",
@@ -60,6 +82,7 @@
     "@types/node": "^17.0.23",
     "@types/semver": "^7.3.9",
     "@types/uuid": "^9.0.0",
+    "@types/yargs": "^17.0.35",
     "@typescript-eslint/parser": "4.8.1",
     "@vercel/ncc": "^0.36.1",
     "cross-env": "^7.0.3",
@@ -74,6 +97,8 @@
     "jest-fail-on-console": "^3.0.2",
     "js-yaml": "^4.1.0",
     "lefthook": "^1.6.1",
+    "node-fetch": "2",
+    "pkg": "^5.8.1",
     "prettier": "^2.5.1",
     "ts-jest": "^27.1.3",
     "ts-node": "10.8.1",

src/cli.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+import yargs from 'yargs';
+// eslint-disable-next-line import/no-unresolved
+import { hideBin } from 'yargs/helpers';
+import buildCommand from './cli/commands/build';
+import testCommand from './cli/commands/test';
+import orchestrateCommand from './cli/commands/orchestrate';
+import activateCommand from './cli/commands/activate';
+import statusCommand from './cli/commands/status';
+import versionCommand from './cli/commands/version';
+import updateCommand from './cli/commands/update';
+import * as core from '@actions/core';
+
+const cli = yargs(hideBin(process.argv))
+  .scriptName('game-ci')
+  .usage('$0 <command> [options]')
+  .command(buildCommand)
+  .command(testCommand)
+  .command(orchestrateCommand)
+  .command(activateCommand)
+  .command(statusCommand)
+  .command(versionCommand)
+  .command(updateCommand)
+  .demandCommand(1, 'You must specify a command. Run game-ci --help for available commands.')
+  .strict()
+  .alias('h', 'help')
+  .epilogue('For more information, visit https://game.ci')
+  .wrap(Math.min(120, process.stdout.columns || 80));
+
+async function main() {
+  try {
+    await cli.parse();
+  } catch (error: any) {
+    if (error.name !== 'YError') {
+      core.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+main();

src/cli/__tests__/cli-integration.test.ts

@@ -0,0 +1,135 @@
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+
+/**
+ * Integration tests that spawn the CLI as a child process and verify
+ * exit codes and output. Uses node with --require ts-node/register to
+ * run the TypeScript entry point directly so no build step is required.
+ */
+
+const CLI_ENTRY = path.resolve(__dirname, '..', '..', 'cli.ts');
+
+function runCli(cliArguments: string[]): Promise<{ code: number | null; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    execFile(
+      process.execPath,
+      ['--require', 'ts-node/register/transpile-only', CLI_ENTRY, ...cliArguments],
+      { timeout: 30_000, cwd: path.resolve(__dirname, '..', '..', '..') },
+      (error, stdout, stderr) => {
+        resolve({
+          code: error ? error.code ?? 1 : 0,
+          stdout: stdout.toString(),
+          stderr: stderr.toString(),
+        });
+      },
+    );
+  });
+}
+
+// Integration tests spawn child processes which need more time than the default 5s
+jest.setTimeout(30_000);
+
+describe('CLI integration', () => {
+  it('exits 0 and shows all commands for --help', async () => {
+    const result = await runCli(['--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('game-ci');
+    expect(result.stdout).toContain('build');
+    expect(result.stdout).toContain('test');
+    expect(result.stdout).toContain('orchestrate');
+    expect(result.stdout).toContain('activate');
+    expect(result.stdout).toContain('status');
+    expect(result.stdout).toContain('version');
+    expect(result.stdout).toContain('update');
+  });
+
+  it('exits 0 and shows version info for version command', async () => {
+    const result = await runCli(['version']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('unity-builder');
+  });
+
+  it('exits 0 and shows build flags for build --help', async () => {
+    const result = await runCli(['build', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('--target-platform');
+    expect(result.stdout).toContain('--unity-version');
+    expect(result.stdout).toContain('--project-path');
+    expect(result.stdout).toContain('--build-name');
+    expect(result.stdout).toContain('--builds-path');
+    expect(result.stdout).toContain('--build-method');
+    expect(result.stdout).toContain('--custom-parameters');
+    expect(result.stdout).toContain('--versioning');
+  });
+
+  it('exits 0 and shows test flags for test --help', async () => {
+    const result = await runCli(['test', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('--target-platform');
+    expect(result.stdout).toContain('--test-mode');
+    expect(result.stdout).toContain('--test-results-path');
+    expect(result.stdout).toContain('--enable-code-coverage');
+  });
+
+  it('exits 0 for test alias t --help', async () => {
+    const result = await runCli(['t', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('--test-mode');
+  });
+
+  it('exits non-zero for an unknown command', async () => {
+    const result = await runCli(['nonexistent']);
+
+    expect(result.code).not.toStrictEqual(0);
+  });
+
+  it('exits non-zero when no command is provided', async () => {
+    const result = await runCli([]);
+
+    expect(result.code).not.toStrictEqual(0);
+  });
+
+  it('exits 0 for orchestrate --help', async () => {
+    const result = await runCli(['orchestrate', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('--target-platform');
+    expect(result.stdout).toContain('--provider-strategy');
+  });
+
+  it('exits 0 for orchestrate alias o --help', async () => {
+    const result = await runCli(['o', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('--provider-strategy');
+  });
+
+  it('exits 0 for activate --help', async () => {
+    const result = await runCli(['activate', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('activate');
+  });
+
+  it('exits 0 for status --help', async () => {
+    const result = await runCli(['status', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('status');
+    expect(result.stdout).toContain('--cache-dir');
+  });
+
+  it('exits 0 for update --help', async () => {
+    const result = await runCli(['update', '--help']);
+
+    expect(result.code).toStrictEqual(0);
+    expect(result.stdout).toContain('update');
+    expect(result.stdout).toContain('--force');
+    expect(result.stdout).toContain('--version');
+  });
+});

src/cli/__tests__/commands.test.ts

@@ -0,0 +1,312 @@
+import buildCommand from '../commands/build';
+import testCommand from '../commands/test';
+import activateCommand from '../commands/activate';
+import orchestrateCommand from '../commands/orchestrate';
+import statusCommand from '../commands/status';
+import versionCommand from '../commands/version';
+import updateCommand from '../commands/update';
+
+function createFakeYargs(): { yargs: any; options: Record<string, any> } {
+  const options: Record<string, any> = {};
+  const yargs: any = {
+    option: jest.fn(),
+    positional: jest.fn(),
+    example: jest.fn(),
+    env: jest.fn(),
+  };
+
+  yargs.option.mockImplementation((name: string, config: any) => {
+    options[name] = config;
+
+    return yargs;
+  });
+  yargs.positional.mockImplementation((name: string, config: any) => {
+    options[name] = config;
+
+    return yargs;
+  });
+  yargs.example.mockReturnValue(yargs);
+  yargs.env.mockReturnValue(yargs);
+
+  return { yargs, options };
+}
+
+describe('CLI commands', () => {
+  describe('build command', () => {
+    it('exports the correct command name', () => {
+      expect(buildCommand.command).toStrictEqual('build');
+    });
+
+    it('has a description', () => {
+      expect(buildCommand.describe).toBeTruthy();
+    });
+
+    it('has a builder function', () => {
+      expect(typeof buildCommand.builder).toStrictEqual('function');
+    });
+
+    it('has a handler function', () => {
+      expect(typeof buildCommand.handler).toStrictEqual('function');
+    });
+
+    it('defines all expected build flags via builder', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (buildCommand.builder as Function)(yargs);
+
+      // Core build flags (from shared + build-specific)
+      expect(options['target-platform']).toBeDefined();
+      expect(options['target-platform'].demandOption).toStrictEqual(true);
+      expect(options['unity-version']).toBeDefined();
+      expect(options['project-path']).toBeDefined();
+      expect(options['build-profile']).toBeDefined();
+      expect(options['build-name']).toBeDefined();
+      expect(options['builds-path']).toBeDefined();
+      expect(options['build-method']).toBeDefined();
+      expect(options['custom-parameters']).toBeDefined();
+      expect(options['versioning']).toBeDefined();
+      expect(options['version']).toBeDefined();
+      expect(options['custom-image']).toBeDefined();
+      expect(options['manual-exit']).toBeDefined();
+      expect(options['enable-gpu']).toBeDefined();
+
+      // Android flags
+      expect(options['android-version-code']).toBeDefined();
+      expect(options['android-export-type']).toBeDefined();
+      expect(options['android-keystore-name']).toBeDefined();
+      expect(options['android-keystore-base64']).toBeDefined();
+      expect(options['android-keystore-pass']).toBeDefined();
+      expect(options['android-keyalias-name']).toBeDefined();
+      expect(options['android-keyalias-pass']).toBeDefined();
+      expect(options['android-target-sdk-version']).toBeDefined();
+      expect(options['android-symbol-type']).toBeDefined();
+
+      // Docker flags
+      expect(options['docker-cpu-limit']).toBeDefined();
+      expect(options['docker-memory-limit']).toBeDefined();
+      expect(options['docker-workspace-path']).toBeDefined();
+      expect(options['run-as-host-user']).toBeDefined();
+      expect(options['chown-files-to']).toBeDefined();
+
+      // Build should NOT have orchestrator-specific flags
+      expect(options['provider-strategy']).toBeUndefined();
+      expect(options['aws-stack-name']).toBeUndefined();
+      expect(options['kube-config']).toBeUndefined();
+    });
+
+    it('sets correct default values', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (buildCommand.builder as Function)(yargs);
+
+      expect(options['unity-version'].default).toStrictEqual('auto');
+      expect(options['project-path'].default).toStrictEqual('.');
+      expect(options['builds-path'].default).toStrictEqual('build');
+      expect(options['versioning'].default).toStrictEqual('Semantic');
+      expect(options['manual-exit'].default).toStrictEqual(false);
+      expect(options['enable-gpu'].default).toStrictEqual(false);
+      expect(options['android-export-type'].default).toStrictEqual('androidPackage');
+      expect(options['android-symbol-type'].default).toStrictEqual('none');
+    });
+
+    it('provides camelCase aliases for kebab-case options', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (buildCommand.builder as Function)(yargs);
+
+      expect(options['target-platform'].alias).toStrictEqual('targetPlatform');
+      expect(options['unity-version'].alias).toStrictEqual('unityVersion');
+      expect(options['project-path'].alias).toStrictEqual('projectPath');
+      expect(options['build-name'].alias).toStrictEqual('buildName');
+      expect(options['builds-path'].alias).toStrictEqual('buildsPath');
+      expect(options['build-method'].alias).toStrictEqual('buildMethod');
+    });
+  });
+
+  describe('test command', () => {
+    it('exports command with alias', () => {
+      expect(testCommand.command).toStrictEqual(['test', 't']);
+    });
+
+    it('has a description', () => {
+      expect(testCommand.describe).toBeTruthy();
+    });
+
+    it('has a builder function', () => {
+      expect(typeof testCommand.builder).toStrictEqual('function');
+    });
+
+    it('has a handler function', () => {
+      expect(typeof testCommand.handler).toStrictEqual('function');
+    });
+
+    it('defines test-specific flags', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (testCommand.builder as Function)(yargs);
+
+      expect(options['test-mode']).toBeDefined();
+      expect(options['test-mode'].default).toStrictEqual('All');
+      expect(options['test-mode'].choices).toStrictEqual(['EditMode', 'PlayMode', 'All']);
+      expect(options['test-results-path']).toBeDefined();
+      expect(options['test-category']).toBeDefined();
+      expect(options['test-filter']).toBeDefined();
+      expect(options['enable-code-coverage']).toBeDefined();
+      expect(options['coverage-options']).toBeDefined();
+    });
+
+    it('includes shared project options', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (testCommand.builder as Function)(yargs);
+
+      expect(options['target-platform']).toBeDefined();
+      expect(options['target-platform'].demandOption).toStrictEqual(true);
+      expect(options['unity-version']).toBeDefined();
+      expect(options['project-path']).toBeDefined();
+      expect(options['custom-image']).toBeDefined();
+    });
+
+    it('includes docker options but not orchestrator options', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (testCommand.builder as Function)(yargs);
+
+      expect(options['docker-cpu-limit']).toBeDefined();
+      expect(options['docker-memory-limit']).toBeDefined();
+      expect(options['provider-strategy']).toBeUndefined();
+      expect(options['aws-stack-name']).toBeUndefined();
+    });
+  });
+
+  describe('activate command', () => {
+    it('exports the correct command name', () => {
+      expect(activateCommand.command).toStrictEqual('activate');
+    });
+
+    it('has a description', () => {
+      expect(activateCommand.describe).toBeTruthy();
+    });
+
+    it('has a builder function', () => {
+      expect(typeof activateCommand.builder).toStrictEqual('function');
+    });
+
+    it('has a handler function', () => {
+      expect(typeof activateCommand.handler).toStrictEqual('function');
+    });
+  });
+
+  describe('orchestrate command', () => {
+    it('exports command with alias', () => {
+      expect(orchestrateCommand.command).toStrictEqual(['orchestrate', 'o']);
+    });
+
+    it('has a description', () => {
+      expect(orchestrateCommand.describe).toBeTruthy();
+    });
+
+    it('has a builder function', () => {
+      expect(typeof orchestrateCommand.builder).toStrictEqual('function');
+    });
+
+    it('has a handler function', () => {
+      expect(typeof orchestrateCommand.handler).toStrictEqual('function');
+    });
+
+    it('defines key orchestrator flags', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (orchestrateCommand.builder as Function)(yargs);
+
+      expect(options['target-platform']).toBeDefined();
+      expect(options['target-platform'].demandOption).toStrictEqual(true);
+      expect(options['provider-strategy']).toBeDefined();
+      expect(options['provider-strategy'].default).toStrictEqual('aws');
+      expect(options['aws-stack-name']).toBeDefined();
+      expect(options['kube-config']).toBeDefined();
+      expect(options['kube-volume']).toBeDefined();
+      expect(options['cache-key']).toBeDefined();
+      expect(options['watch-to-end']).toBeDefined();
+      expect(options['clone-depth']).toBeDefined();
+    });
+
+    it('does not include build-only options', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (orchestrateCommand.builder as Function)(yargs);
+
+      expect(options['build-profile']).toBeUndefined();
+      expect(options['manual-exit']).toBeUndefined();
+      expect(options['enable-gpu']).toBeUndefined();
+      expect(options['android-version-code']).toBeUndefined();
+    });
+  });
+
+  describe('status command', () => {
+    it('exports the correct command name', () => {
+      expect(statusCommand.command).toStrictEqual('status');
+    });
+
+    it('has a description', () => {
+      expect(statusCommand.describe).toBeTruthy();
+    });
+
+    it('has a handler function', () => {
+      expect(typeof statusCommand.handler).toStrictEqual('function');
+    });
+
+    it('includes cache-dir option', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (statusCommand.builder as Function)(yargs);
+
+      expect(options['cache-dir']).toBeDefined();
+      expect(options['project-path']).toBeDefined();
+    });
+  });
+
+  describe('version command', () => {
+    it('exports the correct command name', () => {
+      expect(versionCommand.command).toStrictEqual('version');
+    });
+
+    it('has a description', () => {
+      expect(versionCommand.describe).toBeTruthy();
+    });
+
+    it('has a handler function', () => {
+      expect(typeof versionCommand.handler).toStrictEqual('function');
+    });
+  });
+
+  describe('update command', () => {
+    it('exports the correct command name', () => {
+      expect(updateCommand.command).toStrictEqual('update');
+    });
+
+    it('has a description', () => {
+      expect(updateCommand.describe).toBeTruthy();
+    });
+
+    it('has a builder function', () => {
+      expect(typeof updateCommand.builder).toStrictEqual('function');
+    });
+
+    it('has a handler function', () => {
+      expect(typeof updateCommand.handler).toStrictEqual('function');
+    });
+
+    it('defines force and version flags', () => {
+      const { yargs, options } = createFakeYargs();
+
+      (updateCommand.builder as Function)(yargs);
+
+      expect(options['force']).toBeDefined();
+      expect(options['force'].type).toStrictEqual('boolean');
+      expect(options['force'].default).toStrictEqual(false);
+      expect(options['version']).toBeDefined();
+      expect(options['version'].type).toStrictEqual('string');
+    });
+  });
+});

src/cli/__tests__/input-mapper.test.ts

@@ -0,0 +1,221 @@
+import { mapCliArgumentsToInput, CliArguments } from '../input-mapper';
+import { Cli } from '../../model/cli/cli';
+import GitHub from '../../model/github';
+
+afterEach(() => {
+  jest.restoreAllMocks();
+  Cli.options = undefined;
+});
+
+describe('mapCliArgumentsToInput', () => {
+  describe('basic mapping', () => {
+    it('populates Cli.options from CLI arguments', () => {
+      const cliArguments: CliArguments = {
+        targetPlatform: 'StandaloneLinux64',
+        unityVersion: '2022.3.56f1',
+        projectPath: './my-project',
+      };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options).toBeDefined();
+      expect(Cli.options!['targetPlatform']).toStrictEqual('StandaloneLinux64');
+      expect(Cli.options!['unityVersion']).toStrictEqual('2022.3.56f1');
+      expect(Cli.options!['projectPath']).toStrictEqual('./my-project');
+    });
+
+    it('disables GitHub Actions input reading', () => {
+      const cliArguments: CliArguments = { targetPlatform: 'WebGL' };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(GitHub.githubInputEnabled).toStrictEqual(false);
+    });
+
+    it('sets mode to cli by default when not provided', () => {
+      const cliArguments: CliArguments = { targetPlatform: 'Android' };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['mode']).toStrictEqual('cli');
+    });
+
+    it('preserves an explicitly provided mode', () => {
+      const cliArguments: CliArguments = { targetPlatform: 'Android', mode: 'custom-mode' };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['mode']).toStrictEqual('custom-mode');
+    });
+  });
+
+  describe('default values', () => {
+    it('omits undefined values from Cli.options', () => {
+      const cliArguments: CliArguments = {
+        targetPlatform: 'StandaloneLinux64',
+        unityVersion: undefined,
+        buildName: undefined,
+      };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['targetPlatform']).toStrictEqual('StandaloneLinux64');
+      expect(Cli.options!).not.toHaveProperty('unityVersion');
+      expect(Cli.options!).not.toHaveProperty('buildName');
+    });
+  });
+
+  describe('boolean conversion', () => {
+    it('converts boolean true to string "true"', () => {
+      const cliArguments: CliArguments = { manualExit: true };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['manualExit']).toStrictEqual('true');
+    });
+
+    it('converts boolean false to string "false"', () => {
+      const cliArguments: CliArguments = { enableGpu: false };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['enableGpu']).toStrictEqual('false');
+    });
+
+    it('converts allowDirtyBuild boolean to string', () => {
+      const cliArguments: CliArguments = { allowDirtyBuild: true };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['allowDirtyBuild']).toStrictEqual('true');
+    });
+  });
+
+  describe('yargs internal properties', () => {
+    it('filters out yargs _ property', () => {
+      const cliArguments: CliArguments = {
+        targetPlatform: 'iOS',
+        _: ['build'] as any,
+      };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!).not.toHaveProperty('_');
+    });
+
+    it('filters out yargs $0 property', () => {
+      const cliArguments: CliArguments = {
+        targetPlatform: 'iOS',
+        $0: 'game-ci' as any,
+      };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!).not.toHaveProperty('$0');
+    });
+  });
+
+  describe('flag name conversion', () => {
+    it('passes camelCase keys through directly', () => {
+      const cliArguments: CliArguments = {
+        androidKeystoreName: 'my.keystore',
+        androidKeystorePass: 'secret',
+        dockerCpuLimit: '4',
+        dockerMemoryLimit: '8g',
+      };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['androidKeystoreName']).toStrictEqual('my.keystore');
+      expect(Cli.options!['androidKeystorePass']).toStrictEqual('secret');
+      expect(Cli.options!['dockerCpuLimit']).toStrictEqual('4');
+      expect(Cli.options!['dockerMemoryLimit']).toStrictEqual('8g');
+    });
+
+    it('maps all android-related arguments', () => {
+      const cliArguments: CliArguments = {
+        androidVersionCode: '42',
+        androidExportType: 'androidAppBundle',
+        androidKeystoreBase64: 'base64data',
+        androidKeyaliasName: 'myalias',
+        androidKeyaliasPass: 'aliaspass',
+        androidTargetSdkVersion: '33',
+        androidSymbolType: 'public',
+      };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['androidVersionCode']).toStrictEqual('42');
+      expect(Cli.options!['androidExportType']).toStrictEqual('androidAppBundle');
+      expect(Cli.options!['androidKeystoreBase64']).toStrictEqual('base64data');
+      expect(Cli.options!['androidKeyaliasName']).toStrictEqual('myalias');
+      expect(Cli.options!['androidKeyaliasPass']).toStrictEqual('aliaspass');
+      expect(Cli.options!['androidTargetSdkVersion']).toStrictEqual('33');
+      expect(Cli.options!['androidSymbolType']).toStrictEqual('public');
+    });
+
+    it('maps docker and container arguments', () => {
+      const cliArguments: CliArguments = {
+        dockerIsolationMode: 'hyperv',
+        dockerWorkspacePath: '/custom/workspace',
+        containerRegistryRepository: 'custom/editor',
+        containerRegistryImageVersion: '5',
+        runAsHostUser: 'true',
+        chownFilesTo: 'root:root',
+      };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['dockerIsolationMode']).toStrictEqual('hyperv');
+      expect(Cli.options!['dockerWorkspacePath']).toStrictEqual('/custom/workspace');
+      expect(Cli.options!['containerRegistryRepository']).toStrictEqual('custom/editor');
+      expect(Cli.options!['containerRegistryImageVersion']).toStrictEqual('5');
+      expect(Cli.options!['runAsHostUser']).toStrictEqual('true');
+      expect(Cli.options!['chownFilesTo']).toStrictEqual('root:root');
+    });
+
+    it('maps orchestrator-related arguments', () => {
+      const cliArguments: CliArguments = {
+        providerStrategy: 'k8s',
+        awsStackName: 'my-stack',
+        kubeConfig: 'base64config',
+        kubeVolume: 'my-pvc',
+        kubeVolumeSize: '10Gi',
+        kubeStorageClass: 'gp3',
+        containerCpu: '2048',
+        containerMemory: '4096',
+        cacheKey: 'my-cache',
+        watchToEnd: 'false',
+        cloneDepth: '100',
+      };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.options!['providerStrategy']).toStrictEqual('k8s');
+      expect(Cli.options!['awsStackName']).toStrictEqual('my-stack');
+      expect(Cli.options!['kubeConfig']).toStrictEqual('base64config');
+      expect(Cli.options!['kubeVolume']).toStrictEqual('my-pvc');
+      expect(Cli.options!['kubeVolumeSize']).toStrictEqual('10Gi');
+      expect(Cli.options!['kubeStorageClass']).toStrictEqual('gp3');
+      expect(Cli.options!['containerCpu']).toStrictEqual('2048');
+      expect(Cli.options!['containerMemory']).toStrictEqual('4096');
+      expect(Cli.options!['cacheKey']).toStrictEqual('my-cache');
+      expect(Cli.options!['watchToEnd']).toStrictEqual('false');
+      expect(Cli.options!['cloneDepth']).toStrictEqual('100');
+    });
+  });
+
+  describe('Cli.isCliMode integration', () => {
+    it('enables CLI mode after mapping', () => {
+      const cliArguments: CliArguments = { targetPlatform: 'WebGL' };
+
+      mapCliArgumentsToInput(cliArguments);
+
+      expect(Cli.isCliMode).toStrictEqual(true);
+    });
+
+    it('is not in CLI mode before mapping', () => {
+      expect(Cli.isCliMode).toStrictEqual(false);
+    });
+  });
+});

src/cli/commands/activate.ts

@@ -0,0 +1,83 @@
+import type { CommandModule } from 'yargs';
+import * as core from '@actions/core';
+import { mapCliArgumentsToInput, CliArguments } from '../input-mapper';
+
+interface ActivateArguments extends CliArguments {
+  unityVersion?: string;
+  unitySerial?: string;
+  unityLicensingServer?: string;
+}
+
+const activateCommand: CommandModule<object, ActivateArguments> = {
+  command: 'activate',
+  describe: 'Verify Unity license configuration',
+  builder: (yargs) => {
+    return yargs
+      .option('unity-version', {
+        alias: 'unityVersion',
+        type: 'string',
+        description: 'Version of Unity to activate',
+        default: 'auto',
+      })
+      .option('unity-licensing-server', {
+        alias: 'unityLicensingServer',
+        type: 'string',
+        description: 'The Unity licensing server address for floating licenses',
+        default: '',
+      })
+      .env('UNITY')
+      .example(
+        'UNITY_SERIAL=XXXX-XXXX-XXXX-XXXX game-ci activate',
+        'Activate Unity using a serial from environment variable',
+      )
+      .example(
+        'game-ci activate --unity-licensing-server http://license-server:8080',
+        'Activate Unity using a floating license server',
+      ) as any;
+  },
+  handler: async (cliArguments) => {
+    try {
+      mapCliArgumentsToInput(cliArguments);
+
+      const unitySerial = process.env.UNITY_SERIAL;
+      const unityLicense = process.env.UNITY_LICENSE;
+      const licensingServer = cliArguments.unityLicensingServer || process.env.UNITY_LICENSING_SERVER || '';
+
+      if (licensingServer) {
+        core.info(`Activating Unity via licensing server: ${licensingServer}`);
+        core.info('Floating license activation is handled automatically during builds.');
+        core.info('No manual activation step is needed when using a licensing server.');
+
+        return;
+      }
+
+      if (!unitySerial && !unityLicense) {
+        throw new Error(
+          'No Unity license found.\n\n' +
+            'Provide one of the following:\n' +
+            '  - UNITY_SERIAL environment variable (professional license)\n' +
+            '  - UNITY_LICENSE environment variable (personal license file content)\n' +
+            '  - --unity-licensing-server flag (floating license)\n\n' +
+            'For more information, visit: https://game.ci/docs/github/activation',
+        );
+      }
+
+      if (unitySerial) {
+        const maskedSerial = unitySerial.length > 8 ? `${unitySerial.slice(0, 4)}...${unitySerial.slice(-4)}` : '****';
+        core.info(`Unity serial detected: ${maskedSerial}`);
+        core.info('License will be activated automatically when running a build.');
+      } else if (unityLicense) {
+        core.info('Unity license file detected from UNITY_LICENSE environment variable.');
+        core.info('License will be activated automatically when running a build.');
+      }
+
+      core.info('\nActivation verified. You can now run: game-ci build --target-platform <platform>');
+    } catch (error: any) {
+      core.setFailed(`Activation failed: ${error.message}`);
+
+      throw error;
+    }
+  },
+};
+
+export default activateCommand;

src/cli/commands/build.ts

@@ -0,0 +1,108 @@
+import type { CommandModule } from 'yargs';
+import * as core from '@actions/core';
+import { BuildParameters, ImageTag } from '../../model';
+import { mapCliArgumentsToInput, CliArguments } from '../input-mapper';
+import MacBuilder from '../../model/mac-builder';
+import Docker from '../../model/docker';
+import Action from '../../model/action';
+import PlatformSetup from '../../model/platform-setup';
+import { withProjectOptions, withDockerOptions, withAndroidOptions } from './shared-options';
+
+interface BuildArguments extends CliArguments {
+  targetPlatform: string;
+}
+
+const buildCommand: CommandModule<object, BuildArguments> = {
+  command: 'build',
+  describe: 'Build a Unity project locally via Docker or native runner',
+  builder: (yargs) => {
+    let y = withProjectOptions(yargs);
+    y = withAndroidOptions(y);
+    y = withDockerOptions(y);
+
+    return y
+      .option('build-profile', {
+        alias: 'buildProfile',
+        type: 'string',
+        description: 'Path to the build profile to activate, relative to the project root',
+        default: '',
+      })
+      .option('versioning', {
+        type: 'string',
+        description: 'The versioning scheme to use when building the project',
+        default: 'Semantic',
+      })
+      .option('version', {
+        type: 'string',
+        description: 'The version, when used with the "Custom" versioning scheme',
+        default: '',
+      })
+      .option('manual-exit', {
+        alias: 'manualExit',
+        type: 'boolean',
+        description: 'Suppresses -quit. Exit your build method using EditorApplication.Exit(0) instead.',
+        default: false,
+      })
+      .option('enable-gpu', {
+        alias: 'enableGpu',
+        type: 'boolean',
+        description: 'Launches unity without specifying -nographics',
+        default: false,
+      })
+      .option('cache-unity-installation-on-mac', {
+        alias: 'cacheUnityInstallationOnMac',
+        type: 'boolean',
+        description: 'Whether to cache the Unity hub and editor installation on MacOS',
+        default: false,
+      })
+      .option('unity-hub-version-on-mac', {
+        alias: 'unityHubVersionOnMac',
+        type: 'string',
+        description: 'The version of Unity Hub to install on MacOS (e.g. 3.4.0). Defaults to latest available on brew.',
+        default: '',
+      })
+      .example('game-ci build --target-platform StandaloneLinux64', 'Build for Linux using auto-detected Unity version')
+      .example(
+        'game-ci build --target-platform Android --unity-version 2022.3.56f1 --build-method MyBuild.Run',
+        'Build for Android with a specific Unity version and build method',
+      ) as any;
+  },
+  handler: async (cliArguments) => {
+    try {
+      mapCliArgumentsToInput(cliArguments);
+
+      const buildParameters = await BuildParameters.create();
+      const baseImage = new ImageTag(buildParameters);
+
+      core.info(`Building locally for ${buildParameters.targetPlatform}...`);
+      core.info(`Unity version: ${buildParameters.editorVersion}`);
+      core.info(`Project path: ${buildParameters.projectPath}`);
+
+      const actionFolder = Action.actionFolder;
+      await PlatformSetup.setup(buildParameters, actionFolder);
+
+      const exitCode =
+        process.platform === 'darwin'
+          ? await MacBuilder.run(actionFolder)
+          : await Docker.run(baseImage.toString(), {
+              workspace: process.cwd(),
+              actionFolder,
+              ...buildParameters,
+            });
+
+      core.info(`\nBuild completed with exit code: ${exitCode}`);
+      core.info(`Build version: ${buildParameters.buildVersion}`);
+      core.info(`Build path: ${buildParameters.buildPath}`);
+
+      if (exitCode !== 0) {
+        throw new Error(`Build failed with exit code ${exitCode}`);
+      }
+    } catch (error: any) {
+      core.setFailed(`Build failed: ${error.message}`);
+
+      throw error;
+    }
+  },
+};
+
+export default buildCommand;

src/cli/commands/orchestrate.ts

@@ -0,0 +1,62 @@
+import type { CommandModule } from 'yargs';
+import * as core from '@actions/core';
+import { BuildParameters, ImageTag, Orchestrator } from '../../model';
+import { mapCliArgumentsToInput, CliArguments } from '../input-mapper';
+import { withProjectOptions, withOrchestratorOptions } from './shared-options';
+
+interface OrchestrateArguments extends CliArguments {
+  targetPlatform: string;
+  providerStrategy?: string;
+}
+
+const orchestrateCommand: CommandModule<object, OrchestrateArguments> = {
+  command: ['orchestrate', 'o'],
+  describe: 'Run a build via orchestrator providers (AWS, Kubernetes, etc.)',
+  builder: (yargs) => {
+    let y = withProjectOptions(yargs);
+    y = withOrchestratorOptions(y);
+
+    return y
+      .option('versioning', {
+        type: 'string',
+        description: 'The versioning scheme to use',
+        default: 'None',
+      })
+      .example(
+        'game-ci orchestrate --target-platform StandaloneLinux64 --provider-strategy aws',
+        'Build on AWS using the orchestrator',
+      )
+      .example(
+        'game-ci o --target-platform StandaloneLinux64 --provider-strategy k8s --kube-config <base64>',
+        'Build on Kubernetes (short alias)',
+      ) as any;
+  },
+  handler: async (cliArguments) => {
+    try {
+      mapCliArgumentsToInput(cliArguments);
+
+      const buildParameters = await BuildParameters.create();
+      const baseImage = new ImageTag(buildParameters);
+
+      core.info(`Orchestrating build via ${buildParameters.providerStrategy}...`);
+      core.info(`Target platform: ${buildParameters.targetPlatform}`);
+      core.info(`Unity version: ${buildParameters.editorVersion}`);
+      core.info(`Build GUID: ${buildParameters.buildGuid}`);
+
+      const result = await Orchestrator.run(buildParameters, baseImage.toString());
+
+      core.info(`\nOrchestrated build completed.`);
+      if (result?.BuildResults) {
+        core.info(`Results: ${result.BuildResults}`);
+      } else {
+        core.warning('Build completed but no build results were returned.');
+      }
+    } catch (error: any) {
+      core.setFailed(`Orchestrated build failed: ${error.message}`);
+
+      throw error;
+    }
+  },
+};
+
+export default orchestrateCommand;

src/cli/commands/shared-options.ts

@@ -0,0 +1,308 @@
+import type { Argv } from 'yargs';
+
+/**
+ * Shared option groups for CLI commands. Avoids duplicating option
+ * definitions across build, test, and orchestrate commands.
+ */
+
+export function withProjectOptions<T>(yargs: Argv<T>) {
+  return yargs
+    .option('target-platform', {
+      alias: 'targetPlatform',
+      type: 'string' as const,
+      description: 'Platform that the build should target',
+      demandOption: true,
+    })
+    .option('unity-version', {
+      alias: 'unityVersion',
+      type: 'string' as const,
+      description: 'Version of Unity to use. Use "auto" to detect from ProjectVersion.txt.',
+      default: 'auto',
+    })
+    .option('project-path', {
+      alias: 'projectPath',
+      type: 'string' as const,
+      description: 'Path to the Unity project',
+      default: '.',
+    })
+    .option('build-name', {
+      alias: 'buildName',
+      type: 'string' as const,
+      description: 'Name of the build',
+      default: '',
+    })
+    .option('builds-path', {
+      alias: 'buildsPath',
+      type: 'string' as const,
+      description: 'Path where the builds should be stored',
+      default: 'build',
+    })
+    .option('build-method', {
+      alias: 'buildMethod',
+      type: 'string' as const,
+      description: 'Path to a Namespace.Class.StaticMethod to run to perform the build',
+      default: '',
+    })
+    .option('custom-parameters', {
+      alias: 'customParameters',
+      type: 'string' as const,
+      description: 'Custom parameters to configure the build',
+      default: '',
+    })
+    .option('custom-image', {
+      alias: 'customImage',
+      type: 'string' as const,
+      description: 'Specific docker image that should be used for building the project',
+      default: '',
+    })
+    .option('git-private-token', {
+      alias: 'gitPrivateToken',
+      type: 'string' as const,
+      description: 'GitHub private token for repository access',
+      default: '',
+    })
+    .option('skip-activation', {
+      alias: 'skipActivation',
+      type: 'string' as const,
+      description: 'Skip Unity activation/deactivation',
+      default: 'false',
+    })
+    .option('unity-licensing-server', {
+      alias: 'unityLicensingServer',
+      type: 'string' as const,
+      description: 'The Unity licensing server address',
+      default: '',
+    })
+    .option('container-registry-repository', {
+      alias: 'containerRegistryRepository',
+      type: 'string' as const,
+      description: 'Container registry and repository to pull image from. Only applicable if customImage is not set.',
+      default: 'unityci/editor',
+    })
+    .option('container-registry-image-version', {
+      alias: 'containerRegistryImageVersion',
+      type: 'string' as const,
+      description: 'Container registry image version. Only applicable if customImage is not set.',
+      default: '3',
+    });
+}
+
+export function withDockerOptions<T>(yargs: Argv<T>) {
+  return yargs
+    .option('docker-cpu-limit', {
+      alias: 'dockerCpuLimit',
+      type: 'string' as const,
+      description: 'Number of CPU cores to assign the docker container',
+      default: '',
+    })
+    .option('docker-memory-limit', {
+      alias: 'dockerMemoryLimit',
+      type: 'string' as const,
+      description: 'Amount of memory to assign the docker container (e.g. 512m, 4g)',
+      default: '',
+    })
+    .option('docker-workspace-path', {
+      alias: 'dockerWorkspacePath',
+      type: 'string' as const,
+      description: 'The path to mount the workspace inside the docker container',
+      default: '/github/workspace',
+    })
+    .option('docker-isolation-mode', {
+      alias: 'dockerIsolationMode',
+      type: 'string' as const,
+      description:
+        'Isolation mode to use for the docker container (process, hyperv, or default). Only applicable on Windows.',
+      default: 'default',
+    })
+    .option('run-as-host-user', {
+      alias: 'runAsHostUser',
+      type: 'string' as const,
+      description: 'Whether to run as a user that matches the host system',
+      default: 'false',
+    })
+    .option('chown-files-to', {
+      alias: 'chownFilesTo',
+      type: 'string' as const,
+      description: 'User and optionally group to give ownership of build artifacts',
+      default: '',
+    })
+    .option('ssh-agent', {
+      alias: 'sshAgent',
+      type: 'string' as const,
+      description: 'SSH Agent path to forward to the container',
+      default: '',
+    })
+    .option('ssh-public-keys-directory-path', {
+      alias: 'sshPublicKeysDirectoryPath',
+      type: 'string' as const,
+      description: 'Path to a directory containing SSH public keys to forward to the container',
+      default: '',
+    });
+}
+
+export function withAndroidOptions<T>(yargs: Argv<T>) {
+  return yargs
+    .option('android-version-code', {
+      alias: 'androidVersionCode',
+      type: 'string' as const,
+      description: 'The android versionCode',
+      default: '',
+    })
+    .option('android-export-type', {
+      alias: 'androidExportType',
+      type: 'string' as const,
+      description: 'The android export type (androidPackage, androidAppBundle, androidStudioProject)',
+      default: 'androidPackage',
+    })
+    .option('android-keystore-name', {
+      alias: 'androidKeystoreName',
+      type: 'string' as const,
+      description: 'The android keystoreName',
+      default: '',
+    })
+    .option('android-keystore-base64', {
+      alias: 'androidKeystoreBase64',
+      type: 'string' as const,
+      description: 'The base64 contents of the android keystore file',
+      default: '',
+    })
+    .option('android-keystore-pass', {
+      alias: 'androidKeystorePass',
+      type: 'string' as const,
+      description: 'The android keystorePass',
+      default: '',
+    })
+    .option('android-keyalias-name', {
+      alias: 'androidKeyaliasName',
+      type: 'string' as const,
+      description: 'The android keyaliasName',
+      default: '',
+    })
+    .option('android-keyalias-pass', {
+      alias: 'androidKeyaliasPass',
+      type: 'string' as const,
+      description: 'The android keyaliasPass',
+      default: '',
+    })
+    .option('android-target-sdk-version', {
+      alias: 'androidTargetSdkVersion',
+      type: 'string' as const,
+      description: 'The android target API level',
+      default: '',
+    })
+    .option('android-symbol-type', {
+      alias: 'androidSymbolType',
+      type: 'string' as const,
+      description: 'The android symbol type to export (none, public, debugging)',
+      default: 'none',
+    });
+}
+
+export function withOrchestratorOptions<T>(yargs: Argv<T>) {
+  return yargs
+    .option('provider-strategy', {
+      alias: 'providerStrategy',
+      type: 'string' as const,
+      description: 'Orchestrator provider: aws, k8s, local-docker, local-system',
+      default: 'aws',
+    })
+    .option('aws-stack-name', {
+      alias: 'awsStackName',
+      type: 'string' as const,
+      description: 'The Cloud Formation stack name (AWS provider)',
+      default: 'game-ci',
+    })
+    .option('kube-config', {
+      alias: 'kubeConfig',
+      type: 'string' as const,
+      description: 'Base64 encoded Kubernetes config (K8s provider)',
+      default: '',
+    })
+    .option('kube-volume', {
+      alias: 'kubeVolume',
+      type: 'string' as const,
+      description: 'Persistent Volume Claim name for Unity build (K8s provider)',
+      default: '',
+    })
+    .option('kube-volume-size', {
+      alias: 'kubeVolumeSize',
+      type: 'string' as const,
+      description: 'Disc space for Kubernetes Persistent Volume',
+      default: '5Gi',
+    })
+    .option('kube-storage-class', {
+      alias: 'kubeStorageClass',
+      type: 'string' as const,
+      description: 'Kubernetes storage class to use for orchestrator jobs. Leave empty to install rook cluster.',
+      default: '',
+    })
+    .option('container-cpu', {
+      alias: 'containerCpu',
+      type: 'string' as const,
+      description: 'CPU allocation for remote build container',
+      default: '1024',
+    })
+    .option('container-memory', {
+      alias: 'containerMemory',
+      type: 'string' as const,
+      description: 'Memory allocation for remote build container',
+      default: '3072',
+    })
+    .option('cache-key', {
+      alias: 'cacheKey',
+      type: 'string' as const,
+      description: 'Cache key to indicate bucket for cache',
+      default: '',
+    })
+    .option('allow-dirty-build', {
+      alias: 'allowDirtyBuild',
+      type: 'boolean' as const,
+      description: 'Allow builds from dirty branches',
+      default: false,
+    })
+    .option('watch-to-end', {
+      alias: 'watchToEnd',
+      type: 'string' as const,
+      description: 'Whether to watch the build to completion',
+      default: 'true',
+    })
+    .option('clone-depth', {
+      alias: 'cloneDepth',
+      type: 'string' as const,
+      description: 'Git clone depth (0 for full clone)',
+      default: '50',
+    })
+    .option('read-input-from-override-list', {
+      alias: 'readInputFromOverrideList',
+      type: 'string' as const,
+      description: 'Comma separated list of input value names to read from the input override command',
+      default: '',
+    })
+    .option('read-input-override-command', {
+      alias: 'readInputOverrideCommand',
+      type: 'string' as const,
+      description: 'Command to execute to pull input from an external source (e.g. cloud provider secret managers)',
+      default: '',
+    })
+    .option('post-build-steps', {
+      alias: 'postBuildSteps',
+      type: 'string' as const,
+      description:
+        'Post build job in yaml format with the keys image, secrets (name, value object array), command string',
+      default: '',
+    })
+    .option('pre-build-steps', {
+      alias: 'preBuildSteps',
+      type: 'string' as const,
+      description:
+        'Pre build job after repository setup but before the build job (yaml format with keys image, secrets, command)',
+      default: '',
+    })
+    .option('custom-job', {
+      alias: 'customJob',
+      type: 'string' as const,
+      description:
+        'Custom job instead of the standard build automation (yaml format with keys image, secrets, command)',
+      default: '',
+    });
+}

src/cli/commands/status.ts

@@ -0,0 +1,117 @@
+import type { CommandModule } from 'yargs';
+import * as core from '@actions/core';
+import fs from 'node:fs';
+import path from 'node:path';
+import UnityVersioning from '../../model/unity-versioning';
+
+const statusCommand: CommandModule = {
+  command: 'status',
+  describe: 'Show project info, environment, and cache status',
+  builder: (yargs) => {
+    return yargs
+      .option('project-path', {
+        alias: 'projectPath',
+        type: 'string',
+        description: 'Path to the Unity project',
+        default: '.',
+      })
+      .option('cache-dir', {
+        alias: 'cacheDir',
+        type: 'string',
+        description: 'Path to an additional cache directory to inspect',
+        default: '',
+      });
+  },
+  handler: async (cliArguments) => {
+    const projectPath = (cliArguments.projectPath as string) || '.';
+    const cacheDirectory = cliArguments.cacheDir as string;
+
+    core.info('game-ci Workspace Status');
+    core.info('========================\n');
+
+    // Project detection
+    const projectVersionPath = path.join(projectPath, 'ProjectSettings', 'ProjectVersion.txt');
+    const hasProject = fs.existsSync(projectVersionPath);
+
+    core.info(`Project Path: ${path.resolve(projectPath)}`);
+    core.info(`Unity Project Found: ${hasProject ? 'Yes' : 'No'}`);
+
+    if (hasProject) {
+      try {
+        const unityVersion = UnityVersioning.determineUnityVersion(projectPath, 'auto');
+        core.info(`Unity Version: ${unityVersion}`);
+      } catch {
+        core.info(`Unity Version: Unable to detect`);
+      }
+
+      // Library cache status
+      const libraryPath = path.join(projectPath, 'Library');
+      if (fs.existsSync(libraryPath)) {
+        const stats = fs.statSync(libraryPath);
+        core.info(`Library Cache: Present (modified ${stats.mtime.toISOString()})`);
+
+        const keyDirectories = ['PackageCache', 'ScriptAssemblies', 'ShaderCache', 'Bee'];
+        for (const directory of keyDirectories) {
+          const directoryPath = path.join(libraryPath, directory);
+          if (fs.existsSync(directoryPath)) {
+            const directoryStats = fs.statSync(directoryPath);
+            core.info(`  ${directory}/: exists (modified ${directoryStats.mtime.toISOString()})`);
+          }
+        }
+      } else {
+        core.info(`Library Cache: Not present (clean build required)`);
+      }
+
+      // Cache archive detection
+      if (cacheDirectory && fs.existsSync(cacheDirectory)) {
+        core.info(`\nCache Archives (${cacheDirectory}):`);
+        const cacheFiles = fs.readdirSync(cacheDirectory).filter((f) => f.endsWith('.tar') || f.endsWith('.tar.lz4'));
+        if (cacheFiles.length > 0) {
+          for (const file of cacheFiles) {
+            const filePath = path.join(cacheDirectory, file);
+            const fileStats = fs.statSync(filePath);
+            const sizeMegabytes = (fileStats.size / (1024 * 1024)).toFixed(1);
+            core.info(`  - ${file} (${sizeMegabytes} MB, ${fileStats.mtime.toISOString()})`);
+          }
+        } else {
+          core.info('  No cache archives found.');
+        }
+      }
+
+      // Build output detection
+      const buildsPath = path.join(projectPath, '..', 'build');
+      if (fs.existsSync(buildsPath)) {
+        const builds = fs.readdirSync(buildsPath);
+        if (builds.length > 0) {
+          core.info(`\nBuild Outputs (${buildsPath}):`);
+          for (const build of builds) {
+            const buildPath = path.join(buildsPath, build);
+            const buildStats = fs.statSync(buildPath);
+            core.info(`  - ${build} (${buildStats.isDirectory() ? 'dir' : 'file'}, ${buildStats.mtime.toISOString()})`);
+          }
+        }
+      }
+    }
+
+    // Environment
+    core.info('\nEnvironment:');
+    core.info(`  Platform: ${process.platform}`);
+    core.info(`  Node.js: ${process.version}`);
+    core.info(`  UNITY_SERIAL: ${process.env.UNITY_SERIAL ? 'Set' : 'Not set'}`);
+    core.info(`  UNITY_LICENSE: ${process.env.UNITY_LICENSE ? 'Set' : 'Not set'}`);
+    core.info(`  UNITY_EMAIL: ${process.env.UNITY_EMAIL ? 'Set' : 'Not set'}`);
+    core.info(`  UNITY_PASSWORD: ${process.env.UNITY_PASSWORD ? 'Set' : 'Not set'}`);
+
+    // Docker availability
+    core.info(`\nDocker: Checking...`);
+    try {
+      const { execSync } = await import('node:child_process');
+      const dockerVersion = execSync('docker --version', { encoding: 'utf8' }).trim();
+      core.info(`  ${dockerVersion}`);
+    } catch {
+      core.info(`  Docker not found or not accessible`);
+    }
+  },
+};
+
+export default statusCommand;

src/cli/commands/test.ts

@@ -0,0 +1,126 @@
+import type { CommandModule } from 'yargs';
+import * as core from '@actions/core';
+import { BuildParameters, ImageTag } from '../../model';
+import { mapCliArgumentsToInput, CliArguments } from '../input-mapper';
+import Docker from '../../model/docker';
+import Action from '../../model/action';
+import PlatformSetup from '../../model/platform-setup';
+import { withProjectOptions, withDockerOptions } from './shared-options';
+
+interface TestArguments extends CliArguments {
+  targetPlatform: string;
+  testMode?: string;
+}
+
+const testCommand: CommandModule<object, TestArguments> = {
+  command: ['test', 't'],
+  describe: 'Run tests for a Unity project',
+  builder: (yargs) => {
+    let y = withProjectOptions(yargs);
+    y = withDockerOptions(y);
+
+    return y
+      .option('test-mode', {
+        alias: 'testMode',
+        type: 'string',
+        description: 'The mode to run tests in (EditMode, PlayMode, or All)',
+        default: 'All',
+        choices: ['EditMode', 'PlayMode', 'All'],
+      })
+      .option('test-results-path', {
+        alias: 'testResultsPath',
+        type: 'string',
+        description: 'Path where test results XML should be stored',
+        default: 'test-results',
+      })
+      .option('test-category', {
+        alias: 'testCategory',
+        type: 'string',
+        description: 'Only run tests in the given category (semicolon-separated)',
+        default: '',
+      })
+      .option('test-filter', {
+        alias: 'testFilter',
+        type: 'string',
+        description: 'Only run tests that match the filter (semicolon-separated)',
+        default: '',
+      })
+      .option('coverage-options', {
+        alias: 'coverageOptions',
+        type: 'string',
+        description: 'Options for code coverage (e.g. assemblyFilters, pathFilters)',
+        default: '',
+      })
+      .option('enable-code-coverage', {
+        alias: 'enableCodeCoverage',
+        type: 'boolean',
+        description: 'Enable code coverage when running tests',
+        default: false,
+      })
+      .option('versioning', {
+        type: 'string',
+        description: 'The versioning scheme to use',
+        default: 'None',
+      })
+      .option('cache-unity-installation-on-mac', {
+        alias: 'cacheUnityInstallationOnMac',
+        type: 'boolean',
+        description: 'Whether to cache the Unity hub and editor installation on MacOS',
+        default: false,
+      })
+      .option('unity-hub-version-on-mac', {
+        alias: 'unityHubVersionOnMac',
+        type: 'string',
+        description: 'The version of Unity Hub to install on MacOS (e.g. 3.4.0). Defaults to latest available on brew.',
+        default: '',
+      })
+      .example('game-ci test --target-platform StandaloneLinux64', 'Run all tests for Linux platform')
+      .example(
+        'game-ci t --target-platform StandaloneLinux64 --test-mode EditMode',
+        'Run only EditMode tests (short alias)',
+      )
+      .example(
+        'game-ci test --target-platform StandaloneLinux64 --enable-code-coverage',
+        'Run tests with code coverage',
+      ) as any;
+  },
+  handler: async (cliArguments) => {
+    try {
+      // Map test-specific flags into the input system
+      mapCliArgumentsToInput(cliArguments);
+
+      const buildParameters = await BuildParameters.create();
+      const baseImage = new ImageTag(buildParameters);
+
+      const testMode = cliArguments.testMode || 'All';
+
+      core.info(`Running Unity tests (${testMode})...`);
+      core.info(`Target platform: ${buildParameters.targetPlatform}`);
+      core.info(`Unity version: ${buildParameters.editorVersion}`);
+      core.info(`Project path: ${buildParameters.projectPath}`);
+
+      const actionFolder = Action.actionFolder;
+      await PlatformSetup.setup(buildParameters, actionFolder);
+
+      const exitCode = await Docker.run(baseImage.toString(), {
+        workspace: process.cwd(),
+        actionFolder,
+        ...buildParameters,
+      });
+
+      const resultsPath = cliArguments.testResultsPath || 'test-results';
+      core.info(`\nTests completed with exit code: ${exitCode}`);
+      core.info(`Test results: ${resultsPath}`);
+
+      if (exitCode !== 0) {
+        throw new Error(`Tests failed with exit code ${exitCode}`);
+      }
+    } catch (error: any) {
+      core.setFailed(`Tests failed: ${error.message}`);
+
+      throw error;
+    }
+  },
+};
+
+export default testCommand;

src/cli/commands/update.ts

@@ -0,0 +1,387 @@
+import type { CommandModule } from 'yargs';
+import * as core from '@actions/core';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import https from 'node:https';
+import http from 'node:http';
+import { execFileSync } from 'node:child_process';
+
+const REPO = 'game-ci/unity-builder';
+
+interface GitHubRelease {
+  // eslint-disable-next-line camelcase
+  tag_name: string;
+  assets: Array<{
+    name: string;
+    // eslint-disable-next-line camelcase
+    browser_download_url: string;
+    size: number;
+  }>;
+}
+
+interface UpdateArguments {
+  force?: boolean;
+  version?: string;
+}
+
+/**
+ * Fetches JSON from a URL via HTTPS, following redirects.
+ */
+function fetchJson(url: string): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const get = (targetUrl: string, redirectCount: number) => {
+      if (redirectCount > 5) {
+        reject(new Error('Too many redirects'));
+
+        return;
+      }
+      https
+        .get(
+          targetUrl,
+          {
+            headers: { 'User-Agent': 'game-ci-cli', Accept: 'application/json' },
+          },
+          (response) => {
+            if (
+              response.statusCode &&
+              response.statusCode >= 300 &&
+              response.statusCode < 400 &&
+              response.headers.location
+            ) {
+              get(response.headers.location, redirectCount + 1);
+
+              return;
+            }
+            if (response.statusCode !== 200) {
+              reject(new Error(`HTTP ${response.statusCode} from ${targetUrl}`));
+
+              return;
+            }
+            let data = '';
+            response.on('data', (chunk) => (data += chunk));
+            response.on('end', () => {
+              try {
+                resolve(JSON.parse(data));
+              } catch {
+                reject(new Error('Invalid JSON response'));
+              }
+            });
+          },
+        )
+        .on('error', reject);
+    };
+    get(url, 0);
+  });
+}
+
+/**
+ * Downloads a file from a URL, following redirects. Returns the file content as a Buffer.
+ */
+function downloadFile(url: string): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const get = (targetUrl: string, redirectCount: number) => {
+      if (redirectCount > 10) {
+        reject(new Error('Too many redirects'));
+
+        return;
+      }
+
+      const protocol = targetUrl.startsWith('https') ? https : http;
+      protocol
+        .get(targetUrl, { headers: { 'User-Agent': 'game-ci-cli' } }, (response) => {
+          if (
+            response.statusCode &&
+            response.statusCode >= 300 &&
+            response.statusCode < 400 &&
+            response.headers.location
+          ) {
+            get(response.headers.location, redirectCount + 1);
+
+            return;
+          }
+          if (response.statusCode !== 200) {
+            reject(new Error(`HTTP ${response.statusCode} downloading ${targetUrl}`));
+
+            return;
+          }
+          const chunks: Buffer[] = [];
+          response.on('data', (chunk: Buffer) => chunks.push(chunk));
+          response.on('end', () => resolve(Buffer.concat(chunks)));
+        })
+        .on('error', reject);
+    };
+    get(url, 0);
+  });
+}
+
+/**
+ * Gets the current version from package.json or the compiled binary.
+ */
+function getCurrentVersion(): string {
+  // Try reading from package.json at various relative locations
+  const candidates = [
+    path.join(__dirname, '..', '..', '..', 'package.json'),
+    path.join(__dirname, '..', '..', 'package.json'),
+    path.join(process.cwd(), 'package.json'),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      try {
+        const packageData = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+        if (packageData.version) {
+          return packageData.version;
+        }
+      } catch {
+        // Continue to next candidate
+      }
+    }
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Determines the correct asset name for the current platform/architecture.
+ */
+function getAssetName(): string {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  let osPart: string;
+  switch (platform) {
+    case 'linux':
+      osPart = 'linux';
+      break;
+    case 'darwin':
+      osPart = 'macos';
+      break;
+    case 'win32':
+      osPart = 'windows';
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  let archPart: string;
+  switch (arch) {
+    case 'x64':
+      archPart = 'x64';
+      break;
+    case 'arm64':
+      archPart = 'arm64';
+      break;
+    default:
+      throw new Error(`Unsupported architecture: ${arch}`);
+  }
+
+  const assetBaseName = `game-ci-${osPart}-${archPart}`;
+
+  return osPart === 'windows' ? `${assetBaseName}.exe` : assetBaseName;
+}
+
+/**
+ * Determines the path to the currently running executable.
+ * For standalone binaries (pkg), process.execPath points to the binary itself.
+ * For Node.js execution, we return undefined since self-update does not apply.
+ */
+function getExecutablePath(): string | undefined {
+  // When running as a pkg binary, process.pkg is defined
+  if ((process as any).pkg) {
+    return process.execPath;
+  }
+
+  // When running via Node.js, check if there is a standalone binary in the typical install location
+  const installDirectory = process.env.GAME_CI_INSTALL || path.join(os.homedir(), '.game-ci', 'bin');
+  const binaryName = process.platform === 'win32' ? 'game-ci.exe' : 'game-ci';
+  const installedPath = path.join(installDirectory, binaryName);
+
+  if (fs.existsSync(installedPath)) {
+    return installedPath;
+  }
+
+  return;
+}
+
+/**
+ * Strips leading 'v' from a version string and splits into numeric parts.
+ */
+function parseVersionParts(version: string): number[] {
+  return version
+    .replace(/^v/, '')
+    .split('.')
+    .map((part) => Number(part));
+}
+
+/**
+ * Compares two semver strings. Returns:
+ *  -1 if a < b
+ *   0 if a == b
+ *   1 if a > b
+ */
+function compareSemver(a: string, b: string): number {
+  const partsA = parseVersionParts(a);
+  const partsB = parseVersionParts(b);
+
+  for (let index = 0; index < 3; index++) {
+    const x = partsA[index] || 0;
+    const y = partsB[index] || 0;
+    if (x < y) return -1;
+    if (x > y) return 1;
+  }
+
+  return 0;
+}
+
+const updateCommand: CommandModule<object, UpdateArguments> = {
+  command: 'update',
+  describe: 'Update game-ci to the latest version',
+  builder: (yargs) => {
+    return yargs
+      .option('force', {
+        alias: 'f',
+        type: 'boolean',
+        description: 'Force update even if already on latest version',
+        default: false,
+      })
+      .option('version', {
+        type: 'string',
+        description: 'Update to a specific version (e.g., v2.0.0)',
+        default: '',
+      })
+      .example('game-ci update', 'Update to the latest version')
+      .example('game-ci update --version v2.1.0', 'Update to a specific version')
+      .example('game-ci update --force', 'Force reinstall of the current version') as any;
+  },
+  handler: async (cliArguments) => {
+    try {
+      const currentVersion = getCurrentVersion();
+      core.info(`Current version: v${currentVersion}`);
+      core.info(`Platform: ${process.platform} ${process.arch}`);
+      core.info('');
+
+      // Fetch release info
+      let release: GitHubRelease;
+      const targetVersion = cliArguments.version as string;
+
+      if (targetVersion) {
+        const tag = targetVersion.startsWith('v') ? targetVersion : `v${targetVersion}`;
+        core.info(`Fetching release ${tag}...`);
+        release = await fetchJson(`https://api.github.com/repos/${REPO}/releases/tags/${tag}`);
+      } else {
+        core.info('Checking for updates...');
+        release = await fetchJson(`https://api.github.com/repos/${REPO}/releases/latest`);
+      }
+
+      const latestVersion = release.tag_name;
+      core.info(`Latest version:  ${latestVersion}`);
+      core.info('');
+
+      // Compare versions
+      const comparison = compareSemver(currentVersion, latestVersion);
+      if (comparison >= 0 && !cliArguments.force) {
+        core.info('You are already on the latest version. Use --force to reinstall.');
+
+        return;
+      }
+
+      if (comparison > 0 && !targetVersion) {
+        core.info(`Current version (v${currentVersion}) is newer than latest release (${latestVersion}).`);
+        core.info('Use --force to downgrade, or --version to target a specific release.');
+
+        return;
+      }
+
+      // Find the correct asset
+      const assetName = getAssetName();
+      const asset = release.assets.find((a) => a.name === assetName);
+
+      if (!asset) {
+        const available = release.assets.map((a) => a.name).join(', ');
+        throw new Error(
+          `No binary found for ${process.platform}-${process.arch} (looking for ${assetName}).\nAvailable assets: ${available}`,
+        );
+      }
+
+      const sizeMb = (asset.size / (1024 * 1024)).toFixed(1);
+      core.info(`Downloading ${assetName} (${sizeMb} MB)...`);
+
+      // Download the new binary
+      const binaryData = await downloadFile(asset.browser_download_url);
+
+      // Determine where to write the updated binary
+      const executablePath = getExecutablePath();
+
+      if (!executablePath) {
+        core.info('');
+        core.info('game-ci is running via Node.js (not as a standalone binary).');
+        core.info('To update the npm package, run:');
+        core.info('  npm install -g unity-builder@latest');
+        core.info('');
+        core.info('To install the standalone binary instead:');
+        core.info('  curl -fsSL https://raw.githubusercontent.com/game-ci/unity-builder/main/install.sh | sh');
+
+        return;
+      }
+
+      // Write the new binary.
+      // On Windows, we cannot overwrite a running executable directly.
+      // Write to a temporary file, then rename.
+      const temporaryPath = `${executablePath}.update`;
+      const backupPath = `${executablePath}.backup`;
+
+      fs.writeFileSync(temporaryPath, binaryData);
+
+      if (process.platform !== 'win32') {
+        fs.chmodSync(temporaryPath, 0o755);
+      }
+
+      // Verify the downloaded binary
+      try {
+        const output = execFileSync(temporaryPath, ['version'], { encoding: 'utf8', timeout: 10_000 });
+        core.info(`Verified new binary: ${output.trim().split('\n')[0]}`);
+      } catch (verifyError: any) {
+        fs.unlinkSync(temporaryPath);
+        throw new Error(`Downloaded binary failed verification: ${verifyError.message}`);
+      }
+
+      // Replace the current binary
+      try {
+        // Backup current
+        if (fs.existsSync(backupPath)) {
+          fs.unlinkSync(backupPath);
+        }
+        fs.renameSync(executablePath, backupPath);
+        fs.renameSync(temporaryPath, executablePath);
+
+        // Clean up backup
+        try {
+          fs.unlinkSync(backupPath);
+        } catch {
+          // On Windows the backup may be locked; that is fine
+        }
+      } catch (replaceError: any) {
+        // Attempt to restore from backup
+        if (fs.existsSync(backupPath) && !fs.existsSync(executablePath)) {
+          fs.renameSync(backupPath, executablePath);
+        }
+
+        // Clean up temporary file
+        if (fs.existsSync(temporaryPath)) {
+          fs.unlinkSync(temporaryPath);
+        }
+        throw new Error(`Failed to replace binary: ${replaceError.message}`);
+      }
+
+      core.info('');
+      core.info(`Successfully updated game-ci to ${latestVersion}`);
+    } catch (error: any) {
+      core.error(`Update failed: ${error.message}`);
+
+      throw error;
+    }
+  },
+};
+
+export default updateCommand;

src/cli/commands/version.ts

@@ -0,0 +1,37 @@
+import type { CommandModule } from 'yargs';
+import * as core from '@actions/core';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const versionCommand: CommandModule = {
+  command: 'version',
+  describe: 'Show version info',
+  builder: {},
+  handler: async () => {
+    try {
+      // Read version from package.json
+      let packageJsonPath = path.join(__dirname, '..', '..', '..', 'package.json');
+      if (!fs.existsSync(packageJsonPath)) {
+        packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+      }
+      if (!fs.existsSync(packageJsonPath)) {
+        packageJsonPath = path.join(process.cwd(), 'package.json');
+      }
+
+      if (fs.existsSync(packageJsonPath)) {
+        const packageData = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        core.info(`game-ci (unity-builder) v${packageData.version}`);
+        core.info(`Node.js ${process.version}`);
+        core.info(`Platform: ${process.platform} ${process.arch}`);
+      } else {
+        core.info('game-ci (unity-builder)');
+        core.info('Version information unavailable');
+      }
+    } catch (error: any) {
+      core.info('game-ci (unity-builder)');
+      core.error(`Could not read version: ${error.message}`);
+    }
+  },
+};
+
+export default versionCommand;

src/cli/input-mapper.ts

@@ -0,0 +1,113 @@
+import { Cli } from '../model/cli/cli';
+import GitHub from '../model/github';
+
+/**
+ * Maps CLI arguments (kebab-case flags) to the Input/OrchestratorOptions
+ * interface used by the action. This bridges the gap between user-friendly
+ * CLI flags and the camelCase environment/input system unity-builder expects.
+ *
+ * The existing Input class already queries Cli.options, environment variables,
+ * and GitHub Action inputs in priority order. We populate Cli.options so that
+ * the rest of the codebase works unchanged.
+ */
+export interface CliArguments {
+  targetPlatform?: string;
+  unityVersion?: string;
+  projectPath?: string;
+  buildProfile?: string;
+  buildName?: string;
+  buildsPath?: string;
+  buildMethod?: string;
+  customParameters?: string;
+  versioning?: string;
+  version?: string;
+  customImage?: string;
+  manualExit?: boolean;
+  enableGpu?: boolean;
+
+  androidVersionCode?: string;
+  androidExportType?: string;
+  androidKeystoreName?: string;
+  androidKeystoreBase64?: string;
+  androidKeystorePass?: string;
+  androidKeyaliasName?: string;
+  androidKeyaliasPass?: string;
+  androidTargetSdkVersion?: string;
+  androidSymbolType?: string;
+
+  dockerCpuLimit?: string;
+  dockerMemoryLimit?: string;
+  dockerIsolationMode?: string;
+  dockerWorkspacePath?: string;
+  containerRegistryRepository?: string;
+  containerRegistryImageVersion?: string;
+  runAsHostUser?: string;
+  chownFilesTo?: string;
+
+  sshAgent?: string;
+  sshPublicKeysDirectoryPath?: string;
+  gitPrivateToken?: string;
+
+  providerStrategy?: string;
+  awsStackName?: string;
+  kubeConfig?: string;
+  kubeVolume?: string;
+  kubeVolumeSize?: string;
+  kubeStorageClass?: string;
+  containerCpu?: string;
+  containerMemory?: string;
+  cacheKey?: string;
+  watchToEnd?: string;
+  allowDirtyBuild?: boolean;
+  skipActivation?: string;
+  cloneDepth?: string;
+
+  readInputFromOverrideList?: string;
+  readInputOverrideCommand?: string;
+  postBuildSteps?: string;
+  preBuildSteps?: string;
+  customJob?: string;
+
+  unityLicensingServer?: string;
+
+  cacheUnityInstallationOnMac?: boolean;
+  unityHubVersionOnMac?: string;
+
+  testMode?: string;
+  testResultsPath?: string;
+  testCategory?: string;
+  testFilter?: string;
+  coverageOptions?: string;
+  enableCodeCoverage?: boolean;
+
+  mode?: string;
+
+  [key: string]: unknown;
+}
+
+/**
+ * Converts kebab-case CLI flags to camelCase keys matching the Input class
+ * property names, then injects them into Cli.options so the existing
+ * Input.getInput() / OrchestratorOptions.getInput() chain picks them up.
+ */
+export function mapCliArgumentsToInput(cliArguments: CliArguments): void {
+  // Disable GitHub Actions input reading when in CLI mode
+  GitHub.githubInputEnabled = false;
+
+  // The existing Cli.options mechanism is used by Input.getInput() to query
+  // CLI-provided values. We set it directly.
+  const mapped: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(cliArguments)) {
+    if (value !== undefined && key !== '_' && key !== '$0') {
+      mapped[key] = typeof value === 'boolean' ? String(value) : value;
+    }
+  }
+
+  // Ensure mode is set so Cli.isCliMode returns true
+  if (!mapped['mode']) {
+    mapped['mode'] = 'cli';
+  }
+
+  Cli.options = mapped;
+}

src/index.ts

@@ -1,5 +1,5 @@
 import * as core from '@actions/core';
-import { Action, BuildParameters, Cache, CloudRunner, Docker, ImageTag, Output } from './model';
+import { Action, BuildParameters, Cache, Orchestrator, Docker, ImageTag, Output } from './model';
 import { Cli } from './model/cli/cli';
 import MacBuilder from './model/mac-builder';
 import PlatformSetup from './model/platform-setup';
@@ -33,7 +33,7 @@ async function runMain() {
               ...buildParameters,
             });
     } else {
-      await CloudRunner.run(buildParameters, baseImage.toString());
+      await Orchestrator.run(buildParameters, baseImage.toString());
       exitCode = 0;
     }
 

src/integration/orchestrator-github-checks-integration-test.ts

@@ -1,13 +1,13 @@
 // Integration test for exercising real GitHub check creation and updates.
-import CloudRunner from '../model/cloud-runner/cloud-runner';
+import Orchestrator from '../model/orchestrator/orchestrator';
 import UnityVersioning from '../model/unity-versioning';
 import GitHub from '../model/github';
-import { TIMEOUT_INFINITE, createParameters } from '../test-utils/cloud-runner-test-helpers';
+import { TIMEOUT_INFINITE, createParameters } from '../test-utils/orchestrator-test-helpers';
 
 const runIntegration = process.env.RUN_GITHUB_INTEGRATION_TESTS === 'true';
 const describeOrSkip = runIntegration ? describe : describe.skip;
 
-describeOrSkip('Cloud Runner Github Checks Integration', () => {
+describeOrSkip('Orchestrator Github Checks Integration', () => {
   it(
     'creates and updates a real GitHub check',
     async () => {
@@ -15,10 +15,10 @@ describeOrSkip('Cloud Runner Github Checks Integration', () => {
         versioning: 'None',
         projectPath: 'test-project',
         unityVersion: UnityVersioning.read('test-project'),
-        asyncCloudRunner: `true`,
+        asyncOrchestrator: `true`,
         githubChecks: `true`,
       });
-      await CloudRunner.setup(buildParameter);
+      await Orchestrator.setup(buildParameter);
       const checkId = await GitHub.createGitHubCheck(`integration create`);
       expect(checkId).not.toEqual('');
       await GitHub.updateGitHubCheck(`1 ${new Date().toISOString()}`, `integration`);

src/model/build-parameters.ts

@@ -1,7 +1,7 @@
 import { customAlphabet } from 'nanoid';
 import AndroidVersioning from './android-versioning';
-import CloudRunnerConstants from './cloud-runner/options/cloud-runner-constants';
-import CloudRunnerBuildGuid from './cloud-runner/options/cloud-runner-guid';
+import OrchestratorConstants from './orchestrator/options/orchestrator-constants';
+import OrchestratorBuildGuid from './orchestrator/options/orchestrator-guid';
 import Input from './input';
 import Platform from './platform';
 import UnityVersioning from './unity-versioning';
@@ -10,8 +10,8 @@ import { GitRepoReader } from './input-readers/git-repo';
 import { GithubCliReader } from './input-readers/github-cli';
 import { Cli } from './cli/cli';
 import GitHub from './github';
-import CloudRunnerOptions from './cloud-runner/options/cloud-runner-options';
-import CloudRunner from './cloud-runner/cloud-runner';
+import OrchestratorOptions from './orchestrator/options/orchestrator-options';
+import Orchestrator from './orchestrator/orchestrator';
 import * as core from '@actions/core';
 
 class BuildParameters {
@@ -56,9 +56,18 @@ class BuildParameters {
   public providerStrategy!: string;
   public gitPrivateToken!: string;
   public awsStackName!: string;
+  public awsEndpoint?: string;
+  public awsCloudFormationEndpoint?: string;
+  public awsEcsEndpoint?: string;
+  public awsKinesisEndpoint?: string;
+  public awsCloudWatchLogsEndpoint?: string;
+  public awsS3Endpoint?: string;
+  public storageProvider!: string;
+  public rcloneRemote!: string;
   public kubeConfig!: string;
   public containerMemory!: string;
   public containerCpu!: string;
+  public containerNamespace!: string;
   public kubeVolumeSize!: string;
   public kubeVolume!: string;
   public kubeStorageClass!: string;
@@ -75,11 +84,13 @@ class BuildParameters {
   public runNumber!: string;
   public branch!: string;
   public githubRepo!: string;
+  public orchestratorRepoName!: string;
+  public cloneDepth!: number;
   public gitSha!: string;
   public logId!: string;
   public buildGuid!: string;
-  public cloudRunnerBranch!: string;
-  public cloudRunnerDebug!: boolean | undefined;
+  public orchestratorBranch!: string;
+  public orchestratorDebug!: boolean | undefined;
   public buildPlatform!: string | undefined;
   public isCliMode!: boolean;
   public maxRetainedWorkspaces!: number;
@@ -97,7 +108,7 @@ class BuildParameters {
   public dockerWorkspacePath!: string;
 
   public static shouldUseRetainedWorkspaceMode(buildParameters: BuildParameters) {
-    return buildParameters.maxRetainedWorkspaces > 0 && CloudRunner.lockedWorkspace !== ``;
+    return buildParameters.maxRetainedWorkspaces > 0 && Orchestrator.lockedWorkspace !== ``;
   }
 
   static async create(): Promise<BuildParameters> {
@@ -182,41 +193,52 @@ class BuildParameters {
       dockerIsolationMode: Input.dockerIsolationMode,
       containerRegistryRepository: Input.containerRegistryRepository,
       containerRegistryImageVersion: Input.containerRegistryImageVersion,
-      providerStrategy: CloudRunnerOptions.providerStrategy,
-      buildPlatform: CloudRunnerOptions.buildPlatform,
-      kubeConfig: CloudRunnerOptions.kubeConfig,
-      containerMemory: CloudRunnerOptions.containerMemory,
-      containerCpu: CloudRunnerOptions.containerCpu,
-      kubeVolumeSize: CloudRunnerOptions.kubeVolumeSize,
-      kubeVolume: CloudRunnerOptions.kubeVolume,
-      postBuildContainerHooks: CloudRunnerOptions.postBuildContainerHooks,
-      preBuildContainerHooks: CloudRunnerOptions.preBuildContainerHooks,
-      customJob: CloudRunnerOptions.customJob,
+      providerStrategy: OrchestratorOptions.providerStrategy,
+      buildPlatform: OrchestratorOptions.buildPlatform,
+      kubeConfig: OrchestratorOptions.kubeConfig,
+      containerMemory: OrchestratorOptions.containerMemory,
+      containerCpu: OrchestratorOptions.containerCpu,
+      containerNamespace: OrchestratorOptions.containerNamespace,
+      kubeVolumeSize: OrchestratorOptions.kubeVolumeSize,
+      kubeVolume: OrchestratorOptions.kubeVolume,
+      postBuildContainerHooks: OrchestratorOptions.postBuildContainerHooks,
+      preBuildContainerHooks: OrchestratorOptions.preBuildContainerHooks,
+      customJob: OrchestratorOptions.customJob,
       runNumber: Input.runNumber,
       branch: Input.branch.replace('/head', '') || (await GitRepoReader.GetBranch()),
-      cloudRunnerBranch: CloudRunnerOptions.cloudRunnerBranch.split('/').reverse()[0],
-      cloudRunnerDebug: CloudRunnerOptions.cloudRunnerDebug,
-      githubRepo: (Input.githubRepo ?? (await GitRepoReader.GetRemote())) || 'game-ci/unity-builder',
+      orchestratorBranch: OrchestratorOptions.orchestratorBranch.split('/').reverse()[0],
+      orchestratorDebug: OrchestratorOptions.orchestratorDebug,
+      githubRepo: (Input.githubRepo ?? (await GitRepoReader.GetRemote())) || OrchestratorOptions.orchestratorRepoName,
+      orchestratorRepoName: OrchestratorOptions.orchestratorRepoName,
+      cloneDepth: Number.parseInt(OrchestratorOptions.cloneDepth),
       isCliMode: Cli.isCliMode,
-      awsStackName: CloudRunnerOptions.awsStackName,
+      awsStackName: OrchestratorOptions.awsStackName,
+      awsEndpoint: OrchestratorOptions.awsEndpoint,
+      awsCloudFormationEndpoint: OrchestratorOptions.awsCloudFormationEndpoint,
+      awsEcsEndpoint: OrchestratorOptions.awsEcsEndpoint,
+      awsKinesisEndpoint: OrchestratorOptions.awsKinesisEndpoint,
+      awsCloudWatchLogsEndpoint: OrchestratorOptions.awsCloudWatchLogsEndpoint,
+      awsS3Endpoint: OrchestratorOptions.awsS3Endpoint,
+      storageProvider: OrchestratorOptions.storageProvider,
+      rcloneRemote: OrchestratorOptions.rcloneRemote,
       gitSha: Input.gitSha,
-      logId: customAlphabet(CloudRunnerConstants.alphabet, 9)(),
-      buildGuid: CloudRunnerBuildGuid.generateGuid(Input.runNumber, Input.targetPlatform),
-      commandHooks: CloudRunnerOptions.commandHooks,
-      inputPullCommand: CloudRunnerOptions.inputPullCommand,
-      pullInputList: CloudRunnerOptions.pullInputList,
-      kubeStorageClass: CloudRunnerOptions.kubeStorageClass,
-      cacheKey: CloudRunnerOptions.cacheKey,
-      maxRetainedWorkspaces: Number.parseInt(CloudRunnerOptions.maxRetainedWorkspaces),
-      useLargePackages: CloudRunnerOptions.useLargePackages,
-      useCompressionStrategy: CloudRunnerOptions.useCompressionStrategy,
-      garbageMaxAge: CloudRunnerOptions.garbageMaxAge,
-      githubChecks: CloudRunnerOptions.githubChecks,
-      asyncWorkflow: CloudRunnerOptions.asyncCloudRunner,
-      githubCheckId: CloudRunnerOptions.githubCheckId,
-      finalHooks: CloudRunnerOptions.finalHooks,
-      skipLfs: CloudRunnerOptions.skipLfs,
-      skipCache: CloudRunnerOptions.skipCache,
+      logId: customAlphabet(OrchestratorConstants.alphabet, 9)(),
+      buildGuid: OrchestratorBuildGuid.generateGuid(Input.runNumber, Input.targetPlatform),
+      commandHooks: OrchestratorOptions.commandHooks,
+      inputPullCommand: OrchestratorOptions.inputPullCommand,
+      pullInputList: OrchestratorOptions.pullInputList,
+      kubeStorageClass: OrchestratorOptions.kubeStorageClass,
+      cacheKey: OrchestratorOptions.cacheKey,
+      maxRetainedWorkspaces: Number.parseInt(OrchestratorOptions.maxRetainedWorkspaces),
+      useLargePackages: OrchestratorOptions.useLargePackages,
+      useCompressionStrategy: OrchestratorOptions.useCompressionStrategy,
+      garbageMaxAge: OrchestratorOptions.garbageMaxAge,
+      githubChecks: OrchestratorOptions.githubChecks,
+      asyncWorkflow: OrchestratorOptions.asyncOrchestrator,
+      githubCheckId: OrchestratorOptions.githubCheckId,
+      finalHooks: OrchestratorOptions.finalHooks,
+      skipLfs: OrchestratorOptions.skipLfs,
+      skipCache: OrchestratorOptions.skipCache,
       cacheUnityInstallationOnMac: Input.cacheUnityInstallationOnMac,
       unityHubVersionOnMac: Input.unityHubVersionOnMac,
       dockerWorkspacePath: Input.dockerWorkspacePath,

src/model/cli/cli.ts

@@ -1,14 +1,14 @@
 import { Command } from 'commander-ts';
-import { BuildParameters, CloudRunner, ImageTag, Input } from '..';
+import { BuildParameters, Orchestrator, ImageTag, Input } from '..';
 import * as core from '@actions/core';
 import { ActionYamlReader } from '../input-readers/action-yaml';
-import CloudRunnerLogger from '../cloud-runner/services/core/cloud-runner-logger';
-import CloudRunnerQueryOverride from '../cloud-runner/options/cloud-runner-query-override';
+import OrchestratorLogger from '../orchestrator/services/core/orchestrator-logger';
+import OrchestratorQueryOverride from '../orchestrator/options/orchestrator-query-override';
 import { CliFunction, CliFunctionsRepository } from './cli-functions-repository';
-import { Caching } from '../cloud-runner/remote-client/caching';
-import { LfsHashing } from '../cloud-runner/services/utility/lfs-hashing';
-import { RemoteClient } from '../cloud-runner/remote-client';
-import CloudRunnerOptionsReader from '../cloud-runner/options/cloud-runner-options-reader';
+import { Caching } from '../orchestrator/remote-client/caching';
+import { LfsHashing } from '../orchestrator/services/utility/lfs-hashing';
+import { RemoteClient } from '../orchestrator/remote-client';
+import OrchestratorOptionsReader from '../orchestrator/options/orchestrator-options-reader';
 import GitHub from '../github';
 import { OptionValues } from 'commander';
 import { InputKey } from '../input';
@@ -36,7 +36,7 @@ export class Cli {
     const program = new Command();
     program.version('0.0.1');
 
-    const properties = CloudRunnerOptionsReader.GetProperties();
+    const properties = OrchestratorOptionsReader.GetProperties();
     const actionYamlReader: ActionYamlReader = new ActionYamlReader();
     for (const element of properties) {
       program.option(`--${element} <${element}>`, actionYamlReader.GetActionYamlValue(element));
@@ -62,23 +62,23 @@ export class Cli {
   static async RunCli(): Promise<void> {
     GitHub.githubInputEnabled = false;
     if (Cli.options!['populateOverride'] === `true`) {
-      await CloudRunnerQueryOverride.PopulateQueryOverrideInput();
+      await OrchestratorQueryOverride.PopulateQueryOverrideInput();
     }
     if (Cli.options!['logInput']) {
       Cli.logInput();
     }
     const results = CliFunctionsRepository.GetCliFunctions(Cli.options?.mode);
-    CloudRunnerLogger.log(`Entrypoint: ${results.key}`);
+    OrchestratorLogger.log(`Entrypoint: ${results.key}`);
     Cli.options!.versioning = 'None';
 
-    CloudRunner.buildParameters = await BuildParameters.create();
-    CloudRunner.buildParameters.buildGuid = process.env.BUILD_GUID || ``;
-    CloudRunnerLogger.log(`Build Params:
-      ${JSON.stringify(CloudRunner.buildParameters, undefined, 4)}
+    Orchestrator.buildParameters = await BuildParameters.create();
+    Orchestrator.buildParameters.buildGuid = process.env.BUILD_GUID || ``;
+    OrchestratorLogger.log(`Build Params:
+      ${JSON.stringify(Orchestrator.buildParameters, undefined, 4)}
     `);
-    CloudRunner.lockedWorkspace = process.env.LOCKED_WORKSPACE || ``;
-    CloudRunnerLogger.log(`Locked Workspace: ${CloudRunner.lockedWorkspace}`);
-    await CloudRunner.setup(CloudRunner.buildParameters);
+    Orchestrator.lockedWorkspace = process.env.LOCKED_WORKSPACE || ``;
+    OrchestratorLogger.log(`Locked Workspace: ${Orchestrator.lockedWorkspace}`);
+    await Orchestrator.setup(Orchestrator.buildParameters);
 
     return await results.target[results.propertyKey](Cli.options);
   }
@@ -87,7 +87,7 @@ export class Cli {
   private static logInput() {
     core.info(`\n`);
     core.info(`INPUT:`);
-    const properties = CloudRunnerOptionsReader.GetProperties();
+    const properties = OrchestratorOptionsReader.GetProperties();
     for (const element of properties) {
       if (
         element in Input &&
@@ -104,28 +104,28 @@ export class Cli {
     core.info(`\n`);
   }
 
-  @CliFunction(`cli-build`, `runs a cloud runner build`)
+  @CliFunction(`cli-build`, `runs a orchestrator build`)
   public static async CLIBuild(): Promise<string> {
     const buildParameter = await BuildParameters.create();
     const baseImage = new ImageTag(buildParameter);
 
-    return (await CloudRunner.run(buildParameter, baseImage.toString())).BuildResults;
+    return (await Orchestrator.run(buildParameter, baseImage.toString())).BuildResults;
   }
 
-  @CliFunction(`async-workflow`, `runs a cloud runner build`)
+  @CliFunction(`async-workflow`, `runs a orchestrator build`)
   public static async asyncronousWorkflow(): Promise<string> {
     const buildParameter = await BuildParameters.create();
     const baseImage = new ImageTag(buildParameter);
-    await CloudRunner.setup(buildParameter);
+    await Orchestrator.setup(buildParameter);
 
-    return (await CloudRunner.run(buildParameter, baseImage.toString())).BuildResults;
+    return (await Orchestrator.run(buildParameter, baseImage.toString())).BuildResults;
   }
 
-  @CliFunction(`checks-update`, `runs a cloud runner build`)
+  @CliFunction(`checks-update`, `runs a orchestrator build`)
   public static async checksUpdate() {
     const buildParameter = await BuildParameters.create();
 
-    await CloudRunner.setup(buildParameter);
+    await Orchestrator.setup(buildParameter);
     const input = JSON.parse(process.env.CHECKS_UPDATE || ``);
     core.info(`Checks Update ${process.env.CHECKS_UPDATE}`);
     if (input.mode === `create`) {
@@ -139,37 +139,37 @@ export class Cli {
   public static async GarbageCollect(): Promise<string> {
     const buildParameter = await BuildParameters.create();
 
-    await CloudRunner.setup(buildParameter);
+    await Orchestrator.setup(buildParameter);
 
-    return await CloudRunner.Provider.garbageCollect(``, false, 0, false, false);
+    return await Orchestrator.Provider.garbageCollect(``, false, 0, false, false);
   }
 
   @CliFunction(`list-resources`, `lists active resources`)
   public static async ListResources(): Promise<string[]> {
     const buildParameter = await BuildParameters.create();
 
-    await CloudRunner.setup(buildParameter);
-    const result = await CloudRunner.Provider.listResources();
-    CloudRunnerLogger.log(JSON.stringify(result, undefined, 4));
+    await Orchestrator.setup(buildParameter);
+    const result = await Orchestrator.Provider.listResources();
+    OrchestratorLogger.log(JSON.stringify(result, undefined, 4));
 
     return result.map((x) => x.Name);
   }
 
-  @CliFunction(`list-worfklow`, `lists running workflows`)
-  public static async ListWorfklow(): Promise<string[]> {
+  @CliFunction(`list-workflow`, `lists running workflows`)
+  public static async ListWorkflow(): Promise<string[]> {
     const buildParameter = await BuildParameters.create();
 
-    await CloudRunner.setup(buildParameter);
+    await Orchestrator.setup(buildParameter);
 
-    return (await CloudRunner.Provider.listWorkflow()).map((x) => x.Name);
+    return (await Orchestrator.Provider.listWorkflow()).map((x) => x.Name);
   }
 
   @CliFunction(`watch`, `follows logs of a running workflow`)
   public static async Watch(): Promise<string> {
     const buildParameter = await BuildParameters.create();
 
-    await CloudRunner.setup(buildParameter);
+    await Orchestrator.setup(buildParameter);
 
-    return await CloudRunner.Provider.watchWorkflow();
+    return await Orchestrator.Provider.watchWorkflow();
   }
 }

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

@@ -1,187 +0,0 @@
-import AwsBuildPlatform from './providers/aws';
-import { BuildParameters, Input } from '..';
-import Kubernetes from './providers/k8s';
-import CloudRunnerLogger from './services/core/cloud-runner-logger';
-import { CloudRunnerStepParameters } from './options/cloud-runner-step-parameters';
-import { WorkflowCompositionRoot } from './workflows/workflow-composition-root';
-import { CloudRunnerError } from './error/cloud-runner-error';
-import { TaskParameterSerializer } from './services/core/task-parameter-serializer';
-import * as core from '@actions/core';
-import CloudRunnerSecret from './options/cloud-runner-secret';
-import { ProviderInterface } from './providers/provider-interface';
-import CloudRunnerEnvironmentVariable from './options/cloud-runner-environment-variable';
-import TestCloudRunner from './providers/test';
-import LocalCloudRunner from './providers/local';
-import LocalDockerCloudRunner from './providers/docker';
-import GitHub from '../github';
-import SharedWorkspaceLocking from './services/core/shared-workspace-locking';
-import { FollowLogStreamService } from './services/core/follow-log-stream-service';
-import CloudRunnerResult from './services/core/cloud-runner-result';
-
-class CloudRunner {
-  public static Provider: ProviderInterface;
-  public static buildParameters: BuildParameters;
-  private static defaultSecrets: CloudRunnerSecret[];
-  private static cloudRunnerEnvironmentVariables: CloudRunnerEnvironmentVariable[];
-  static lockedWorkspace: string = ``;
-  public static readonly retainedWorkspacePrefix: string = `retained-workspace`;
-  public static get isCloudRunnerEnvironment() {
-    return process.env[`GITHUB_ACTIONS`] !== `true`;
-  }
-  public static get isCloudRunnerAsyncEnvironment() {
-    return process.env[`ASYNC_WORKFLOW`] === `true`;
-  }
-  public static async setup(buildParameters: BuildParameters) {
-    CloudRunnerLogger.setup();
-    CloudRunnerLogger.log(`Setting up cloud runner`);
-    CloudRunner.buildParameters = buildParameters;
-    if (CloudRunner.buildParameters.githubCheckId === ``) {
-      CloudRunner.buildParameters.githubCheckId = await GitHub.createGitHubCheck(CloudRunner.buildParameters.buildGuid);
-    }
-    CloudRunner.setupSelectedBuildPlatform();
-    CloudRunner.defaultSecrets = TaskParameterSerializer.readDefaultSecrets();
-    CloudRunner.cloudRunnerEnvironmentVariables =
-      TaskParameterSerializer.createCloudRunnerEnvironmentVariables(buildParameters);
-    if (GitHub.githubInputEnabled) {
-      const buildParameterPropertyNames = Object.getOwnPropertyNames(buildParameters);
-      for (const element of CloudRunner.cloudRunnerEnvironmentVariables) {
-        // CloudRunnerLogger.log(`Cloud Runner output ${Input.ToEnvVarFormat(element.name)} = ${element.value}`);
-        core.setOutput(Input.ToEnvVarFormat(element.name), element.value);
-      }
-      for (const element of buildParameterPropertyNames) {
-        // CloudRunnerLogger.log(`Cloud Runner output ${Input.ToEnvVarFormat(element)} = ${buildParameters[element]}`);
-        core.setOutput(Input.ToEnvVarFormat(element), buildParameters[element]);
-      }
-      core.setOutput(
-        Input.ToEnvVarFormat(`buildArtifact`),
-        `build-${CloudRunner.buildParameters.buildGuid}.tar${
-          CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
-        }`,
-      );
-    }
-    FollowLogStreamService.Reset();
-  }
-
-  private static setupSelectedBuildPlatform() {
-    CloudRunnerLogger.log(`Cloud Runner platform selected ${CloudRunner.buildParameters.providerStrategy}`);
-    switch (CloudRunner.buildParameters.providerStrategy) {
-      case 'k8s':
-        CloudRunner.Provider = new Kubernetes(CloudRunner.buildParameters);
-        break;
-      case 'aws':
-        CloudRunner.Provider = new AwsBuildPlatform(CloudRunner.buildParameters);
-        break;
-      case 'test':
-        CloudRunner.Provider = new TestCloudRunner();
-        break;
-      case 'local-docker':
-        CloudRunner.Provider = new LocalDockerCloudRunner();
-        break;
-      case 'local-system':
-        CloudRunner.Provider = new LocalCloudRunner();
-        break;
-    }
-  }
-
-  static async run(buildParameters: BuildParameters, baseImage: string) {
-    if (baseImage.includes(`undefined`)) {
-      throw new Error(`baseImage is undefined`);
-    }
-    await CloudRunner.setup(buildParameters);
-    await CloudRunner.Provider.setupWorkflow(
-      CloudRunner.buildParameters.buildGuid,
-      CloudRunner.buildParameters,
-      CloudRunner.buildParameters.branch,
-      CloudRunner.defaultSecrets,
-    );
-    try {
-      if (buildParameters.maxRetainedWorkspaces > 0) {
-        CloudRunner.lockedWorkspace = SharedWorkspaceLocking.NewWorkspaceName();
-
-        const result = await SharedWorkspaceLocking.GetLockedWorkspace(
-          CloudRunner.lockedWorkspace,
-          CloudRunner.buildParameters.buildGuid,
-          CloudRunner.buildParameters,
-        );
-
-        if (result) {
-          CloudRunnerLogger.logLine(`Using retained workspace ${CloudRunner.lockedWorkspace}`);
-          CloudRunner.cloudRunnerEnvironmentVariables = [
-            ...CloudRunner.cloudRunnerEnvironmentVariables,
-            { name: `LOCKED_WORKSPACE`, value: CloudRunner.lockedWorkspace },
-          ];
-        } else {
-          CloudRunnerLogger.log(`Max retained workspaces reached ${buildParameters.maxRetainedWorkspaces}`);
-          buildParameters.maxRetainedWorkspaces = 0;
-          CloudRunner.lockedWorkspace = ``;
-        }
-      }
-      await CloudRunner.updateStatusWithBuildParameters();
-      const output = await new WorkflowCompositionRoot().run(
-        new CloudRunnerStepParameters(
-          baseImage,
-          CloudRunner.cloudRunnerEnvironmentVariables,
-          CloudRunner.defaultSecrets,
-        ),
-      );
-      await CloudRunner.Provider.cleanupWorkflow(
-        CloudRunner.buildParameters,
-        CloudRunner.buildParameters.branch,
-        CloudRunner.defaultSecrets,
-      );
-      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
-      if (buildParameters.asyncWorkflow && this.isCloudRunnerEnvironment && this.isCloudRunnerAsyncEnvironment) {
-        await GitHub.updateGitHubCheck(CloudRunner.buildParameters.buildGuid, `success`, `success`, `completed`);
-      }
-
-      if (BuildParameters.shouldUseRetainedWorkspaceMode(buildParameters)) {
-        const workspace = CloudRunner.lockedWorkspace || ``;
-        await SharedWorkspaceLocking.ReleaseWorkspace(
-          workspace,
-          CloudRunner.buildParameters.buildGuid,
-          CloudRunner.buildParameters,
-        );
-        const isLocked = await SharedWorkspaceLocking.IsWorkspaceLocked(workspace, CloudRunner.buildParameters);
-        if (isLocked) {
-          throw new Error(
-            `still locked after releasing ${await SharedWorkspaceLocking.GetAllLocksForWorkspace(
-              workspace,
-              buildParameters,
-            )}`,
-          );
-        }
-        CloudRunner.lockedWorkspace = ``;
-      }
-
-      await GitHub.triggerWorkflowOnComplete(CloudRunner.buildParameters.finalHooks);
-
-      if (buildParameters.constantGarbageCollection) {
-        CloudRunner.Provider.garbageCollect(``, true, buildParameters.garbageMaxAge, true, true);
-      }
-
-      return new CloudRunnerResult(buildParameters, output, true, true, false);
-    } catch (error: any) {
-      CloudRunnerLogger.log(JSON.stringify(error, undefined, 4));
-      await GitHub.updateGitHubCheck(
-        CloudRunner.buildParameters.buildGuid,
-        `Failed - Error ${error?.message || error}`,
-        `failure`,
-        `completed`,
-      );
-      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
-      await CloudRunnerError.handleException(error, CloudRunner.buildParameters, CloudRunner.defaultSecrets);
-      throw error;
-    }
-  }
-
-  private static async updateStatusWithBuildParameters() {
-    const content = { ...CloudRunner.buildParameters };
-    content.gitPrivateToken = ``;
-    content.unitySerial = ``;
-    content.unityEmail = ``;
-    content.unityPassword = ``;
-    const jsonContent = JSON.stringify(content, undefined, 4);
-    await GitHub.updateGitHubCheck(jsonContent, CloudRunner.buildParameters.buildGuid);
-  }
-}
-export default CloudRunner;

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

@@ -1,15 +0,0 @@
-import CloudRunnerLogger from '../services/core/cloud-runner-logger';
-import * as core from '@actions/core';
-import CloudRunner from '../cloud-runner';
-import CloudRunnerSecret from '../options/cloud-runner-secret';
-import BuildParameters from '../../build-parameters';
-
-export class CloudRunnerError {
-  public static async handleException(error: unknown, buildParameters: BuildParameters, secrets: CloudRunnerSecret[]) {
-    CloudRunnerLogger.error(JSON.stringify(error, undefined, 4));
-    core.setFailed('Cloud Runner failed');
-    if (CloudRunner.Provider !== undefined) {
-      await CloudRunner.Provider.cleanupWorkflow(buildParameters, buildParameters.branch, secrets);
-    }
-  }
-}

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

@@ -1,4 +0,0 @@
-class CloudRunnerConstants {
-  static alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
-}
-export default CloudRunnerConstants;

src/model/cloud-runner/options/cloud-runner-environment-variable.ts

@@ -1,5 +0,0 @@
-class CloudRunnerEnvironmentVariable {
-  public name!: string;
-  public value!: string;
-}
-export default CloudRunnerEnvironmentVariable;

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

@@ -1,90 +0,0 @@
-import path from 'node:path';
-import CloudRunnerOptions from './cloud-runner-options';
-import CloudRunner from '../cloud-runner';
-import BuildParameters from '../../build-parameters';
-
-export class CloudRunnerFolders {
-  public static readonly repositoryFolder = 'repo';
-
-  public static ToLinuxFolder(folder: string) {
-    return folder.replace(/\\/g, `/`);
-  }
-
-  // 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 uniqueCloudRunnerJobFolderAbsolute(): string {
-    return CloudRunner.buildParameters && BuildParameters.shouldUseRetainedWorkspaceMode(CloudRunner.buildParameters)
-      ? path.join(`/`, CloudRunnerFolders.buildVolumeFolder, CloudRunner.lockedWorkspace)
-      : path.join(`/`, CloudRunnerFolders.buildVolumeFolder, CloudRunner.buildParameters.buildGuid);
-  }
-
-  public static get cacheFolderForAllFull(): string {
-    return path.join('/', CloudRunnerFolders.buildVolumeFolder, CloudRunnerFolders.cacheFolder);
-  }
-
-  public static get cacheFolderForCacheKeyFull(): string {
-    return path.join(
-      '/',
-      CloudRunnerFolders.buildVolumeFolder,
-      CloudRunnerFolders.cacheFolder,
-      CloudRunner.buildParameters.cacheKey,
-    );
-  }
-
-  public static get builderPathAbsolute(): string {
-    return path.join(
-      CloudRunnerOptions.useSharedBuilder
-        ? `/${CloudRunnerFolders.buildVolumeFolder}`
-        : CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute,
-      `builder`,
-    );
-  }
-
-  public static get repoPathAbsolute(): string {
-    return path.join(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute, CloudRunnerFolders.repositoryFolder);
-  }
-
-  public static get projectPathAbsolute(): string {
-    return path.join(CloudRunnerFolders.repoPathAbsolute, CloudRunner.buildParameters.projectPath);
-  }
-
-  public static get libraryFolderAbsolute(): string {
-    return path.join(CloudRunnerFolders.projectPathAbsolute, `Library`);
-  }
-
-  public static get projectBuildFolderAbsolute(): string {
-    return path.join(CloudRunnerFolders.repoPathAbsolute, CloudRunner.buildParameters.buildPath);
-  }
-
-  public static get lfsFolderAbsolute(): string {
-    return path.join(CloudRunnerFolders.repoPathAbsolute, `.git`, `lfs`);
-  }
-
-  public static get purgeRemoteCaching(): boolean {
-    return process.env.PURGE_REMOTE_BUILDER_CACHE !== undefined;
-  }
-
-  public static get lfsCacheFolderFull() {
-    return path.join(CloudRunnerFolders.cacheFolderForCacheKeyFull, `lfs`);
-  }
-
-  public static get libraryCacheFolderFull() {
-    return path.join(CloudRunnerFolders.cacheFolderForCacheKeyFull, `Library`);
-  }
-
-  public static get unityBuilderRepoUrl(): string {
-    return `https://${CloudRunner.buildParameters.gitPrivateToken}@github.com/game-ci/unity-builder.git`;
-  }
-
-  public static get targetBuildRepoUrl(): string {
-    return `https://${CloudRunner.buildParameters.gitPrivateToken}@github.com/${CloudRunner.buildParameters.githubRepo}.git`;
-  }
-
-  public static get buildVolumeFolder() {
-    return 'data';
-  }
-
-  public static get cacheFolder() {
-    return 'cache';
-  }
-}

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

@@ -1,10 +0,0 @@
-import Input from '../../input';
-import CloudRunnerOptions from './cloud-runner-options';
-
-class CloudRunnerOptionsReader {
-  static GetProperties() {
-    return [...Object.getOwnPropertyNames(Input), ...Object.getOwnPropertyNames(CloudRunnerOptions)];
-  }
-}
-
-export default CloudRunnerOptionsReader;

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

@@ -1,283 +0,0 @@
-import { Cli } from '../../cli/cli';
-import CloudRunnerQueryOverride from './cloud-runner-query-override';
-import GitHub from '../../github';
-import * as core from '@actions/core';
-
-class CloudRunnerOptions {
-  // ### ### ###
-  // Input Handling
-  // ### ### ###
-  public static getInput(query: string): string | undefined {
-    if (GitHub.githubInputEnabled) {
-      const coreInput = core.getInput(query);
-      if (coreInput && coreInput !== '') {
-        return coreInput;
-      }
-    }
-    const alternativeQuery = CloudRunnerOptions.ToEnvVarFormat(query);
-
-    // Query input sources
-    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];
-    }
-  }
-
-  public static ToEnvVarFormat(input: string): string {
-    if (input.toUpperCase() === input) {
-      return input;
-    }
-
-    return input
-      .replace(/([A-Z])/g, ' $1')
-      .trim()
-      .toUpperCase()
-      .replace(/ /g, '_');
-  }
-
-  // ### ### ###
-  // Provider parameters
-  // ### ### ###
-
-  static get region(): string {
-    return CloudRunnerOptions.getInput('region') || 'eu-west-2';
-  }
-
-  // ### ### ###
-  // GitHub  parameters
-  // ### ### ###
-  static get githubChecks(): boolean {
-    const value = CloudRunnerOptions.getInput('githubChecks');
-
-    return value === `true` || false;
-  }
-  static get githubCheckId(): string {
-    return CloudRunnerOptions.getInput('githubCheckId') || ``;
-  }
-
-  static get githubOwner(): string {
-    return CloudRunnerOptions.getInput('githubOwner') || CloudRunnerOptions.githubRepo?.split(`/`)[0] || '';
-  }
-
-  static get githubRepoName(): string {
-    return CloudRunnerOptions.getInput('githubRepoName') || CloudRunnerOptions.githubRepo?.split(`/`)[1] || '';
-  }
-
-  static get finalHooks(): string[] {
-    return CloudRunnerOptions.getInput('finalHooks')?.split(',') || [];
-  }
-
-  // ### ### ###
-  // Git syncronization parameters
-  // ### ### ###
-
-  static get githubRepo(): string | undefined {
-    return CloudRunnerOptions.getInput('GITHUB_REPOSITORY') || CloudRunnerOptions.getInput('GITHUB_REPO') || undefined;
-  }
-  static get branch(): string {
-    if (CloudRunnerOptions.getInput(`GITHUB_REF`)) {
-      return (
-        CloudRunnerOptions.getInput(`GITHUB_REF`)?.replace('refs/', '').replace(`head/`, '').replace(`heads/`, '') || ``
-      );
-    } else if (CloudRunnerOptions.getInput('branch')) {
-      return CloudRunnerOptions.getInput('branch') || ``;
-    } else {
-      return '';
-    }
-  }
-
-  // ### ### ###
-  // Cloud Runner parameters
-  // ### ### ###
-
-  static get buildPlatform(): string {
-    const input = CloudRunnerOptions.getInput('buildPlatform');
-    if (input && input !== '') {
-      return input;
-    }
-    if (CloudRunnerOptions.providerStrategy !== 'local') {
-      return 'linux';
-    }
-
-    return process.platform;
-  }
-
-  static get cloudRunnerBranch(): string {
-    return CloudRunnerOptions.getInput('cloudRunnerBranch') || 'main';
-  }
-
-  static get providerStrategy(): string {
-    const provider =
-      CloudRunnerOptions.getInput('cloudRunnerCluster') || CloudRunnerOptions.getInput('providerStrategy');
-    if (Cli.isCliMode) {
-      return provider || 'aws';
-    }
-
-    return provider || 'local';
-  }
-
-  static get containerCpu(): string {
-    return CloudRunnerOptions.getInput('containerCpu') || `1024`;
-  }
-
-  static get containerMemory(): string {
-    return CloudRunnerOptions.getInput('containerMemory') || `3072`;
-  }
-
-  static get customJob(): string {
-    return CloudRunnerOptions.getInput('customJob') || '';
-  }
-
-  // ### ### ###
-  // Custom commands from files parameters
-  // ### ### ###
-
-  static get containerHookFiles(): string[] {
-    return CloudRunnerOptions.getInput('containerHookFiles')?.split(`,`) || [];
-  }
-
-  static get commandHookFiles(): string[] {
-    return CloudRunnerOptions.getInput('commandHookFiles')?.split(`,`) || [];
-  }
-
-  // ### ### ###
-  // Custom commands from yaml parameters
-  // ### ### ###
-
-  static get commandHooks(): string {
-    return CloudRunnerOptions.getInput('commandHooks') || '';
-  }
-
-  static get postBuildContainerHooks(): string {
-    return CloudRunnerOptions.getInput('postBuildContainerHooks') || '';
-  }
-
-  static get preBuildContainerHooks(): string {
-    return CloudRunnerOptions.getInput('preBuildContainerHooks') || '';
-  }
-
-  // ### ### ###
-  // Input override handling
-  // ### ### ###
-
-  static get pullInputList(): string[] {
-    return CloudRunnerOptions.getInput('pullInputList')?.split(`,`) || [];
-  }
-
-  static get inputPullCommand(): string {
-    const value = CloudRunnerOptions.getInput('inputPullCommand');
-
-    if (value === 'gcp-secret-manager') {
-      return 'gcloud secrets versions access 1 --secret="{0}"';
-    } else if (value === 'aws-secret-manager') {
-      return 'aws secretsmanager get-secret-value --secret-id {0}';
-    }
-
-    return value || '';
-  }
-
-  // ### ### ###
-  // Aws
-  // ### ### ###
-
-  static get awsStackName() {
-    return CloudRunnerOptions.getInput('awsStackName') || 'game-ci';
-  }
-
-  // ### ### ###
-  // K8s
-  // ### ### ###
-
-  static get kubeConfig(): string {
-    return CloudRunnerOptions.getInput('kubeConfig') || '';
-  }
-
-  static get kubeVolume(): string {
-    return CloudRunnerOptions.getInput('kubeVolume') || '';
-  }
-
-  static get kubeVolumeSize(): string {
-    return CloudRunnerOptions.getInput('kubeVolumeSize') || '25Gi';
-  }
-
-  static get kubeStorageClass(): string {
-    return CloudRunnerOptions.getInput('kubeStorageClass') || '';
-  }
-
-  // ### ### ###
-  // Caching
-  // ### ### ###
-
-  static get cacheKey(): string {
-    return CloudRunnerOptions.getInput('cacheKey') || CloudRunnerOptions.branch;
-  }
-
-  // ### ### ###
-  // Utility Parameters
-  // ### ### ###
-
-  static get cloudRunnerDebug(): boolean {
-    return (
-      CloudRunnerOptions.getInput(`cloudRunnerTests`) === `true` ||
-      CloudRunnerOptions.getInput(`cloudRunnerDebug`) === `true` ||
-      CloudRunnerOptions.getInput(`cloudRunnerDebugTree`) === `true` ||
-      CloudRunnerOptions.getInput(`cloudRunnerDebugEnv`) === `true` ||
-      false
-    );
-  }
-  static get skipLfs(): boolean {
-    return CloudRunnerOptions.getInput(`skipLfs`) === `true`;
-  }
-  static get skipCache(): boolean {
-    return CloudRunnerOptions.getInput(`skipCache`) === `true`;
-  }
-
-  public static get asyncCloudRunner(): boolean {
-    return CloudRunnerOptions.getInput('asyncCloudRunner') === 'true';
-  }
-
-  public static get useLargePackages(): boolean {
-    return CloudRunnerOptions.getInput(`useLargePackages`) === `true`;
-  }
-
-  public static get useSharedBuilder(): boolean {
-    return CloudRunnerOptions.getInput(`useSharedBuilder`) === `true`;
-  }
-
-  public static get useCompressionStrategy(): boolean {
-    return CloudRunnerOptions.getInput(`useCompressionStrategy`) === `true`;
-  }
-
-  public static get useCleanupCron(): boolean {
-    return (CloudRunnerOptions.getInput(`useCleanupCron`) || 'true') === 'true';
-  }
-
-  // ### ### ###
-  // Retained Workspace
-  // ### ### ###
-
-  public static get maxRetainedWorkspaces(): string {
-    return CloudRunnerOptions.getInput(`maxRetainedWorkspaces`) || `0`;
-  }
-
-  // ### ### ###
-  // Garbage Collection
-  // ### ### ###
-
-  static get garbageMaxAge(): number {
-    return Number(CloudRunnerOptions.getInput(`garbageMaxAge`)) || 24;
-  }
-}
-
-export default CloudRunnerOptions;

src/model/cloud-runner/options/cloud-runner-query-override.ts

@@ -1,67 +0,0 @@
-import Input from '../../input';
-import { GenericInputReader } from '../../input-readers/generic-input-reader';
-import CloudRunnerOptions from './cloud-runner-options';
-
-const formatFunction = (value: string, arguments_: any[]) => {
-  for (const element of arguments_) {
-    value = value.replace(`{${element.key}}`, element.value);
-  }
-
-  return value;
-};
-
-class CloudRunnerQueryOverride {
-  static queryOverrides: { [key: string]: string } | undefined;
-
-  // TODO accept premade secret sources or custom secret source definition yamls
-
-  public static query(key: string, alternativeKey: string) {
-    if (CloudRunnerQueryOverride.queryOverrides && CloudRunnerQueryOverride.queryOverrides[key] !== undefined) {
-      return CloudRunnerQueryOverride.queryOverrides[key];
-    }
-    if (
-      CloudRunnerQueryOverride.queryOverrides &&
-      alternativeKey &&
-      CloudRunnerQueryOverride.queryOverrides[alternativeKey] !== undefined
-    ) {
-      return CloudRunnerQueryOverride.queryOverrides[alternativeKey];
-    }
-
-    return;
-  }
-
-  private static shouldUseOverride(query: string) {
-    if (CloudRunnerOptions.inputPullCommand !== '') {
-      if (CloudRunnerOptions.pullInputList.length > 0) {
-        const doesInclude =
-          CloudRunnerOptions.pullInputList.includes(query) ||
-          CloudRunnerOptions.pullInputList.includes(Input.ToEnvVarFormat(query));
-
-        return doesInclude ? true : false;
-      } else {
-        return true;
-      }
-    }
-  }
-
-  private static async queryOverride(query: string) {
-    if (!this.shouldUseOverride(query)) {
-      throw new Error(`Should not be trying to run override query on ${query}`);
-    }
-
-    return await GenericInputReader.Run(
-      formatFunction(CloudRunnerOptions.inputPullCommand, [{ key: 0, value: query }]),
-    );
-  }
-
-  public static async PopulateQueryOverrideInput() {
-    const queries = CloudRunnerOptions.pullInputList;
-    CloudRunnerQueryOverride.queryOverrides = {};
-    for (const element of queries) {
-      if (CloudRunnerQueryOverride.shouldUseOverride(element)) {
-        CloudRunnerQueryOverride.queryOverrides[element] = await CloudRunnerQueryOverride.queryOverride(element);
-      }
-    }
-  }
-}
-export default CloudRunnerQueryOverride;

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

@@ -1,3 +0,0 @@
-export class CloudRunnerStatics {
-  public static readonly logPrefix = `Cloud-Runner`;
-}

src/model/cloud-runner/options/cloud-runner-step-parameters.ts

@@ -1,13 +0,0 @@
-import CloudRunnerEnvironmentVariable from './cloud-runner-environment-variable';
-import CloudRunnerSecret from './cloud-runner-secret';
-
-export class CloudRunnerStepParameters {
-  public image: string;
-  public environment: CloudRunnerEnvironmentVariable[];
-  public secrets: CloudRunnerSecret[];
-  constructor(image: string, environmentVariables: CloudRunnerEnvironmentVariable[], secrets: CloudRunnerSecret[]) {
-    this.image = image;
-    this.environment = environmentVariables;
-    this.secrets = secrets;
-  }
-}

src/model/cloud-runner/providers/k8s/kubernetes-job-spec-factory.ts

@@ -1,127 +0,0 @@
-import { V1EnvVar, V1EnvVarSource, V1SecretKeySelector } from '@kubernetes/client-node';
-import BuildParameters from '../../../build-parameters';
-import { CommandHookService } from '../../services/hooks/command-hook-service';
-import CloudRunnerEnvironmentVariable from '../../options/cloud-runner-environment-variable';
-import CloudRunnerSecret from '../../options/cloud-runner-secret';
-import CloudRunner from '../../cloud-runner';
-
-class KubernetesJobSpecFactory {
-  static getJobSpec(
-    command: string,
-    image: string,
-    mountdir: string,
-    workingDirectory: string,
-    environment: CloudRunnerEnvironmentVariable[],
-    secrets: CloudRunnerSecret[],
-    buildGuid: string,
-    buildParameters: BuildParameters,
-    secretName: string,
-    pvcName: string,
-    jobName: string,
-    k8s: any,
-    containerName: string,
-    ip: string = '',
-  ) {
-    const job = new k8s.V1Job();
-    job.apiVersion = 'batch/v1';
-    job.kind = 'Job';
-    job.metadata = {
-      name: jobName,
-      labels: {
-        app: 'unity-builder',
-        buildGuid,
-      },
-    };
-    job.spec = {
-      ttlSecondsAfterFinished: 9999,
-      backoffLimit: 0,
-      template: {
-        spec: {
-          volumes: [
-            {
-              name: 'build-mount',
-              persistentVolumeClaim: {
-                claimName: pvcName,
-              },
-            },
-          ],
-          containers: [
-            {
-              ttlSecondsAfterFinished: 9999,
-              name: containerName,
-              image,
-              command: ['/bin/sh'],
-              args: [
-                '-c',
-                `${CommandHookService.ApplyHooksToCommands(`${command}\nsleep 2m`, CloudRunner.buildParameters)}`,
-              ],
-
-              workingDir: `${workingDirectory}`,
-              resources: {
-                requests: {
-                  memory: `${Number.parseInt(buildParameters.containerMemory) / 1024}G` || '750M',
-                  cpu: Number.parseInt(buildParameters.containerCpu) / 1024 || '1',
-                },
-              },
-              env: [
-                ...environment.map((x) => {
-                  const environmentVariable = new V1EnvVar();
-                  environmentVariable.name = x.name;
-                  environmentVariable.value = x.value;
-
-                  return environmentVariable;
-                }),
-                ...secrets.map((x) => {
-                  const secret = new V1EnvVarSource();
-                  secret.secretKeyRef = new V1SecretKeySelector();
-                  secret.secretKeyRef.key = x.ParameterKey;
-                  secret.secretKeyRef.name = secretName;
-                  const environmentVariable = new V1EnvVar();
-                  environmentVariable.name = x.EnvironmentVariable;
-                  environmentVariable.valueFrom = secret;
-
-                  return environmentVariable;
-                }),
-                { name: 'LOG_SERVICE_IP', value: ip },
-              ],
-              volumeMounts: [
-                {
-                  name: 'build-mount',
-                  mountPath: `${mountdir}`,
-                },
-              ],
-              lifecycle: {
-                preStop: {
-                  exec: {
-                    command: [
-                      `wait 60s;
-                      cd /data/builder/action/steps;
-                      chmod +x /return_license.sh;
-                      /return_license.sh;`,
-                    ],
-                  },
-                },
-              },
-            },
-          ],
-          restartPolicy: 'Never',
-        },
-      },
-    };
-
-    if (process.env['CLOUD_RUNNER_MINIKUBE']) {
-      job.spec.template.spec.volumes[0] = {
-        name: 'build-mount',
-        hostPath: {
-          path: `/data`,
-          type: `Directory`,
-        },
-      };
-    }
-
-    job.spec.template.spec.containers[0].resources.requests[`ephemeral-storage`] = '10Gi';
-
-    return job;
-  }
-}
-export default KubernetesJobSpecFactory;

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

@@ -1,23 +0,0 @@
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
-import { CoreV1Api } from '@kubernetes/client-node';
-class KubernetesPods {
-  public static async IsPodRunning(podName: string, namespace: string, kubeClient: CoreV1Api) {
-    const pods = (await kubeClient.listNamespacedPod(namespace)).body.items.filter((x) => podName === x.metadata?.name);
-    const running = pods.length > 0 && (pods[0].status?.phase === `Running` || pods[0].status?.phase === `Pending`);
-    const phase = pods[0]?.status?.phase || 'undefined status';
-    CloudRunnerLogger.log(`Getting pod status: ${phase}`);
-    if (phase === `Failed`) {
-      throw new Error(`K8s pod failed`);
-    }
-
-    return running;
-  }
-  public static async GetPodStatus(podName: string, namespace: string, kubeClient: CoreV1Api) {
-    const pods = (await kubeClient.listNamespacedPod(namespace)).body.items.find((x) => podName === x.metadata?.name);
-    const phase = pods?.status?.phase || 'undefined status';
-
-    return phase;
-  }
-}
-
-export default KubernetesPods;

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

@@ -1,116 +0,0 @@
-import { waitUntil } from 'async-wait-until';
-import * as core from '@actions/core';
-import * as k8s from '@kubernetes/client-node';
-import BuildParameters from '../../../build-parameters';
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
-import { IncomingMessage } from 'node:http';
-import GitHub from '../../../github';
-
-class KubernetesStorage {
-  public static async createPersistentVolumeClaim(
-    buildParameters: BuildParameters,
-    pvcName: string,
-    kubeClient: k8s.CoreV1Api,
-    namespace: string,
-  ) {
-    if (buildParameters.kubeVolume !== ``) {
-      CloudRunnerLogger.log(`Kube Volume was input was set ${buildParameters.kubeVolume} overriding ${pvcName}`);
-      pvcName = buildParameters.kubeVolume;
-
-      return;
-    }
-    const allPvc = (await kubeClient.listNamespacedPersistentVolumeClaim(namespace)).body.items;
-    const pvcList = allPvc.map((x) => x.metadata?.name);
-    CloudRunnerLogger.log(`Current PVCs in namespace ${namespace}`);
-    CloudRunnerLogger.log(JSON.stringify(pvcList, undefined, 4));
-    if (pvcList.includes(pvcName)) {
-      CloudRunnerLogger.log(`pvc ${pvcName} already exists`);
-      if (GitHub.githubInputEnabled) {
-        core.setOutput('volume', pvcName);
-      }
-
-      return;
-    }
-    CloudRunnerLogger.log(`Creating PVC ${pvcName} (does not exist)`);
-    const result = await KubernetesStorage.createPVC(pvcName, buildParameters, kubeClient, namespace);
-    await KubernetesStorage.handleResult(result, kubeClient, namespace, pvcName);
-  }
-
-  public static async getPVCPhase(kubeClient: k8s.CoreV1Api, name: string, namespace: string) {
-    try {
-      return (await kubeClient.readNamespacedPersistentVolumeClaim(name, namespace)).body.status?.phase;
-    } catch (error) {
-      core.error('Failed to get PVC phase');
-      core.error(JSON.stringify(error, undefined, 4));
-      throw error;
-    }
-  }
-
-  public static async watchUntilPVCNotPending(kubeClient: k8s.CoreV1Api, name: string, namespace: string) {
-    try {
-      CloudRunnerLogger.log(`watch Until PVC Not Pending ${name} ${namespace}`);
-      CloudRunnerLogger.log(`${await this.getPVCPhase(kubeClient, name, namespace)}`);
-      await waitUntil(
-        async () => {
-          return (await this.getPVCPhase(kubeClient, name, namespace)) === 'Pending';
-        },
-        {
-          timeout: 750000,
-          intervalBetweenAttempts: 15000,
-        },
-      );
-    } catch (error: any) {
-      core.error('Failed to watch PVC');
-      core.error(error.toString());
-      core.error(
-        `PVC Body: ${JSON.stringify(
-          (await kubeClient.readNamespacedPersistentVolumeClaim(name, namespace)).body,
-          undefined,
-          4,
-        )}`,
-      );
-      throw error;
-    }
-  }
-
-  private static async createPVC(
-    pvcName: string,
-    buildParameters: BuildParameters,
-    kubeClient: k8s.CoreV1Api,
-    namespace: string,
-  ) {
-    const pvc = new k8s.V1PersistentVolumeClaim();
-    pvc.apiVersion = 'v1';
-    pvc.kind = 'PersistentVolumeClaim';
-    pvc.metadata = {
-      name: pvcName,
-    };
-    pvc.spec = {
-      accessModes: ['ReadWriteOnce'],
-      storageClassName: buildParameters.kubeStorageClass === '' ? 'standard' : buildParameters.kubeStorageClass,
-      resources: {
-        requests: {
-          storage: buildParameters.kubeVolumeSize,
-        },
-      },
-    };
-    const result = await kubeClient.createNamespacedPersistentVolumeClaim(namespace, pvc);
-
-    return result;
-  }
-
-  private static async handleResult(
-    result: { response: IncomingMessage; body: k8s.V1PersistentVolumeClaim },
-    kubeClient: k8s.CoreV1Api,
-    namespace: string,
-    pvcName: string,
-  ) {
-    const name = result.body.metadata?.name || '';
-    CloudRunnerLogger.log(`PVC ${name} created`);
-    await this.watchUntilPVCNotPending(kubeClient, name, namespace);
-    CloudRunnerLogger.log(`PVC ${name} is ready and not pending`);
-    core.setOutput('volume', pvcName);
-  }
-}
-
-export default KubernetesStorage;

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

@@ -1,119 +0,0 @@
-import { CoreV1Api, KubeConfig } from '@kubernetes/client-node';
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
-import { waitUntil } from 'async-wait-until';
-import { CloudRunnerSystem } from '../../services/core/cloud-runner-system';
-import CloudRunner from '../../cloud-runner';
-import KubernetesPods from './kubernetes-pods';
-import { FollowLogStreamService } from '../../services/core/follow-log-stream-service';
-
-class KubernetesTaskRunner {
-  static readonly maxRetry: number = 3;
-  static lastReceivedMessage: string = ``;
-
-  static async runTask(
-    kubeConfig: KubeConfig,
-    kubeClient: CoreV1Api,
-    jobName: string,
-    podName: string,
-    containerName: string,
-    namespace: string,
-  ) {
-    let output = '';
-    let shouldReadLogs = true;
-    let shouldCleanup = true;
-    let retriesAfterFinish = 0;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      await new Promise((resolve) => setTimeout(resolve, 3000));
-      CloudRunnerLogger.log(
-        `Streaming logs from pod: ${podName} container: ${containerName} namespace: ${namespace} ${CloudRunner.buildParameters.kubeVolumeSize}/${CloudRunner.buildParameters.containerCpu}/${CloudRunner.buildParameters.containerMemory}`,
-      );
-      let extraFlags = ``;
-      extraFlags += (await KubernetesPods.IsPodRunning(podName, namespace, kubeClient))
-        ? ` -f -c ${containerName}`
-        : ` --previous`;
-
-      const callback = (outputChunk: string) => {
-        output += outputChunk;
-
-        // split output chunk and handle per line
-        for (const chunk of outputChunk.split(`\n`)) {
-          ({ shouldReadLogs, shouldCleanup, output } = FollowLogStreamService.handleIteration(
-            chunk,
-            shouldReadLogs,
-            shouldCleanup,
-            output,
-          ));
-        }
-      };
-      try {
-        await CloudRunnerSystem.Run(`kubectl logs ${podName}${extraFlags}`, false, true, callback);
-      } catch (error: any) {
-        await new Promise((resolve) => setTimeout(resolve, 3000));
-        const continueStreaming = await KubernetesPods.IsPodRunning(podName, namespace, kubeClient);
-        CloudRunnerLogger.log(`K8s logging error ${error} ${continueStreaming}`);
-        if (continueStreaming) {
-          continue;
-        }
-        if (retriesAfterFinish < KubernetesTaskRunner.maxRetry) {
-          retriesAfterFinish++;
-
-          continue;
-        }
-        throw error;
-      }
-      if (FollowLogStreamService.DidReceiveEndOfTransmission) {
-        CloudRunnerLogger.log('end of log stream');
-        break;
-      }
-    }
-
-    return output;
-  }
-
-  static async watchUntilPodRunning(kubeClient: CoreV1Api, podName: string, namespace: string) {
-    let waitComplete: boolean = false;
-    let message = ``;
-    CloudRunnerLogger.log(`Watching ${podName} ${namespace}`);
-    await waitUntil(
-      async () => {
-        const status = await kubeClient.readNamespacedPodStatus(podName, namespace);
-        const phase = status?.body.status?.phase;
-        waitComplete = phase !== 'Pending';
-        message = `Phase:${status.body.status?.phase} \n Reason:${
-          status.body.status?.conditions?.[0].reason || ''
-        } \n Message:${status.body.status?.conditions?.[0].message || ''}`;
-
-        // CloudRunnerLogger.log(
-        //   JSON.stringify(
-        //     (await kubeClient.listNamespacedEvent(namespace)).body.items
-        //       .map((x) => {
-        //         return {
-        //           message: x.message || ``,
-        //           name: x.metadata.name || ``,
-        //           reason: x.reason || ``,
-        //         };
-        //       })
-        //       .filter((x) => x.name.includes(podName)),
-        //     undefined,
-        //     4,
-        //   ),
-        // );
-        if (waitComplete || phase !== 'Pending') return true;
-
-        return false;
-      },
-      {
-        timeout: 2000000,
-        intervalBetweenAttempts: 15000,
-      },
-    );
-    if (!waitComplete) {
-      CloudRunnerLogger.log(message);
-    }
-
-    return waitComplete;
-  }
-}
-
-export default KubernetesTaskRunner;

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

@@ -1,181 +0,0 @@
-import { assert } from 'node:console';
-import fs from 'node:fs';
-import path from 'node:path';
-import CloudRunner from '../cloud-runner';
-import CloudRunnerLogger from '../services/core/cloud-runner-logger';
-import { CloudRunnerFolders } from '../options/cloud-runner-folders';
-import { CloudRunnerSystem } from '../services/core/cloud-runner-system';
-import { LfsHashing } from '../services/utility/lfs-hashing';
-import { RemoteClientLogger } from './remote-client-logger';
-import { Cli } from '../../cli/cli';
-import { CliFunction } from '../../cli/cli-functions-repository';
-// eslint-disable-next-line github/no-then
-const fileExists = async (fpath: fs.PathLike) => !!(await fs.promises.stat(fpath).catch(() => false));
-
-export class Caching {
-  @CliFunction(`cache-push`, `push to cache`)
-  static async cachePush() {
-    try {
-      const buildParameter = JSON.parse(process.env.BUILD_PARAMETERS || '{}');
-      CloudRunner.buildParameters = buildParameter;
-      await Caching.PushToCache(
-        Cli.options!['cachePushTo'],
-        Cli.options!['cachePushFrom'],
-        Cli.options!['artifactName'] || '',
-      );
-    } catch (error: any) {
-      CloudRunnerLogger.log(`${error}`);
-    }
-  }
-
-  @CliFunction(`cache-pull`, `pull from cache`)
-  static async cachePull() {
-    try {
-      const buildParameter = JSON.parse(process.env.BUILD_PARAMETERS || '{}');
-      CloudRunner.buildParameters = buildParameter;
-      await Caching.PullFromCache(
-        Cli.options!['cachePushFrom'],
-        Cli.options!['cachePushTo'],
-        Cli.options!['artifactName'] || '',
-      );
-    } catch (error: any) {
-      CloudRunnerLogger.log(`${error}`);
-    }
-  }
-
-  public static async PushToCache(cacheFolder: string, sourceFolder: string, cacheArtifactName: string) {
-    CloudRunnerLogger.log(`Pushing to cache ${sourceFolder}`);
-    cacheArtifactName = cacheArtifactName.replace(' ', '');
-    const startPath = process.cwd();
-    let compressionSuffix = '';
-    if (CloudRunner.buildParameters.useCompressionStrategy === true) {
-      compressionSuffix = `.lz4`;
-    }
-    CloudRunnerLogger.log(`Compression: ${CloudRunner.buildParameters.useCompressionStrategy} ${compressionSuffix}`);
-    try {
-      if (!(await fileExists(cacheFolder))) {
-        await CloudRunnerSystem.Run(`mkdir -p ${cacheFolder}`);
-      }
-      process.chdir(path.resolve(sourceFolder, '..'));
-
-      if (CloudRunner.buildParameters.cloudRunnerDebug === true) {
-        CloudRunnerLogger.log(
-          `Hashed cache folder ${await LfsHashing.hashAllFiles(sourceFolder)} ${sourceFolder} ${path.basename(
-            sourceFolder,
-          )}`,
-        );
-      }
-      const contents = await fs.promises.readdir(path.basename(sourceFolder));
-      CloudRunnerLogger.log(
-        `There is ${contents.length} files/dir in the source folder ${path.basename(sourceFolder)}`,
-      );
-
-      if (contents.length === 0) {
-        CloudRunnerLogger.log(
-          `Did not push source folder to cache because it was empty ${path.basename(sourceFolder)}`,
-        );
-        process.chdir(`${startPath}`);
-
-        return;
-      }
-
-      await CloudRunnerSystem.Run(
-        `tar -cf ${cacheArtifactName}.tar${compressionSuffix} "${path.basename(sourceFolder)}"`,
-      );
-      await CloudRunnerSystem.Run(`du ${cacheArtifactName}.tar${compressionSuffix}`);
-      assert(await fileExists(`${cacheArtifactName}.tar${compressionSuffix}`), 'cache archive exists');
-      assert(await fileExists(path.basename(sourceFolder)), 'source folder exists');
-      await CloudRunnerSystem.Run(`mv ${cacheArtifactName}.tar${compressionSuffix} ${cacheFolder}`);
-      RemoteClientLogger.log(`moved cache entry ${cacheArtifactName} to ${cacheFolder}`);
-      assert(
-        await fileExists(`${path.join(cacheFolder, cacheArtifactName)}.tar${compressionSuffix}`),
-        'cache archive exists inside cache folder',
-      );
-    } catch (error) {
-      process.chdir(`${startPath}`);
-      throw error;
-    }
-    process.chdir(`${startPath}`);
-  }
-  public static async PullFromCache(cacheFolder: string, destinationFolder: string, cacheArtifactName: string = ``) {
-    CloudRunnerLogger.log(`Pulling from cache ${destinationFolder} ${CloudRunner.buildParameters.skipCache}`);
-    if (`${CloudRunner.buildParameters.skipCache}` === `true`) {
-      CloudRunnerLogger.log(`Skipping cache debugSkipCache is true`);
-
-      return;
-    }
-    cacheArtifactName = cacheArtifactName.replace(' ', '');
-    let compressionSuffix = '';
-    if (CloudRunner.buildParameters.useCompressionStrategy === true) {
-      compressionSuffix = `.lz4`;
-    }
-    const startPath = process.cwd();
-    RemoteClientLogger.log(`Caching for (lz4 ${compressionSuffix}) ${path.basename(destinationFolder)}`);
-    try {
-      if (!(await fileExists(cacheFolder))) {
-        await fs.promises.mkdir(cacheFolder);
-      }
-
-      if (!(await fileExists(destinationFolder))) {
-        await fs.promises.mkdir(destinationFolder);
-      }
-
-      const latestInBranch = await (
-        await CloudRunnerSystem.Run(`ls -t "${cacheFolder}" | grep .tar${compressionSuffix}$ | head -1`)
-      )
-        .replace(/\n/g, ``)
-        .replace(`.tar${compressionSuffix}`, '');
-
-      process.chdir(cacheFolder);
-
-      const cacheSelection =
-        cacheArtifactName !== `` && (await fileExists(`${cacheArtifactName}.tar${compressionSuffix}`))
-          ? cacheArtifactName
-          : latestInBranch;
-      await CloudRunnerLogger.log(`cache key ${cacheArtifactName} selection ${cacheSelection}`);
-
-      if (await fileExists(`${cacheSelection}.tar${compressionSuffix}`)) {
-        const resultsFolder = `results${CloudRunner.buildParameters.buildGuid}`;
-        await CloudRunnerSystem.Run(`mkdir -p ${resultsFolder}`);
-        RemoteClientLogger.log(`cache item exists ${cacheFolder}/${cacheSelection}.tar${compressionSuffix}`);
-        const fullResultsFolder = path.join(cacheFolder, resultsFolder);
-        await CloudRunnerSystem.Run(`tar -xf ${cacheSelection}.tar${compressionSuffix} -C ${fullResultsFolder}`);
-        RemoteClientLogger.log(`cache item extracted to ${fullResultsFolder}`);
-        assert(await fileExists(fullResultsFolder), `cache extraction results folder exists`);
-        const destinationParentFolder = path.resolve(destinationFolder, '..');
-
-        if (await fileExists(destinationFolder)) {
-          await fs.promises.rmdir(destinationFolder, { recursive: true });
-        }
-        await CloudRunnerSystem.Run(
-          `mv "${path.join(fullResultsFolder, path.basename(destinationFolder))}" "${destinationParentFolder}"`,
-        );
-        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)}`,
-        );
-      } else {
-        RemoteClientLogger.logWarning(`cache item ${cacheArtifactName} doesn't exist ${destinationFolder}`);
-        if (cacheSelection !== ``) {
-          RemoteClientLogger.logWarning(
-            `cache item ${cacheArtifactName}.tar${compressionSuffix} doesn't exist ${destinationFolder}`,
-          );
-          throw new Error(`Failed to get cache item, but cache hit was found: ${cacheSelection}`);
-        }
-      }
-    } catch (error) {
-      process.chdir(startPath);
-      throw error;
-    }
-    process.chdir(startPath);
-  }
-
-  public static async handleCachePurging() {
-    if (process.env.PURGE_REMOTE_BUILDER_CACHE !== undefined) {
-      RemoteClientLogger.log(`purging ${CloudRunnerFolders.purgeRemoteCaching}`);
-      fs.promises.rmdir(CloudRunnerFolders.cacheFolder, { recursive: true });
-    }
-  }
-}

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

@@ -1,251 +0,0 @@
-import fs from 'node:fs';
-import CloudRunner from '../cloud-runner';
-import { CloudRunnerFolders } from '../options/cloud-runner-folders';
-import { Caching } from './caching';
-import { LfsHashing } from '../services/utility/lfs-hashing';
-import { RemoteClientLogger } from './remote-client-logger';
-import path from 'node:path';
-import { assert } from 'node:console';
-import CloudRunnerLogger from '../services/core/cloud-runner-logger';
-import { CliFunction } from '../../cli/cli-functions-repository';
-import { CloudRunnerSystem } from '../services/core/cloud-runner-system';
-import YAML from 'yaml';
-import GitHub from '../../github';
-import BuildParameters from '../../build-parameters';
-import { Cli } from '../../cli/cli';
-import CloudRunnerOptions from '../options/cloud-runner-options';
-
-export class RemoteClient {
-  @CliFunction(`remote-cli-pre-build`, `sets up a repository, usually before a game-ci build`)
-  static async setupRemoteClient() {
-    CloudRunnerLogger.log(`bootstrap game ci cloud runner...`);
-    if (!(await RemoteClient.handleRetainedWorkspace())) {
-      await RemoteClient.bootstrapRepository();
-    }
-    await RemoteClient.replaceLargePackageReferencesWithSharedReferences();
-    await RemoteClient.runCustomHookFiles(`before-build`);
-  }
-
-  @CliFunction('remote-cli-log-stream', `log stream from standard input`)
-  public static async remoteClientLogStream() {
-    const logFile = Cli.options!['logFile'];
-    process.stdin.resume();
-    process.stdin.setEncoding('utf8');
-
-    let lingeringLine = '';
-
-    process.stdin.on('data', (chunk) => {
-      const lines = chunk.toString().split('\n');
-
-      lines[0] = lingeringLine + lines[0];
-      lingeringLine = lines.pop() || '';
-
-      for (const element of lines) {
-        if (CloudRunnerOptions.providerStrategy !== 'k8s') {
-          CloudRunnerLogger.log(element);
-        } else {
-          fs.appendFileSync(logFile, element);
-          CloudRunnerLogger.log(element);
-        }
-      }
-    });
-
-    process.stdin.on('end', () => {
-      if (CloudRunnerOptions.providerStrategy !== 'k8s') {
-        CloudRunnerLogger.log(lingeringLine);
-      } else {
-        fs.appendFileSync(logFile, lingeringLine);
-        CloudRunnerLogger.log(lingeringLine);
-      }
-    });
-  }
-
-  @CliFunction(`remote-cli-post-build`, `runs a cloud runner build`)
-  public static async remoteClientPostBuild(): Promise<string> {
-    RemoteClientLogger.log(`Running POST build tasks`);
-
-    await Caching.PushToCache(
-      CloudRunnerFolders.ToLinuxFolder(`${CloudRunnerFolders.cacheFolderForCacheKeyFull}/Library`),
-      CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.libraryFolderAbsolute),
-      `lib-${CloudRunner.buildParameters.buildGuid}`,
-    );
-
-    await Caching.PushToCache(
-      CloudRunnerFolders.ToLinuxFolder(`${CloudRunnerFolders.cacheFolderForCacheKeyFull}/build`),
-      CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.projectBuildFolderAbsolute),
-      `build-${CloudRunner.buildParameters.buildGuid}`,
-    );
-
-    if (!BuildParameters.shouldUseRetainedWorkspaceMode(CloudRunner.buildParameters)) {
-      await CloudRunnerSystem.Run(
-        `rm -r ${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute)}`,
-      );
-    }
-
-    await RemoteClient.runCustomHookFiles(`after-build`);
-
-    // WIP - need to give the pod permissions to create config map
-    await RemoteClientLogger.handleLogManagementPostJob();
-
-    return new Promise((result) => result(``));
-  }
-  static async runCustomHookFiles(hookLifecycle: string) {
-    RemoteClientLogger.log(`RunCustomHookFiles: ${hookLifecycle}`);
-    const gameCiCustomHooksPath = path.join(CloudRunnerFolders.repoPathAbsolute, `game-ci`, `hooks`);
-    try {
-      const files = fs.readdirSync(gameCiCustomHooksPath);
-      for (const file of files) {
-        const fileContents = fs.readFileSync(path.join(gameCiCustomHooksPath, file), `utf8`);
-        const fileContentsObject = YAML.parse(fileContents.toString());
-        if (fileContentsObject.hook === hookLifecycle) {
-          RemoteClientLogger.log(`Active Hook File ${file} \n \n file contents: \n ${fileContents}`);
-          await CloudRunnerSystem.Run(fileContentsObject.commands);
-        }
-      }
-    } catch (error) {
-      RemoteClientLogger.log(JSON.stringify(error, undefined, 4));
-    }
-  }
-  public static async bootstrapRepository() {
-    await CloudRunnerSystem.Run(
-      `mkdir -p ${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute)}`,
-    );
-    await CloudRunnerSystem.Run(
-      `mkdir -p ${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.cacheFolderForCacheKeyFull)}`,
-    );
-    await RemoteClient.cloneRepoWithoutLFSFiles();
-    await RemoteClient.sizeOfFolder(
-      'repo before lfs cache pull',
-      CloudRunnerFolders.ToLinuxFolder(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.ToLinuxFolder(CloudRunnerFolders.lfsCacheFolderFull),
-      CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.lfsFolderAbsolute),
-      `${lfsHashes.lfsGuidSum}`,
-    );
-    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.ToLinuxFolder(CloudRunnerFolders.lfsCacheFolderFull),
-      CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.lfsFolderAbsolute),
-      `${lfsHashes.lfsGuidSum}`,
-    );
-    await Caching.PullFromCache(
-      CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.libraryCacheFolderFull),
-      CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.libraryFolderAbsolute),
-    );
-    await RemoteClient.sizeOfFolder('repo after library cache pull', CloudRunnerFolders.repoPathAbsolute);
-    await Caching.handleCachePurging();
-  }
-
-  private static async sizeOfFolder(message: string, folder: string) {
-    if (CloudRunner.buildParameters.cloudRunnerDebug) {
-      CloudRunnerLogger.log(`Size of ${message}`);
-      await CloudRunnerSystem.Run(`du -sh ${folder}`);
-    }
-  }
-
-  private static async cloneRepoWithoutLFSFiles() {
-    process.chdir(`${CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute}`);
-    if (
-      fs.existsSync(CloudRunnerFolders.repoPathAbsolute) &&
-      !fs.existsSync(path.join(CloudRunnerFolders.repoPathAbsolute, `.git`))
-    ) {
-      await CloudRunnerSystem.Run(`rm -r ${CloudRunnerFolders.repoPathAbsolute}`);
-      CloudRunnerLogger.log(`${CloudRunnerFolders.repoPathAbsolute} repo exists, but no git folder, cleaning up`);
-    }
-
-    if (
-      BuildParameters.shouldUseRetainedWorkspaceMode(CloudRunner.buildParameters) &&
-      fs.existsSync(path.join(CloudRunnerFolders.repoPathAbsolute, `.git`))
-    ) {
-      process.chdir(CloudRunnerFolders.repoPathAbsolute);
-      RemoteClientLogger.log(
-        `${
-          CloudRunnerFolders.repoPathAbsolute
-        } repo exists - skipping clone - retained workspace mode ${BuildParameters.shouldUseRetainedWorkspaceMode(
-          CloudRunner.buildParameters,
-        )}`,
-      );
-      await CloudRunnerSystem.Run(`git fetch && git reset --hard ${CloudRunner.buildParameters.gitSha}`);
-
-      return;
-    }
-
-    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:`);
-    await CloudRunnerSystem.Run(`git config --global filter.lfs.smudge "git-lfs smudge --skip -- %f"`);
-    await CloudRunnerSystem.Run(`git config --global filter.lfs.process "git-lfs filter-process --skip"`);
-    try {
-      await CloudRunnerSystem.Run(
-        `git clone ${CloudRunnerFolders.targetBuildRepoUrl} ${path.basename(CloudRunnerFolders.repoPathAbsolute)}`,
-      );
-    } catch (error: any) {
-      throw error;
-    }
-    process.chdir(CloudRunnerFolders.repoPathAbsolute);
-    await CloudRunnerSystem.Run(`git lfs install`);
-    assert(fs.existsSync(`.git`), 'git folder exists');
-    RemoteClientLogger.log(`${CloudRunner.buildParameters.branch}`);
-    if (CloudRunner.buildParameters.gitSha !== undefined) {
-      await CloudRunnerSystem.Run(`git checkout ${CloudRunner.buildParameters.gitSha}`);
-    } else {
-      await CloudRunnerSystem.Run(`git checkout ${CloudRunner.buildParameters.branch}`);
-      RemoteClientLogger.log(`buildParameter Git Sha is empty`);
-    }
-
-    assert(fs.existsSync(path.join(`.git`, `lfs`)), 'LFS folder should not exist before caching');
-    RemoteClientLogger.log(`Checked out ${CloudRunner.buildParameters.branch}`);
-  }
-
-  static async replaceLargePackageReferencesWithSharedReferences() {
-    CloudRunnerLogger.log(`Use Shared Pkgs ${CloudRunner.buildParameters.useLargePackages}`);
-    GitHub.updateGitHubCheck(`Use Shared Pkgs ${CloudRunner.buildParameters.useLargePackages}`, ``);
-    if (CloudRunner.buildParameters.useLargePackages) {
-      const filePath = path.join(CloudRunnerFolders.projectPathAbsolute, `Packages/manifest.json`);
-      let manifest = fs.readFileSync(filePath, 'utf8');
-      manifest = manifest.replace(/LargeContent/g, '../../../LargeContent');
-      fs.writeFileSync(filePath, manifest);
-      CloudRunnerLogger.log(`Package Manifest \n ${manifest}`);
-      GitHub.updateGitHubCheck(`Package Manifest \n ${manifest}`, ``);
-    }
-  }
-
-  private static async pullLatestLFS() {
-    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"`);
-    if (!CloudRunner.buildParameters.skipLfs) {
-      await CloudRunnerSystem.Run(`git lfs pull`);
-      RemoteClientLogger.log(`pulled latest LFS files`);
-      assert(fs.existsSync(CloudRunnerFolders.lfsFolderAbsolute));
-    }
-  }
-  static async handleRetainedWorkspace() {
-    RemoteClientLogger.log(
-      `Retained Workspace: ${BuildParameters.shouldUseRetainedWorkspaceMode(CloudRunner.buildParameters)}`,
-    );
-    if (
-      BuildParameters.shouldUseRetainedWorkspaceMode(CloudRunner.buildParameters) &&
-      fs.existsSync(CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute)) &&
-      fs.existsSync(CloudRunnerFolders.ToLinuxFolder(path.join(CloudRunnerFolders.repoPathAbsolute, `.git`)))
-    ) {
-      CloudRunnerLogger.log(`Retained Workspace Already Exists!`);
-      process.chdir(CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.repoPathAbsolute));
-      await CloudRunnerSystem.Run(`git fetch`);
-      await CloudRunnerSystem.Run(`git lfs pull`);
-      await CloudRunnerSystem.Run(`git reset --hard "${CloudRunner.buildParameters.gitSha}"`);
-      await CloudRunnerSystem.Run(`git checkout ${CloudRunner.buildParameters.gitSha}`);
-
-      return true;
-    }
-
-    return false;
-  }
-}

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

@@ -1,82 +0,0 @@
-import CloudRunnerLogger from '../services/core/cloud-runner-logger';
-import fs from 'node:fs';
-import path from 'node:path';
-import CloudRunner from '../cloud-runner';
-import CloudRunnerOptions from '../options/cloud-runner-options';
-
-export class RemoteClientLogger {
-  private static get LogFilePath() {
-    return path.join(`/home`, `job-log.txt`);
-  }
-
-  public static log(message: string) {
-    const finalMessage = `[Client] ${message}`;
-    this.appendToFile(finalMessage);
-    CloudRunnerLogger.log(finalMessage);
-  }
-
-  public static logCliError(message: string) {
-    CloudRunnerLogger.log(`[Client][Error] ${message}`);
-  }
-
-  public static logCliDiagnostic(message: string) {
-    CloudRunnerLogger.log(`[Client][Diagnostic] ${message}`);
-  }
-
-  public static logWarning(message: string) {
-    CloudRunnerLogger.logWarning(message);
-  }
-
-  public static appendToFile(message: string) {
-    if (CloudRunner.isCloudRunnerEnvironment) {
-      fs.appendFileSync(RemoteClientLogger.LogFilePath, `${message}\n`);
-    }
-  }
-
-  public static async handleLogManagementPostJob() {
-    if (CloudRunnerOptions.providerStrategy !== 'k8s') {
-      return;
-    }
-    CloudRunnerLogger.log(`Collected Logs`);
-
-    // check for log file not existing
-    if (!fs.existsSync(RemoteClientLogger.LogFilePath)) {
-      CloudRunnerLogger.log(`Log file does not exist`);
-
-      // check if CloudRunner.isCloudRunnerEnvironment is true, log
-      if (!CloudRunner.isCloudRunnerEnvironment) {
-        CloudRunnerLogger.log(`Cloud Runner is not running in a cloud environment, not collecting logs`);
-      }
-
-      return;
-    }
-    CloudRunnerLogger.log(`Log file exist`);
-    await new Promise((resolve) => setTimeout(resolve, 1));
-
-    // let hashedLogs = fs.readFileSync(RemoteClientLogger.LogFilePath).toString();
-    //
-    // hashedLogs = md5(hashedLogs);
-    //
-    // for (let index = 0; index < 3; index++) {
-    //   CloudRunnerLogger.log(`LOGHASH: ${hashedLogs}`);
-    //   const logs = fs.readFileSync(RemoteClientLogger.LogFilePath).toString();
-    //   CloudRunnerLogger.log(`LOGS: ${Buffer.from(logs).toString('base64')}`);
-    //   CloudRunnerLogger.log(
-    //     `Game CI's "Cloud Runner System" will cancel the log when it has successfully received the log data to verify all logs have been received.`,
-    //   );
-    //
-    //   // wait for 15 seconds to allow the log to be sent
-    //   await new Promise((resolve) => setTimeout(resolve, 15000));
-    // }
-  }
-  public static HandleLog(message: string): boolean {
-    if (RemoteClientLogger.value !== '') {
-      RemoteClientLogger.value += `\n`;
-    }
-
-    RemoteClientLogger.value += message;
-
-    return false;
-  }
-  static value: string = '';
-}

src/model/cloud-runner/services/hooks/container-hook-service.ts

@@ -1,265 +0,0 @@
-import YAML from 'yaml';
-import CloudRunner from '../../cloud-runner';
-import { CustomWorkflow } from '../../workflows/custom-workflow';
-import { RemoteClientLogger } from '../../remote-client/remote-client-logger';
-import path from 'node:path';
-import fs from 'node:fs';
-import Input from '../../../input';
-import CloudRunnerOptions from '../../options/cloud-runner-options';
-import { ContainerHook as ContainerHook } from './container-hook';
-import { CloudRunnerStepParameters } from '../../options/cloud-runner-step-parameters';
-
-export class ContainerHookService {
-  static GetContainerHooksFromFiles(hookLifecycle: string): ContainerHook[] {
-    const results: ContainerHook[] = [];
-    try {
-      const gameCiCustomStepsPath = path.join(process.cwd(), `game-ci`, `container-hooks`);
-      const files = fs.readdirSync(gameCiCustomStepsPath);
-      for (const file of files) {
-        if (!CloudRunnerOptions.containerHookFiles.includes(file.replace(`.yaml`, ``))) {
-          // RemoteClientLogger.log(`Skipping CustomStepFile: ${file}`);
-          continue;
-        }
-        const fileContents = fs.readFileSync(path.join(gameCiCustomStepsPath, file), `utf8`);
-        const fileContentsObject = ContainerHookService.ParseContainerHooks(fileContents)[0];
-        if (fileContentsObject.hook === hookLifecycle) {
-          results.push(fileContentsObject);
-        }
-      }
-    } catch (error) {
-      RemoteClientLogger.log(`Failed Getting: ${hookLifecycle} \n ${JSON.stringify(error, undefined, 4)}`);
-    }
-
-    // RemoteClientLogger.log(`Active Steps From Files: \n ${JSON.stringify(results, undefined, 4)}`);
-
-    const builtInContainerHooks: ContainerHook[] = ContainerHookService.ParseContainerHooks(
-      `- name: aws-s3-upload-build
-  image: amazon/aws-cli
-  hook: after
-  commands: |
-    aws configure set aws_access_key_id $AWS_ACCESS_KEY_ID --profile default
-    aws configure set aws_secret_access_key $AWS_SECRET_ACCESS_KEY --profile default
-    aws configure set region $AWS_DEFAULT_REGION --profile default
-    aws s3 cp /data/cache/$CACHE_KEY/build/build-${CloudRunner.buildParameters.buildGuid}.tar${
-        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
-      } s3://${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/$CACHE_KEY/build/build-$BUILD_GUID.tar${
-        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
-      }
-    rm /data/cache/$CACHE_KEY/build/build-${CloudRunner.buildParameters.buildGuid}.tar${
-        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
-      }
-  secrets:
-  - name: awsAccessKeyId
-    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
-  - name: awsSecretAccessKey
-    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
-  - name: awsDefaultRegion
-    value: ${process.env.AWS_REGION || ``}
-- name: aws-s3-pull-build
-  image: amazon/aws-cli
-  commands: |
-    aws configure set aws_access_key_id $AWS_ACCESS_KEY_ID --profile default
-    aws configure set aws_secret_access_key $AWS_SECRET_ACCESS_KEY --profile default
-    aws configure set region $AWS_DEFAULT_REGION --profile default
-    aws s3 ls ${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/ || true
-    aws s3 ls ${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/$CACHE_KEY/build || true
-    mkdir -p /data/cache/$CACHE_KEY/build/
-    aws s3 cp s3://${
-      CloudRunner.buildParameters.awsStackName
-    }/cloud-runner-cache/$CACHE_KEY/build/build-$BUILD_GUID_TARGET.tar${
-        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
-      } /data/cache/$CACHE_KEY/build/build-$BUILD_GUID_TARGET.tar${
-        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
-      }
-  secrets:
-    - name: AWS_ACCESS_KEY_ID
-    - name: AWS_SECRET_ACCESS_KEY
-    - name: AWS_DEFAULT_REGION
-    - name: BUILD_GUID_TARGET
-- name: steam-deploy-client
-  image: steamcmd/steamcmd
-  commands: |
-    apt-get update
-    apt-get install -y curl tar coreutils git tree > /dev/null
-    curl -s https://gist.githubusercontent.com/frostebite/1d56f5505b36b403b64193b7a6e54cdc/raw/fa6639ed4ef750c4268ea319d63aa80f52712ffb/deploy-client-steam.sh | bash
-  secrets:
-    - name: STEAM_USERNAME
-    - name: STEAM_PASSWORD
-    - name: STEAM_APPID
-    - name: STEAM_SSFN_FILE_NAME
-    - name: STEAM_SSFN_FILE_CONTENTS
-    - name: STEAM_CONFIG_VDF_1
-    - name: STEAM_CONFIG_VDF_2
-    - name: STEAM_CONFIG_VDF_3
-    - name: STEAM_CONFIG_VDF_4
-    - name: BUILD_GUID_TARGET
-    - name: RELEASE_BRANCH
-- name: steam-deploy-project
-  image: steamcmd/steamcmd
-  commands: |
-    apt-get update
-    apt-get install -y curl tar coreutils git tree > /dev/null
-    curl -s https://gist.githubusercontent.com/frostebite/969da6a41002a0e901174124b643709f/raw/02403e53fb292026cba81ddcf4ff35fc1eba111d/steam-deploy-project.sh | bash
-  secrets:
-    - name: STEAM_USERNAME
-    - name: STEAM_PASSWORD
-    - name: STEAM_APPID
-    - name: STEAM_SSFN_FILE_NAME
-    - name: STEAM_SSFN_FILE_CONTENTS
-    - name: STEAM_CONFIG_VDF_1
-    - name: STEAM_CONFIG_VDF_2
-    - name: STEAM_CONFIG_VDF_3
-    - name: STEAM_CONFIG_VDF_4
-    - name: BUILD_GUID_2
-    - name: RELEASE_BRANCH
-- name: aws-s3-upload-cache
-  image: amazon/aws-cli
-  hook: after
-  commands: |
-    aws configure set aws_access_key_id $AWS_ACCESS_KEY_ID --profile default
-    aws configure set aws_secret_access_key $AWS_SECRET_ACCESS_KEY --profile default
-    aws configure set region $AWS_DEFAULT_REGION --profile default
-    aws s3 cp --recursive /data/cache/$CACHE_KEY/lfs s3://${
-      CloudRunner.buildParameters.awsStackName
-    }/cloud-runner-cache/$CACHE_KEY/lfs
-    rm -r /data/cache/$CACHE_KEY/lfs
-    aws s3 cp --recursive /data/cache/$CACHE_KEY/Library s3://${
-      CloudRunner.buildParameters.awsStackName
-    }/cloud-runner-cache/$CACHE_KEY/Library
-    rm -r /data/cache/$CACHE_KEY/Library
-  secrets:
-  - name: AWS_ACCESS_KEY_ID
-    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
-  - name: AWS_SECRET_ACCESS_KEY
-    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
-  - name: AWS_DEFAULT_REGION
-    value: ${process.env.AWS_REGION || ``}
-- name: aws-s3-pull-cache
-  image: amazon/aws-cli
-  hook: before
-  commands: |
-    aws configure set aws_access_key_id $AWS_ACCESS_KEY_ID --profile default
-    aws configure set aws_secret_access_key $AWS_SECRET_ACCESS_KEY --profile default
-    aws configure set region $AWS_DEFAULT_REGION --profile default
-    mkdir -p /data/cache/$CACHE_KEY/Library/
-    mkdir -p /data/cache/$CACHE_KEY/lfs/
-    aws s3 ls ${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/ || true
-    aws s3 ls ${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/$CACHE_KEY/ || true
-    BUCKET1="${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/$CACHE_KEY/Library/"
-    aws s3 ls $BUCKET1 || true
-    OBJECT1="$(aws s3 ls $BUCKET1 | sort | tail -n 1 | awk '{print $4}' || '')"
-    aws s3 cp s3://$BUCKET1$OBJECT1 /data/cache/$CACHE_KEY/Library/ || true
-    BUCKET2="${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/$CACHE_KEY/lfs/"
-    aws s3 ls $BUCKET2 || true
-    OBJECT2="$(aws s3 ls $BUCKET2 | sort | tail -n 1 | awk '{print $4}' || '')"
-    aws s3 cp s3://$BUCKET2$OBJECT2 /data/cache/$CACHE_KEY/lfs/ || true
-  secrets:
-  - name: AWS_ACCESS_KEY_ID
-    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
-  - name: AWS_SECRET_ACCESS_KEY
-    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
-  - name: AWS_DEFAULT_REGION
-    value: ${process.env.AWS_REGION || ``}
-- name: debug-cache
-  image: ubuntu
-  hook: after
-  commands: |
-    apt-get update > /dev/null
-    ${CloudRunnerOptions.cloudRunnerDebug ? `apt-get install -y tree > /dev/null` : `#`}
-    ${CloudRunnerOptions.cloudRunnerDebug ? `tree -L 3 /data/cache` : `#`}
-  secrets:
-  - name: awsAccessKeyId
-    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
-  - name: awsSecretAccessKey
-    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
-  - name: awsDefaultRegion
-    value: ${process.env.AWS_REGION || ``}`,
-    ).filter((x) => CloudRunnerOptions.containerHookFiles.includes(x.name) && x.hook === hookLifecycle);
-    if (builtInContainerHooks.length > 0) {
-      results.push(...builtInContainerHooks);
-    }
-
-    return results;
-  }
-
-  private static ConvertYamlSecrets(object: ContainerHook) {
-    if (object.secrets === undefined) {
-      object.secrets = [];
-
-      return;
-    }
-    object.secrets = object.secrets.map((x: { [key: string]: any }) => {
-      return {
-        ParameterKey: x.name,
-        EnvironmentVariable: Input.ToEnvVarFormat(x.name),
-        ParameterValue: x.value,
-      };
-    });
-  }
-
-  public static ParseContainerHooks(steps: string): ContainerHook[] {
-    if (steps === '') {
-      return [];
-    }
-    const isArray = steps.replace(/\s/g, ``)[0] === `-`;
-    const object: ContainerHook[] = isArray ? YAML.parse(steps) : [YAML.parse(steps)];
-    for (const step of object) {
-      ContainerHookService.ConvertYamlSecrets(step);
-      if (step.secrets === undefined) {
-        step.secrets = [];
-      } else {
-        for (const secret of step.secrets) {
-          if (secret.ParameterValue === undefined && process.env[secret.EnvironmentVariable] !== undefined) {
-            if (CloudRunner.buildParameters?.cloudRunnerDebug) {
-              // CloudRunnerLogger.log(`Injecting custom step ${step.name} from env var ${secret.ParameterKey}`);
-            }
-            secret.ParameterValue = process.env[secret.ParameterKey] || ``;
-          }
-        }
-      }
-      if (step.image === undefined) {
-        step.image = `ubuntu`;
-      }
-    }
-    if (object === undefined) {
-      throw new Error(`Failed to parse ${steps}`);
-    }
-
-    return object;
-  }
-
-  static async RunPostBuildSteps(cloudRunnerStepState: CloudRunnerStepParameters) {
-    let output = ``;
-    const steps: ContainerHook[] = [
-      ...ContainerHookService.ParseContainerHooks(CloudRunner.buildParameters.postBuildContainerHooks),
-      ...ContainerHookService.GetContainerHooksFromFiles(`after`),
-    ];
-
-    if (steps.length > 0) {
-      output += await CustomWorkflow.runContainerJob(
-        steps,
-        cloudRunnerStepState.environment,
-        cloudRunnerStepState.secrets,
-      );
-    }
-
-    return output;
-  }
-  static async RunPreBuildSteps(cloudRunnerStepState: CloudRunnerStepParameters) {
-    let output = ``;
-    const steps: ContainerHook[] = [
-      ...ContainerHookService.ParseContainerHooks(CloudRunner.buildParameters.preBuildContainerHooks),
-      ...ContainerHookService.GetContainerHooksFromFiles(`before`),
-    ];
-
-    if (steps.length > 0) {
-      output += await CustomWorkflow.runContainerJob(
-        steps,
-        cloudRunnerStepState.environment,
-        cloudRunnerStepState.secrets,
-      );
-    }
-
-    return output;
-  }
-}

src/model/cloud-runner/services/hooks/container-hook.ts

@@ -1,9 +0,0 @@
-import CloudRunnerSecret from '../../options/cloud-runner-secret';
-
-export class ContainerHook {
-  public commands!: string;
-  public secrets: CloudRunnerSecret[] = new Array<CloudRunnerSecret>();
-  public name!: string;
-  public image: string = `ubuntu`;
-  public hook!: string;
-}

src/model/cloud-runner/tests/cloud-runner-s3-steps.test.ts

@@ -1,48 +0,0 @@
-import CloudRunner from '../cloud-runner';
-import { BuildParameters, ImageTag } from '../..';
-import UnityVersioning from '../../unity-versioning';
-import { Cli } from '../../cli/cli';
-import CloudRunnerLogger from '../services/core/cloud-runner-logger';
-import { v4 as uuidv4 } from 'uuid';
-import CloudRunnerOptions from '../options/cloud-runner-options';
-import setups from './cloud-runner-suite.test';
-import { CloudRunnerSystem } from '../services/core/cloud-runner-system';
-import { OptionValues } from 'commander';
-
-async function CreateParameters(overrides: OptionValues | undefined) {
-  if (overrides) {
-    Cli.options = overrides;
-  }
-
-  return await BuildParameters.create();
-}
-
-describe('Cloud Runner pre-built S3 steps', () => {
-  it('Responds', () => {});
-  setups();
-  if (CloudRunnerOptions.cloudRunnerDebug && CloudRunnerOptions.providerStrategy !== `local-docker`) {
-    it('Run build and prebuilt s3 cache pull, cache push and upload build', async () => {
-      const overrides = {
-        versioning: 'None',
-        projectPath: 'test-project',
-        unityVersion: UnityVersioning.determineUnityVersion('test-project', UnityVersioning.read('test-project')),
-        targetPlatform: 'StandaloneLinux64',
-        cacheKey: `test-case-${uuidv4()}`,
-        containerHookFiles: `aws-s3-pull-cache,aws-s3-upload-cache,aws-s3-upload-build`,
-      };
-      const buildParameter2 = await CreateParameters(overrides);
-      const baseImage2 = new ImageTag(buildParameter2);
-      const results2Object = await CloudRunner.run(buildParameter2, baseImage2.toString());
-      const results2 = results2Object.BuildResults;
-      CloudRunnerLogger.log(`run 2 succeeded`);
-
-      const build2ContainsBuildSucceeded = results2.includes('Build succeeded');
-      expect(build2ContainsBuildSucceeded).toBeTruthy();
-
-      const results = await CloudRunnerSystem.RunAndReadLines(
-        `aws s3 ls s3://${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/`,
-      );
-      CloudRunnerLogger.log(results.join(`,`));
-    }, 1_000_000_000);
-  }
-});

src/model/cloud-runner/tests/e2e/cloud-runner-end2end-caching.test.ts

@@ -1,92 +0,0 @@
-import CloudRunner from '../../cloud-runner';
-import { BuildParameters, ImageTag } from '../../..';
-import UnityVersioning from '../../../unity-versioning';
-import { Cli } from '../../../cli/cli';
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
-import { v4 as uuidv4 } from 'uuid';
-import CloudRunnerOptions from '../../options/cloud-runner-options';
-import setups from '../cloud-runner-suite.test';
-import * as fs from 'node:fs';
-import { CloudRunnerSystem } from '../../services/core/cloud-runner-system';
-
-async function CreateParameters(overrides: any) {
-  if (overrides) {
-    Cli.options = overrides;
-  }
-
-  return await BuildParameters.create();
-}
-
-describe('Cloud Runner Caching', () => {
-  it('Responds', () => {});
-  setups();
-  if (CloudRunnerOptions.cloudRunnerDebug) {
-    it('Run one build it should not use cache, run subsequent build which should use cache', async () => {
-      const overrides = {
-        versioning: 'None',
-        image: 'ubuntu',
-        projectPath: 'test-project',
-        unityVersion: UnityVersioning.determineUnityVersion('test-project', UnityVersioning.read('test-project')),
-        targetPlatform: 'StandaloneLinux64',
-        cacheKey: `test-case-${uuidv4()}`,
-        containerHookFiles: `debug-cache`,
-        cloudRunnerBranch: `cloud-runner-develop`,
-      };
-      if (CloudRunnerOptions.providerStrategy === `k8s`) {
-        overrides.containerHookFiles += `,aws-s3-pull-cache,aws-s3-upload-cache`;
-      }
-      const buildParameter = await CreateParameters(overrides);
-      expect(buildParameter.projectPath).toEqual(overrides.projectPath);
-
-      const baseImage = new ImageTag(buildParameter);
-      const resultsObject = await CloudRunner.run(buildParameter, baseImage.toString());
-      const results = resultsObject.BuildResults;
-      const libraryString = 'Rebuilding Library because the asset database could not be found!';
-      const cachePushFail = 'Did not push source folder to cache because it was empty Library';
-      const buildSucceededString = 'Build succeeded';
-
-      expect(results).toContain(libraryString);
-      expect(results).toContain(buildSucceededString);
-      expect(results).not.toContain(cachePushFail);
-
-      CloudRunnerLogger.log(`run 1 succeeded`);
-
-      if (CloudRunnerOptions.providerStrategy === `local-docker`) {
-        await CloudRunnerSystem.Run(`tree ./cloud-runner-cache/cache`);
-        await CloudRunnerSystem.Run(
-          `cp ./cloud-runner-cache/cache/${buildParameter.cacheKey}/Library/lib-${buildParameter.buildGuid}.tar ./`,
-        );
-        await CloudRunnerSystem.Run(`mkdir results`);
-        await CloudRunnerSystem.Run(`tar -xf lib-${buildParameter.buildGuid}.tar -C ./results`);
-        await CloudRunnerSystem.Run(`tree -d ./results`);
-        const cacheFolderExists = fs.existsSync(`cloud-runner-cache/cache/${overrides.cacheKey}`);
-        expect(cacheFolderExists).toBeTruthy();
-      }
-      const buildParameter2 = await CreateParameters(overrides);
-
-      buildParameter2.cacheKey = buildParameter.cacheKey;
-      const baseImage2 = new ImageTag(buildParameter2);
-      const results2Object = await CloudRunner.run(buildParameter2, baseImage2.toString());
-      const results2 = results2Object.BuildResults;
-      CloudRunnerLogger.log(`run 2 succeeded`);
-
-      const build2ContainsCacheKey = results2.includes(buildParameter.cacheKey);
-      const build2ContainsBuildSucceeded = results2.includes(buildSucceededString);
-      const build2NotContainsZeroLibraryCacheFilesMessage = !results2.includes(
-        'There is 0 files/dir in the cache pulled contents for Library',
-      );
-      const build2NotContainsZeroLFSCacheFilesMessage = !results2.includes(
-        'There is 0 files/dir in the cache pulled contents for LFS',
-      );
-
-      expect(build2ContainsCacheKey).toBeTruthy();
-      expect(results2).toContain('Activation successful');
-      expect(build2ContainsBuildSucceeded).toBeTruthy();
-      expect(results2).toContain(buildSucceededString);
-      const splitResults = results2.split('Activation successful');
-      expect(splitResults[splitResults.length - 1]).not.toContain(libraryString);
-      expect(build2NotContainsZeroLibraryCacheFilesMessage).toBeTruthy();
-      expect(build2NotContainsZeroLFSCacheFilesMessage).toBeTruthy();
-    }, 1_000_000_000);
-  }
-});

src/model/cloud-runner/tests/e2e/cloud-runner-end2end-retaining.test.ts

@@ -1,92 +0,0 @@
-import CloudRunner from '../../cloud-runner';
-import { ImageTag } from '../../..';
-import UnityVersioning from '../../../unity-versioning';
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
-import { v4 as uuidv4 } from 'uuid';
-import CloudRunnerOptions from '../../options/cloud-runner-options';
-import setups from './../cloud-runner-suite.test';
-import * as fs from 'node:fs';
-import path from 'node:path';
-import { CloudRunnerFolders } from '../../options/cloud-runner-folders';
-import SharedWorkspaceLocking from '../../services/core/shared-workspace-locking';
-import { CreateParameters } from '../create-test-parameter';
-import { CloudRunnerSystem } from '../../services/core/cloud-runner-system';
-
-describe('Cloud Runner Retain Workspace', () => {
-  it('Responds', () => {});
-  setups();
-  if (CloudRunnerOptions.cloudRunnerDebug) {
-    it('Run one build it should not already be retained, run subsequent build which should use retained workspace', async () => {
-      const overrides = {
-        versioning: 'None',
-        projectPath: 'test-project',
-        unityVersion: UnityVersioning.determineUnityVersion('test-project', UnityVersioning.read('test-project')),
-        targetPlatform: 'StandaloneLinux64',
-        cacheKey: `test-case-${uuidv4()}`,
-        maxRetainedWorkspaces: 1,
-      };
-      const buildParameter = await CreateParameters(overrides);
-      expect(buildParameter.projectPath).toEqual(overrides.projectPath);
-
-      const baseImage = new ImageTag(buildParameter);
-      const resultsObject = await CloudRunner.run(buildParameter, baseImage.toString());
-      const results = resultsObject.BuildResults;
-      const libraryString = 'Rebuilding Library because the asset database could not be found!';
-      const cachePushFail = 'Did not push source folder to cache because it was empty Library';
-      const buildSucceededString = 'Build succeeded';
-
-      expect(results).toContain(libraryString);
-      expect(results).toContain(buildSucceededString);
-      expect(results).not.toContain(cachePushFail);
-
-      if (CloudRunnerOptions.providerStrategy === `local-docker`) {
-        const cacheFolderExists = fs.existsSync(`cloud-runner-cache/cache/${overrides.cacheKey}`);
-        expect(cacheFolderExists).toBeTruthy();
-        await CloudRunnerSystem.Run(`tree -d ./cloud-runner-cache`);
-      }
-
-      CloudRunnerLogger.log(`run 1 succeeded`);
-
-      // await CloudRunnerSystem.Run(`tree -d ./cloud-runner-cache/${}`);
-      const buildParameter2 = await CreateParameters(overrides);
-
-      buildParameter2.cacheKey = buildParameter.cacheKey;
-      const baseImage2 = new ImageTag(buildParameter2);
-      const results2Object = await CloudRunner.run(buildParameter2, baseImage2.toString());
-      const results2 = results2Object.BuildResults;
-      CloudRunnerLogger.log(`run 2 succeeded`);
-
-      const build2ContainsCacheKey = results2.includes(buildParameter.cacheKey);
-      const build2ContainsBuildGuid1FromRetainedWorkspace = results2.includes(buildParameter.buildGuid);
-      const build2ContainsRetainedWorkspacePhrase = results2.includes(`Retained Workspace:`);
-      const build2ContainsWorkspaceExistsAlreadyPhrase = results2.includes(`Retained Workspace Already Exists!`);
-      const build2ContainsBuildSucceeded = results2.includes(buildSucceededString);
-      const build2NotContainsZeroLibraryCacheFilesMessage = !results2.includes(
-        'There is 0 files/dir in the cache pulled contents for Library',
-      );
-      const build2NotContainsZeroLFSCacheFilesMessage = !results2.includes(
-        'There is 0 files/dir in the cache pulled contents for LFS',
-      );
-
-      expect(build2ContainsCacheKey).toBeTruthy();
-      expect(build2ContainsRetainedWorkspacePhrase).toBeTruthy();
-      expect(build2ContainsWorkspaceExistsAlreadyPhrase).toBeTruthy();
-      expect(build2ContainsBuildGuid1FromRetainedWorkspace).toBeTruthy();
-      expect(build2ContainsBuildSucceeded).toBeTruthy();
-      expect(build2NotContainsZeroLibraryCacheFilesMessage).toBeTruthy();
-      expect(build2NotContainsZeroLFSCacheFilesMessage).toBeTruthy();
-      const splitResults = results2.split('Activation successful');
-      expect(splitResults[splitResults.length - 1]).not.toContain(libraryString);
-    }, 1_000_000_000);
-    afterAll(async () => {
-      await SharedWorkspaceLocking.CleanupWorkspace(CloudRunner.lockedWorkspace || ``, CloudRunner.buildParameters);
-      if (
-        fs.existsSync(`./cloud-runner-cache/${path.basename(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute)}`)
-      ) {
-        CloudRunnerLogger.log(
-          `Cleaning up ./cloud-runner-cache/${path.basename(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute)}`,
-        );
-      }
-    });
-  }
-});

src/model/cloud-runner/tests/e2e/cloud-runner-kubernetes.test.ts

@@ -1,56 +0,0 @@
-import CloudRunner from '../../cloud-runner';
-import UnityVersioning from '../../../unity-versioning';
-import { Cli } from '../../../cli/cli';
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
-import { v4 as uuidv4 } from 'uuid';
-import CloudRunnerOptions from '../../options/cloud-runner-options';
-import setups from '../cloud-runner-suite.test';
-import BuildParameters from '../../../build-parameters';
-import ImageTag from '../../../image-tag';
-
-async function CreateParameters(overrides: any) {
-  if (overrides) {
-    Cli.options = overrides;
-  }
-
-  return await BuildParameters.create();
-}
-
-describe('Cloud Runner Kubernetes', () => {
-  it('Responds', () => {});
-  setups();
-
-  if (CloudRunnerOptions.cloudRunnerDebug) {
-    it('Run one build it using K8s without error', async () => {
-      if (CloudRunnerOptions.providerStrategy !== `k8s`) {
-        return;
-      }
-      process.env.USE_IL2CPP = 'false';
-      const overrides = {
-        versioning: 'None',
-        projectPath: 'test-project',
-        unityVersion: UnityVersioning.determineUnityVersion('test-project', UnityVersioning.read('test-project')),
-        targetPlatform: 'StandaloneLinux64',
-        cacheKey: `test-case-${uuidv4()}`,
-        providerStrategy: 'k8s',
-        buildPlatform: 'linux',
-      };
-      const buildParameter = await CreateParameters(overrides);
-      expect(buildParameter.projectPath).toEqual(overrides.projectPath);
-
-      const baseImage = new ImageTag(buildParameter);
-      const resultsObject = await CloudRunner.run(buildParameter, baseImage.toString());
-      const results = resultsObject.BuildResults;
-      const libraryString = 'Rebuilding Library because the asset database could not be found!';
-      const cachePushFail = 'Did not push source folder to cache because it was empty Library';
-      const buildSucceededString = 'Build succeeded';
-
-      expect(results).toContain('Collected Logs');
-      expect(results).toContain(libraryString);
-      expect(results).toContain(buildSucceededString);
-      expect(results).not.toContain(cachePushFail);
-
-      CloudRunnerLogger.log(`run 1 succeeded`);
-    }, 1_000_000_000);
-  }
-});

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

@@ -1,114 +0,0 @@
-import CloudRunnerLogger from '../services/core/cloud-runner-logger';
-import { CloudRunnerFolders } from '../options/cloud-runner-folders';
-import { CloudRunnerStepParameters } from '../options/cloud-runner-step-parameters';
-import { WorkflowInterface } from './workflow-interface';
-import { CommandHookService } from '../services/hooks/command-hook-service';
-import path from 'node:path';
-import CloudRunner from '../cloud-runner';
-import { ContainerHookService } from '../services/hooks/container-hook-service';
-
-export class BuildAutomationWorkflow implements WorkflowInterface {
-  async run(cloudRunnerStepState: CloudRunnerStepParameters) {
-    return await BuildAutomationWorkflow.standardBuildAutomation(cloudRunnerStepState.image, cloudRunnerStepState);
-  }
-
-  private static async standardBuildAutomation(baseImage: string, cloudRunnerStepState: CloudRunnerStepParameters) {
-    // TODO accept post and pre build steps as yaml files in the repo
-    CloudRunnerLogger.log(`Cloud Runner is running standard build automation`);
-
-    let output = '';
-
-    output += await ContainerHookService.RunPreBuildSteps(cloudRunnerStepState);
-    CloudRunnerLogger.logWithTime('Configurable pre build step(s) time');
-    CloudRunnerLogger.log(baseImage);
-    CloudRunnerLogger.logLine(` `);
-    CloudRunnerLogger.logLine('Starting build automation job');
-
-    output += await CloudRunner.Provider.runTaskInWorkflow(
-      CloudRunner.buildParameters.buildGuid,
-      baseImage.toString(),
-      BuildAutomationWorkflow.BuildWorkflow,
-      `/${CloudRunnerFolders.buildVolumeFolder}`,
-      `/${CloudRunnerFolders.buildVolumeFolder}/`,
-      cloudRunnerStepState.environment,
-      cloudRunnerStepState.secrets,
-    );
-    CloudRunnerLogger.logWithTime('Build time');
-
-    output += await ContainerHookService.RunPostBuildSteps(cloudRunnerStepState);
-    CloudRunnerLogger.logWithTime('Configurable post build step(s) time');
-
-    CloudRunnerLogger.log(`Cloud Runner finished running standard build automation`);
-
-    return output;
-  }
-
-  private static get BuildWorkflow() {
-    const setupHooks = CommandHookService.getHooks(CloudRunner.buildParameters.commandHooks).filter((x) =>
-      x.step?.includes(`setup`),
-    );
-    const buildHooks = CommandHookService.getHooks(CloudRunner.buildParameters.commandHooks).filter((x) =>
-      x.step?.includes(`build`),
-    );
-    const builderPath = CloudRunnerFolders.ToLinuxFolder(
-      path.join(CloudRunnerFolders.builderPathAbsolute, 'dist', `index.js`),
-    );
-
-    return `echo "cloud runner build workflow starting"
-      apt-get update > /dev/null
-      apt-get install -y curl tar tree npm git-lfs jq git > /dev/null
-      npm --version
-      npm i -g n > /dev/null
-      npm i -g semver > /dev/null
-      npm install --global yarn > /dev/null
-      n 20.8.0
-      node --version
-      ${setupHooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
-      export GITHUB_WORKSPACE="${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.repoPathAbsolute)}"
-      df -H /data/
-      ${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)}
-      ${buildHooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}`;
-  }
-
-  private static setupCommands(builderPath: string) {
-    const commands = `mkdir -p ${CloudRunnerFolders.ToLinuxFolder(
-      CloudRunnerFolders.builderPathAbsolute,
-    )} && git clone -q -b ${CloudRunner.buildParameters.cloudRunnerBranch} ${
-      CloudRunnerFolders.unityBuilderRepoUrl
-    } "${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.builderPathAbsolute)}" && chmod +x ${builderPath}`;
-
-    const cloneBuilderCommands = `if [ -e "${CloudRunnerFolders.ToLinuxFolder(
-      CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute,
-    )}" ] && [ -e "${CloudRunnerFolders.ToLinuxFolder(
-      path.join(CloudRunnerFolders.builderPathAbsolute, `.git`),
-    )}" ] ; then echo "Builder Already Exists!" && tree ${
-      CloudRunnerFolders.builderPathAbsolute
-    }; else ${commands} ; fi`;
-
-    return `export GIT_DISCOVERY_ACROSS_FILESYSTEM=1
-${cloneBuilderCommands}
-echo "log start" >> /home/job-log.txt
-node ${builderPath} -m remote-cli-pre-build`;
-  }
-
-  private static BuildCommands(builderPath: string) {
-    const distFolder = path.join(CloudRunnerFolders.builderPathAbsolute, 'dist');
-    const ubuntuPlatformsFolder = path.join(CloudRunnerFolders.builderPathAbsolute, 'dist', 'platforms', 'ubuntu');
-
-    return `
-    mkdir -p ${`${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.projectBuildFolderAbsolute)}/build`}
-    cd ${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.projectPathAbsolute)}
-    cp -r "${CloudRunnerFolders.ToLinuxFolder(path.join(distFolder, 'default-build-script'))}" "/UnityBuilderAction"
-    cp -r "${CloudRunnerFolders.ToLinuxFolder(path.join(ubuntuPlatformsFolder, 'entrypoint.sh'))}" "/entrypoint.sh"
-    cp -r "${CloudRunnerFolders.ToLinuxFolder(path.join(ubuntuPlatformsFolder, 'steps'))}" "/steps"
-    chmod -R +x "/entrypoint.sh"
-    chmod -R +x "/steps"
-    echo "game ci start"
-    echo "game ci start" >> /home/job-log.txt
-    /entrypoint.sh | node ${builderPath} -m remote-cli-log-stream --logFile /home/job-log.txt
-    node ${builderPath} -m remote-cli-post-build`;
-  }
-}

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

@@ -1,51 +0,0 @@
-import CloudRunnerLogger from '../services/core/cloud-runner-logger';
-import CloudRunnerSecret from '../options/cloud-runner-secret';
-import { CloudRunnerFolders } from '../options/cloud-runner-folders';
-import CloudRunnerEnvironmentVariable from '../options/cloud-runner-environment-variable';
-import { ContainerHookService } from '../services/hooks/container-hook-service';
-import { ContainerHook } from '../services/hooks/container-hook';
-import CloudRunner from '../cloud-runner';
-
-export class CustomWorkflow {
-  public static async runContainerJobFromString(
-    buildSteps: string,
-    environmentVariables: CloudRunnerEnvironmentVariable[],
-    secrets: CloudRunnerSecret[],
-  ): Promise<string> {
-    return await CustomWorkflow.runContainerJob(
-      ContainerHookService.ParseContainerHooks(buildSteps),
-      environmentVariables,
-      secrets,
-    );
-  }
-
-  public static async runContainerJob(
-    steps: ContainerHook[],
-    environmentVariables: CloudRunnerEnvironmentVariable[],
-    secrets: CloudRunnerSecret[],
-  ) {
-    try {
-      let output = '';
-
-      // if (CloudRunner.buildParameters?.cloudRunnerDebug) {
-      //   CloudRunnerLogger.log(`Custom Job Description \n${JSON.stringify(buildSteps, undefined, 4)}`);
-      // }
-      for (const step of steps) {
-        CloudRunnerLogger.log(`Cloud Runner is running in custom job mode`);
-        output += await CloudRunner.Provider.runTaskInWorkflow(
-          CloudRunner.buildParameters.buildGuid,
-          step.image,
-          step.commands,
-          `/${CloudRunnerFolders.buildVolumeFolder}`,
-          `/${CloudRunnerFolders.projectPathAbsolute}/`,
-          environmentVariables,
-          [...secrets, ...step.secrets],
-        );
-      }
-
-      return output;
-    } catch (error) {
-      throw error;
-    }
-  }
-}

src/model/cloud-runner/workflows/workflow-composition-root.ts

@@ -1,39 +0,0 @@
-import { CloudRunnerStepParameters } from '../options/cloud-runner-step-parameters';
-import { CustomWorkflow } from './custom-workflow';
-import { WorkflowInterface } from './workflow-interface';
-import { BuildAutomationWorkflow } from './build-automation-workflow';
-import CloudRunner from '../cloud-runner';
-import CloudRunnerOptions from '../options/cloud-runner-options';
-import { AsyncWorkflow } from './async-workflow';
-
-export class WorkflowCompositionRoot implements WorkflowInterface {
-  async run(cloudRunnerStepState: CloudRunnerStepParameters) {
-    try {
-      if (
-        CloudRunnerOptions.asyncCloudRunner &&
-        !CloudRunner.isCloudRunnerAsyncEnvironment &&
-        !CloudRunner.isCloudRunnerEnvironment
-      ) {
-        return await AsyncWorkflow.runAsyncWorkflow(cloudRunnerStepState.environment, cloudRunnerStepState.secrets);
-      }
-
-      if (CloudRunner.buildParameters.customJob !== '') {
-        return await CustomWorkflow.runContainerJobFromString(
-          CloudRunner.buildParameters.customJob,
-          cloudRunnerStepState.environment,
-          cloudRunnerStepState.secrets,
-        );
-      }
-
-      return await new BuildAutomationWorkflow().run(
-        new CloudRunnerStepParameters(
-          cloudRunnerStepState.image.toString(),
-          cloudRunnerStepState.environment,
-          cloudRunnerStepState.secrets,
-        ),
-      );
-    } catch (error) {
-      throw error;
-    }
-  }
-}

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

@@ -1,8 +0,0 @@
-import { CloudRunnerStepParameters } from '../options/cloud-runner-step-parameters';
-
-export interface WorkflowInterface {
-  run(
-    // eslint-disable-next-line no-unused-vars
-    cloudRunnerStepState: CloudRunnerStepParameters,
-  ): Promise<string>;
-}

src/model/docker.ts

@@ -55,7 +55,10 @@ class Docker {
     if (!existsSync(githubHome)) mkdirSync(githubHome);
     const githubWorkflow = path.join(runnerTempPath, '_github_workflow');
     if (!existsSync(githubWorkflow)) mkdirSync(githubWorkflow);
-    const commandPrefix = image === `alpine` ? `/bin/sh` : `/bin/bash`;
+
+    // Alpine-based images (alpine, rclone/rclone, etc.) don't have /bin/bash, only /bin/sh
+    const isAlpineBasedImage = image === 'alpine' || image.startsWith('rclone/');
+    const commandPrefix = isAlpineBasedImage ? `/bin/sh` : `/bin/bash`;
 
     return `docker run \
             --workdir ${dockerWorkspacePath} \

src/model/github.ts

@@ -1,6 +1,6 @@
-import CloudRunnerLogger from './cloud-runner/services/core/cloud-runner-logger';
-import CloudRunner from './cloud-runner/cloud-runner';
-import CloudRunnerOptions from './cloud-runner/options/cloud-runner-options';
+import OrchestratorLogger from './orchestrator/services/core/orchestrator-logger';
+import Orchestrator from './orchestrator/orchestrator';
+import OrchestratorOptions from './orchestrator/options/orchestrator-options';
 import * as core from '@actions/core';
 import { Octokit } from '@octokit/core';
 
@@ -19,15 +19,15 @@ class GitHub {
   }
   private static get octokitPAT() {
     return new Octokit({
-      auth: CloudRunner.buildParameters.gitPrivateToken,
+      auth: Orchestrator.buildParameters.gitPrivateToken,
     });
   }
   private static get sha() {
-    return CloudRunner.buildParameters.gitSha;
+    return Orchestrator.buildParameters.gitSha;
   }
 
   private static get checkName() {
-    return `Cloud Runner (${CloudRunner.buildParameters.buildGuid})`;
+    return `Orchestrator (${Orchestrator.buildParameters.buildGuid})`;
   }
 
   private static get nameReadable() {
@@ -35,24 +35,24 @@ class GitHub {
   }
 
   private static get checkRunId() {
-    return CloudRunner.buildParameters.githubCheckId;
+    return Orchestrator.buildParameters.githubCheckId;
   }
 
   private static get owner() {
-    return CloudRunnerOptions.githubOwner;
+    return OrchestratorOptions.githubOwner;
   }
 
   private static get repo() {
-    return CloudRunnerOptions.githubRepoName;
+    return OrchestratorOptions.githubRepoName;
   }
 
   public static async createGitHubCheck(summary: string) {
-    if (!CloudRunner.buildParameters.githubChecks) {
+    if (!Orchestrator.buildParameters.githubChecks) {
       return ``;
     }
     GitHub.startedDate = new Date().toISOString();
 
-    CloudRunnerLogger.log(`Creating github check`);
+    OrchestratorLogger.log(`Creating github check`);
     const data = {
       owner: GitHub.owner,
       repo: GitHub.repo,
@@ -61,7 +61,7 @@ class GitHub {
       head_sha: GitHub.sha,
       status: 'queued',
       // eslint-disable-next-line camelcase
-      external_id: CloudRunner.buildParameters.buildGuid,
+      external_id: Orchestrator.buildParameters.buildGuid,
       // eslint-disable-next-line camelcase
       started_at: GitHub.startedDate,
       output: {
@@ -79,7 +79,7 @@ class GitHub {
     };
     const result = await GitHub.createGitHubCheckRequest(data);
 
-    CloudRunnerLogger.log(`Creating github check ${result.status}`);
+    OrchestratorLogger.log(`Creating github check ${result.status}`);
 
     return result.data.id.toString();
   }
@@ -90,11 +90,11 @@ class GitHub {
     result = `neutral`,
     status = `in_progress`,
   ) {
-    if (`${CloudRunner.buildParameters.githubChecks}` !== `true`) {
+    if (`${Orchestrator.buildParameters.githubChecks}` !== `true`) {
       return;
     }
-    CloudRunnerLogger.log(
-      `githubChecks: ${CloudRunner.buildParameters.githubChecks} checkRunId: ${GitHub.checkRunId} sha: ${GitHub.sha} async: ${CloudRunner.isCloudRunnerAsyncEnvironment}`,
+    OrchestratorLogger.log(
+      `githubChecks: ${Orchestrator.buildParameters.githubChecks} checkRunId: ${GitHub.checkRunId} sha: ${GitHub.sha} async: ${Orchestrator.isOrchestratorAsyncEnvironment}`,
     );
     GitHub.longDescriptionContent += `\n${longDescription}`;
     if (GitHub.result !== `success` && GitHub.result !== `failure`) {
@@ -130,7 +130,7 @@ class GitHub {
       data.conclusion = result;
     }
 
-    await (CloudRunner.isCloudRunnerAsyncEnvironment || GitHub.forceAsyncTest
+    await (Orchestrator.isOrchestratorAsyncEnvironment || GitHub.forceAsyncTest
       ? GitHub.runUpdateAsyncChecksWorkflow(data, `update`)
       : GitHub.updateGitHubCheckRequest(data));
   }
@@ -152,7 +152,7 @@ class GitHub {
       repo: GitHub.repo,
     });
     const workflows = workflowsResult.data.workflows;
-    CloudRunnerLogger.log(`Got ${workflows.length} workflows`);
+    OrchestratorLogger.log(`Got ${workflows.length} workflows`);
     let selectedId = ``;
     for (let index = 0; index < workflowsResult.data.total_count; index++) {
       if (workflows[index].name === GitHub.asyncChecksApiWorkflowName) {
@@ -168,7 +168,7 @@ class GitHub {
       repo: GitHub.repo,
       // eslint-disable-next-line camelcase
       workflow_id: selectedId,
-      ref: CloudRunnerOptions.branch,
+      ref: OrchestratorOptions.branch,
       inputs: {
         checksObject: JSON.stringify({ data, mode }),
       },
@@ -176,7 +176,7 @@ class GitHub {
   }
 
   static async triggerWorkflowOnComplete(triggerWorkflowOnComplete: string[]) {
-    const isLocalAsync = CloudRunner.buildParameters.asyncWorkflow && !CloudRunner.isCloudRunnerAsyncEnvironment;
+    const isLocalAsync = Orchestrator.buildParameters.asyncWorkflow && !Orchestrator.isOrchestratorAsyncEnvironment;
     if (isLocalAsync || triggerWorkflowOnComplete === undefined || triggerWorkflowOnComplete.length === 0) {
       return;
     }
@@ -186,7 +186,7 @@ class GitHub {
         repo: GitHub.repo,
       });
       const workflows = workflowsResult.data.workflows;
-      CloudRunnerLogger.log(`Got ${workflows.length} workflows`);
+      OrchestratorLogger.log(`Got ${workflows.length} workflows`);
       for (const element of triggerWorkflowOnComplete) {
         let selectedId = ``;
         for (let index = 0; index < workflowsResult.data.total_count; index++) {
@@ -203,9 +203,9 @@ class GitHub {
           repo: GitHub.repo,
           // eslint-disable-next-line camelcase
           workflow_id: selectedId,
-          ref: CloudRunnerOptions.branch,
+          ref: OrchestratorOptions.branch,
           inputs: {
-            buildGuid: CloudRunner.buildParameters.buildGuid,
+            buildGuid: Orchestrator.buildParameters.buildGuid,
           },
         });
       }

src/model/image-environment-factory.ts

@@ -5,16 +5,17 @@ class ImageEnvironmentFactory {
     const environmentVariables = ImageEnvironmentFactory.getEnvironmentVariables(parameters, additionalVariables);
     let string = '';
     for (const p of environmentVariables) {
-      if (p.value === '' || p.value === undefined) {
+      if (p.value === '' || p.value === undefined || p.value === null) {
         continue;
       }
-      if (p.name !== 'ANDROID_KEYSTORE_BASE64' && p.value.toString().includes(`\n`)) {
+      const valueAsString = typeof p.value === 'string' ? p.value : String(p.value);
+      if (p.name !== 'ANDROID_KEYSTORE_BASE64' && valueAsString.includes(`\n`)) {
         string += `--env ${p.name} `;
-        process.env[p.name] = p.value.toString();
+        process.env[p.name] = valueAsString;
         continue;
       }
 
-      string += `--env ${p.name}="${p.value}" `;
+      string += `--env ${p.name}="${valueAsString}" `;
     }
 
     return string;
@@ -82,17 +83,12 @@ class ImageEnvironmentFactory {
       { name: 'RUNNER_TEMP', value: process.env.RUNNER_TEMP },
       { name: 'RUNNER_WORKSPACE', value: process.env.RUNNER_WORKSPACE },
     ];
-    if (parameters.providerStrategy === 'local-docker') {
-      for (const element of additionalVariables) {
-        if (!environmentVariables.some((x) => element?.name === x?.name)) {
-          environmentVariables.push(element);
-        }
-      }
-      for (const variable of environmentVariables) {
-        if (!environmentVariables.some((x) => variable?.name === x?.name)) {
-          environmentVariables = environmentVariables.filter((x) => x !== variable);
-        }
-      }
+
+    // Always merge additional variables (e.g., secrets/env from Orchestrator) uniquely by name
+    for (const element of additionalVariables) {
+      if (!element || !element.name) continue;
+      environmentVariables = environmentVariables.filter((x) => x?.name !== element.name);
+      environmentVariables.push(element);
     }
     if (parameters.sshAgent) {
       environmentVariables.push({ name: 'SSH_AUTH_SOCK', value: '/ssh-agent' });

src/model/index.ts

@@ -9,7 +9,8 @@ import Platform from './platform';
 import Project from './project';
 import Unity from './unity';
 import Versioning from './versioning';
-import CloudRunner from './cloud-runner/cloud-runner';
+import Orchestrator from './orchestrator/orchestrator';
+import loadProvider, { ProviderLoader } from './orchestrator/providers/provider-loader';
 
 export {
   Action,
@@ -23,5 +24,7 @@ export {
   Project,
   Unity,
   Versioning,
-  CloudRunner as CloudRunner,
+  Orchestrator as Orchestrator,
+  loadProvider,
+  ProviderLoader,
 };

src/model/input-readers/generic-input-reader.ts

@@ -1,12 +1,12 @@
-import { CloudRunnerSystem } from '../cloud-runner/services/core/cloud-runner-system';
-import CloudRunnerOptions from '../cloud-runner/options/cloud-runner-options';
+import { OrchestratorSystem } from '../orchestrator/services/core/orchestrator-system';
+import OrchestratorOptions from '../orchestrator/options/orchestrator-options';
 
 export class GenericInputReader {
   public static async Run(command: string) {
-    if (CloudRunnerOptions.providerStrategy === 'local') {
+    if (OrchestratorOptions.providerStrategy === 'local') {
       return '';
     }
 
-    return await CloudRunnerSystem.Run(command, false, true);
+    return await OrchestratorSystem.Run(command, false, true);
   }
 }

src/model/input-readers/git-repo.test.ts

@@ -1,6 +1,6 @@
 import { GitRepoReader } from './git-repo';
-import { CloudRunnerSystem } from '../cloud-runner/services/core/cloud-runner-system';
-import CloudRunnerOptions from '../cloud-runner/options/cloud-runner-options';
+import { OrchestratorSystem } from '../orchestrator/services/core/orchestrator-system';
+import OrchestratorOptions from '../orchestrator/options/orchestrator-options';
 
 describe(`git repo tests`, () => {
   it(`Branch value parsed from CLI to not contain illegal characters`, async () => {
@@ -10,15 +10,15 @@ describe(`git repo tests`, () => {
 
   it(`returns valid branch name when using https`, async () => {
     const mockValue = 'https://github.com/example/example.git';
-    await jest.spyOn(CloudRunnerSystem, 'Run').mockReturnValue(Promise.resolve(mockValue));
-    await jest.spyOn(CloudRunnerOptions, 'providerStrategy', 'get').mockReturnValue('not-local');
+    await jest.spyOn(OrchestratorSystem, 'Run').mockReturnValue(Promise.resolve(mockValue));
+    await jest.spyOn(OrchestratorOptions, 'providerStrategy', 'get').mockReturnValue('not-local');
     expect(await GitRepoReader.GetRemote()).toEqual(`example/example`);
   });
 
   it(`returns valid branch name when using ssh`, async () => {
     const mockValue = 'git@github.com:example/example.git';
-    await jest.spyOn(CloudRunnerSystem, 'Run').mockReturnValue(Promise.resolve(mockValue));
-    await jest.spyOn(CloudRunnerOptions, 'providerStrategy', 'get').mockReturnValue('not-local');
+    await jest.spyOn(OrchestratorSystem, 'Run').mockReturnValue(Promise.resolve(mockValue));
+    await jest.spyOn(OrchestratorOptions, 'providerStrategy', 'get').mockReturnValue('not-local');
     expect(await GitRepoReader.GetRemote()).toEqual(`example/example`);
   });
 });

src/model/input-readers/git-repo.ts

@@ -1,33 +1,33 @@
 import { assert } from 'node:console';
 import fs from 'node:fs';
-import { CloudRunnerSystem } from '../cloud-runner/services/core/cloud-runner-system';
-import CloudRunnerLogger from '../cloud-runner/services/core/cloud-runner-logger';
-import CloudRunnerOptions from '../cloud-runner/options/cloud-runner-options';
+import { OrchestratorSystem } from '../orchestrator/services/core/orchestrator-system';
+import OrchestratorLogger from '../orchestrator/services/core/orchestrator-logger';
+import OrchestratorOptions from '../orchestrator/options/orchestrator-options';
 import Input from '../input';
 
 export class GitRepoReader {
   public static async GetRemote() {
-    if (CloudRunnerOptions.providerStrategy === 'local') {
+    if (OrchestratorOptions.providerStrategy === 'local') {
       return '';
     }
     assert(fs.existsSync(`.git`));
-    const value = (await CloudRunnerSystem.Run(`cd ${Input.projectPath} && git remote -v`, false, true)).replace(
+    const value = (await OrchestratorSystem.Run(`cd ${Input.projectPath} && git remote -v`, false, true)).replace(
       / /g,
       ``,
     );
-    CloudRunnerLogger.log(`value ${value}`);
+    OrchestratorLogger.log(`value ${value}`);
     assert(value.includes('github.com'));
 
     return value.split('github.com')[1].split('.git')[0].slice(1);
   }
 
   public static async GetBranch() {
-    if (CloudRunnerOptions.providerStrategy === 'local') {
+    if (OrchestratorOptions.providerStrategy === 'local') {
       return '';
     }
     assert(fs.existsSync(`.git`));
 
-    return (await CloudRunnerSystem.Run(`cd ${Input.projectPath} && git branch --show-current`, false, true))
+    return (await OrchestratorSystem.Run(`cd ${Input.projectPath} && git branch --show-current`, false, true))
       .split('\n')[0]
       .replace(/ /g, ``)
       .replace('/head', '');

src/model/input-readers/github-cli.ts

@@ -1,19 +1,19 @@
-import { CloudRunnerSystem } from '../cloud-runner/services/core/cloud-runner-system';
+import { OrchestratorSystem } from '../orchestrator/services/core/orchestrator-system';
 import * as core from '@actions/core';
-import CloudRunnerOptions from '../cloud-runner/options/cloud-runner-options';
+import OrchestratorOptions from '../orchestrator/options/orchestrator-options';
 
 export class GithubCliReader {
   static async GetGitHubAuthToken() {
-    if (CloudRunnerOptions.providerStrategy === 'local') {
+    if (OrchestratorOptions.providerStrategy === 'local') {
       return '';
     }
     try {
-      const authStatus = await CloudRunnerSystem.Run(`gh auth status`, true, true);
+      const authStatus = await OrchestratorSystem.Run(`gh auth status`, true, true);
       if (authStatus.includes('You are not logged') || authStatus === '') {
         return '';
       }
 
-      return (await CloudRunnerSystem.Run(`gh auth status -t`, false, true))
+      return (await OrchestratorSystem.Run(`gh auth status -t`, false, true))
         .split(`Token: `)[1]
         .replace(/ /g, '')
         .replace(/\n/g, '');

src/model/input-readers/test-license-reader.ts

@@ -1,13 +1,13 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import YAML from 'yaml';
-import CloudRunnerOptions from '../cloud-runner/options/cloud-runner-options';
+import OrchestratorOptions from '../orchestrator/options/orchestrator-options';
 
 export function ReadLicense(): string {
-  if (CloudRunnerOptions.providerStrategy === 'local') {
+  if (OrchestratorOptions.providerStrategy === 'local') {
     return '';
   }
-  const pipelineFile = path.join(__dirname, `.github`, `workflows`, `cloud-runner-k8s-pipeline.yml`);
+  const pipelineFile = path.join(__dirname, `.github`, `workflows`, `orchestrator-k8s-pipeline.yml`);
 
   return fs.existsSync(pipelineFile) ? YAML.parse(fs.readFileSync(pipelineFile, 'utf8')).env.UNITY_LICENSE : '';
 }

src/model/input.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { Cli } from './cli/cli';
-import CloudRunnerQueryOverride from './cloud-runner/options/cloud-runner-query-override';
+import OrchestratorQueryOverride from './orchestrator/options/orchestrator-query-override';
 import Platform from './platform';
 import GitHub from './github';
 import os from 'node:os';
@@ -32,8 +32,8 @@ class Input {
       return Cli.query(query, alternativeQuery);
     }
 
-    if (CloudRunnerQueryOverride.query(query, alternativeQuery)) {
-      return CloudRunnerQueryOverride.query(query, alternativeQuery);
+    if (OrchestratorQueryOverride.query(query, alternativeQuery)) {
+      return OrchestratorQueryOverride.query(query, alternativeQuery);
     }
 
     if (process.env[query] !== undefined) {

src/model/orchestrator/error/orchestrator-error.ts

@@ -0,0 +1,15 @@
+import OrchestratorLogger from '../services/core/orchestrator-logger';
+import * as core from '@actions/core';
+import Orchestrator from '../orchestrator';
+import OrchestratorSecret from '../options/orchestrator-secret';
+import BuildParameters from '../../build-parameters';
+
+export class OrchestratorError {
+  public static async handleException(error: unknown, buildParameters: BuildParameters, secrets: OrchestratorSecret[]) {
+    OrchestratorLogger.error(JSON.stringify(error, undefined, 4));
+    core.setFailed('Orchestrator failed');
+    if (Orchestrator.Provider !== undefined) {
+      await Orchestrator.Provider.cleanupWorkflow(buildParameters, buildParameters.branch, secrets);
+    }
+  }
+}

src/model/orchestrator/options/orchestrator-constants.ts

@@ -0,0 +1,4 @@
+class OrchestratorConstants {
+  static alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
+}
+export default OrchestratorConstants;

src/model/orchestrator/options/orchestrator-environment-variable.ts

@@ -0,0 +1,5 @@
+class OrchestratorEnvironmentVariable {
+  public name!: string;
+  public value!: string;
+}
+export default OrchestratorEnvironmentVariable;

src/model/orchestrator/options/orchestrator-folders.ts

@@ -0,0 +1,90 @@
+import path from 'node:path';
+import OrchestratorOptions from './orchestrator-options';
+import Orchestrator from '../orchestrator';
+import BuildParameters from '../../build-parameters';
+
+export class OrchestratorFolders {
+  public static readonly repositoryFolder = 'repo';
+
+  public static ToLinuxFolder(folder: string) {
+    return folder.replace(/\\/g, `/`);
+  }
+
+  // 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 uniqueOrchestratorJobFolderAbsolute(): string {
+    return Orchestrator.buildParameters && BuildParameters.shouldUseRetainedWorkspaceMode(Orchestrator.buildParameters)
+      ? path.join(`/`, OrchestratorFolders.buildVolumeFolder, Orchestrator.lockedWorkspace)
+      : path.join(`/`, OrchestratorFolders.buildVolumeFolder, Orchestrator.buildParameters.buildGuid);
+  }
+
+  public static get cacheFolderForAllFull(): string {
+    return path.join('/', OrchestratorFolders.buildVolumeFolder, OrchestratorFolders.cacheFolder);
+  }
+
+  public static get cacheFolderForCacheKeyFull(): string {
+    return path.join(
+      '/',
+      OrchestratorFolders.buildVolumeFolder,
+      OrchestratorFolders.cacheFolder,
+      Orchestrator.buildParameters.cacheKey,
+    );
+  }
+
+  public static get builderPathAbsolute(): string {
+    return path.join(
+      OrchestratorOptions.useSharedBuilder
+        ? `/${OrchestratorFolders.buildVolumeFolder}`
+        : OrchestratorFolders.uniqueOrchestratorJobFolderAbsolute,
+      `builder`,
+    );
+  }
+
+  public static get repoPathAbsolute(): string {
+    return path.join(OrchestratorFolders.uniqueOrchestratorJobFolderAbsolute, OrchestratorFolders.repositoryFolder);
+  }
+
+  public static get projectPathAbsolute(): string {
+    return path.join(OrchestratorFolders.repoPathAbsolute, Orchestrator.buildParameters.projectPath);
+  }
+
+  public static get libraryFolderAbsolute(): string {
+    return path.join(OrchestratorFolders.projectPathAbsolute, `Library`);
+  }
+
+  public static get projectBuildFolderAbsolute(): string {
+    return path.join(OrchestratorFolders.repoPathAbsolute, Orchestrator.buildParameters.buildPath);
+  }
+
+  public static get lfsFolderAbsolute(): string {
+    return path.join(OrchestratorFolders.repoPathAbsolute, `.git`, `lfs`);
+  }
+
+  public static get purgeRemoteCaching(): boolean {
+    return process.env.PURGE_REMOTE_BUILDER_CACHE !== undefined;
+  }
+
+  public static get lfsCacheFolderFull() {
+    return path.join(OrchestratorFolders.cacheFolderForCacheKeyFull, `lfs`);
+  }
+
+  public static get libraryCacheFolderFull() {
+    return path.join(OrchestratorFolders.cacheFolderForCacheKeyFull, `Library`);
+  }
+
+  public static get unityBuilderRepoUrl(): string {
+    return `https://${Orchestrator.buildParameters.gitPrivateToken}@github.com/${Orchestrator.buildParameters.orchestratorRepoName}.git`;
+  }
+
+  public static get targetBuildRepoUrl(): string {
+    return `https://${Orchestrator.buildParameters.gitPrivateToken}@github.com/${Orchestrator.buildParameters.githubRepo}.git`;
+  }
+
+  public static get buildVolumeFolder() {
+    return 'data';
+  }
+
+  public static get cacheFolder() {
+    return 'cache';
+  }
+}

src/model/orchestrator/options/orchestrator-guid.ts

@@ -1,11 +1,11 @@
 import { customAlphabet } from 'nanoid';
-import CloudRunnerConstants from './cloud-runner-constants';
+import OrchestratorConstants from './orchestrator-constants';
 
-class CloudRunnerNamespace {
+class OrchestratorNamespace {
   static generateGuid(runNumber: string | number, platform: string) {
-    const nanoid = customAlphabet(CloudRunnerConstants.alphabet, 4);
+    const nanoid = customAlphabet(OrchestratorConstants.alphabet, 4);
 
     return `${runNumber}-${platform.toLowerCase().replace('standalone', '')}-${nanoid()}`;
   }
 }
-export default CloudRunnerNamespace;
+export default OrchestratorNamespace;

src/model/orchestrator/options/orchestrator-options-reader.ts

@@ -0,0 +1,10 @@
+import Input from '../../input';
+import OrchestratorOptions from './orchestrator-options';
+
+class OrchestratorOptionsReader {
+  static GetProperties() {
+    return [...Object.getOwnPropertyNames(Input), ...Object.getOwnPropertyNames(OrchestratorOptions)];
+  }
+}
+
+export default OrchestratorOptionsReader;

src/model/orchestrator/options/orchestrator-options.ts

@@ -0,0 +1,338 @@
+import { Cli } from '../../cli/cli';
+import OrchestratorQueryOverride from './orchestrator-query-override';
+import GitHub from '../../github';
+import * as core from '@actions/core';
+
+class OrchestratorOptions {
+  // ### ### ###
+  // Input Handling
+  // ### ### ###
+  public static getInput(query: string): string | undefined {
+    if (GitHub.githubInputEnabled) {
+      const coreInput = core.getInput(query);
+      if (coreInput && coreInput !== '') {
+        return coreInput;
+      }
+    }
+    const alternativeQuery = OrchestratorOptions.ToEnvVarFormat(query);
+
+    // Query input sources
+    if (Cli.query(query, alternativeQuery)) {
+      return Cli.query(query, alternativeQuery);
+    }
+
+    if (OrchestratorQueryOverride.query(query, alternativeQuery)) {
+      return OrchestratorQueryOverride.query(query, alternativeQuery);
+    }
+
+    if (process.env[query] !== undefined) {
+      return process.env[query];
+    }
+
+    if (alternativeQuery !== query && process.env[alternativeQuery] !== undefined) {
+      return process.env[alternativeQuery];
+    }
+  }
+
+  public static ToEnvVarFormat(input: string): string {
+    if (input.toUpperCase() === input) {
+      return input;
+    }
+
+    return input
+      .replace(/([A-Z])/g, ' $1')
+      .trim()
+      .toUpperCase()
+      .replace(/ /g, '_');
+  }
+
+  // ### ### ###
+  // Provider parameters
+  // ### ### ###
+
+  static get region(): string {
+    return OrchestratorOptions.getInput('region') || 'eu-west-2';
+  }
+
+  // ### ### ###
+  // GitHub  parameters
+  // ### ### ###
+  static get githubChecks(): boolean {
+    const value = OrchestratorOptions.getInput('githubChecks');
+
+    return value === `true` || false;
+  }
+  static get githubCheckId(): string {
+    return OrchestratorOptions.getInput('githubCheckId') || ``;
+  }
+
+  static get githubOwner(): string {
+    return OrchestratorOptions.getInput('githubOwner') || OrchestratorOptions.githubRepo?.split(`/`)[0] || '';
+  }
+
+  static get githubRepoName(): string {
+    return OrchestratorOptions.getInput('githubRepoName') || OrchestratorOptions.githubRepo?.split(`/`)[1] || '';
+  }
+
+  static get orchestratorRepoName(): string {
+    return OrchestratorOptions.getInput('orchestratorRepoName') || 'game-ci/unity-builder';
+  }
+
+  static get cloneDepth(): string {
+    return OrchestratorOptions.getInput('cloneDepth') || '50';
+  }
+
+  static get finalHooks(): string[] {
+    return OrchestratorOptions.getInput('finalHooks')?.split(',') || [];
+  }
+
+  // ### ### ###
+  // Git syncronization parameters
+  // ### ### ###
+
+  static get githubRepo(): string | undefined {
+    return (
+      OrchestratorOptions.getInput('GITHUB_REPOSITORY') || OrchestratorOptions.getInput('GITHUB_REPO') || undefined
+    );
+  }
+  static get branch(): string {
+    if (OrchestratorOptions.getInput(`GITHUB_REF`)) {
+      return (
+        OrchestratorOptions.getInput(`GITHUB_REF`)?.replace('refs/', '').replace(`head/`, '').replace(`heads/`, '') ||
+        ``
+      );
+    } else if (OrchestratorOptions.getInput('branch')) {
+      return OrchestratorOptions.getInput('branch') || ``;
+    } else {
+      return '';
+    }
+  }
+
+  // ### ### ###
+  // Orchestrator parameters
+  // ### ### ###
+
+  static get buildPlatform(): string {
+    const input = OrchestratorOptions.getInput('buildPlatform');
+    if (input && input !== '') {
+      return input;
+    }
+    if (OrchestratorOptions.providerStrategy !== 'local') {
+      return 'linux';
+    }
+
+    return process.platform;
+  }
+
+  static get orchestratorBranch(): string {
+    return OrchestratorOptions.getInput('orchestratorBranch') || 'main';
+  }
+
+  static get providerStrategy(): string {
+    const provider =
+      OrchestratorOptions.getInput('orchestratorCluster') || OrchestratorOptions.getInput('providerStrategy');
+    if (Cli.isCliMode) {
+      return provider || 'aws';
+    }
+
+    return provider || 'local';
+  }
+
+  static get containerCpu(): string {
+    return OrchestratorOptions.getInput('containerCpu') || `1024`;
+  }
+
+  static get containerMemory(): string {
+    return OrchestratorOptions.getInput('containerMemory') || `3072`;
+  }
+
+  static get containerNamespace(): string {
+    return OrchestratorOptions.getInput('containerNamespace') || `default`;
+  }
+
+  static get customJob(): string {
+    return OrchestratorOptions.getInput('customJob') || '';
+  }
+
+  // ### ### ###
+  // Custom commands from files parameters
+  // ### ### ###
+
+  static get containerHookFiles(): string[] {
+    return OrchestratorOptions.getInput('containerHookFiles')?.split(`,`) || [];
+  }
+
+  static get commandHookFiles(): string[] {
+    return OrchestratorOptions.getInput('commandHookFiles')?.split(`,`) || [];
+  }
+
+  // ### ### ###
+  // Custom commands from yaml parameters
+  // ### ### ###
+
+  static get commandHooks(): string {
+    return OrchestratorOptions.getInput('commandHooks') || '';
+  }
+
+  static get postBuildContainerHooks(): string {
+    return OrchestratorOptions.getInput('postBuildContainerHooks') || '';
+  }
+
+  static get preBuildContainerHooks(): string {
+    return OrchestratorOptions.getInput('preBuildContainerHooks') || '';
+  }
+
+  // ### ### ###
+  // Input override handling
+  // ### ### ###
+
+  static get pullInputList(): string[] {
+    return OrchestratorOptions.getInput('pullInputList')?.split(`,`) || [];
+  }
+
+  static get inputPullCommand(): string {
+    const value = OrchestratorOptions.getInput('inputPullCommand');
+
+    if (value === 'gcp-secret-manager') {
+      return 'gcloud secrets versions access 1 --secret="{0}"';
+    } else if (value === 'aws-secret-manager') {
+      return 'aws secretsmanager get-secret-value --secret-id {0}';
+    }
+
+    return value || '';
+  }
+
+  // ### ### ###
+  // Aws
+  // ### ### ###
+
+  static get awsStackName() {
+    return OrchestratorOptions.getInput('awsStackName') || 'game-ci';
+  }
+
+  static get awsEndpoint(): string | undefined {
+    return OrchestratorOptions.getInput('awsEndpoint');
+  }
+
+  static get awsCloudFormationEndpoint(): string | undefined {
+    return OrchestratorOptions.getInput('awsCloudFormationEndpoint') || OrchestratorOptions.awsEndpoint;
+  }
+
+  static get awsEcsEndpoint(): string | undefined {
+    return OrchestratorOptions.getInput('awsEcsEndpoint') || OrchestratorOptions.awsEndpoint;
+  }
+
+  static get awsKinesisEndpoint(): string | undefined {
+    return OrchestratorOptions.getInput('awsKinesisEndpoint') || OrchestratorOptions.awsEndpoint;
+  }
+
+  static get awsCloudWatchLogsEndpoint(): string | undefined {
+    return OrchestratorOptions.getInput('awsCloudWatchLogsEndpoint') || OrchestratorOptions.awsEndpoint;
+  }
+
+  static get awsS3Endpoint(): string | undefined {
+    return OrchestratorOptions.getInput('awsS3Endpoint') || OrchestratorOptions.awsEndpoint;
+  }
+
+  // ### ### ###
+  // Storage
+  // ### ### ###
+
+  static get storageProvider(): string {
+    return OrchestratorOptions.getInput('storageProvider') || 's3';
+  }
+
+  static get rcloneRemote(): string {
+    return OrchestratorOptions.getInput('rcloneRemote') || '';
+  }
+
+  // ### ### ###
+  // K8s
+  // ### ### ###
+
+  static get kubeConfig(): string {
+    return OrchestratorOptions.getInput('kubeConfig') || '';
+  }
+
+  static get kubeVolume(): string {
+    return OrchestratorOptions.getInput('kubeVolume') || '';
+  }
+
+  static get kubeVolumeSize(): string {
+    return OrchestratorOptions.getInput('kubeVolumeSize') || '25Gi';
+  }
+
+  static get kubeStorageClass(): string {
+    return OrchestratorOptions.getInput('kubeStorageClass') || '';
+  }
+
+  // ### ### ###
+  // Caching
+  // ### ### ###
+
+  static get cacheKey(): string {
+    return OrchestratorOptions.getInput('cacheKey') || OrchestratorOptions.branch;
+  }
+
+  // ### ### ###
+  // Utility Parameters
+  // ### ### ###
+
+  static get orchestratorDebug(): boolean {
+    return (
+      OrchestratorOptions.getInput(`orchestratorTests`) === `true` ||
+      OrchestratorOptions.getInput(`orchestratorDebug`) === `true` ||
+      OrchestratorOptions.getInput(`orchestratorDebugTree`) === `true` ||
+      OrchestratorOptions.getInput(`orchestratorDebugEnv`) === `true` ||
+      false
+    );
+  }
+  static get skipLfs(): boolean {
+    return OrchestratorOptions.getInput(`skipLfs`) === `true`;
+  }
+  static get skipCache(): boolean {
+    return OrchestratorOptions.getInput(`skipCache`) === `true`;
+  }
+
+  public static get asyncOrchestrator(): boolean {
+    return OrchestratorOptions.getInput('asyncOrchestrator') === 'true';
+  }
+
+  public static get resourceTracking(): boolean {
+    return OrchestratorOptions.getInput('resourceTracking') === 'true';
+  }
+
+  public static get useLargePackages(): boolean {
+    return OrchestratorOptions.getInput(`useLargePackages`) === `true`;
+  }
+
+  public static get useSharedBuilder(): boolean {
+    return OrchestratorOptions.getInput(`useSharedBuilder`) === `true`;
+  }
+
+  public static get useCompressionStrategy(): boolean {
+    return OrchestratorOptions.getInput(`useCompressionStrategy`) === `true`;
+  }
+
+  public static get useCleanupCron(): boolean {
+    return (OrchestratorOptions.getInput(`useCleanupCron`) || 'true') === 'true';
+  }
+
+  // ### ### ###
+  // Retained Workspace
+  // ### ### ###
+
+  public static get maxRetainedWorkspaces(): string {
+    return OrchestratorOptions.getInput(`maxRetainedWorkspaces`) || `0`;
+  }
+
+  // ### ### ###
+  // Garbage Collection
+  // ### ### ###
+
+  static get garbageMaxAge(): number {
+    return Number(OrchestratorOptions.getInput(`garbageMaxAge`)) || 24;
+  }
+}
+
+export default OrchestratorOptions;

src/model/orchestrator/options/orchestrator-query-override.ts

@@ -0,0 +1,67 @@
+import Input from '../../input';
+import { GenericInputReader } from '../../input-readers/generic-input-reader';
+import OrchestratorOptions from './orchestrator-options';
+
+const formatFunction = (value: string, arguments_: any[]) => {
+  for (const element of arguments_) {
+    value = value.replace(`{${element.key}}`, element.value);
+  }
+
+  return value;
+};
+
+class OrchestratorQueryOverride {
+  static queryOverrides: { [key: string]: string } | undefined;
+
+  // TODO accept premade secret sources or custom secret source definition yamls
+
+  public static query(key: string, alternativeKey: string) {
+    if (OrchestratorQueryOverride.queryOverrides && OrchestratorQueryOverride.queryOverrides[key] !== undefined) {
+      return OrchestratorQueryOverride.queryOverrides[key];
+    }
+    if (
+      OrchestratorQueryOverride.queryOverrides &&
+      alternativeKey &&
+      OrchestratorQueryOverride.queryOverrides[alternativeKey] !== undefined
+    ) {
+      return OrchestratorQueryOverride.queryOverrides[alternativeKey];
+    }
+
+    return;
+  }
+
+  private static shouldUseOverride(query: string) {
+    if (OrchestratorOptions.inputPullCommand !== '') {
+      if (OrchestratorOptions.pullInputList.length > 0) {
+        const doesInclude =
+          OrchestratorOptions.pullInputList.includes(query) ||
+          OrchestratorOptions.pullInputList.includes(Input.ToEnvVarFormat(query));
+
+        return doesInclude ? true : false;
+      } else {
+        return true;
+      }
+    }
+  }
+
+  private static async queryOverride(query: string) {
+    if (!this.shouldUseOverride(query)) {
+      throw new Error(`Should not be trying to run override query on ${query}`);
+    }
+
+    return await GenericInputReader.Run(
+      formatFunction(OrchestratorOptions.inputPullCommand, [{ key: 0, value: query }]),
+    );
+  }
+
+  public static async PopulateQueryOverrideInput() {
+    const queries = OrchestratorOptions.pullInputList;
+    OrchestratorQueryOverride.queryOverrides = {};
+    for (const element of queries) {
+      if (OrchestratorQueryOverride.shouldUseOverride(element)) {
+        OrchestratorQueryOverride.queryOverrides[element] = await OrchestratorQueryOverride.queryOverride(element);
+      }
+    }
+  }
+}
+export default OrchestratorQueryOverride;

src/model/orchestrator/options/orchestrator-secret.ts

@@ -1,6 +1,6 @@
-class CloudRunnerSecret {
+class OrchestratorSecret {
   public ParameterKey!: string;
   public EnvironmentVariable!: string;
   public ParameterValue!: string;
 }
-export default CloudRunnerSecret;
+export default OrchestratorSecret;

src/model/orchestrator/options/orchestrator-statics.ts

@@ -0,0 +1,3 @@
+export class OrchestratorStatics {
+  public static readonly logPrefix = `Orchestrator`;
+}

src/model/orchestrator/options/orchestrator-step-parameters.ts

@@ -0,0 +1,13 @@
+import OrchestratorEnvironmentVariable from './orchestrator-environment-variable';
+import OrchestratorSecret from './orchestrator-secret';
+
+export class OrchestratorStepParameters {
+  public image: string;
+  public environment: OrchestratorEnvironmentVariable[];
+  public secrets: OrchestratorSecret[];
+  constructor(image: string, environmentVariables: OrchestratorEnvironmentVariable[], secrets: OrchestratorSecret[]) {
+    this.image = image;
+    this.environment = environmentVariables;
+    this.secrets = secrets;
+  }
+}

src/model/orchestrator/orchestrator.ts

@@ -0,0 +1,345 @@
+import AwsBuildPlatform from './providers/aws';
+import { BuildParameters, Input } from '..';
+import Kubernetes from './providers/k8s';
+import OrchestratorLogger from './services/core/orchestrator-logger';
+import { OrchestratorStepParameters } from './options/orchestrator-step-parameters';
+import { WorkflowCompositionRoot } from './workflows/workflow-composition-root';
+import { OrchestratorError } from './error/orchestrator-error';
+import { TaskParameterSerializer } from './services/core/task-parameter-serializer';
+import * as core from '@actions/core';
+import OrchestratorSecret from './options/orchestrator-secret';
+import { ProviderInterface } from './providers/provider-interface';
+import OrchestratorEnvironmentVariable from './options/orchestrator-environment-variable';
+import TestOrchestrator from './providers/test';
+import LocalOrchestrator from './providers/local';
+import LocalDockerOrchestrator from './providers/docker';
+import loadProvider from './providers/provider-loader';
+import GitHub from '../github';
+import SharedWorkspaceLocking from './services/core/shared-workspace-locking';
+import { FollowLogStreamService } from './services/core/follow-log-stream-service';
+import OrchestratorResult from './services/core/orchestrator-result';
+import OrchestratorOptions from './options/orchestrator-options';
+import ResourceTracking from './services/core/resource-tracking';
+
+class Orchestrator {
+  public static Provider: ProviderInterface;
+  public static buildParameters: BuildParameters;
+  private static defaultSecrets: OrchestratorSecret[];
+  private static orchestratorEnvironmentVariables: OrchestratorEnvironmentVariable[];
+  static lockedWorkspace: string = ``;
+  public static readonly retainedWorkspacePrefix: string = `retained-workspace`;
+
+  // When true, validates AWS CloudFormation templates even when using local-docker execution
+  // This is set by AWS_FORCE_PROVIDER=aws-local mode
+  public static validateAwsTemplates: boolean = false;
+  public static get isOrchestratorEnvironment() {
+    return process.env[`GITHUB_ACTIONS`] !== `true`;
+  }
+  public static get isOrchestratorAsyncEnvironment() {
+    return process.env[`ASYNC_WORKFLOW`] === `true`;
+  }
+  public static async setup(buildParameters: BuildParameters) {
+    OrchestratorLogger.setup();
+    OrchestratorLogger.log(`Setting up orchestrator`);
+    Orchestrator.buildParameters = buildParameters;
+    ResourceTracking.logAllocationSummary('setup');
+    await ResourceTracking.logDiskUsageSnapshot('setup');
+    if (Orchestrator.buildParameters.githubCheckId === ``) {
+      Orchestrator.buildParameters.githubCheckId = await GitHub.createGitHubCheck(
+        Orchestrator.buildParameters.buildGuid,
+      );
+    }
+    await Orchestrator.setupSelectedBuildPlatform();
+    Orchestrator.defaultSecrets = TaskParameterSerializer.readDefaultSecrets();
+    Orchestrator.orchestratorEnvironmentVariables =
+      TaskParameterSerializer.createOrchestratorEnvironmentVariables(buildParameters);
+    if (GitHub.githubInputEnabled) {
+      const buildParameterPropertyNames = Object.getOwnPropertyNames(buildParameters);
+      for (const element of Orchestrator.orchestratorEnvironmentVariables) {
+        // OrchestratorLogger.log(`Orchestrator output ${Input.ToEnvVarFormat(element.name)} = ${element.value}`);
+        core.setOutput(Input.ToEnvVarFormat(element.name), element.value);
+      }
+      for (const element of buildParameterPropertyNames) {
+        // OrchestratorLogger.log(`Orchestrator output ${Input.ToEnvVarFormat(element)} = ${buildParameters[element]}`);
+        core.setOutput(Input.ToEnvVarFormat(element), buildParameters[element]);
+      }
+      core.setOutput(
+        Input.ToEnvVarFormat(`buildArtifact`),
+        `build-${Orchestrator.buildParameters.buildGuid}.tar${
+          Orchestrator.buildParameters.useCompressionStrategy ? '.lz4' : ''
+        }`,
+      );
+    }
+    FollowLogStreamService.Reset();
+  }
+
+  private static async setupSelectedBuildPlatform() {
+    OrchestratorLogger.log(`Orchestrator platform selected ${Orchestrator.buildParameters.providerStrategy}`);
+
+    // Detect LocalStack endpoints and handle AWS provider appropriately
+    // AWS_FORCE_PROVIDER options:
+    //   - 'aws': Force AWS provider (requires LocalStack Pro with ECS support)
+    //   - 'aws-local': Validate AWS templates/config but execute via local-docker (for CI without ECS)
+    //   - unset/other: Auto-fallback to local-docker when LocalStack detected
+    const awsForceProvider = process.env.AWS_FORCE_PROVIDER || '';
+    const forceAwsProvider = awsForceProvider === 'aws' || awsForceProvider === 'true';
+    const useAwsLocalMode = awsForceProvider === 'aws-local';
+    const endpointsToCheck = [
+      process.env.AWS_ENDPOINT,
+      process.env.AWS_S3_ENDPOINT,
+      process.env.AWS_CLOUD_FORMATION_ENDPOINT,
+      process.env.AWS_ECS_ENDPOINT,
+      process.env.AWS_KINESIS_ENDPOINT,
+      process.env.AWS_CLOUD_WATCH_LOGS_ENDPOINT,
+      OrchestratorOptions.awsEndpoint,
+      OrchestratorOptions.awsS3Endpoint,
+      OrchestratorOptions.awsCloudFormationEndpoint,
+      OrchestratorOptions.awsEcsEndpoint,
+      OrchestratorOptions.awsKinesisEndpoint,
+      OrchestratorOptions.awsCloudWatchLogsEndpoint,
+    ]
+      .filter((x) => typeof x === 'string')
+      .join(' ');
+    const isLocalStack = /localstack|localhost|127\.0\.0\.1/i.test(endpointsToCheck);
+    let provider = Orchestrator.buildParameters.providerStrategy;
+    let validateAwsTemplates = false;
+
+    if (provider === 'aws' && isLocalStack) {
+      if (useAwsLocalMode) {
+        // aws-local mode: Validate AWS templates but execute via local-docker
+        // This provides confidence in AWS CloudFormation without requiring LocalStack Pro
+        OrchestratorLogger.log('AWS_FORCE_PROVIDER=aws-local: Validating AWS templates, executing via local-docker');
+        validateAwsTemplates = true;
+        provider = 'local-docker';
+      } else if (forceAwsProvider) {
+        // Force full AWS provider (requires LocalStack Pro with ECS support)
+        OrchestratorLogger.log(
+          'LocalStack endpoints detected but AWS_FORCE_PROVIDER=aws; using full AWS provider (requires ECS support)',
+        );
+      } else {
+        // Auto-fallback to local-docker
+        OrchestratorLogger.log('LocalStack endpoints detected; routing provider to local-docker for this run');
+        OrchestratorLogger.log(
+          'Note: Set AWS_FORCE_PROVIDER=aws-local to validate AWS templates with local-docker execution',
+        );
+        provider = 'local-docker';
+      }
+    }
+
+    // Store whether we should validate AWS templates (used by aws-local mode)
+    Orchestrator.validateAwsTemplates = validateAwsTemplates;
+
+    switch (provider) {
+      case 'k8s':
+        Orchestrator.Provider = new Kubernetes(Orchestrator.buildParameters);
+        break;
+      case 'aws':
+        Orchestrator.Provider = new AwsBuildPlatform(Orchestrator.buildParameters);
+
+        // Validate that AWS provider is actually being used when expected
+        if (isLocalStack && forceAwsProvider) {
+          OrchestratorLogger.log('✓ AWS provider initialized with LocalStack - AWS functionality will be validated');
+        } else if (isLocalStack && !forceAwsProvider) {
+          OrchestratorLogger.log(
+            '⚠ WARNING: AWS provider was requested but LocalStack detected without AWS_FORCE_PROVIDER',
+          );
+          OrchestratorLogger.log('⚠ This may cause AWS functionality tests to fail validation');
+        }
+        break;
+      case 'test':
+        Orchestrator.Provider = new TestOrchestrator();
+        break;
+      case 'local-docker':
+        Orchestrator.Provider = new LocalDockerOrchestrator();
+        break;
+      case 'local-system':
+        Orchestrator.Provider = new LocalOrchestrator();
+        break;
+      case 'local':
+        Orchestrator.Provider = new LocalOrchestrator();
+        break;
+      default:
+        // Try to load provider using the dynamic loader for unknown providers
+        try {
+          Orchestrator.Provider = await loadProvider(provider, Orchestrator.buildParameters);
+        } catch (error: any) {
+          OrchestratorLogger.log(`Failed to load provider '${provider}' using dynamic loader: ${error.message}`);
+          OrchestratorLogger.log('Falling back to local provider...');
+          Orchestrator.Provider = new LocalOrchestrator();
+        }
+        break;
+    }
+
+    // Final validation: Ensure provider matches expectations
+    const finalProviderName = Orchestrator.Provider.constructor.name;
+    if (Orchestrator.buildParameters.providerStrategy === 'aws' && finalProviderName !== 'AWSBuildEnvironment') {
+      OrchestratorLogger.log(`⚠ WARNING: Expected AWS provider but got ${finalProviderName}`);
+      OrchestratorLogger.log('⚠ AWS functionality tests may not be validating AWS services correctly');
+    }
+  }
+
+  static async run(buildParameters: BuildParameters, baseImage: string) {
+    if (baseImage.includes(`undefined`)) {
+      throw new Error(`baseImage is undefined`);
+    }
+    await Orchestrator.setup(buildParameters);
+
+    // When aws-local mode is enabled, validate AWS CloudFormation templates
+    // This ensures AWS templates are correct even when executing via local-docker
+    if (Orchestrator.validateAwsTemplates) {
+      await Orchestrator.validateAwsCloudFormationTemplates();
+    }
+    await Orchestrator.Provider.setupWorkflow(
+      Orchestrator.buildParameters.buildGuid,
+      Orchestrator.buildParameters,
+      Orchestrator.buildParameters.branch,
+      Orchestrator.defaultSecrets,
+    );
+    try {
+      if (buildParameters.maxRetainedWorkspaces > 0) {
+        Orchestrator.lockedWorkspace = SharedWorkspaceLocking.NewWorkspaceName();
+
+        const result = await SharedWorkspaceLocking.GetLockedWorkspace(
+          Orchestrator.lockedWorkspace,
+          Orchestrator.buildParameters.buildGuid,
+          Orchestrator.buildParameters,
+        );
+
+        if (result) {
+          OrchestratorLogger.logLine(`Using retained workspace ${Orchestrator.lockedWorkspace}`);
+          Orchestrator.orchestratorEnvironmentVariables = [
+            ...Orchestrator.orchestratorEnvironmentVariables,
+            { name: `LOCKED_WORKSPACE`, value: Orchestrator.lockedWorkspace },
+          ];
+        } else {
+          OrchestratorLogger.log(`Max retained workspaces reached ${buildParameters.maxRetainedWorkspaces}`);
+          buildParameters.maxRetainedWorkspaces = 0;
+          Orchestrator.lockedWorkspace = ``;
+        }
+      }
+      await Orchestrator.updateStatusWithBuildParameters();
+      const output = await new WorkflowCompositionRoot().run(
+        new OrchestratorStepParameters(
+          baseImage,
+          Orchestrator.orchestratorEnvironmentVariables,
+          Orchestrator.defaultSecrets,
+        ),
+      );
+      await Orchestrator.Provider.cleanupWorkflow(
+        Orchestrator.buildParameters,
+        Orchestrator.buildParameters.branch,
+        Orchestrator.defaultSecrets,
+      );
+      if (!Orchestrator.buildParameters.isCliMode) core.endGroup();
+      if (buildParameters.asyncWorkflow && this.isOrchestratorEnvironment && this.isOrchestratorAsyncEnvironment) {
+        await GitHub.updateGitHubCheck(Orchestrator.buildParameters.buildGuid, `success`, `success`, `completed`);
+      }
+
+      if (BuildParameters.shouldUseRetainedWorkspaceMode(buildParameters)) {
+        const workspace = Orchestrator.lockedWorkspace || ``;
+        await SharedWorkspaceLocking.ReleaseWorkspace(
+          workspace,
+          Orchestrator.buildParameters.buildGuid,
+          Orchestrator.buildParameters,
+        );
+        const isLocked = await SharedWorkspaceLocking.IsWorkspaceLocked(workspace, Orchestrator.buildParameters);
+        if (isLocked) {
+          throw new Error(
+            `still locked after releasing ${await SharedWorkspaceLocking.GetAllLocksForWorkspace(
+              workspace,
+              buildParameters,
+            )}`,
+          );
+        }
+        Orchestrator.lockedWorkspace = ``;
+      }
+
+      await GitHub.triggerWorkflowOnComplete(Orchestrator.buildParameters.finalHooks);
+
+      if (buildParameters.constantGarbageCollection) {
+        Orchestrator.Provider.garbageCollect(``, true, buildParameters.garbageMaxAge, true, true);
+      }
+
+      return new OrchestratorResult(buildParameters, output, true, true, false);
+    } catch (error: any) {
+      OrchestratorLogger.log(JSON.stringify(error, undefined, 4));
+      await GitHub.updateGitHubCheck(
+        Orchestrator.buildParameters.buildGuid,
+        `Failed - Error ${error?.message || error}`,
+        `failure`,
+        `completed`,
+      );
+      if (!Orchestrator.buildParameters.isCliMode) core.endGroup();
+      await OrchestratorError.handleException(error, Orchestrator.buildParameters, Orchestrator.defaultSecrets);
+      throw error;
+    }
+  }
+
+  private static async updateStatusWithBuildParameters() {
+    const content = { ...Orchestrator.buildParameters };
+    content.gitPrivateToken = ``;
+    content.unitySerial = ``;
+    content.unityEmail = ``;
+    content.unityPassword = ``;
+    const jsonContent = JSON.stringify(content, undefined, 4);
+    await GitHub.updateGitHubCheck(jsonContent, Orchestrator.buildParameters.buildGuid);
+  }
+
+  /**
+   * Validates AWS CloudFormation templates without deploying them.
+   * Used by aws-local mode to ensure AWS templates are correct when executing via local-docker.
+   * This provides confidence that AWS ECS deployments would work with the generated templates.
+   */
+  private static async validateAwsCloudFormationTemplates() {
+    OrchestratorLogger.log('=== AWS CloudFormation Template Validation (aws-local mode) ===');
+
+    try {
+      // Import AWS template formations
+      const { BaseStackFormation } = await import('./providers/aws/cloud-formations/base-stack-formation');
+      const { TaskDefinitionFormation } = await import('./providers/aws/cloud-formations/task-definition-formation');
+
+      // Validate base stack template
+      const baseTemplate = BaseStackFormation.formation;
+      OrchestratorLogger.log(`✓ Base stack template generated (${baseTemplate.length} chars)`);
+
+      // Check for required resources in base stack
+      const requiredBaseResources = ['AWS::EC2::VPC', 'AWS::ECS::Cluster', 'AWS::S3::Bucket', 'AWS::IAM::Role'];
+      for (const resource of requiredBaseResources) {
+        if (baseTemplate.includes(resource)) {
+          OrchestratorLogger.log(`  ✓ Contains ${resource}`);
+        } else {
+          throw new Error(`Base stack template missing required resource: ${resource}`);
+        }
+      }
+
+      // Validate task definition template
+      const taskTemplate = TaskDefinitionFormation.formation;
+      OrchestratorLogger.log(`✓ Task definition template generated (${taskTemplate.length} chars)`);
+
+      // Check for required resources in task definition
+      const requiredTaskResources = ['AWS::ECS::TaskDefinition', 'AWS::Logs::LogGroup'];
+      for (const resource of requiredTaskResources) {
+        if (taskTemplate.includes(resource)) {
+          OrchestratorLogger.log(`  ✓ Contains ${resource}`);
+        } else {
+          throw new Error(`Task definition template missing required resource: ${resource}`);
+        }
+      }
+
+      // Validate YAML syntax by checking for common patterns
+      if (!baseTemplate.includes('AWSTemplateFormatVersion')) {
+        throw new Error('Base stack template missing AWSTemplateFormatVersion');
+      }
+      if (!taskTemplate.includes('AWSTemplateFormatVersion')) {
+        throw new Error('Task definition template missing AWSTemplateFormatVersion');
+      }
+
+      OrchestratorLogger.log('=== AWS CloudFormation templates validated successfully ===');
+      OrchestratorLogger.log('Note: Actual execution will use local-docker provider');
+    } catch (error: any) {
+      OrchestratorLogger.log(`AWS CloudFormation template validation failed: ${error.message}`);
+      throw error;
+    }
+  }
+}
+export default Orchestrator;

src/model/orchestrator/providers/README.md

@@ -0,0 +1,222 @@
+# Provider Loader Dynamic Imports
+
+## What is a Provider?
+
+A **provider** is a pluggable backend that Orchestrator uses to run builds and workflows. Examples include **AWS**, **Kubernetes**, or local execution. Each provider implements the [ProviderInterface](https://github.com/game-ci/unity-builder/blob/main/src/model/orchestrator/providers/provider-interface.ts), which defines the common lifecycle methods (setup, run, cleanup, garbage collection, etc.).
+
+This abstraction makes Orchestrator flexible: you can switch execution environments or add your own provider (via npm package, GitHub repo, or local path) without changing the rest of your pipeline.
+
+## Dynamic Provider Loading
+
+The provider loader now supports dynamic loading of providers from multiple sources including local file paths, GitHub repositories, and NPM packages.
+
+## Features
+
+- **Local File Paths**: Load providers from relative or absolute file paths
+- **GitHub URLs**: Clone and load providers from GitHub repositories with automatic updates
+- **NPM Packages**: Load providers from installed NPM packages
+- **Automatic Updates**: GitHub repositories are automatically updated when changes are available
+- **Caching**: Local caching of cloned repositories for improved performance
+- **Fallback Support**: Graceful fallback to local provider if loading fails
+
+## Usage Examples
+
+### Loading Built-in Providers
+
+```typescript
+import { ProviderLoader } from './provider-loader';
+
+// Load built-in providers
+const awsProvider = await ProviderLoader.loadProvider('aws', buildParameters);
+const k8sProvider = await ProviderLoader.loadProvider('k8s', buildParameters);
+```
+
+### Loading Local Providers
+
+```typescript
+// Load from relative path
+const localProvider = await ProviderLoader.loadProvider('./my-local-provider', buildParameters);
+
+// Load from absolute path
+const absoluteProvider = await ProviderLoader.loadProvider('/path/to/provider', buildParameters);
+```
+
+### Loading GitHub Providers
+
+```typescript
+// Load from GitHub URL
+const githubProvider = await ProviderLoader.loadProvider(
+  'https://github.com/user/my-provider', 
+  buildParameters
+);
+
+// Load from specific branch
+const branchProvider = await ProviderLoader.loadProvider(
+  'https://github.com/user/my-provider/tree/develop', 
+  buildParameters
+);
+
+// Load from specific path in repository
+const pathProvider = await ProviderLoader.loadProvider(
+  'https://github.com/user/my-provider/tree/main/src/providers', 
+  buildParameters
+);
+
+// Shorthand notation
+const shorthandProvider = await ProviderLoader.loadProvider('user/repo', buildParameters);
+const branchShorthand = await ProviderLoader.loadProvider('user/repo@develop', buildParameters);
+```
+
+### Loading NPM Packages
+
+```typescript
+// Load from NPM package
+const npmProvider = await ProviderLoader.loadProvider('my-provider-package', buildParameters);
+
+// Load from scoped NPM package
+const scopedProvider = await ProviderLoader.loadProvider('@scope/my-provider', buildParameters);
+```
+
+## Provider Interface
+
+All providers must implement the `ProviderInterface`:
+
+```typescript
+interface ProviderInterface {
+  cleanupWorkflow(): Promise<void>;
+  setupWorkflow(buildGuid: string, buildParameters: BuildParameters, branchName: string, defaultSecretsArray: any[]): Promise<void>;
+  runTaskInWorkflow(buildGuid: string, task: string, workingDirectory: string, buildVolumeFolder: string, environmentVariables: any[], secrets: any[]): Promise<string>;
+  garbageCollect(): Promise<void>;
+  listResources(): Promise<ProviderResource[]>;
+  listWorkflow(): Promise<ProviderWorkflow[]>;
+  watchWorkflow(): Promise<void>;
+}
+```
+
+## Example Provider Implementation
+
+```typescript
+// my-provider.ts
+import { ProviderInterface } from './provider-interface';
+import BuildParameters from './build-parameters';
+
+export default class MyProvider implements ProviderInterface {
+  constructor(private buildParameters: BuildParameters) {}
+
+  async cleanupWorkflow(): Promise<void> {
+    // Cleanup logic
+  }
+
+  async setupWorkflow(buildGuid: string, buildParameters: BuildParameters, branchName: string, defaultSecretsArray: any[]): Promise<void> {
+    // Setup logic
+  }
+
+  async runTaskInWorkflow(buildGuid: string, task: string, workingDirectory: string, buildVolumeFolder: string, environmentVariables: any[], secrets: any[]): Promise<string> {
+    // Task execution logic
+    return 'Task completed';
+  }
+
+  async garbageCollect(): Promise<void> {
+    // Garbage collection logic
+  }
+
+  async listResources(): Promise<ProviderResource[]> {
+    return [];
+  }
+
+  async listWorkflow(): Promise<ProviderWorkflow[]> {
+    return [];
+  }
+
+  async watchWorkflow(): Promise<void> {
+    // Watch logic
+  }
+}
+```
+
+## Utility Methods
+
+### Analyze Provider Source
+
+```typescript
+// Analyze a provider source without loading it
+const sourceInfo = ProviderLoader.analyzeProviderSource('https://github.com/user/repo');
+console.log(sourceInfo.type); // 'github'
+console.log(sourceInfo.owner); // 'user'
+console.log(sourceInfo.repo); // 'repo'
+```
+
+### Clean Up Cache
+
+```typescript
+// Clean up old cached repositories (older than 30 days)
+await ProviderLoader.cleanupCache();
+
+// Clean up repositories older than 7 days
+await ProviderLoader.cleanupCache(7);
+```
+
+### Get Available Providers
+
+```typescript
+// Get list of built-in providers
+const providers = ProviderLoader.getAvailableProviders();
+console.log(providers); // ['aws', 'k8s', 'test', 'local-docker', 'local-system', 'local']
+```
+
+## Supported URL Formats
+
+### GitHub URLs
+- `https://github.com/user/repo`
+- `https://github.com/user/repo.git`
+- `https://github.com/user/repo/tree/branch`
+- `https://github.com/user/repo/tree/branch/path/to/provider`
+- `git@github.com:user/repo.git`
+
+### Shorthand GitHub References
+- `user/repo`
+- `user/repo@branch`
+- `user/repo@branch/path/to/provider`
+
+### Local Paths
+- `./relative/path`
+- `../relative/path`
+- `/absolute/path`
+- `C:\\path\\to\\provider` (Windows)
+
+### NPM Packages
+- `package-name`
+- `@scope/package-name`
+
+## Caching
+
+GitHub repositories are automatically cached in the `.provider-cache` directory. The cache key is generated based on the repository owner, name, and branch. This ensures that:
+
+1. Repositories are only cloned once
+2. Updates are checked and applied automatically
+3. Performance is improved for repeated loads
+4. Storage is managed efficiently
+
+## Error Handling
+
+The provider loader includes comprehensive error handling:
+
+- **Missing packages**: Clear error messages when providers cannot be found
+- **Interface validation**: Ensures providers implement the required interface
+- **Git operations**: Handles network issues and repository access problems
+- **Fallback mechanism**: Falls back to local provider if loading fails
+
+## Configuration
+
+The provider loader can be configured through environment variables:
+
+- `PROVIDER_CACHE_DIR`: Custom cache directory (default: `.provider-cache`)
+- `GIT_TIMEOUT`: Git operation timeout in milliseconds (default: 30000)
+
+## Best Practices
+
+1. **Use specific branches or tags**: Always specify the branch or specific tag when loading from GitHub
+2. **Implement proper error handling**: Wrap provider loading in try-catch blocks
+3. **Clean up regularly**: Use the cleanup utility to manage cache size
+4. **Test locally first**: Test providers locally before deploying
+5. **Use semantic versioning**: Tag your provider repositories for stable versions

src/model/orchestrator/providers/aws/aws-base-stack.ts

@@ -1,14 +1,18 @@
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
+import OrchestratorLogger from '../../services/core/orchestrator-logger';
 import * as core from '@actions/core';
 import {
   CloudFormation,
   CreateStackCommand,
+  // eslint-disable-next-line import/named
   CreateStackCommandInput,
   DescribeStacksCommand,
+  // eslint-disable-next-line import/named
   DescribeStacksCommandInput,
   ListStacksCommand,
+  // eslint-disable-next-line import/named
   Parameter,
   UpdateStackCommand,
+  // eslint-disable-next-line import/named
   UpdateStackCommandInput,
   waitUntilStackCreateComplete,
   waitUntilStackUpdateComplete,
@@ -16,6 +20,17 @@ import {
 import { BaseStackFormation } from './cloud-formations/base-stack-formation';
 import crypto from 'node:crypto';
 
+const DEFAULT_STACK_WAIT_TIME_SECONDS = 600;
+
+function getStackWaitTime(): number {
+  const overrideValue = Number(process.env.ORCHESTRATOR_AWS_STACK_WAIT_TIME ?? '');
+  if (!Number.isNaN(overrideValue) && overrideValue > 0) {
+    return overrideValue;
+  }
+
+  return DEFAULT_STACK_WAIT_TIME_SECONDS;
+}
+
 export class AWSBaseStack {
   constructor(baseStackName: string) {
     this.baseStackName = baseStackName;
@@ -24,6 +39,7 @@ export class AWSBaseStack {
 
   async setupBaseStack(CF: CloudFormation) {
     const baseStackName = this.baseStackName;
+    const stackWaitTimeSeconds = getStackWaitTime();
 
     const baseStack = BaseStackFormation.formation;
 
@@ -54,18 +70,39 @@ export class AWSBaseStack {
     };
 
     const stacks = await CF.send(
-      new ListStacksCommand({ StackStatusFilter: ['UPDATE_COMPLETE', 'CREATE_COMPLETE', 'ROLLBACK_COMPLETE'] }),
+      new ListStacksCommand({
+        StackStatusFilter: [
+          'CREATE_IN_PROGRESS',
+          'UPDATE_IN_PROGRESS',
+          'UPDATE_COMPLETE',
+          'CREATE_COMPLETE',
+          'ROLLBACK_COMPLETE',
+        ],
+      }),
     );
     const stackNames = stacks.StackSummaries?.map((x) => x.StackName) || [];
-    const stackExists: Boolean = stackNames.includes(baseStackName) || false;
+    const stackExists: boolean = stackNames.includes(baseStackName);
     const describeStack = async () => {
       return await CF.send(new DescribeStacksCommand(describeStackInput));
     };
     try {
       if (!stackExists) {
-        CloudRunnerLogger.log(`${baseStackName} stack does not exist (${JSON.stringify(stackNames)})`);
-        await CF.send(new CreateStackCommand(createStackInput));
-        CloudRunnerLogger.log(`created stack (version: ${parametersHash})`);
+        OrchestratorLogger.log(`${baseStackName} stack does not exist (${JSON.stringify(stackNames)})`);
+        let created = false;
+        try {
+          await CF.send(new CreateStackCommand(createStackInput));
+          created = true;
+        } catch (error: any) {
+          const message = `${error?.name ?? ''} ${error?.message ?? ''}`;
+          if (message.includes('AlreadyExistsException')) {
+            OrchestratorLogger.log(`Base stack already exists, continuing with describe`);
+          } else {
+            throw error;
+          }
+        }
+        if (created) {
+          OrchestratorLogger.log(`created stack (version: ${parametersHash})`);
+        }
       }
       const CFState = await describeStack();
       let stack = CFState.Stacks?.[0];
@@ -75,32 +112,35 @@ export class AWSBaseStack {
       const stackVersion = stack.Parameters?.find((x) => x.ParameterKey === 'Version')?.ParameterValue;
 
       if (stack.StackStatus === 'CREATE_IN_PROGRESS') {
+        OrchestratorLogger.log(
+          `Waiting up to ${stackWaitTimeSeconds}s for '${baseStackName}' CloudFormation creation to finish`,
+        );
         await waitUntilStackCreateComplete(
           {
             client: CF,
-            maxWaitTime: 200,
+            maxWaitTime: stackWaitTimeSeconds,
           },
           describeStackInput,
         );
       }
 
       if (stackExists) {
-        CloudRunnerLogger.log(`Base stack exists (version: ${stackVersion}, local version: ${parametersHash})`);
+        OrchestratorLogger.log(`Base stack exists (version: ${stackVersion}, local version: ${parametersHash})`);
         if (parametersHash !== stackVersion) {
-          CloudRunnerLogger.log(`Attempting update of base stack`);
+          OrchestratorLogger.log(`Attempting update of base stack`);
           try {
             await CF.send(new UpdateStackCommand(updateInput));
           } catch (error: any) {
             if (error['message'].includes('No updates are to be performed')) {
-              CloudRunnerLogger.log(`No updates are to be performed`);
+              OrchestratorLogger.log(`No updates are to be performed`);
             } else {
-              CloudRunnerLogger.log(`Update Failed (Stack name: ${baseStackName})`);
-              CloudRunnerLogger.log(error['message']);
+              OrchestratorLogger.log(`Update Failed (Stack name: ${baseStackName})`);
+              OrchestratorLogger.log(error['message']);
             }
-            CloudRunnerLogger.log(`Continuing...`);
+            OrchestratorLogger.log(`Continuing...`);
           }
         } else {
-          CloudRunnerLogger.log(`No update required`);
+          OrchestratorLogger.log(`No update required`);
         }
         stack = (await describeStack()).Stacks?.[0];
         if (!stack) {
@@ -109,16 +149,19 @@ export class AWSBaseStack {
           );
         }
         if (stack.StackStatus === 'UPDATE_IN_PROGRESS') {
+          OrchestratorLogger.log(
+            `Waiting up to ${stackWaitTimeSeconds}s for '${baseStackName}' CloudFormation update to finish`,
+          );
           await waitUntilStackUpdateComplete(
             {
               client: CF,
-              maxWaitTime: 200,
+              maxWaitTime: stackWaitTimeSeconds,
             },
             describeStackInput,
           );
         }
       }
-      CloudRunnerLogger.log('base stack is now ready');
+      OrchestratorLogger.log('base stack is now ready');
     } catch (error) {
       core.error(JSON.stringify(await describeStack(), undefined, 4));
       throw error;

src/model/orchestrator/providers/aws/aws-client-factory.ts

@@ -0,0 +1,93 @@
+import { CloudFormation } from '@aws-sdk/client-cloudformation';
+import { ECS } from '@aws-sdk/client-ecs';
+import { Kinesis } from '@aws-sdk/client-kinesis';
+import { CloudWatchLogs } from '@aws-sdk/client-cloudwatch-logs';
+import { S3 } from '@aws-sdk/client-s3';
+import { Input } from '../../..';
+import OrchestratorOptions from '../../options/orchestrator-options';
+
+export class AwsClientFactory {
+  private static cloudFormation: CloudFormation;
+  private static ecs: ECS;
+  private static kinesis: Kinesis;
+  private static cloudWatchLogs: CloudWatchLogs;
+  private static s3: S3;
+
+  private static getCredentials() {
+    // Explicitly provide credentials from environment variables for LocalStack compatibility
+    // LocalStack accepts any credentials, but the AWS SDK needs them to be explicitly set
+    const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
+    const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+
+    if (accessKeyId && secretAccessKey) {
+      return {
+        accessKeyId,
+        secretAccessKey,
+      };
+    }
+
+    // Return undefined to let AWS SDK use default credential chain
+    return;
+  }
+
+  static getCloudFormation(): CloudFormation {
+    if (!this.cloudFormation) {
+      this.cloudFormation = new CloudFormation({
+        region: Input.region,
+        endpoint: OrchestratorOptions.awsCloudFormationEndpoint,
+        credentials: AwsClientFactory.getCredentials(),
+      });
+    }
+
+    return this.cloudFormation;
+  }
+
+  static getECS(): ECS {
+    if (!this.ecs) {
+      this.ecs = new ECS({
+        region: Input.region,
+        endpoint: OrchestratorOptions.awsEcsEndpoint,
+        credentials: AwsClientFactory.getCredentials(),
+      });
+    }
+
+    return this.ecs;
+  }
+
+  static getKinesis(): Kinesis {
+    if (!this.kinesis) {
+      this.kinesis = new Kinesis({
+        region: Input.region,
+        endpoint: OrchestratorOptions.awsKinesisEndpoint,
+        credentials: AwsClientFactory.getCredentials(),
+      });
+    }
+
+    return this.kinesis;
+  }
+
+  static getCloudWatchLogs(): CloudWatchLogs {
+    if (!this.cloudWatchLogs) {
+      this.cloudWatchLogs = new CloudWatchLogs({
+        region: Input.region,
+        endpoint: OrchestratorOptions.awsCloudWatchLogsEndpoint,
+        credentials: AwsClientFactory.getCredentials(),
+      });
+    }
+
+    return this.cloudWatchLogs;
+  }
+
+  static getS3(): S3 {
+    if (!this.s3) {
+      this.s3 = new S3({
+        region: Input.region,
+        endpoint: OrchestratorOptions.awsS3Endpoint,
+        forcePathStyle: true,
+        credentials: AwsClientFactory.getCredentials(),
+      });
+    }
+
+    return this.s3;
+  }
+}

src/model/orchestrator/providers/aws/aws-cloud-formation-templates.ts

@@ -21,6 +21,7 @@ export class AWSCloudFormationTemplates {
 
   public static getSecretDefinitionTemplate(p1: string, p2: string) {
     return `
+          Secrets:
             - Name: '${p1}'
               ValueFrom: !Ref ${p2}Secret
 `;

src/model/orchestrator/providers/aws/aws-error.ts

@@ -1,16 +1,16 @@
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
+import OrchestratorLogger from '../../services/core/orchestrator-logger';
 import { CloudFormation, DescribeStackEventsCommand } from '@aws-sdk/client-cloudformation';
 import * as core from '@actions/core';
-import CloudRunner from '../../cloud-runner';
+import Orchestrator from '../../orchestrator';
 
 export class AWSError {
   static async handleStackCreationFailure(error: any, CF: CloudFormation, taskDefStackName: string) {
-    CloudRunnerLogger.log('aws error: ');
+    OrchestratorLogger.log('aws error: ');
     core.error(JSON.stringify(error, undefined, 4));
-    if (CloudRunner.buildParameters.cloudRunnerDebug) {
-      CloudRunnerLogger.log('Getting events and resources for task stack');
+    if (Orchestrator.buildParameters.orchestratorDebug) {
+      OrchestratorLogger.log('Getting events and resources for task stack');
       const events = (await CF.send(new DescribeStackEventsCommand({ StackName: taskDefStackName }))).StackEvents;
-      CloudRunnerLogger.log(JSON.stringify(events, undefined, 4));
+      OrchestratorLogger.log(JSON.stringify(events, undefined, 4));
     }
   }
 }

src/model/orchestrator/providers/aws/aws-job-stack.ts

@@ -1,22 +1,34 @@
 import {
   CloudFormation,
   CreateStackCommand,
+  // eslint-disable-next-line import/named
   CreateStackCommandInput,
   DescribeStackResourcesCommand,
   DescribeStacksCommand,
   ListStacksCommand,
   waitUntilStackCreateComplete,
 } from '@aws-sdk/client-cloudformation';
-import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
-import CloudRunnerSecret from '../../options/cloud-runner-secret';
+import OrchestratorAWSTaskDef from './orchestrator-aws-task-def';
+import OrchestratorSecret from '../../options/orchestrator-secret';
 import { AWSCloudFormationTemplates } from './aws-cloud-formation-templates';
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
+import OrchestratorLogger from '../../services/core/orchestrator-logger';
 import { AWSError } from './aws-error';
-import CloudRunner from '../../cloud-runner';
+import Orchestrator from '../../orchestrator';
 import { CleanupCronFormation } from './cloud-formations/cleanup-cron-formation';
-import CloudRunnerOptions from '../../options/cloud-runner-options';
+import OrchestratorOptions from '../../options/orchestrator-options';
 import { TaskDefinitionFormation } from './cloud-formations/task-definition-formation';
 
+const DEFAULT_STACK_WAIT_TIME_SECONDS = 600;
+
+function getStackWaitTime(): number {
+  const overrideValue = Number(process.env.ORCHESTRATOR_AWS_STACK_WAIT_TIME ?? '');
+  if (!Number.isNaN(overrideValue) && overrideValue > 0) {
+    return overrideValue;
+  }
+
+  return DEFAULT_STACK_WAIT_TIME_SECONDS;
+}
+
 export class AWSJobStack {
   private baseStackName: string;
   constructor(baseStackName: string) {
@@ -31,23 +43,23 @@ export class AWSJobStack {
     commands: string,
     mountdir: string,
     workingdir: string,
-    secrets: CloudRunnerSecret[],
-  ): Promise<CloudRunnerAWSTaskDef> {
+    secrets: OrchestratorSecret[],
+  ): Promise<OrchestratorAWSTaskDef> {
     const taskDefStackName = `${this.baseStackName}-${buildGuid}`;
     let taskDefCloudFormation = AWSCloudFormationTemplates.readTaskCloudFormationTemplate();
     taskDefCloudFormation = taskDefCloudFormation.replace(
       `ContainerCpu:
     Default: 1024`,
       `ContainerCpu:
-    Default: ${Number.parseInt(CloudRunner.buildParameters.containerCpu)}`,
+    Default: ${Number.parseInt(Orchestrator.buildParameters.containerCpu)}`,
     );
     taskDefCloudFormation = taskDefCloudFormation.replace(
       `ContainerMemory:
     Default: 2048`,
       `ContainerMemory:
-    Default: ${Number.parseInt(CloudRunner.buildParameters.containerMemory)}`,
+    Default: ${Number.parseInt(Orchestrator.buildParameters.containerMemory)}`,
     );
-    if (!CloudRunnerOptions.asyncCloudRunner) {
+    if (!OrchestratorOptions.asyncOrchestrator) {
       taskDefCloudFormation = AWSCloudFormationTemplates.insertAtTemplate(
         taskDefCloudFormation,
         '# template resources logstream',
@@ -121,8 +133,8 @@ export class AWSJobStack {
       },
       ...secretsMappedToCloudFormationParameters,
     ];
-    CloudRunnerLogger.log(
-      `Starting AWS job with memory: ${CloudRunner.buildParameters.containerMemory} cpu: ${CloudRunner.buildParameters.containerCpu}`,
+    OrchestratorLogger.log(
+      `Starting AWS job with memory: ${Orchestrator.buildParameters.containerMemory} cpu: ${Orchestrator.buildParameters.containerCpu}`,
     );
     let previousStackExists = true;
     while (previousStackExists) {
@@ -135,7 +147,7 @@ export class AWSJobStack {
         const element = stacks.StackSummaries[index];
         if (element.StackName === taskDefStackName && element.StackStatus !== 'DELETE_COMPLETE') {
           previousStackExists = true;
-          CloudRunnerLogger.log(`Previous stack still exists: ${JSON.stringify(element)}`);
+          OrchestratorLogger.log(`Previous stack still exists: ${JSON.stringify(element)}`);
           await new Promise((promise) => setTimeout(promise, 5000));
         }
       }
@@ -147,12 +159,15 @@ export class AWSJobStack {
       Parameters: parameters,
     };
     try {
-      CloudRunnerLogger.log(`Creating job aws formation ${taskDefStackName}`);
+      const stackWaitTimeSeconds = getStackWaitTime();
+      OrchestratorLogger.log(
+        `Creating job aws formation ${taskDefStackName} (waiting up to ${stackWaitTimeSeconds}s for completion)`,
+      );
       await CF.send(new CreateStackCommand(createStackInput));
       await waitUntilStackCreateComplete(
         {
           client: CF,
-          maxWaitTime: 200,
+          maxWaitTime: stackWaitTimeSeconds,
         },
         { StackName: taskDefStackName },
       );
@@ -186,7 +201,7 @@ export class AWSJobStack {
         },
         {
           ParameterKey: 'BUILDGUID',
-          ParameterValue: CloudRunner.buildParameters.buildGuid,
+          ParameterValue: Orchestrator.buildParameters.buildGuid,
         },
         {
           ParameterKey: 'EnvironmentName',
@@ -194,9 +209,9 @@ export class AWSJobStack {
         },
       ],
     };
-    if (CloudRunnerOptions.useCleanupCron) {
+    if (OrchestratorOptions.useCleanupCron) {
       try {
-        CloudRunnerLogger.log(`Creating job cleanup formation`);
+        OrchestratorLogger.log(`Creating job cleanup formation`);
         await CF.send(new CreateStackCommand(createCleanupStackInput));
 
         // await CF.waitFor('stackCreateComplete', { StackName: createCleanupStackInput.StackName }).promise();

src/model/orchestrator/providers/aws/aws-task-runner.ts

@@ -1,38 +1,61 @@
-import {
-  DescribeTasksCommand,
-  ECS,
-  RunTaskCommand,
-  RunTaskCommandInput,
-  Task,
-  waitUntilTasksRunning,
-} from '@aws-sdk/client-ecs';
-import {
-  DescribeStreamCommand,
-  DescribeStreamCommandOutput,
-  GetRecordsCommand,
-  GetRecordsCommandOutput,
-  GetShardIteratorCommand,
-  Kinesis,
-} from '@aws-sdk/client-kinesis';
-import CloudRunnerEnvironmentVariable from '../../options/cloud-runner-environment-variable';
+import { DescribeTasksCommand, RunTaskCommand, waitUntilTasksRunning } from '@aws-sdk/client-ecs';
+import { DescribeStreamCommand, GetRecordsCommand, GetShardIteratorCommand } from '@aws-sdk/client-kinesis';
+import OrchestratorEnvironmentVariable from '../../options/orchestrator-environment-variable';
 import * as core from '@actions/core';
-import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
+import OrchestratorAWSTaskDef from './orchestrator-aws-task-def';
 import * as zlib from 'node:zlib';
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
+import OrchestratorLogger from '../../services/core/orchestrator-logger';
 import { Input } from '../../..';
-import CloudRunner from '../../cloud-runner';
+import Orchestrator from '../../orchestrator';
 import { CommandHookService } from '../../services/hooks/command-hook-service';
 import { FollowLogStreamService } from '../../services/core/follow-log-stream-service';
-import CloudRunnerOptions from '../../options/cloud-runner-options';
+import OrchestratorOptions from '../../options/orchestrator-options';
 import GitHub from '../../../github';
+import { AwsClientFactory } from './aws-client-factory';
 
 class AWSTaskRunner {
-  public static ECS: ECS;
-  public static Kinesis: Kinesis;
   private static readonly encodedUnderscore = `$252F`;
+
+  /**
+   * Transform localhost endpoints to host.docker.internal for container environments.
+   * When LocalStack is used, ECS tasks run in Docker containers that need to reach
+   * LocalStack on the host machine via host.docker.internal.
+   */
+  private static transformEndpointsForContainer(
+    environment: OrchestratorEnvironmentVariable[],
+  ): OrchestratorEnvironmentVariable[] {
+    const endpointEnvironmentNames = new Set([
+      'AWS_S3_ENDPOINT',
+      'AWS_ENDPOINT',
+      'AWS_CLOUD_FORMATION_ENDPOINT',
+      'AWS_ECS_ENDPOINT',
+      'AWS_KINESIS_ENDPOINT',
+      'AWS_CLOUD_WATCH_LOGS_ENDPOINT',
+      'INPUT_AWSS3ENDPOINT',
+      'INPUT_AWSENDPOINT',
+    ]);
+
+    return environment.map((x) => {
+      let value = x.value;
+      if (
+        typeof value === 'string' &&
+        endpointEnvironmentNames.has(x.name) &&
+        (value.startsWith('http://localhost') || value.startsWith('http://127.0.0.1'))
+      ) {
+        // Replace localhost with host.docker.internal so ECS containers can access host services
+        value = value
+          .replace('http://localhost', 'http://host.docker.internal')
+          .replace('http://127.0.0.1', 'http://host.docker.internal');
+        OrchestratorLogger.log(`AWS TaskRunner: Replaced localhost with host.docker.internal for ${x.name}: ${value}`);
+      }
+
+      return { name: x.name, value };
+    });
+  }
+
   static async runTask(
-    taskDef: CloudRunnerAWSTaskDef,
-    environment: CloudRunnerEnvironmentVariable[],
+    taskDef: OrchestratorAWSTaskDef,
+    environment: OrchestratorEnvironmentVariable[],
     commands: string,
   ): Promise<{ output: string; shouldCleanup: boolean }> {
     const cluster = taskDef.baseResources?.find((x) => x.LogicalResourceId === 'ECSCluster')?.PhysicalResourceId || '';
@@ -47,6 +70,9 @@ class AWSTaskRunner {
     const streamName =
       taskDef.taskDefResources?.find((x) => x.LogicalResourceId === 'KinesisStream')?.PhysicalResourceId || '';
 
+    // Transform localhost endpoints for container environment
+    const transformedEnvironment = AWSTaskRunner.transformEndpointsForContainer(environment);
+
     const runParameters = {
       cluster,
       taskDefinition,
@@ -55,8 +81,8 @@ class AWSTaskRunner {
         containerOverrides: [
           {
             name: taskDef.taskDefStackName,
-            environment,
-            command: ['-c', CommandHookService.ApplyHooksToCommands(commands, CloudRunner.buildParameters)],
+            environment: transformedEnvironment,
+            command: ['-c', CommandHookService.ApplyHooksToCommands(commands, Orchestrator.buildParameters)],
           },
         ],
       },
@@ -71,45 +97,49 @@ class AWSTaskRunner {
     };
 
     if (JSON.stringify(runParameters.overrides.containerOverrides).length > 8192) {
-      CloudRunnerLogger.log(JSON.stringify(runParameters.overrides.containerOverrides, undefined, 4));
+      OrchestratorLogger.log(JSON.stringify(runParameters.overrides.containerOverrides, undefined, 4));
       throw new Error(`Container Overrides length must be at most 8192`);
     }
 
-    const task = await AWSTaskRunner.ECS.send(new RunTaskCommand(runParameters as RunTaskCommandInput));
+    const task = await AwsClientFactory.getECS().send(new RunTaskCommand(runParameters as any));
     const taskArn = task.tasks?.[0].taskArn || '';
-    CloudRunnerLogger.log('Cloud runner job is starting');
+    OrchestratorLogger.log('Orchestrator job is starting');
     await AWSTaskRunner.waitUntilTaskRunning(taskArn, cluster);
-    CloudRunnerLogger.log(
-      `Cloud runner job status is running ${(await AWSTaskRunner.describeTasks(cluster, taskArn))?.lastStatus} Async:${
-        CloudRunnerOptions.asyncCloudRunner
+    OrchestratorLogger.log(
+      `Orchestrator job status is running ${(await AWSTaskRunner.describeTasks(cluster, taskArn))?.lastStatus} Async:${
+        OrchestratorOptions.asyncOrchestrator
       }`,
     );
-    if (CloudRunnerOptions.asyncCloudRunner) {
+    if (OrchestratorOptions.asyncOrchestrator) {
       const shouldCleanup: boolean = false;
       const output: string = '';
-      CloudRunnerLogger.log(`Watch Cloud Runner To End: false`);
+      OrchestratorLogger.log(`Watch Orchestrator To End: false`);
 
       return { output, shouldCleanup };
     }
 
-    CloudRunnerLogger.log(`Streaming...`);
+    OrchestratorLogger.log(`Streaming...`);
     const { output, shouldCleanup } = await this.streamLogsUntilTaskStops(cluster, taskArn, streamName);
     let exitCode;
     let containerState;
     let taskData;
     while (exitCode === undefined) {
-      await new Promise((resolve) => resolve(10000));
+      await new Promise((resolve) => setTimeout(resolve, 10000));
       taskData = await AWSTaskRunner.describeTasks(cluster, taskArn);
-      containerState = taskData.containers?.[0];
+      const containers = taskData?.containers as any[] | undefined;
+      if (!containers || containers.length === 0) {
+        continue;
+      }
+      containerState = containers[0];
       exitCode = containerState?.exitCode;
     }
-    CloudRunnerLogger.log(`Container State: ${JSON.stringify(containerState, undefined, 4)}`);
+    OrchestratorLogger.log(`Container State: ${JSON.stringify(containerState, undefined, 4)}`);
     if (exitCode === undefined) {
-      CloudRunnerLogger.logWarning(`Undefined exitcode for container`);
+      OrchestratorLogger.logWarning(`Undefined exitcode for container`);
     }
     const wasSuccessful = exitCode === 0;
     if (wasSuccessful) {
-      CloudRunnerLogger.log(`Cloud runner job has finished successfully`);
+      OrchestratorLogger.log(`Orchestrator job has finished successfully`);
 
       return { output, shouldCleanup };
     }
@@ -125,19 +155,18 @@ class AWSTaskRunner {
     try {
       await waitUntilTasksRunning(
         {
-          client: AWSTaskRunner.ECS,
-          maxWaitTime: 120,
+          client: AwsClientFactory.getECS(),
+          maxWaitTime: 300,
+          minDelay: 5,
+          maxDelay: 30,
         },
         { tasks: [taskArn], cluster },
       );
     } catch (error_) {
       const error = error_ as Error;
       await new Promise((resolve) => setTimeout(resolve, 3000));
-      CloudRunnerLogger.log(
-        `Cloud runner job has ended ${
-          (await AWSTaskRunner.describeTasks(cluster, taskArn)).containers?.[0].lastStatus
-        }`,
-      );
+      const taskAfterError = await AWSTaskRunner.describeTasks(cluster, taskArn);
+      OrchestratorLogger.log(`Orchestrator job has ended ${taskAfterError?.containers?.[0]?.lastStatus}`);
 
       core.setFailed(error);
       core.error(error);
@@ -145,22 +174,42 @@ class AWSTaskRunner {
   }
 
   static async describeTasks(clusterName: string, taskArn: string) {
-    const tasks = await AWSTaskRunner.ECS.send(new DescribeTasksCommand({ cluster: clusterName, tasks: [taskArn] }));
-    if (tasks.tasks?.[0]) {
-      return tasks.tasks?.[0];
-    } else {
-      throw new Error('No task found');
+    const maxAttempts = 10;
+    let delayMs = 1000;
+    const maxDelayMs = 60000;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const tasks = await AwsClientFactory.getECS().send(
+          new DescribeTasksCommand({ cluster: clusterName, tasks: [taskArn] }),
+        );
+        if (tasks.tasks?.[0]) {
+          return tasks.tasks?.[0];
+        }
+        throw new Error('No task found');
+      } catch (error: any) {
+        const isThrottle = error?.name === 'ThrottlingException' || /rate exceeded/i.test(String(error?.message));
+        if (!isThrottle || attempt === maxAttempts) {
+          throw error;
+        }
+        const jitterMs = Math.floor(Math.random() * Math.min(1000, delayMs));
+        const sleepMs = delayMs + jitterMs;
+        OrchestratorLogger.log(
+          `AWS throttled DescribeTasks (attempt ${attempt}/${maxAttempts}), backing off ${sleepMs}ms (${delayMs} + jitter ${jitterMs})`,
+        );
+        await new Promise((r) => setTimeout(r, sleepMs));
+        delayMs = Math.min(delayMs * 2, maxDelayMs);
+      }
     }
   }
 
   static async streamLogsUntilTaskStops(clusterName: string, taskArn: string, kinesisStreamName: string) {
     await new Promise((resolve) => setTimeout(resolve, 3000));
-    CloudRunnerLogger.log(`Streaming...`);
+    OrchestratorLogger.log(`Streaming...`);
     const stream = await AWSTaskRunner.getLogStream(kinesisStreamName);
     let iterator = await AWSTaskRunner.getLogIterator(stream);
 
-    const logBaseUrl = `https://${Input.region}.console.aws.amazon.com/cloudwatch/home?region=${Input.region}#logsV2:log-groups/log-group/${CloudRunner.buildParameters.awsStackName}${AWSTaskRunner.encodedUnderscore}${CloudRunner.buildParameters.awsStackName}-${CloudRunner.buildParameters.buildGuid}`;
-    CloudRunnerLogger.log(`You view the log stream on AWS Cloud Watch: ${logBaseUrl}`);
+    const logBaseUrl = `https://${Input.region}.console.aws.amazon.com/cloudwatch/home?region=${Input.region}#logsV2:log-groups/log-group/${Orchestrator.buildParameters.awsStackName}${AWSTaskRunner.encodedUnderscore}${Orchestrator.buildParameters.awsStackName}-${Orchestrator.buildParameters.buildGuid}`;
+    OrchestratorLogger.log(`You view the log stream on AWS Cloud Watch: ${logBaseUrl}`);
     await GitHub.updateGitHubCheck(`You view the log stream on AWS Cloud Watch:  ${logBaseUrl}`, ``);
     let shouldReadLogs = true;
     let shouldCleanup = true;
@@ -170,6 +219,9 @@ class AWSTaskRunner {
       await new Promise((resolve) => setTimeout(resolve, 1500));
       const taskData = await AWSTaskRunner.describeTasks(clusterName, taskArn);
       ({ timestamp, shouldReadLogs } = AWSTaskRunner.checkStreamingShouldContinue(taskData, timestamp, shouldReadLogs));
+      if (taskData?.lastStatus !== 'RUNNING') {
+        await new Promise((resolve) => setTimeout(resolve, 3500));
+      }
       ({ iterator, shouldReadLogs, output, shouldCleanup } = await AWSTaskRunner.handleLogStreamIteration(
         iterator,
         shouldReadLogs,
@@ -187,7 +239,22 @@ class AWSTaskRunner {
     output: string,
     shouldCleanup: boolean,
   ) {
-    const records = await AWSTaskRunner.Kinesis.send(new GetRecordsCommand({ ShardIterator: iterator }));
+    let records: any;
+    try {
+      records = await AwsClientFactory.getKinesis().send(new GetRecordsCommand({ ShardIterator: iterator }));
+    } catch (error: any) {
+      const isThrottle = error?.name === 'ThrottlingException' || /rate exceeded/i.test(String(error?.message));
+      if (isThrottle) {
+        const baseBackoffMs = 1000;
+        const jitterMs = Math.floor(Math.random() * 1000);
+        const sleepMs = baseBackoffMs + jitterMs;
+        OrchestratorLogger.log(`AWS throttled GetRecords, backing off ${sleepMs}ms (1000 + jitter ${jitterMs})`);
+        await new Promise((r) => setTimeout(r, sleepMs));
+
+        return { iterator, shouldReadLogs, output, shouldCleanup };
+      }
+      throw error;
+    }
     iterator = records.NextShardIterator || '';
     ({ shouldReadLogs, output, shouldCleanup } = AWSTaskRunner.logRecords(
       records,
@@ -200,27 +267,27 @@ class AWSTaskRunner {
     return { iterator, shouldReadLogs, output, shouldCleanup };
   }
 
-  private static checkStreamingShouldContinue(taskData: Task, timestamp: number, shouldReadLogs: boolean) {
+  private static checkStreamingShouldContinue(taskData: any, timestamp: number, shouldReadLogs: boolean) {
     if (taskData?.lastStatus === 'UNKNOWN') {
-      CloudRunnerLogger.log('## Cloud runner job unknwon');
+      OrchestratorLogger.log('## Orchestrator job unknwon');
     }
     if (taskData?.lastStatus !== 'RUNNING') {
       if (timestamp === 0) {
-        CloudRunnerLogger.log('## Cloud runner job stopped, streaming end of logs');
+        OrchestratorLogger.log('## Orchestrator job stopped, streaming end of logs');
         timestamp = Date.now();
       }
       if (timestamp !== 0 && Date.now() - timestamp > 30000) {
-        CloudRunnerLogger.log('## Cloud runner status is not RUNNING for 30 seconds, last query for logs');
+        OrchestratorLogger.log('## Orchestrator status is not RUNNING for 30 seconds, last query for logs');
         shouldReadLogs = false;
       }
-      CloudRunnerLogger.log(`## Status of job: ${taskData.lastStatus}`);
+      OrchestratorLogger.log(`## Status of job: ${taskData.lastStatus}`);
     }
 
     return { timestamp, shouldReadLogs };
   }
 
   private static logRecords(
-    records: GetRecordsCommandOutput,
+    records: any,
     iterator: string,
     shouldReadLogs: boolean,
     output: string,
@@ -248,13 +315,13 @@ class AWSTaskRunner {
   }
 
   private static async getLogStream(kinesisStreamName: string) {
-    return await AWSTaskRunner.Kinesis.send(new DescribeStreamCommand({ StreamName: kinesisStreamName }));
+    return await AwsClientFactory.getKinesis().send(new DescribeStreamCommand({ StreamName: kinesisStreamName }));
   }
 
-  private static async getLogIterator(stream: DescribeStreamCommandOutput) {
+  private static async getLogIterator(stream: any) {
     return (
       (
-        await AWSTaskRunner.Kinesis.send(
+        await AwsClientFactory.getKinesis().send(
           new GetShardIteratorCommand({
             ShardIteratorType: 'TRIM_HORIZON',
             StreamName: stream.StreamDescription?.StreamName ?? '',

src/model/orchestrator/providers/aws/cloud-formations/task-definition-formation.ts

@@ -1,7 +1,7 @@
-import CloudRunner from '../../../cloud-runner';
+import Orchestrator from '../../../orchestrator';
 
 export class TaskDefinitionFormation {
-  public static readonly description: string = `Game CI Cloud Runner Task Stack`;
+  public static readonly description: string = `Game CI Orchestrator Task Stack`;
   public static get formation(): string {
     return `AWSTemplateFormatVersion: 2010-09-09
 Description: ${TaskDefinitionFormation.description}
@@ -29,11 +29,11 @@ Parameters:
     Default: 80
     Description: What port number the application inside the docker container is binding to
   ContainerCpu:
-    Default: ${CloudRunner.buildParameters.containerCpu}
+    Default: ${Orchestrator.buildParameters.containerCpu}
     Type: Number
     Description: How much CPU to give the container. 1024 is 1 CPU
   ContainerMemory:
-    Default: ${CloudRunner.buildParameters.containerMemory}
+    Default: ${Orchestrator.buildParameters.containerMemory}
     Type: Number
     Description: How much memory in megabytes to give the container
   BUILDGUID:
@@ -127,8 +127,7 @@ Resources:
             - SourceVolume: efs-data
               ContainerPath: !Ref EFSMountDirectory
               ReadOnly: false
-          Secrets:
-            # template secrets p3 - container def
+          # template secrets p3 - container def
           LogConfiguration:
             LogDriver: awslogs
             Options:

src/model/orchestrator/providers/aws/index.ts

@@ -1,13 +1,11 @@
 import { CloudFormation, DeleteStackCommand, waitUntilStackDeleteComplete } from '@aws-sdk/client-cloudformation';
-import { ECS as ECSClient } from '@aws-sdk/client-ecs';
-import { Kinesis } from '@aws-sdk/client-kinesis';
-import CloudRunnerSecret from '../../options/cloud-runner-secret';
-import CloudRunnerEnvironmentVariable from '../../options/cloud-runner-environment-variable';
-import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
+import OrchestratorSecret from '../../options/orchestrator-secret';
+import OrchestratorEnvironmentVariable from '../../options/orchestrator-environment-variable';
+import OrchestratorAWSTaskDef from './orchestrator-aws-task-def';
 import AwsTaskRunner from './aws-task-runner';
 import { ProviderInterface } from '../provider-interface';
 import BuildParameters from '../../../build-parameters';
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
+import OrchestratorLogger from '../../services/core/orchestrator-logger';
 import { AWSJobStack as AwsJobStack } from './aws-job-stack';
 import { AWSBaseStack as AwsBaseStack } from './aws-base-stack';
 import { Input } from '../../..';
@@ -15,7 +13,20 @@ import { GarbageCollectionService } from './services/garbage-collection-service'
 import { ProviderResource } from '../provider-resource';
 import { ProviderWorkflow } from '../provider-workflow';
 import { TaskService } from './services/task-service';
-import CloudRunnerOptions from '../../options/cloud-runner-options';
+import OrchestratorOptions from '../../options/orchestrator-options';
+import { AwsClientFactory } from './aws-client-factory';
+import ResourceTracking from '../../services/core/resource-tracking';
+
+const DEFAULT_STACK_WAIT_TIME_SECONDS = 600;
+
+function getStackWaitTime(): number {
+  const overrideValue = Number(process.env.ORCHESTRATOR_AWS_STACK_WAIT_TIME ?? '');
+  if (!Number.isNaN(overrideValue) && overrideValue > 0) {
+    return overrideValue;
+  }
+
+  return DEFAULT_STACK_WAIT_TIME_SECONDS;
+}
 
 class AWSBuildEnvironment implements ProviderInterface {
   private baseStackName: string;
@@ -77,7 +88,7 @@ class AWSBuildEnvironment implements ProviderInterface {
     defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
   ) {
     process.env.AWS_REGION = Input.region;
-    const CF = new CloudFormation({ region: Input.region });
+    const CF = AwsClientFactory.getCloudFormation();
     await new AwsBaseStack(this.baseStackName).setupBaseStack(CF);
   }
 
@@ -87,15 +98,16 @@ class AWSBuildEnvironment implements ProviderInterface {
     commands: string,
     mountdir: string,
     workingdir: string,
-    environment: CloudRunnerEnvironmentVariable[],
-    secrets: CloudRunnerSecret[],
+    environment: OrchestratorEnvironmentVariable[],
+    secrets: OrchestratorSecret[],
   ): Promise<string> {
     process.env.AWS_REGION = Input.region;
-    const ECS = new ECSClient({ region: Input.region });
-    const CF = new CloudFormation({ region: Input.region });
-    AwsTaskRunner.ECS = ECS;
-    AwsTaskRunner.Kinesis = new Kinesis({ region: Input.region });
-    CloudRunnerLogger.log(`AWS Region: ${CF.config.region}`);
+    ResourceTracking.logAllocationSummary('aws workflow');
+    await ResourceTracking.logDiskUsageSnapshot('aws workflow (host)');
+    AwsClientFactory.getECS();
+    const CF = AwsClientFactory.getCloudFormation();
+    AwsClientFactory.getKinesis();
+    OrchestratorLogger.log(`AWS Region: ${CF.config.region}`);
     const entrypoint = ['/bin/sh'];
     const startTimeMs = Date.now();
     const taskDef = await new AwsJobStack(this.baseStackName).setupCloudFormations(
@@ -112,36 +124,37 @@ class AWSBuildEnvironment implements ProviderInterface {
     let postRunTaskTimeMs;
     try {
       const postSetupStacksTimeMs = Date.now();
-      CloudRunnerLogger.log(`Setup job time: ${Math.floor((postSetupStacksTimeMs - startTimeMs) / 1000)}s`);
+      OrchestratorLogger.log(`Setup job time: ${Math.floor((postSetupStacksTimeMs - startTimeMs) / 1000)}s`);
       const { output, shouldCleanup } = await AwsTaskRunner.runTask(taskDef, environment, commands);
       postRunTaskTimeMs = Date.now();
-      CloudRunnerLogger.log(`Run job time: ${Math.floor((postRunTaskTimeMs - postSetupStacksTimeMs) / 1000)}s`);
+      OrchestratorLogger.log(`Run job time: ${Math.floor((postRunTaskTimeMs - postSetupStacksTimeMs) / 1000)}s`);
       if (shouldCleanup) {
         await this.cleanupResources(CF, taskDef);
       }
       const postCleanupTimeMs = Date.now();
       if (postRunTaskTimeMs !== undefined)
-        CloudRunnerLogger.log(`Cleanup job time: ${Math.floor((postCleanupTimeMs - postRunTaskTimeMs) / 1000)}s`);
+        OrchestratorLogger.log(`Cleanup job time: ${Math.floor((postCleanupTimeMs - postRunTaskTimeMs) / 1000)}s`);
 
       return output;
     } catch (error) {
-      CloudRunnerLogger.log(`error running task ${error}`);
+      OrchestratorLogger.log(`error running task ${error}`);
       await this.cleanupResources(CF, taskDef);
       throw error;
     }
   }
 
-  async cleanupResources(CF: CloudFormation, taskDef: CloudRunnerAWSTaskDef) {
-    CloudRunnerLogger.log('Cleanup starting');
+  async cleanupResources(CF: CloudFormation, taskDef: OrchestratorAWSTaskDef) {
+    const stackWaitTimeSeconds = getStackWaitTime();
+    OrchestratorLogger.log(`Cleanup starting (waiting up to ${stackWaitTimeSeconds}s for stack deletion)`);
     await CF.send(new DeleteStackCommand({ StackName: taskDef.taskDefStackName }));
-    if (CloudRunnerOptions.useCleanupCron) {
+    if (OrchestratorOptions.useCleanupCron) {
       await CF.send(new DeleteStackCommand({ StackName: `${taskDef.taskDefStackName}-cleanup` }));
     }
 
     await waitUntilStackDeleteComplete(
       {
         client: CF,
-        maxWaitTime: 200,
+        maxWaitTime: stackWaitTimeSeconds,
       },
       {
         StackName: taskDef.taskDefStackName,
@@ -150,14 +163,14 @@ class AWSBuildEnvironment implements ProviderInterface {
     await waitUntilStackDeleteComplete(
       {
         client: CF,
-        maxWaitTime: 200,
+        maxWaitTime: stackWaitTimeSeconds,
       },
       {
         StackName: `${taskDef.taskDefStackName}-cleanup`,
       },
     );
-    CloudRunnerLogger.log(`Deleted Stack: ${taskDef.taskDefStackName}`);
-    CloudRunnerLogger.log('Cleanup complete');
+    OrchestratorLogger.log(`Deleted Stack: ${taskDef.taskDefStackName}`);
+    OrchestratorLogger.log('Cleanup complete');
   }
 }
 export default AWSBuildEnvironment;

src/model/orchestrator/providers/aws/orchestrator-aws-task-def.ts

@@ -1,9 +1,10 @@
+// eslint-disable-next-line import/named
 import { StackResource } from '@aws-sdk/client-cloudformation';
 
-class CloudRunnerAWSTaskDef {
+class OrchestratorAWSTaskDef {
   public taskDefStackName!: string;
   public taskDefCloudFormation!: string;
   public taskDefResources: StackResource[] | undefined;
   public baseResources: StackResource[] | undefined;
 }
-export default CloudRunnerAWSTaskDef;
+export default OrchestratorAWSTaskDef;

src/model/orchestrator/providers/aws/services/garbage-collection-service.ts

@@ -1,14 +1,10 @@
-import {
-  CloudFormation,
-  DeleteStackCommand,
-  DeleteStackCommandInput,
-  DescribeStackResourcesCommand,
-} from '@aws-sdk/client-cloudformation';
-import { CloudWatchLogs, DeleteLogGroupCommand } from '@aws-sdk/client-cloudwatch-logs';
-import { ECS, StopTaskCommand } from '@aws-sdk/client-ecs';
+import { DeleteStackCommand, DescribeStackResourcesCommand } from '@aws-sdk/client-cloudformation';
+import { DeleteLogGroupCommand } from '@aws-sdk/client-cloudwatch-logs';
+import { StopTaskCommand } from '@aws-sdk/client-ecs';
 import Input from '../../../../input';
-import CloudRunnerLogger from '../../../services/core/cloud-runner-logger';
+import OrchestratorLogger from '../../../services/core/orchestrator-logger';
 import { TaskService } from './task-service';
+import { AwsClientFactory } from '../aws-client-factory';
 
 export class GarbageCollectionService {
   static isOlderThan1day(date: Date) {
@@ -19,9 +15,9 @@ export class GarbageCollectionService {
 
   public static async cleanup(deleteResources = false, OneDayOlderOnly: boolean = false) {
     process.env.AWS_REGION = Input.region;
-    const CF = new CloudFormation({ region: Input.region });
-    const ecs = new ECS({ region: Input.region });
-    const cwl = new CloudWatchLogs({ region: Input.region });
+    const CF = AwsClientFactory.getCloudFormation();
+    const ecs = AwsClientFactory.getECS();
+    const cwl = AwsClientFactory.getCloudWatchLogs();
     const taskDefinitionsInUse = new Array();
     const tasks = await TaskService.getTasks();
 
@@ -29,7 +25,7 @@ export class GarbageCollectionService {
       const { taskElement, element } = task;
       taskDefinitionsInUse.push(taskElement.taskDefinitionArn);
       if (deleteResources && (!OneDayOlderOnly || GarbageCollectionService.isOlderThan1day(taskElement.createdAt!))) {
-        CloudRunnerLogger.log(`Stopping task ${taskElement.containers?.[0].name}`);
+        OrchestratorLogger.log(`Stopping task ${taskElement.containers?.[0].name}`);
         await ecs.send(new StopTaskCommand({ task: taskElement.taskArn || '', cluster: element }));
       }
     }
@@ -41,7 +37,7 @@ export class GarbageCollectionService {
           (x) => x.ResourceType === 'AWS::ECS::TaskDefinition' && taskDefinitionsInUse.includes(x.PhysicalResourceId),
         )
       ) {
-        CloudRunnerLogger.log(`Skipping ${element.StackName} - active task was running not deleting`);
+        OrchestratorLogger.log(`Skipping ${element.StackName} - active task was running not deleting`);
 
         return;
       }
@@ -51,14 +47,13 @@ export class GarbageCollectionService {
         (!OneDayOlderOnly || (element.CreationTime && GarbageCollectionService.isOlderThan1day(element.CreationTime)))
       ) {
         if (element.StackName === 'game-ci' || element.TemplateDescription === 'Game-CI base stack') {
-          CloudRunnerLogger.log(`Skipping ${element.StackName} ignore list`);
+          OrchestratorLogger.log(`Skipping ${element.StackName} ignore list`);
 
           return;
         }
 
-        CloudRunnerLogger.log(`Deleting ${element.StackName}`);
-        const deleteStackInput: DeleteStackCommandInput = { StackName: element.StackName };
-        await CF.send(new DeleteStackCommand(deleteStackInput));
+        OrchestratorLogger.log(`Deleting ${element.StackName}`);
+        await CF.send(new DeleteStackCommand({ StackName: element.StackName }));
       }
     }
     const logGroups = await TaskService.getLogGroups();
@@ -67,14 +62,14 @@ export class GarbageCollectionService {
         deleteResources &&
         (!OneDayOlderOnly || GarbageCollectionService.isOlderThan1day(new Date(element.creationTime!)))
       ) {
-        CloudRunnerLogger.log(`Deleting ${element.logGroupName}`);
+        OrchestratorLogger.log(`Deleting ${element.logGroupName}`);
         await cwl.send(new DeleteLogGroupCommand({ logGroupName: element.logGroupName || '' }));
       }
     }
 
     const locks = await TaskService.getLocks();
     for (const element of locks) {
-      CloudRunnerLogger.log(`Lock: ${element.Key}`);
+      OrchestratorLogger.log(`Lock: ${element.Key}`);
     }
   }
 }

src/model/orchestrator/providers/aws/services/task-service.ts

@@ -1,31 +1,22 @@
 import {
-  CloudFormation,
   DescribeStackResourcesCommand,
   DescribeStacksCommand,
   ListStacksCommand,
-  StackSummary,
 } from '@aws-sdk/client-cloudformation';
-import {
-  CloudWatchLogs,
-  DescribeLogGroupsCommand,
-  DescribeLogGroupsCommandInput,
-  LogGroup,
-} from '@aws-sdk/client-cloudwatch-logs';
-import {
-  DescribeTasksCommand,
-  DescribeTasksCommandInput,
-  ECS,
-  ListClustersCommand,
-  ListTasksCommand,
-  ListTasksCommandInput,
-  Task,
-} from '@aws-sdk/client-ecs';
-import { ListObjectsCommand, ListObjectsCommandInput, S3 } from '@aws-sdk/client-s3';
+import type { StackSummary } from '@aws-sdk/client-cloudformation';
+// eslint-disable-next-line import/named
+import { DescribeLogGroupsCommand, DescribeLogGroupsCommandInput } from '@aws-sdk/client-cloudwatch-logs';
+import type { LogGroup } from '@aws-sdk/client-cloudwatch-logs';
+import { DescribeTasksCommand, ListClustersCommand, ListTasksCommand } from '@aws-sdk/client-ecs';
+import type { Task } from '@aws-sdk/client-ecs';
+import { ListObjectsV2Command } from '@aws-sdk/client-s3';
 import Input from '../../../../input';
-import CloudRunnerLogger from '../../../services/core/cloud-runner-logger';
+import OrchestratorLogger from '../../../services/core/orchestrator-logger';
 import { BaseStackFormation } from '../cloud-formations/base-stack-formation';
 import AwsTaskRunner from '../aws-task-runner';
-import CloudRunner from '../../../cloud-runner';
+import Orchestrator from '../../../orchestrator';
+import { AwsClientFactory } from '../aws-client-factory';
+import SharedWorkspaceLocking from '../../../services/core/shared-workspace-locking';
 
 export class TaskService {
   static async watch() {
@@ -38,27 +29,27 @@ export class TaskService {
 
     return output;
   }
-  public static async getCloudFormationJobStacks() {
+  public static async getCloudFormationJobStacks(): Promise<StackSummary[]> {
     const result: StackSummary[] = [];
-    CloudRunnerLogger.log(``);
-    CloudRunnerLogger.log(`List Cloud Formation Stacks`);
+    OrchestratorLogger.log(``);
+    OrchestratorLogger.log(`List Cloud Formation Stacks`);
     process.env.AWS_REGION = Input.region;
-    const CF = new CloudFormation({ region: Input.region });
+    const CF = AwsClientFactory.getCloudFormation();
     const stacks =
       (await CF.send(new ListStacksCommand({}))).StackSummaries?.filter(
         (_x) =>
           _x.StackStatus !== 'DELETE_COMPLETE' && _x.TemplateDescription !== BaseStackFormation.baseStackDecription,
       ) || [];
-    CloudRunnerLogger.log(``);
-    CloudRunnerLogger.log(`Cloud Formation Stacks ${stacks.length}`);
+    OrchestratorLogger.log(``);
+    OrchestratorLogger.log(`Cloud Formation Stacks ${stacks.length}`);
     for (const element of stacks) {
       if (!element.CreationTime) {
-        CloudRunnerLogger.log(`${element.StackName} due to undefined CreationTime`);
+        OrchestratorLogger.log(`${element.StackName} due to undefined CreationTime`);
       }
 
       const ageDate: Date = new Date(Date.now() - (element.CreationTime?.getTime() ?? 0));
 
-      CloudRunnerLogger.log(
+      OrchestratorLogger.log(
         `Task Stack ${element.StackName} - Age D${Math.floor(
           ageDate.getHours() / 24,
         )} H${ageDate.getHours()} M${ageDate.getMinutes()}`,
@@ -70,69 +61,79 @@ export class TaskService {
         (_x) =>
           _x.StackStatus !== 'DELETE_COMPLETE' && _x.TemplateDescription === BaseStackFormation.baseStackDecription,
       ) || [];
-    CloudRunnerLogger.log(``);
-    CloudRunnerLogger.log(`Base Stacks ${baseStacks.length}`);
+    OrchestratorLogger.log(``);
+    OrchestratorLogger.log(`Base Stacks ${baseStacks.length}`);
     for (const element of baseStacks) {
       if (!element.CreationTime) {
-        CloudRunnerLogger.log(`${element.StackName} due to undefined CreationTime`);
+        OrchestratorLogger.log(`${element.StackName} due to undefined CreationTime`);
       }
 
       const ageDate: Date = new Date(Date.now() - (element.CreationTime?.getTime() ?? 0));
 
-      CloudRunnerLogger.log(
+      OrchestratorLogger.log(
         `Task Stack ${element.StackName} - Age D${Math.floor(
           ageDate.getHours() / 24,
         )} H${ageDate.getHours()} M${ageDate.getMinutes()}`,
       );
       result.push(element);
     }
-    CloudRunnerLogger.log(``);
+    OrchestratorLogger.log(``);
 
     return result;
   }
-  public static async getTasks() {
+  public static async getTasks(): Promise<{ taskElement: Task; element: string }[]> {
     const result: { taskElement: Task; element: string }[] = [];
-    CloudRunnerLogger.log(``);
-    CloudRunnerLogger.log(`List Tasks`);
+    OrchestratorLogger.log(``);
+    OrchestratorLogger.log(`List Tasks`);
     process.env.AWS_REGION = Input.region;
-    const ecs = new ECS({ region: Input.region });
-    const clusters = (await ecs.send(new ListClustersCommand({}))).clusterArns || [];
-    CloudRunnerLogger.log(`Task Clusters ${clusters.length}`);
+    const ecs = AwsClientFactory.getECS();
+    const clusters: string[] = [];
+    {
+      let nextToken: string | undefined;
+      do {
+        const clusterResponse = await ecs.send(new ListClustersCommand({ nextToken }));
+        clusters.push(...(clusterResponse.clusterArns ?? []));
+        nextToken = clusterResponse.nextToken;
+      } while (nextToken);
+    }
+    OrchestratorLogger.log(`Task Clusters ${clusters.length}`);
     for (const element of clusters) {
-      const input: ListTasksCommandInput = {
-        cluster: element,
-      };
-
-      const list = (await ecs.send(new ListTasksCommand(input))).taskArns || [];
-      if (list.length > 0) {
-        const describeInput: DescribeTasksCommandInput = { tasks: list, cluster: element };
+      const taskArns: string[] = [];
+      {
+        let nextToken: string | undefined;
+        do {
+          const taskResponse = await ecs.send(new ListTasksCommand({ cluster: element, nextToken }));
+          taskArns.push(...(taskResponse.taskArns ?? []));
+          nextToken = taskResponse.nextToken;
+        } while (nextToken);
+      }
+      if (taskArns.length > 0) {
+        const describeInput = { tasks: taskArns, cluster: element };
         const describeList = (await ecs.send(new DescribeTasksCommand(describeInput))).tasks || [];
         if (describeList.length === 0) {
-          CloudRunnerLogger.log(`No Tasks`);
+          OrchestratorLogger.log(`No Tasks`);
           continue;
         }
-        CloudRunnerLogger.log(`Tasks ${describeList.length}`);
+        OrchestratorLogger.log(`Tasks ${describeList.length}`);
         for (const taskElement of describeList) {
           if (taskElement === undefined) {
             continue;
           }
-          taskElement.overrides = {};
-          taskElement.attachments = [];
           if (taskElement.createdAt === undefined) {
-            CloudRunnerLogger.log(`Skipping ${taskElement.taskDefinitionArn} no createdAt date`);
+            OrchestratorLogger.log(`Skipping ${taskElement.taskDefinitionArn} no createdAt date`);
             continue;
           }
           result.push({ taskElement, element });
         }
       }
     }
-    CloudRunnerLogger.log(``);
+    OrchestratorLogger.log(``);
 
     return result;
   }
   public static async awsDescribeJob(job: string) {
     process.env.AWS_REGION = Input.region;
-    const CF = new CloudFormation({ region: Input.region });
+    const CF = AwsClientFactory.getCloudFormation();
     try {
       const stack =
         (await CF.send(new ListStacksCommand({}))).StackSummaries?.find((_x) => _x.StackName === job) || undefined;
@@ -142,7 +143,7 @@ export class TaskService {
         throw new Error('stack not defined');
       }
       if (!stack.CreationTime) {
-        CloudRunnerLogger.log(`${stack.StackName} due to undefined CreationTime`);
+        OrchestratorLogger.log(`${stack.StackName} due to undefined CreationTime`);
       }
       const ageDate: Date = new Date(Date.now() - (stack.CreationTime?.getTime() ?? 0));
       const message = `
@@ -152,40 +153,43 @@ export class TaskService {
     ${JSON.stringify(stackInfo, undefined, 4)}
     ${JSON.stringify(stackInfo2, undefined, 4)}
     `;
-      CloudRunnerLogger.log(message);
+      OrchestratorLogger.log(message);
 
       return message;
     } catch (error) {
-      CloudRunnerLogger.error(
+      OrchestratorLogger.error(
         `Failed to describe job ${job}: ${error instanceof Error ? error.message : String(error)}`,
       );
       throw error;
     }
   }
-  public static async getLogGroups() {
-    const result: Array<LogGroup> = [];
+  public static async getLogGroups(): Promise<LogGroup[]> {
+    const result: LogGroup[] = [];
     process.env.AWS_REGION = Input.region;
-    const ecs = new CloudWatchLogs();
+    const cwl = AwsClientFactory.getCloudWatchLogs();
     let logStreamInput: DescribeLogGroupsCommandInput = {
       /* logGroupNamePrefix: 'game-ci' */
     };
-    let logGroupsDescribe = await ecs.send(new DescribeLogGroupsCommand(logStreamInput));
+    let logGroupsDescribe = await cwl.send(new DescribeLogGroupsCommand(logStreamInput));
     const logGroups = logGroupsDescribe.logGroups || [];
     while (logGroupsDescribe.nextToken) {
-      logStreamInput = { /* logGroupNamePrefix: 'game-ci',*/ nextToken: logGroupsDescribe.nextToken };
-      logGroupsDescribe = await ecs.send(new DescribeLogGroupsCommand(logStreamInput));
+      logStreamInput = {
+        /* logGroupNamePrefix: 'game-ci',*/
+        nextToken: logGroupsDescribe.nextToken,
+      };
+      logGroupsDescribe = await cwl.send(new DescribeLogGroupsCommand(logStreamInput));
       logGroups.push(...(logGroupsDescribe?.logGroups || []));
     }
 
-    CloudRunnerLogger.log(`Log Groups ${logGroups.length}`);
+    OrchestratorLogger.log(`Log Groups ${logGroups.length}`);
     for (const element of logGroups) {
       if (element.creationTime === undefined) {
-        CloudRunnerLogger.log(`Skipping ${element.logGroupName} no createdAt date`);
+        OrchestratorLogger.log(`Skipping ${element.logGroupName} no createdAt date`);
         continue;
       }
       const ageDate: Date = new Date(Date.now() - element.creationTime);
 
-      CloudRunnerLogger.log(
+      OrchestratorLogger.log(
         `Task Stack ${element.logGroupName} - Age D${Math.floor(
           ageDate.getHours() / 24,
         )} H${ageDate.getHours()} M${ageDate.getMinutes()}`,
@@ -195,15 +199,22 @@ export class TaskService {
 
     return result;
   }
-  public static async getLocks() {
+  public static async getLocks(): Promise<Array<{ Key: string }>> {
     process.env.AWS_REGION = Input.region;
-    const s3 = new S3({ region: Input.region });
-    const listRequest: ListObjectsCommandInput = {
-      Bucket: CloudRunner.buildParameters.awsStackName,
+    if (Orchestrator.buildParameters.storageProvider === 'rclone') {
+      // eslint-disable-next-line no-unused-vars
+      type ListObjectsFunction = (prefix: string) => Promise<string[]>;
+      const objects = await (SharedWorkspaceLocking as unknown as { listObjects: ListObjectsFunction }).listObjects('');
+
+      return objects.map((x: string) => ({ Key: x }));
+    }
+    const s3 = AwsClientFactory.getS3();
+    const listRequest = {
+      Bucket: Orchestrator.buildParameters.awsStackName,
     };
 
-    const results = await s3.send(new ListObjectsCommand(listRequest));
+    const results = await s3.send(new ListObjectsV2Command(listRequest));
 
-    return results.Contents || [];
+    return (results.Contents || []).map((object) => ({ Key: object.Key || '' }));
   }
 }

src/model/orchestrator/providers/docker/index.ts

@@ -1,20 +1,20 @@
 import BuildParameters from '../../../build-parameters';
-import CloudRunnerEnvironmentVariable from '../../options/cloud-runner-environment-variable';
-import CloudRunnerLogger from '../../services/core/cloud-runner-logger';
+import OrchestratorEnvironmentVariable from '../../options/orchestrator-environment-variable';
+import OrchestratorLogger from '../../services/core/orchestrator-logger';
 import { ProviderInterface } from '../provider-interface';
-import CloudRunnerSecret from '../../options/cloud-runner-secret';
+import OrchestratorSecret from '../../options/orchestrator-secret';
 import Docker from '../../../docker';
 import { Action } from '../../..';
 import { writeFileSync } from 'node:fs';
-import CloudRunner from '../../cloud-runner';
+import Orchestrator from '../../orchestrator';
 import { ProviderResource } from '../provider-resource';
 import { ProviderWorkflow } from '../provider-workflow';
-import { CloudRunnerSystem } from '../../services/core/cloud-runner-system';
+import { OrchestratorSystem } from '../../services/core/orchestrator-system';
 import * as fs from 'node:fs';
 import { CommandHookService } from '../../services/hooks/command-hook-service';
 import { StringKeyValuePair } from '../../../shared-types';
 
-class LocalDockerCloudRunner implements ProviderInterface {
+class LocalDockerOrchestrator implements ProviderInterface {
   public buildParameters!: BuildParameters;
 
   listResources(): Promise<ProviderResource[]> {
@@ -50,15 +50,15 @@ class LocalDockerCloudRunner implements ProviderInterface {
     const { workspace } = Action;
     if (
       fs.existsSync(
-        `${workspace}/cloud-runner-cache/cache/build/build-${buildParameters.buildGuid}.tar${
-          CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
+        `${workspace}/orchestrator-cache/cache/build/build-${buildParameters.buildGuid}.tar${
+          Orchestrator.buildParameters.useCompressionStrategy ? '.lz4' : ''
         }`,
       )
     ) {
-      await CloudRunnerSystem.Run(`ls ${workspace}/cloud-runner-cache/cache/build/`);
-      await CloudRunnerSystem.Run(
-        `rm -r ${workspace}/cloud-runner-cache/cache/build/build-${buildParameters.buildGuid}.tar${
-          CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
+      await OrchestratorSystem.Run(`ls ${workspace}/orchestrator-cache/cache/build/`);
+      await OrchestratorSystem.Run(
+        `rm -r ${workspace}/orchestrator-cache/cache/build/build-${buildParameters.buildGuid}.tar${
+          Orchestrator.buildParameters.useCompressionStrategy ? '.lz4' : ''
         }`,
       );
     }
@@ -80,22 +80,47 @@ class LocalDockerCloudRunner implements ProviderInterface {
     commands: string,
     mountdir: string,
     workingdir: string,
-    environment: CloudRunnerEnvironmentVariable[],
-    secrets: CloudRunnerSecret[],
+    environment: OrchestratorEnvironmentVariable[],
+    secrets: OrchestratorSecret[],
   ): Promise<string> {
-    CloudRunnerLogger.log(buildGuid);
-    CloudRunnerLogger.log(commands);
+    OrchestratorLogger.log(buildGuid);
+    OrchestratorLogger.log(commands);
 
     const { workspace, actionFolder } = Action;
     const content: StringKeyValuePair[] = [];
     for (const x of secrets) {
       content.push({ name: x.EnvironmentVariable, value: x.ParameterValue });
     }
+
+    // Replace localhost with host.docker.internal for LocalStack endpoints (similar to K8s)
+    // This allows Docker containers to access LocalStack running on the host
+    const endpointEnvironmentNames = new Set([
+      'AWS_S3_ENDPOINT',
+      'AWS_ENDPOINT',
+      'AWS_CLOUD_FORMATION_ENDPOINT',
+      'AWS_ECS_ENDPOINT',
+      'AWS_KINESIS_ENDPOINT',
+      'AWS_CLOUD_WATCH_LOGS_ENDPOINT',
+      'INPUT_AWSS3ENDPOINT',
+      'INPUT_AWSENDPOINT',
+    ]);
     for (const x of environment) {
-      content.push({ name: x.name, value: x.value });
+      let value = x.value;
+      if (
+        typeof value === 'string' &&
+        endpointEnvironmentNames.has(x.name) &&
+        (value.startsWith('http://localhost') || value.startsWith('http://127.0.0.1'))
+      ) {
+        // Replace localhost with host.docker.internal so containers can access host services
+        value = value
+          .replace('http://localhost', 'http://host.docker.internal')
+          .replace('http://127.0.0.1', 'http://host.docker.internal');
+        OrchestratorLogger.log(`Replaced localhost with host.docker.internal for ${x.name}: ${value}`);
+      }
+      content.push({ name: x.name, value });
     }
 
-    // if (this.buildParameters?.cloudRunnerIntegrationTests) {
+    // if (this.buildParameters?.orchestratorIntegrationTests) {
     //   core.info(JSON.stringify(content, undefined, 4));
     //   core.info(JSON.stringify(secrets, undefined, 4));
     //   core.info(JSON.stringify(environment, undefined, 4));
@@ -112,25 +137,33 @@ class LocalDockerCloudRunner implements ProviderInterface {
 
     // core.info(JSON.stringify({ workspace, actionFolder, ...this.buildParameters, ...content }, undefined, 4));
     const entrypointFilePath = `start.sh`;
-    const fileContents = `#!/bin/bash
+
+    // Use #!/bin/sh for POSIX compatibility (Alpine-based images like rclone/rclone don't have bash)
+    const fileContents = `#!/bin/sh
 set -e
 
-mkdir -p /github/workspace/cloud-runner-cache
+mkdir -p /github/workspace/orchestrator-cache
 mkdir -p /data/cache
-cp -a /github/workspace/cloud-runner-cache/. ${sharedFolder}
+cp -a /github/workspace/orchestrator-cache/. ${sharedFolder}
 ${CommandHookService.ApplyHooksToCommands(commands, this.buildParameters)}
-cp -a ${sharedFolder}. /github/workspace/cloud-runner-cache/
+# Only copy cache directory, exclude retained workspaces to avoid running out of disk space
+if [ -d "${sharedFolder}cache" ]; then
+  cp -a ${sharedFolder}cache/. /github/workspace/orchestrator-cache/cache/ || true
+fi
+# Copy test files from /data/ root to workspace for test assertions
+# This allows tests to write files to /data/ and have them available in the workspace
+find ${sharedFolder} -maxdepth 1 -type f -name "test-*" -exec cp -a {} /github/workspace/orchestrator-cache/ \\; || true
 `;
     writeFileSync(`${workspace}/${entrypointFilePath}`, fileContents, {
       flag: 'w',
     });
 
-    if (CloudRunner.buildParameters.cloudRunnerDebug) {
-      CloudRunnerLogger.log(`Running local-docker: \n ${fileContents}`);
+    if (Orchestrator.buildParameters.orchestratorDebug) {
+      OrchestratorLogger.log(`Running local-docker: \n ${fileContents}`);
     }
 
-    if (fs.existsSync(`${workspace}/cloud-runner-cache`)) {
-      await CloudRunnerSystem.Run(`ls ${workspace}/cloud-runner-cache && du -sh ${workspace}/cloud-runner-cache`);
+    if (fs.existsSync(`${workspace}/orchestrator-cache`)) {
+      await OrchestratorSystem.Run(`ls ${workspace}/orchestrator-cache && du -sh ${workspace}/orchestrator-cache`);
     }
     const exitCode = await Docker.run(
       image,
@@ -160,4 +193,4 @@ cp -a ${sharedFolder}. /github/workspace/cloud-runner-cache/
     return myOutput;
   }
 }
-export default LocalDockerCloudRunner;
+export default LocalDockerOrchestrator;