Lint

Strip INPUT_* env variables from subprocesses
2021-05-05 16:58:35 -04:00 · 2021-05-05 16:48:27 -04:00
197 changed files with 33752 additions and 27170 deletions
@@ -1,5 +1,3 @@
 node_modules/
 packages/*/node_modules/
-packages/*/lib/
-packages/glob/__tests__/_temp
-packages/*/src/generated/*/
+packages/*/lib/
@@ -1,13 +1,6 @@
 {
-  "plugins": [
-    "jest",
-    "@typescript-eslint",
-    "prettier"
-  ],
-  "extends": [
-    "plugin:github/recommended",
-    "plugin:prettier/recommended"
-  ],
+  "plugins": ["jest", "@typescript-eslint"],
+  "extends": ["plugin:github/es6"],
  "parser": "@typescript-eslint/parser",
  "parserOptions": {
    "ecmaVersion": 9,
@@ -15,62 +8,21 @@
    "project": "./tsconfig.eslint.json"
  },
  "rules": {
-    "prettier/prettier": [
-      "error",
-      {
-        "endOfLine": "auto"
-      }
-    ],
    "eslint-comments/no-use": "off",
-    "no-constant-condition": ["error", { "checkLoops": false }],
-    "github/no-then": "off",
    "import/no-namespace": "off",
-    "no-shadow": "off",
    "no-unused-vars": "off",
-    "i18n-text/no-en": "off",
-    "filenames/match-regex": "off",
-    "import/no-commonjs": "off",
-    "import/named": "off",
-    "no-sequences": "off",
-    "import/no-unresolved": "off",
-    "no-undef": "off",
-    "no-only-tests/no-only-tests": "off",
    "@typescript-eslint/no-unused-vars": "error",
-    "@typescript-eslint/explicit-member-accessibility": [
-      "error",
-      {
-        "accessibility": "no-public"
-      }
-    ],
+    "@typescript-eslint/explicit-member-accessibility": ["error", {"accessibility": "no-public"}],
    "@typescript-eslint/no-require-imports": "error",
    "@typescript-eslint/array-type": "error",
    "@typescript-eslint/await-thenable": "error",
-    "@typescript-eslint/ban-ts-comment": "error",
+    "@typescript-eslint/ban-ts-ignore": "error",
    "camelcase": "off",
    "@typescript-eslint/camelcase": "off",
-    "@typescript-eslint/consistent-type-assertions": "off",
-    "@typescript-eslint/explicit-function-return-type": [
-      "error",
-      {
-        "allowExpressions": true
-      }
-    ],
-    "@typescript-eslint/func-call-spacing": [
-      "error",
-      "never"
-    ],
-    "@typescript-eslint/naming-convention": [
-      "error",
-      {
-        "format": null,
-        "filter": {
-          // you can expand this regex as you find more cases that require quoting that you want to allow
-          "regex": "^[A-Z][A-Za-z]*$",
-          "match": true
-        },
-        "selector": "memberLike"
-      }
-    ],
+    "@typescript-eslint/class-name-casing": "error",
+    "@typescript-eslint/explicit-function-return-type": ["error", {"allowExpressions": true}],
+    "@typescript-eslint/func-call-spacing": ["error", "never"],
+    "@typescript-eslint/generic-type-naming": ["error", "^[A-Z][A-Za-z]*$"],
    "@typescript-eslint/no-array-constructor": "error",
    "@typescript-eslint/no-empty-interface": "error",
    "@typescript-eslint/no-explicit-any": "error",
@@ -80,6 +32,7 @@
    "@typescript-eslint/no-misused-new": "error",
    "@typescript-eslint/no-namespace": "error",
    "@typescript-eslint/no-non-null-assertion": "warn",
+    "@typescript-eslint/no-object-literal-type-assertion": "error",
    "@typescript-eslint/no-unnecessary-qualifier": "error",
    "@typescript-eslint/no-unnecessary-type-assertion": "error",
    "@typescript-eslint/no-useless-constructor": "error",
@@ -87,21 +40,19 @@
    "@typescript-eslint/prefer-for-of": "warn",
    "@typescript-eslint/prefer-function-type": "warn",
    "@typescript-eslint/prefer-includes": "error",
+    "@typescript-eslint/prefer-interface": "error",
    "@typescript-eslint/prefer-string-starts-ends-with": "error",
    "@typescript-eslint/promise-function-async": "error",
    "@typescript-eslint/require-array-sort-compare": "error",
+    "@typescript-eslint/restrict-plus-operands": "error",
    "semi": "off",
-    "@typescript-eslint/semi": [
-      "error",
-      "never"
-    ],
+    "@typescript-eslint/semi": ["error", "never"],
    "@typescript-eslint/type-annotation-spacing": "error",
    "@typescript-eslint/unbound-method": "error"
  },
-  "ignorePatterns": "packages/glob/__tests__/_temp/**/",
  "env": {
    "node": true,
    "es6": true,
    "jest/globals": true
  }
-}
+}
@@ -28,7 +28,7 @@ Note that before a PR will be accepted, you must ensure:

 ### Useful Scripts

- `npm run bootstrap` This runs `lerna exec -- npm install` which will install dependencies in this repository's packages and cross-link packages where necessary.
+- `npm run bootstrap` This runs `lerna bootstrap` which will install dependencies in this repository's packages and cross-link packages where necessary.
 - `npm run build` This compiles TypeScript code in each package (this is especially important if one package relies on changes in another when you're running tests). This is just an alias for `lerna run tsc`.
 - `npm run format` This checks that formatting has been applied with Prettier.
 - `npm test` This runs all Jest tests in all packages in this repository.
@@ -1,5 +1,3 @@
-# Temporarily disabled while v2.0.0 of @actions/artifact is under development
-
 name: artifact-unit-tests
 on:
  push:
@@ -24,12 +22,17 @@ jobs:

    steps:
    - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2

-    - name: Set Node.js 20.x
-      uses: actions/setup-node@v3
+    - name: Set Node.js 12.x
+      uses: actions/setup-node@v1
      with:
-        node-version: 20.x
+        node-version: 12.x
+
+    # In order to upload & download artifacts from a shell script, certain env variables need to be set that are only available in the
+    # node context. This runs a local action that gets and sets the necessary env variables that are needed
+    - name: Set env variables
+      uses: ./packages/artifact/__tests__/ci-test-action/

    # Need root node_modules because certain npm packages like jest are configured for the entire repository and it won't be possible
    # without these to just compile the artifacts package
@@ -41,95 +44,45 @@ jobs:
        npm ci
        npm run tsc
      working-directory: packages/artifact
-
+    
    - name: Set artifact file contents
      shell: bash
      run: |
-        echo "file1=hello from file 1" >> $GITHUB_ENV
-        echo "file2=hello from file 2" >> $GITHUB_ENV
+        echo "non-gzip-artifact-content=hello" >> $GITHUB_ENV
+        echo "gzip-artifact-content=Some large amount of text that has a compression ratio that is greater than 100%. If greater than 100%, gzip is used to upload the file" >> $GITHUB_ENV

    - name: Create files that will be uploaded
      run: |
-        mkdir artifact-path
-        echo '${{ env.file1 }}' > artifact-path/first.txt
-        echo '${{ env.file2 }}' > artifact-path/second.txt
+        mkdir artifact-path 
+        echo ${{ env.non-gzip-artifact-content }} > artifact-path/world.txt
+        echo ${{ env.gzip-artifact-content }} > artifact-path/gzip.txt

-    - name: Upload Artifacts using actions/github-script@v6
-      uses: actions/github-script@v6
-      with:
-        script: |
-          const artifact = require('./packages/artifact/lib/artifact')
-
-          const artifactName = 'my-artifact-${{ matrix.runs-on }}'
-          console.log('artifactName: ' + artifactName)
-
-          const fileContents = ['artifact-path/first.txt','artifact-path/second.txt']
-
-          const uploadResult = await artifact.create().uploadArtifact(artifactName, fileContents, './')
-          console.log(uploadResult)
-
-          const success = uploadResult.success
-          const size = uploadResult.size
-          const id = uploadResult.id
-
-          if (!success) {
-            throw new Error('Failed to upload artifact')
-          } else {
-            console.log(`Successfully uploaded artifact ${id}`)
-          }
-           
-  verify:
-    runs-on: ubuntu-latest
-    needs: [build]
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-
-    - name: Set Node.js 20.x
-      uses: actions/setup-node@v3
-      with:
-        node-version: 20.x
-
-    # Need root node_modules because certain npm packages like jest are configured for the entire repository and it won't be possible
-    # without these to just compile the artifacts package
-    - name: Install root npm packages
-      run: npm ci
-
-    - name: Compile artifact package
+    # We're using node -e to call the functions directly available in the @actions/artifact package
+    - name: Upload artifacts using uploadArtifact()
      run: |
-        npm ci
-        npm run tsc
-      working-directory: packages/artifact
+        node -e "Promise.resolve(require('./packages/artifact/lib/artifact-client').create().uploadArtifact('my-artifact-1',['artifact-path/world.txt'], '${{ github.workspace }}'))"
+        node -e "Promise.resolve(require('./packages/artifact/lib/artifact-client').create().uploadArtifact('my-artifact-2',['artifact-path/gzip.txt'], '${{ github.workspace }}'))"

-    - name: List artifacts using actions/github-script@v6
-      uses: actions/github-script@v6
-      with:
-        script: |
-          const artifact = require('./packages/artifact/lib/artifact')
+    - name: Download artifacts using downloadArtifact()
+      run: |
+        mkdir artifact-1-directory
+        node -e "Promise.resolve(require('./packages/artifact/lib/artifact-client').create().downloadArtifact('my-artifact-1','artifact-1-directory'))"
+        mkdir artifact-2-directory
+        node -e "Promise.resolve(require('./packages/artifact/lib/artifact-client').create().downloadArtifact('my-artifact-2','artifact-2-directory'))"
+    
+    - name: Verify downloadArtifact()
+      shell: bash
+      run: |
+        packages/artifact/__tests__/test-artifact-file.sh "artifact-1-directory/artifact-path/world.txt" "${{ env.non-gzip-artifact-content }}"
+        packages/artifact/__tests__/test-artifact-file.sh "artifact-2-directory/artifact-path/gzip.txt" "${{ env.gzip-artifact-content }}"

-          const workflowRunId = process.env.GITHUB_RUN_ID
-          const repository = process.env.GITHUB_REPOSITORY
-          const repositoryOwner = repository.split('/')[0]
-          const repositoryName = repository.split('/')[1]
+    - name: Download artifacts using downloadAllArtifacts()
+      run: |
+        mkdir multi-artifact-directory
+        node -e "Promise.resolve(require('./packages/artifact/lib/artifact-client').create().downloadAllArtifacts('multi-artifact-directory'))"

-          const listResult = await artifact.create().listArtifacts(workflowRunId, repositoryOwner, repositoryName, '${{ secrets.GITHUB_TOKEN }}')
-          console.log(listResult)
-
-          const artifacts = listResult.artifacts
-
-          if (artifacts.length !== 3) {
-            throw new Error('Expected 3 artifacts but only found ' + artifacts.length + ' artifacts')
-          }
-
-          const artifactNames = artifacts.map(artifact => artifact.name)
-          if (!artifactNames.includes('my-artifact-ubuntu-latest')){
-            throw new Error("Expected artifact list to contain an artifact named my-artifact-ubuntu-latest but it's missing")
-          }
-          if (!artifactNames.includes('my-artifact-windows-latest')){
-            throw new Error("Expected artifact list to contain an artifact named my-artifact-windows-latest but it's missing")
-          }
-          if (!artifactNames.includes('my-artifact-macos-latest')){
-            throw new Error("Expected artifact list to contain an artifact named my-artifact-macos-latest but it's missing")
-          }
-
-          console.log('Successfully listed artifacts that were uploaded')
+    - name: Verify downloadAllArtifacts()
+      shell: bash
+      run: |
+        packages/artifact/__tests__/test-artifact-file.sh "multi-artifact-directory/my-artifact-1/artifact-path/world.txt" "${{ env.non-gzip-artifact-content }}"
+        packages/artifact/__tests__/test-artifact-file.sh "multi-artifact-directory/my-artifact-2/artifact-path/gzip.txt" "${{ env.gzip-artifact-content }}"
@@ -18,12 +18,12 @@ jobs:

    steps:
    - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2

-    - name: Set Node.js 20.x
-      uses: actions/setup-node@v3
+    - name: Set Node.js 12.x
+      uses: actions/setup-node@v1
      with:
-        node-version: 20.x
+        node-version: 12.x

    - name: npm install
      run: npm install
@@ -31,8 +31,8 @@ jobs:
    - name: Bootstrap
      run: npm run bootstrap

-    - name: audit tools (without allow-list)
-      run: npm audit --audit-level=moderate
+   # - name: audit tools #disabled while we wait for https://github.com/actions/toolkit/issues/539
+   #   run: npm audit --audit-level=moderate

    - name: audit packages
      run: npm run audit-all
@@ -22,12 +22,12 @@ jobs:

    steps:
    - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2

-    - name: Set Node.js 20.x
-      uses: actions/setup-node@v3
+    - name: Set Node.js 12.x
+      uses: actions/setup-node@v1
      with:
-        node-version: 20.x
+        node-version: 12.x

    # In order to save & restore cache from a shell script, certain env variables need to be set that are only available in the
    # node context. This runs a local action that gets and sets the necessary env variables that are needed
@@ -1,90 +0,0 @@
-name: cache-windows-bsd-unit-tests
-on:
-  push:
-    branches:
-      - main
-    paths-ignore:
-      - '**.md'
-  pull_request:
-    paths-ignore:
-      - '**.md'
-
-jobs:
-  build:
-    name: Build
-
-    runs-on: windows-latest
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-
-    - shell: bash
-      run: |
-        rm "C:\Program Files\Git\usr\bin\tar.exe"
-
-    - name: Set Node.js 20.x
-      uses: actions/setup-node@v1
-      with:
-        node-version: 20.x
-
-    # In order to save & restore cache from a shell script, certain env variables need to be set that are only available in the
-    # node context. This runs a local action that gets and sets the necessary env variables that are needed
-    - name: Set env variables
-      uses: ./packages/cache/__tests__/__fixtures__/
-
-    # Need root node_modules because certain npm packages like jest are configured for the entire repository and it won't be possible
-    # without these to just compile the cache package
-    - name: Install root npm packages
-      run: npm ci
-
-    - name: Compile cache package
-      run: |
-        npm ci
-        npm run tsc
-      working-directory: packages/cache
-    
-    - name: Generate files in working directory
-      shell: bash
-      run: packages/cache/__tests__/create-cache-files.sh ${{ runner.os }} test-cache
-
-    - name: Generate files outside working directory
-      shell: bash
-      run: packages/cache/__tests__/create-cache-files.sh ${{ runner.os }} ~/test-cache
-
-    # We're using node -e to call the functions directly available in the @actions/cache package
-    - name: Save cache using saveCache()
-      run: |
-        node -e "Promise.resolve(require('./packages/cache/lib/cache').saveCache(['test-cache','~/test-cache'],'test-${{ runner.os }}-${{ github.run_id }}'))"
-
-    - name: Delete cache folders before restoring
-      shell: bash
-      run: |
-        rm -rf test-cache
-        rm -rf ~/test-cache
-
-    - name: Restore cache using restoreCache() with http-client
-      run: |
-        node -e "Promise.resolve(require('./packages/cache/lib/cache').restoreCache(['test-cache','~/test-cache'],'test-${{ runner.os }}-${{ github.run_id }}',[],{useAzureSdk: false}))"
-
-    - name: Verify cache restored with http-client
-      shell: bash
-      run: |
-        packages/cache/__tests__/verify-cache-files.sh ${{ runner.os }} test-cache
-        packages/cache/__tests__/verify-cache-files.sh ${{ runner.os }} ~/test-cache
-
-    - name: Delete cache folders before restoring
-      shell: bash
-      run: |
-        rm -rf test-cache
-        rm -rf ~/test-cache
-
-    - name: Restore cache using restoreCache() with Azure SDK
-      run: |
-        node -e "Promise.resolve(require('./packages/cache/lib/cache').restoreCache(['test-cache','~/test-cache'],'test-${{ runner.os }}-${{ github.run_id }}'))"
-
-    - name: Verify cache restored with Azure SDK
-      shell: bash
-      run: |
-        packages/cache/__tests__/verify-cache-files.sh ${{ runner.os }} test-cache
-        packages/cache/__tests__/verify-cache-files.sh ${{ runner.os }} ~/test-cache
@@ -2,8 +2,6 @@ name: "Code Scanning - Action"

 on:
  push:
-    branches:    
-      - main
  pull_request:
  schedule:
    - cron: '0 0 * * 0'
@@ -20,18 +18,18 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v1
      with:
         languages: javascript
        
    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
+      uses: github/codeql-action/autobuild@v1

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v1
@@ -5,60 +5,55 @@ on:
    inputs:
      package:
        required: true
-        description: 'core, artifact, cache, exec, github, glob, http-client, io, tool-cache'
-
+        description: 'core, artifact, cache, exec, github, glob, io, tool-cache'
+ 
 jobs:
  test:
    runs-on: macos-latest

    steps:
      - name: setup repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2

      - name: verify package exists
        run: ls packages/${{ github.event.inputs.package }}
-
-      - name: Set Node.js 20.x
-        uses: actions/setup-node@v3
-        with:
-          node-version: 20.x
-
+        
      - name: npm install
        run: npm install
-
+        
      - name: bootstrap
        run: npm run bootstrap
-
+        
      - name: build
        run: npm run build
-
+        
      - name: test
        run: npm run test

      - name: pack
        run: npm pack
        working-directory: packages/${{ github.event.inputs.package }}
-
+        
      - name: upload artifact
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v2
        with:
          name: ${{ github.event.inputs.package }}
          path: packages/${{ github.event.inputs.package }}/*.tgz
-
+        
  publish:
    runs-on: macos-latest
    needs: test
    environment: npm-publish
    steps:
-
+        
      - name: download artifact
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v2
        with:
          name: ${{ github.event.inputs.package }}

      - name: setup authentication
        run: echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" >> .npmrc
-        env:
+        env: 
          NPM_TOKEN: ${{ secrets.TOKEN }}

      - name: publish
@@ -68,13 +63,13 @@ jobs:
        if: failure()
        run: |
          curl -X POST -H 'Content-type: application/json' --data '{"text":":pb__failed: Failed to publish a new version of ${{ github.event.inputs.package }}"}' $SLACK_WEBHOOK
-        env:
+        env: 
          SLACK_WEBHOOK: ${{ secrets.SLACK }}
-
+        
      - name: notify slack on success
        if: success()
        run: |
          curl -X POST -H 'Content-type: application/json' --data '{"text":":dance: Successfully published a new version of ${{ github.event.inputs.package }}"}' $SLACK_WEBHOOK
-        env:
+        env: 
          SLACK_WEBHOOK: ${{ secrets.SLACK }}
-
+        
@@ -23,12 +23,12 @@ jobs:

    steps:
    - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2

-    - name: Set Node.js 20.x
-      uses: actions/setup-node@v3
+    - name: Set Node.js 12.x
+      uses: actions/setup-node@v1
      with:
-        node-version: 20.x
+        node-version: 12.x

    - name: npm install
      run: npm install
@@ -40,7 +40,7 @@ jobs:
      run: npm run build

    - name: npm test
-      run: npm test -- --runInBand --forceExit
+      run: npm test
      env:
        GITHUB_TOKEN: ${{ github.token }}

@@ -9,7 +9,7 @@ jobs:
    if: ${{ github.repository_owner == 'actions' }}
    steps:
    - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2
    - name: Update Octokit
      working-directory: packages/github 
      run: |
@@ -30,7 +30,7 @@ jobs:
        fi
    - name: Create PR
      if: ${{steps.status.outputs.createPR}}
-      uses: actions/github-script@v6
+      uses: actions/github-script@v2
      with:
          github-token: ${{secrets.GITHUB_TOKEN}}
          script: |
@@ -1,5 +1,3 @@
 node_modules/
 packages/*/node_modules/
-packages/*/lib/
-packages/glob/__tests__/_temp/**/
-packages/*/src/generated/*/
+packages/*/lib/
@@ -7,6 +7,5 @@
  "trailingComma": "none",
  "bracketSpacing": false,
  "arrowParens": "avoid",
-  "parser": "typescript",
-  "endOfLine": "auto"
+  "parser": "typescript"
 }
@@ -1,4 +1,4 @@
 * @actions/actions-runtime

-/packages/artifact/   @actions/artifacts-actions
-/packages/cache/      @actions/actions-cache
+/packages/artifact/   @actions/actions-service
+/packages/cache/      @actions/actions-service
@@ -46,15 +46,6 @@ $ npm install @actions/glob
 ```
 <br/>

-:phone: [@actions/http-client](packages/http-client)
-
-A lightweight HTTP client optimized for building actions. Read more [here](packages/http-client)
-
-```bash
-$ npm install @actions/http-client
-```
-<br/>
-
 :pencil2: [@actions/io](packages/io)

 Provides disk i/o functions like cp, mv, rmRF, which etc. Read more [here](packages/io)
@@ -32,7 +32,7 @@ jobs:
        os: [ubuntu-16.04, windows-2019]
    runs-on: ${{matrix.os}}
    actions:
-    - uses: actions/setup-node@v3
+    - uses: actions/setup-node@v1
      with:
        version: ${{matrix.node}}
    - run: | 
@@ -50,18 +50,7 @@ function setSecret(secret: string): void {}

 Now, future logs containing BAR will be masked. E.g. running `echo "Hello FOO BAR World"` will now print `Hello FOO **** World`.

-**WARNING** The add-mask and setSecret commands only support single-line
-secrets or multi-line secrets that have been escaped. `@actions/core`
-`setSecret` will escape the string you provide by default. When an escaped
-multi-line string is provided the whole string and each of its lines
-individually will be masked. For example you can mask `first\nsecond\r\nthird`
-using:
-
-```sh
-echo "::add-mask::first%0Asecond%0D%0Athird"
-```
-
-This will mask `first%0Asecond%0D%0Athird`, `first`, `second` and `third`.
+**WARNING** The add-mask and setSecret  commands only support single line secrets. To register a multiline secrets you must register each line individually otherwise it will not be masked.

 **WARNING** Do **not** mask short values if you can avoid it, it could render your output unreadable (and future steps' output as well).
 For example, if you mask the letter `l`, running `echo "Hello FOO BAR World"` will now print `He*********o FOO BAR Wor****d`
@@ -111,12 +100,9 @@ There are several commands to emit different levels of log output:
 | log level | example usage |
 |---|---|
 | [debug](action-debugging.md)  | `echo "::debug::My debug message"` |
-| notice | `echo "::notice::My notice message"` |
 | warning | `echo "::warning::My warning message"` |
 | error | `echo "::error::My error message"` |

-Additional syntax options are described at [the workflow command documentation](https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-debug-message).
-
 ### Command Echoing

 By default, the echoing of commands to stdout only occurs if [Step Debugging is enabled](./action-debugging.md#How-to-Access-Step-Debug-Logs)
@@ -18,7 +18,7 @@ e.g. To use https://github.com/actions/setup-node, users will author:

 ```yaml
 steps:
-    using: actions/setup-node@v3
+    using: actions/setup-node@v1
 ```

 # Define Metadata
@@ -6,7 +6,7 @@ Problem Matchers are a way to scan the output of actions for a specified regex p

 Currently, GitHub Actions limit the annotation count in a workflow run.

- 10 warning annotations, 10 error annotations, and 10 notice annotations per step
+- 10 warning annotations and 10 error annotations per step
 - 50 annotations per job (sum of annotations from all the steps)
 - 50 annotations per run (separate from the job annotations, these annotations aren’t created by users)

@@ -144,6 +144,6 @@ Use ECMAScript regular expression syntax when testing patterns.

 ### File property getting dropped

-[Enable debug logging](https://docs.github.com/en/actions/managing-workflow-runs/enabling-debug-logging) to determine why the file is getting dropped.
+[Enable debug logging](https://help.github.com/en/actions/configuring-and-managing-workflows/managing-a-workflow-run#enabling-debug-logging) to determine why the file is getting dropped.

 This usually happens when the file does not exist or is not under the workflow repo.
@@ -4,7 +4,7 @@ Self-hosted runners [can be configured](https://help.github.com/en/actions/hosti

 For actions to **just work** behind a proxy server:

-  1. Use [tool-cache](/packages/tool-cache) version >= 1.3.1
-  2. Optionally use [actions/http-client](/packages/http-client)
+  1. Use [tool-cache] version >= 1.3.1
+  2. Optionally use [actions/http-client](https://github.com/actions/http-client)

-If you are using other http clients, refer to the [environment variables set by the runner](https://help.github.com/en/actions/hosting-your-own-runners/using-a-proxy-server-with-self-hosted-runners).
+If you are using other http clients, refer to the [environment variables set by the runner](https://help.github.com/en/actions/hosting-your-own-runners/using-a-proxy-server-with-self-hosted-runners).
@@ -4,6 +4,7 @@ module.exports = {
  roots: ['<rootDir>/packages'],
  testEnvironment: 'node',
  testMatch: ['**/__tests__/*.test.ts'],
+  testRunner: 'jest-circus/runner',
  transform: {
    '^.+\\.ts$': 'ts-jest'
  },
@@ -1,6 +1,6 @@
 {
  "packages": [
-    "packages/**/*"
+    "packages/*"
  ],
  "version": "independent"
-}
+}
@@ -1,24 +0,0 @@
-{
-  "tasksRunnerOptions": {
-    "default": {
-      "runner": "nx/tasks-runners/default",
-      "options": {
-        "cacheableOperations": []
-      }
-    }
-  },
-  "affected": {
-    "defaultBase": "master"
-  },
-  "$schema": "./node_modules/nx/schemas/nx-schema.json",
-  "namedInputs": {
-    "default": [
-      "{projectRoot}/**/*",
-      "sharedGlobals"
-    ],
-    "sharedGlobals": [],
-    "production": [
-      "default"
-    ]
-  }
-}
@@ -3,34 +3,30 @@
  "private": true,
  "scripts": {
    "audit-all": "lerna run audit-moderate",
-    "bootstrap": "lerna exec -- npm install",
+    "bootstrap": "lerna bootstrap",
    "build": "lerna run tsc",
-    "clean": "lerna clean",
-    "repair": "lerna repair",
    "check-all": "concurrently \"npm:format-check\" \"npm:lint\" \"npm:test\" \"npm:build -- -- --noEmit\"",
    "format": "prettier --write packages/**/*.ts",
    "format-check": "prettier --check packages/**/*.ts",
    "lint": "eslint packages/**/*.ts",
-    "lint-fix": "eslint packages/**/*.ts --fix",
    "new-package": "scripts/create-package",
    "test": "jest --testTimeout 10000"
  },
  "devDependencies": {
-    "@types/jest": "^29.5.4",
-    "@types/node": "^20.5.7",
-    "@types/signale": "^1.4.1",
-    "concurrently": "^6.1.0",
-    "eslint": "^8.0.1",
-    "eslint-config-prettier": "^8.9.0",
-    "eslint-plugin-github": "^4.9.2",
-    "eslint-plugin-jest": "^27.2.3",
-    "eslint-plugin-prettier": "^5.0.0",
+    "@types/jest": "^24.0.11",
+    "@types/node": "^12.12.47",
+    "@types/signale": "^1.2.1",
+    "@typescript-eslint/parser": "^2.2.7",
+    "concurrently": "^4.1.0",
+    "eslint": "^5.16.0",
+    "eslint-plugin-github": "^2.0.0",
+    "eslint-plugin-jest": "^22.5.1",
    "flow-bin": "^0.115.0",
-    "jest": "^29.6.4",
-    "lerna": "^7.1.4",
-    "nx": "16.6.0",
-    "prettier": "^3.0.0",
-    "ts-jest": "^29.1.1",
-    "typescript": "^5.2.2"
+    "jest": "^25.1.0",
+    "jest-circus": "^24.7.1",
+    "lerna": "^3.18.4",
+    "prettier": "^1.19.1",
+    "ts-jest": "^25.4.0",
+    "typescript": "^3.9.9"
  }
-}
+}
@@ -2,12 +2,212 @@

 ## Usage

-You can use this package to interact with the Actions artifacts.
+You can use this package to interact with the actions artifacts.
+- [Upload an Artifact](#Upload-an-Artifact)
+- [Download a Single Artifact](#Download-a-Single-Artifact)
+- [Download All Artifacts](#Download-all-Artifacts)
+- [Additional Documentation](#Additional-Documentation)
+- [Contributions](#Contributions)

-This most recently published version of this package (`1.1.1`) can be found [here](https://github.com/actions/toolkit/tree/@actions/artifact@1.1.1/packages/artifact)
+Relative paths and absolute paths are both allowed. Relative paths are rooted against the current working directory.

-## 🚧 Under construction 🚧
+## Upload an Artifact

-This package is currently undergoing a major overhaul in preparation for `v4` versions of `upload-artifact` and `download-artifact` (these Actions will use a new `2.0.0` version of `@actions/artifact` that will soon be released). The upcoming version of `@actions/artifact` will take advantage of a major re-architecture with entirely new APIs.
+Method Name: `uploadArtifact`

-The upcoming `2.0.0` package and `v4` artifact Actions aim to solve some of the major pain-points that have made artifact usage difficult up until now.
+#### Inputs
+ - `name`
+    - The name of the artifact that is being uploaded
+    - Required
+ - `files`
+    - A list of file paths that describe what should be uploaded as part of the artifact
+    - If a path is provided that does not exist, an error will be thrown
+    - Can be absolute or relative. Internally everything is normalized and resolved
+    - Required
+ - `rootDirectory`
+    - A file path that denotes the root directory of the files being uploaded. This path is used to strip the paths provided in `files` to control how they are uploaded and structured
+    - If a file specified in `files` is not in the `rootDirectory`, an error will be thrown
+    - Required
+ - `options`
+    - Extra options that allow for the customization of the upload behavior
+    - Optional
+
+#### Available Options
+
+ - `continueOnError`
+    - Indicates if the artifact upload should continue in the event a file fails to upload. If there is a error during upload, a partial artifact will always be created and available for download at the end. The `size` reported will be the amount of storage that the user or org will be charged for the partial artifact.
+    - If set to `false`, and an error is encountered, all other uploads will stop and any files that were queued will not be attempted to be uploaded. The partial artifact available will only include files up until the failure.
+    - If set to `true` and an error is encountered, the failed file will be skipped and ignored and all other queued files will be attempted to be uploaded. There will be an artifact available for download at the end with everything excluding the file that failed to upload
+    - Optional, defaults to `true` if not specified
+- `retentionDays`
+    - Duration after which artifact will expire in days
+    - Minimum value: 1
+    - Maximum value: 90 unless changed by repository setting
+    - If this is set to a greater value than the retention settings allowed, the retention on artifacts will be reduced to match the max value allowed on the server, and the upload process will continue. An input of 0 assumes default retention value.
+
+#### Example using Absolute File Paths
+
+```js
+const artifact = require('@actions/artifact');
+const artifactClient = artifact.create()
+const artifactName = 'my-artifact';
+const files = [
+    '/home/user/files/plz-upload/file1.txt',
+    '/home/user/files/plz-upload/file2.txt',
+    '/home/user/files/plz-upload/dir/file3.txt'
+]
+const rootDirectory = '/home/user/files/plz-upload'
+const options = {
+    continueOnError: true
+}
+
+const uploadResult = await artifactClient.uploadArtifact(artifactName, files, rootDirectory, options)
+```
+
+#### Example using Relative File Paths
+```js
+// Assuming the current working directory is /home/user/files/plz-upload
+const artifact = require('@actions/artifact');
+const artifactClient = artifact.create()
+const artifactName = 'my-artifact';
+const files = [
+    'file1.txt',
+    'file2.txt',
+    'dir/file3.txt'
+]
+
+const rootDirectory = '.' // Also possible to use __dirname
+const options = {
+    continueOnError: false
+}
+
+const uploadResponse = await artifactClient.uploadArtifact(artifactName, files, rootDirectory, options)
+```
+
+#### Upload Result
+
+The returned `UploadResponse` will contain the following information
+
+- `artifactName`
+    - The name of the artifact that was uploaded
+- `artifactItems`
+    - A list of all files that describe what is uploaded if there are no errors encountered. Usually this will be equal to the inputted `files` with the exception of empty directories (will not be uploaded)
+- `size`
+    - Total size of the artifact that was uploaded in bytes
+- `failedItems`
+    - A list of items that were not uploaded successfully (this will include queued items that were not uploaded if `continueOnError` is set to false). This is a subset of `artifactItems`
+
+## Download a Single Artifact
+
+Method Name: `downloadArtifact`
+
+#### Inputs
+ - `name`
+    - The name of the artifact to download
+    - Required
+ - `path`
+    - Path that denotes where the artifact will be downloaded to
+    - Optional. Defaults to the GitHub workspace directory(`$GITHUB_WORKSPACE`) if not specified
+ - `options`
+    - Extra options that allow for the customization of the download behavior
+    - Optional
+
+
+#### Available Options
+
+ - `createArtifactFolder`
+    - Specifies if a folder (the artifact name) is created for the artifact that is downloaded (contents downloaded into this folder),
+    - Optional. Defaults to false if not specified
+
+#### Example
+
+```js
+const artifact = require('@actions/artifact');
+const artifactClient = artifact.create()
+const artifactName = 'my-artifact';
+const path = 'some/directory'
+const options = {
+    createArtifactFolder: false
+}
+
+const downloadResponse = await artifactClient.downloadArtifact(artifactName, path, options)
+
+// Post download, the directory structure will look like this
+/some
+    /directory
+        /file1.txt
+        /file2.txt
+        /dir
+            /file3.txt
+
+// If createArtifactFolder is set to true, the directory structure will look like this
+/some
+    /directory
+        /my-artifact
+            /file1.txt
+            /file2.txt
+            /dir
+                /file3.txt
+```
+
+#### Download Response
+
+The returned `DownloadResponse` will contain the following information
+
+  - `artifactName`
+    - The name of the artifact that was downloaded
+  - `downloadPath`
+    - The full Path to where the artifact was downloaded
+
+
+## Download All Artifacts
+
+Method Name: `downloadAllArtifacts`
+
+#### Inputs
+ - `path`
+    - Path that denotes where the artifact will be downloaded to
+    - Optional. Defaults to the GitHub workspace directory(`$GITHUB_WORKSPACE`) if not specified
+
+```js
+const artifact = require('@actions/artifact');
+const artifactClient = artifact.create();
+const downloadResponse = await artifactClient.downloadAllArtifacts();
+
+// output result
+for (response in downloadResponse) {
+    console.log(response.artifactName);
+    console.log(response.downloadPath);
+}
+```
+
+Because there are multiple artifacts, an extra directory (denoted by the name of the artifact) will be created for each artifact in the path. With 2 artifacts(`my-artifact-1` and `my-artifact-2` for example) and the default path, the directory structure will be as follows:
+```js
+/GITHUB_WORKSPACE
+    /my-artifact-1
+        / .. contents of `my-artifact-1`
+    /my-artifact-2
+        / .. contents of `my-artifact-2`
+```
+
+#### Download Result
+
+An array will be returned that describes the results for downloading all artifacts. The number of items in the array indicates the number of artifacts that were downloaded.
+
+Each artifact will have the same `DownloadResponse` as if it was individually downloaded
+  - `artifactName`
+    - The name of the artifact that was downloaded
+  - `downloadPath`
+    - The full Path to where the artifact was downloaded
+
+## Additional Documentation
+
+Check out [additional-information](docs/additional-information.md) for extra documentation around usage, restrictions and behavior.
+
+Check out [implementation-details](docs/implementation-details.md) for extra information about the implementation of this package.
+
+## Contributions
+
+See [contributor guidelines](https://github.com/actions/toolkit/blob/main/.github/CONTRIBUTING.md) for general guidelines and information about toolkit contributions.
+
+For contributions related to this package, see [artifact contributions](CONTRIBUTIONS.md) for more information.
@@ -58,39 +58,3 @@

 - Bump @actions/http-client to version 1.0.11 to fix proxy related issues during artifact upload and download

-### 0.5.2
-
- Add HTTP 500 as a retryable status code for artifact upload and download.
-
-### 0.6.0
-
- Support upload from named pipes [#748](https://github.com/actions/toolkit/pull/748)
- Fixes to percentage values being greater than 100% when downloading all artifacts [#889](https://github.com/actions/toolkit/pull/889)
- Improved logging and output during artifact upload [#949](https://github.com/actions/toolkit/pull/949)
- Improvements to client-side validation for certain invalid characters not allowed during upload: [#951](https://github.com/actions/toolkit/pull/951)
- Faster upload speeds for certain types of large files by exempting gzip compression [#956](https://github.com/actions/toolkit/pull/956)
- More detailed logging when dealing with chunked uploads [#957](https://github.com/actions/toolkit/pull/957)
-
-### 0.6.1
-
- Fix for failing 0 byte file uploads on Windows [#962](https://github.com/actions/toolkit/pull/962)
-
-### 1.0.0
-
- Update `lockfileVersion` to `v2` in `package-lock.json` [#1009](https://github.com/actions/toolkit/pull/1009)
-
-### 1.0.1
-
- Update to v2.0.0 of `@actions/http-client`
-
-### 1.0.2
-
- Update to v2.0.1 of `@actions/http-client` [#1087](https://github.com/actions/toolkit/pull/1087)
-
-### 1.1.0
-
- Add `x-actions-results-crc64` and `x-actions-results-md5` checksum headers on upload [#1063](https://github.com/actions/toolkit/pull/1063)
-
-### 1.1.1
-
- Fixed a bug in Node16 where if an HTTP download finished too quickly (<1ms, e.g. when it's mocked) we attempt to delete a temp file that has not been created yet [#1278](https://github.com/actions/toolkit/pull/1278/commits/b9de68a590daf37c6747e38d3cb4f1dd2cfb791c)
@@ -1,200 +0,0 @@
-import * as http from 'http'
-import * as net from 'net'
-import {HttpClient} from '@actions/http-client'
-import * as config from '../src/internal/shared/config'
-import {createArtifactTwirpClient} from '../src/internal/shared/artifact-twirp-client'
-import * as core from '@actions/core'
-
-jest.mock('@actions/http-client')
-
-describe('artifact-http-client', () => {
-  beforeAll(() => {
-    // mock all output so that there is less noise when running tests
-    jest.spyOn(console, 'log').mockImplementation(() => {})
-    jest.spyOn(core, 'debug').mockImplementation(() => {})
-    jest.spyOn(core, 'info').mockImplementation(() => {})
-    jest.spyOn(core, 'warning').mockImplementation(() => {})
-    jest
-      .spyOn(config, 'getResultsServiceUrl')
-      .mockReturnValue('http://localhost:8080')
-    jest.spyOn(config, 'getRuntimeToken').mockReturnValue('token')
-  })
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('should successfully create a client', () => {
-    const client = createArtifactTwirpClient('upload')
-    expect(client).toBeDefined()
-  })
-
-  it('should make a request', async () => {
-    const mockPost = jest.fn(() => {
-      const msg = new http.IncomingMessage(new net.Socket())
-      msg.statusCode = 200
-      return {
-        message: msg,
-        readBody: async () => {
-          return Promise.resolve(
-            `{"ok": true, "signedUploadUrl": "http://localhost:8080/upload"}`
-          )
-        }
-      }
-    })
-    const mockHttpClient = (
-      HttpClient as unknown as jest.Mock
-    ).mockImplementation(() => {
-      return {
-        post: mockPost
-      }
-    })
-
-    const client = createArtifactTwirpClient('upload')
-    const artifact = await client.CreateArtifact({
-      workflowRunBackendId: '1234',
-      workflowJobRunBackendId: '5678',
-      name: 'artifact',
-      version: 4
-    })
-
-    expect(mockHttpClient).toHaveBeenCalledTimes(1)
-    expect(mockPost).toHaveBeenCalledTimes(1)
-    expect(artifact).toBeDefined()
-    expect(artifact.ok).toBe(true)
-    expect(artifact.signedUploadUrl).toBe('http://localhost:8080/upload')
-  })
-
-  it('should retry if the request fails', async () => {
-    const mockPost = jest
-      .fn(() => {
-        const msgSucceeded = new http.IncomingMessage(new net.Socket())
-        msgSucceeded.statusCode = 200
-        return {
-          message: msgSucceeded,
-          readBody: async () => {
-            return Promise.resolve(
-              `{"ok": true, "signedUploadUrl": "http://localhost:8080/upload"}`
-            )
-          }
-        }
-      })
-      .mockImplementationOnce(() => {
-        const msgFailed = new http.IncomingMessage(new net.Socket())
-        msgFailed.statusCode = 500
-        msgFailed.statusMessage = 'Internal Server Error'
-        return {
-          message: msgFailed,
-          readBody: async () => {
-            return Promise.resolve(`{"ok": false}`)
-          }
-        }
-      })
-    const mockHttpClient = (
-      HttpClient as unknown as jest.Mock
-    ).mockImplementation(() => {
-      return {
-        post: mockPost
-      }
-    })
-
-    const client = createArtifactTwirpClient(
-      'upload',
-      5, // retry 5 times
-      1, // wait 1 ms
-      1.5 // backoff factor
-    )
-    const artifact = await client.CreateArtifact({
-      workflowRunBackendId: '1234',
-      workflowJobRunBackendId: '5678',
-      name: 'artifact',
-      version: 4
-    })
-
-    expect(mockHttpClient).toHaveBeenCalledTimes(1)
-    expect(artifact).toBeDefined()
-    expect(artifact.ok).toBe(true)
-    expect(artifact.signedUploadUrl).toBe('http://localhost:8080/upload')
-    expect(mockPost).toHaveBeenCalledTimes(2)
-  })
-
-  it('should fail if the request fails 5 times', async () => {
-    const mockPost = jest.fn(() => {
-      const msgFailed = new http.IncomingMessage(new net.Socket())
-      msgFailed.statusCode = 500
-      msgFailed.statusMessage = 'Internal Server Error'
-      return {
-        message: msgFailed,
-        readBody: async () => {
-          return Promise.resolve(`{"ok": false}`)
-        }
-      }
-    })
-
-    const mockHttpClient = (
-      HttpClient as unknown as jest.Mock
-    ).mockImplementation(() => {
-      return {
-        post: mockPost
-      }
-    })
-    const client = createArtifactTwirpClient(
-      'upload',
-      5, // retry 5 times
-      1, // wait 1 ms
-      1.5 // backoff factor
-    )
-    await expect(async () => {
-      await client.CreateArtifact({
-        workflowRunBackendId: '1234',
-        workflowJobRunBackendId: '5678',
-        name: 'artifact',
-        version: 4
-      })
-    }).rejects.toThrowError(
-      'Failed to make request after 5 attempts: Failed request: (500) Internal Server Error'
-    )
-    expect(mockHttpClient).toHaveBeenCalledTimes(1)
-    expect(mockPost).toHaveBeenCalledTimes(5)
-  })
-
-  it('should fail immediately if there is a non-retryable error', async () => {
-    const mockPost = jest.fn(() => {
-      const msgFailed = new http.IncomingMessage(new net.Socket())
-      msgFailed.statusCode = 401
-      msgFailed.statusMessage = 'Unauthorized'
-      return {
-        message: msgFailed,
-        readBody: async () => {
-          return Promise.resolve(`{"ok": false}`)
-        }
-      }
-    })
-
-    const mockHttpClient = (
-      HttpClient as unknown as jest.Mock
-    ).mockImplementation(() => {
-      return {
-        post: mockPost
-      }
-    })
-    const client = createArtifactTwirpClient(
-      'upload',
-      5, // retry 5 times
-      1, // wait 1 ms
-      1.5 // backoff factor
-    )
-    await expect(async () => {
-      await client.CreateArtifact({
-        workflowRunBackendId: '1234',
-        workflowJobRunBackendId: '5678',
-        name: 'artifact',
-        version: 4
-      })
-    }).rejects.toThrowError(
-      'Received non-retryable error: Failed request: (401) Unauthorized'
-    )
-    expect(mockHttpClient).toHaveBeenCalledTimes(1)
-    expect(mockPost).toHaveBeenCalledTimes(1)
-  })
-})
@@ -0,0 +1,5 @@
+name: 'Set env variables'
+description: 'Sets certain env variables so that e2e artifact upload and download can be tested in a shell'
+runs:
+  using: 'node12'
+  main: 'index.js'
@@ -0,0 +1,14 @@
+// Certain env variables are not set by default in a shell context and are only available in a node context from a running action
+// In order to be able to upload and download artifacts e2e in a shell when running CI tests, we need these env variables set
+const fs = require('fs');
+const os = require('os');
+const filePath = process.env[`GITHUB_ENV`]
+fs.appendFileSync(filePath, `ACTIONS_RUNTIME_URL=${process.env.ACTIONS_RUNTIME_URL}${os.EOL}`, {
+    encoding: 'utf8'
+})
+fs.appendFileSync(filePath, `ACTIONS_RUNTIME_TOKEN=${process.env.ACTIONS_RUNTIME_TOKEN}${os.EOL}`, {
+    encoding: 'utf8'
+})
+fs.appendFileSync(filePath, `GITHUB_RUN_ID=${process.env.GITHUB_RUN_ID}${os.EOL}`, {
+    encoding: 'utf8'
+})
@@ -1,279 +0,0 @@
-import fs from 'fs'
-import * as http from 'http'
-import * as net from 'net'
-import * as path from 'path'
-import * as core from '@actions/core'
-import * as github from '@actions/github'
-import {HttpClient} from '@actions/http-client'
-import type {RestEndpointMethods} from '@octokit/plugin-rest-endpoint-methods/dist-types/generated/method-types'
-import archiver from 'archiver'
-
-import {downloadArtifact} from '../src/internal/download/download-artifact'
-import {getUserAgentString} from '../src/internal/shared/user-agent'
-
-type MockedDownloadArtifact = jest.MockedFunction<
-  RestEndpointMethods['actions']['downloadArtifact']
->
-
-const testDir = path.join(__dirname, '_temp', 'download-artifact')
-const fixtures = {
-  workspaceDir: path.join(testDir, 'workspace'),
-  exampleArtifact: {
-    path: path.join(testDir, 'artifact.zip'),
-    files: [
-      {
-        path: 'hello.txt',
-        content: 'Hello World!'
-      },
-      {
-        path: 'goodbye.txt',
-        content: 'Goodbye World!'
-      }
-    ]
-  },
-  artifactID: 1234,
-  repositoryOwner: 'actions',
-  repositoryName: 'toolkit',
-  token: 'ghp_1234567890',
-  blobStorageUrl: 'https://blob-storage.local?signed=true'
-}
-
-jest.mock('@actions/github', () => ({
-  getOctokit: jest.fn().mockReturnValue({
-    rest: {
-      actions: {
-        downloadArtifact: jest.fn()
-      }
-    }
-  })
-}))
-
-jest.mock('@actions/http-client')
-
-// Create a zip archive with the contents of the example artifact
-const createTestArchive = async (): Promise<void> => {
-  const archive = archiver('zip', {
-    zlib: {level: 9}
-  })
-  for (const file of fixtures.exampleArtifact.files) {
-    archive.append(file.content, {name: file.path})
-  }
-  archive.finalize()
-
-  return new Promise((resolve, reject) => {
-    archive.pipe(fs.createWriteStream(fixtures.exampleArtifact.path))
-    archive.on('error', reject)
-    archive.on('finish', resolve)
-  })
-}
-
-const expectExtractedArchive = async (dir: string): Promise<void> => {
-  for (const file of fixtures.exampleArtifact.files) {
-    const filePath = path.join(dir, file.path)
-    expect(fs.readFileSync(filePath, 'utf8')).toEqual(file.content)
-  }
-}
-
-describe('download-artifact', () => {
-  beforeEach(async () => {
-    jest.spyOn(core, 'debug').mockImplementation(() => {})
-    jest.spyOn(core, 'info').mockImplementation(() => {})
-    jest.spyOn(core, 'warning').mockImplementation(() => {})
-
-    await fs.promises.mkdir(testDir, {recursive: true})
-    await createTestArchive()
-
-    process.env['GITHUB_WORKSPACE'] = fixtures.workspaceDir
-  })
-
-  afterEach(async () => {
-    jest.restoreAllMocks()
-    await fs.promises.rm(testDir, {recursive: true})
-    delete process.env['GITHUB_WORKSPACE']
-  })
-
-  it('should successfully download an artifact to $GITHUB_WORKSPACE', async () => {
-    const downloadArtifactMock = github.getOctokit(fixtures.token).rest.actions
-      .downloadArtifact as MockedDownloadArtifact
-    downloadArtifactMock.mockResolvedValueOnce({
-      headers: {
-        location: fixtures.blobStorageUrl
-      },
-      status: 302,
-      url: '',
-      data: Buffer.from('')
-    })
-
-    const getMock = jest.fn(() => {
-      const message = new http.IncomingMessage(new net.Socket())
-      message.statusCode = 200
-      message.push(fs.readFileSync(fixtures.exampleArtifact.path))
-      return {
-        message
-      }
-    })
-    const httpClientMock = (HttpClient as jest.Mock).mockImplementation(() => {
-      return {
-        get: getMock
-      }
-    })
-
-    const response = await downloadArtifact(
-      fixtures.artifactID,
-      fixtures.repositoryOwner,
-      fixtures.repositoryName,
-      fixtures.token
-    )
-
-    expect(downloadArtifactMock).toHaveBeenCalledWith({
-      owner: fixtures.repositoryOwner,
-      repo: fixtures.repositoryName,
-      artifact_id: fixtures.artifactID,
-      archive_format: 'zip',
-      request: {
-        redirect: 'manual'
-      }
-    })
-    expect(httpClientMock).toHaveBeenCalledWith(getUserAgentString())
-    expect(getMock).toHaveBeenCalledWith(fixtures.blobStorageUrl)
-
-    expectExtractedArchive(fixtures.workspaceDir)
-
-    expect(response.success).toBe(true)
-    expect(response.downloadPath).toBe(fixtures.workspaceDir)
-  })
-
-  it('should successfully download an artifact to user defined path', async () => {
-    const customPath = path.join(testDir, 'custom')
-
-    const downloadArtifactMock = github.getOctokit(fixtures.token).rest.actions
-      .downloadArtifact as MockedDownloadArtifact
-    downloadArtifactMock.mockResolvedValueOnce({
-      headers: {
-        location: fixtures.blobStorageUrl
-      },
-      status: 302,
-      url: '',
-      data: Buffer.from('')
-    })
-
-    const getMock = jest.fn(() => {
-      const message = new http.IncomingMessage(new net.Socket())
-      message.statusCode = 200
-      message.push(fs.readFileSync(fixtures.exampleArtifact.path))
-      return {
-        message
-      }
-    })
-    const httpClientMock = (HttpClient as jest.Mock).mockImplementation(() => {
-      return {
-        get: getMock
-      }
-    })
-
-    const response = await downloadArtifact(
-      fixtures.artifactID,
-      fixtures.repositoryOwner,
-      fixtures.repositoryName,
-      fixtures.token,
-      {
-        path: customPath
-      }
-    )
-
-    expect(downloadArtifactMock).toHaveBeenCalledWith({
-      owner: fixtures.repositoryOwner,
-      repo: fixtures.repositoryName,
-      artifact_id: fixtures.artifactID,
-      archive_format: 'zip',
-      request: {
-        redirect: 'manual'
-      }
-    })
-    expect(httpClientMock).toHaveBeenCalledWith(getUserAgentString())
-    expect(getMock).toHaveBeenCalledWith(fixtures.blobStorageUrl)
-
-    expectExtractedArchive(customPath)
-
-    expect(response.success).toBe(true)
-    expect(response.downloadPath).toBe(customPath)
-  })
-
-  it('should fail if download artifact API does not respond with location', async () => {
-    const downloadArtifactMock = github.getOctokit(fixtures.token).rest.actions
-      .downloadArtifact as MockedDownloadArtifact
-    downloadArtifactMock.mockResolvedValueOnce({
-      headers: {},
-      status: 302,
-      url: '',
-      data: Buffer.from('')
-    })
-
-    await expect(
-      downloadArtifact(
-        fixtures.artifactID,
-        fixtures.repositoryOwner,
-        fixtures.repositoryName,
-        fixtures.token
-      )
-    ).rejects.toBeInstanceOf(Error)
-
-    expect(downloadArtifactMock).toHaveBeenCalledWith({
-      owner: fixtures.repositoryOwner,
-      repo: fixtures.repositoryName,
-      artifact_id: fixtures.artifactID,
-      archive_format: 'zip',
-      request: {
-        redirect: 'manual'
-      }
-    })
-  })
-
-  it('should fail if blob storage response is non-200', async () => {
-    const downloadArtifactMock = github.getOctokit(fixtures.token).rest.actions
-      .downloadArtifact as MockedDownloadArtifact
-    downloadArtifactMock.mockResolvedValueOnce({
-      headers: {
-        location: fixtures.blobStorageUrl
-      },
-      status: 302,
-      url: '',
-      data: Buffer.from('')
-    })
-
-    const getMock = jest.fn(() => {
-      const message = new http.IncomingMessage(new net.Socket())
-      message.statusCode = 500
-      message.push('Internal Server Error')
-      return {
-        message
-      }
-    })
-    const httpClientMock = (HttpClient as jest.Mock).mockImplementation(() => {
-      return {
-        get: getMock
-      }
-    })
-
-    await expect(
-      downloadArtifact(
-        fixtures.artifactID,
-        fixtures.repositoryOwner,
-        fixtures.repositoryName,
-        fixtures.token
-      )
-    ).rejects.toBeInstanceOf(Error)
-
-    expect(downloadArtifactMock).toHaveBeenCalledWith({
-      owner: fixtures.repositoryOwner,
-      repo: fixtures.repositoryName,
-      artifact_id: fixtures.artifactID,
-      archive_format: 'zip',
-      request: {
-        redirect: 'manual'
-      }
-    })
-    expect(httpClientMock).toHaveBeenCalledWith(getUserAgentString())
-    expect(getMock).toHaveBeenCalledWith(fixtures.blobStorageUrl)
-  })
-})
@@ -0,0 +1,552 @@
+import * as path from 'path'
+import * as core from '@actions/core'
+import {URL} from 'url'
+import {getDownloadSpecification} from '../src/internal/download-specification'
+import {ContainerEntry} from '../src/internal/contracts'
+
+const artifact1Name = 'my-artifact'
+const artifact2Name = 'my-artifact-extra'
+
+// Populating with only the information that is necessary
+function getPartialContainerEntry(): ContainerEntry {
+  return {
+    containerId: 10,
+    scopeIdentifier: '00000000-0000-0000-0000-000000000000',
+    path: 'ADD_INFORMATION',
+    itemType: 'ADD_INFORMATION',
+    status: 'created',
+    dateCreated: '2020-02-06T22:13:35.373Z',
+    dateLastModified: '2020-02-06T22:13:35.453Z',
+    createdBy: '82f0bf89-6e55-4e5a-b8b6-f75eb992578c',
+    lastModifiedBy: '82f0bf89-6e55-4e5a-b8b6-f75eb992578c',
+    itemLocation: 'ADD_INFORMATION',
+    contentLocation: 'ADD_INFORMATION',
+    contentId: '',
+    fileLength: 100
+  }
+}
+
+function createFileEntry(entryPath: string): ContainerEntry {
+  const newFileEntry = getPartialContainerEntry()
+  newFileEntry.path = entryPath
+  newFileEntry.itemType = 'file'
+  newFileEntry.itemLocation = createItemLocation(entryPath)
+  newFileEntry.contentLocation = createContentLocation(entryPath)
+  return newFileEntry
+}
+
+function createDirectoryEntry(directoryPath: string): ContainerEntry {
+  const newDirectoryEntry = getPartialContainerEntry()
+  newDirectoryEntry.path = directoryPath
+  newDirectoryEntry.itemType = 'folder'
+  newDirectoryEntry.itemLocation = createItemLocation(directoryPath)
+  newDirectoryEntry.contentLocation = createContentLocation(directoryPath)
+  return newDirectoryEntry
+}
+
+function createItemLocation(relativePath: string): string {
+  const itemLocation = new URL(
+    'https://testing/_apis/resources/Containers/10000'
+  )
+  itemLocation.searchParams.append('itemPath', relativePath)
+  itemLocation.searchParams.append('metadata', 'true')
+  return itemLocation.toString()
+}
+
+function createContentLocation(relativePath: string): string {
+  const itemLocation = new URL(
+    'https://testing/_apis/resources/Containers/10000'
+  )
+  itemLocation.searchParams.append('itemPath', relativePath)
+  return itemLocation.toString()
+}
+
+/*
+    Represents a set of container entries for two artifacts with the following directory structure
+
+    /my-artifact
+        /file1.txt
+        /file2.txt
+        /dir1
+            /file3.txt
+            /dir2
+                /dir3
+                    /dir4
+                        file4.txt
+                        file5.txt (no length property)
+                        file6.txt (empty file)
+    /my-artifact-extra
+        /file1.txt
+*/
+
+// main artifact
+const file1Path = path.join(artifact1Name, 'file1.txt')
+const file2Path = path.join(artifact1Name, 'file2.txt')
+const dir1Path = path.join(artifact1Name, 'dir1')
+const file3Path = path.join(dir1Path, 'file3.txt')
+const dir2Path = path.join(dir1Path, 'dir2')
+const dir3Path = path.join(dir2Path, 'dir3')
+const dir4Path = path.join(dir3Path, 'dir4')
+const file4Path = path.join(dir4Path, 'file4.txt')
+const file5Path = path.join(dir4Path, 'file5.txt')
+const file6Path = path.join(dir4Path, 'file6.txt')
+
+const rootDirectoryEntry = createDirectoryEntry(artifact1Name)
+const directoryEntry1 = createDirectoryEntry(dir1Path)
+const directoryEntry2 = createDirectoryEntry(dir2Path)
+const directoryEntry3 = createDirectoryEntry(dir3Path)
+const directoryEntry4 = createDirectoryEntry(dir4Path)
+const fileEntry1 = createFileEntry(file1Path)
+const fileEntry2 = createFileEntry(file2Path)
+const fileEntry3 = createFileEntry(file3Path)
+const fileEntry4 = createFileEntry(file4Path)
+
+const missingLengthFileEntry = createFileEntry(file5Path)
+missingLengthFileEntry.fileLength = undefined // one file does not have a fileLength
+const emptyLengthFileEntry = createFileEntry(file6Path)
+emptyLengthFileEntry.fileLength = 0 // empty file path
+
+// extra artifact
+const artifact2File1Path = path.join(artifact2Name, 'file1.txt')
+const rootDirectoryEntry2 = createDirectoryEntry(artifact2Name)
+const extraFileEntry = createFileEntry(artifact2File1Path)
+
+const artifactContainerEntries: ContainerEntry[] = [
+  rootDirectoryEntry,
+  fileEntry1,
+  fileEntry2,
+  directoryEntry1,
+  fileEntry3,
+  directoryEntry2,
+  directoryEntry3,
+  directoryEntry4,
+  fileEntry4,
+  missingLengthFileEntry,
+  emptyLengthFileEntry,
+  rootDirectoryEntry2,
+  extraFileEntry
+]
+
+describe('Search', () => {
+  beforeAll(async () => {
+    // mock all output so that there is less noise when running tests
+    jest.spyOn(console, 'log').mockImplementation(() => {})
+    jest.spyOn(core, 'debug').mockImplementation(() => {})
+    jest.spyOn(core, 'info').mockImplementation(() => {})
+    jest.spyOn(core, 'warning').mockImplementation(() => {})
+  })
+
+  it('Download Specification - Absolute Path with no root directory', () => {
+    const testDownloadPath = path.join(
+      __dirname,
+      'some',
+      'destination',
+      'folder'
+    )
+
+    const specification = getDownloadSpecification(
+      artifact1Name,
+      artifactContainerEntries,
+      testDownloadPath,
+      false
+    )
+
+    expect(specification.rootDownloadLocation).toEqual(testDownloadPath)
+    expect(specification.filesToDownload.length).toEqual(5)
+
+    const item1ExpectedTargetPath = path.join(testDownloadPath, 'file1.txt')
+    const item2ExpectedTargetPath = path.join(testDownloadPath, 'file2.txt')
+    const item3ExpectedTargetPath = path.join(
+      testDownloadPath,
+      'dir1',
+      'file3.txt'
+    )
+    const item4ExpectedTargetPath = path.join(
+      testDownloadPath,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file4.txt'
+    )
+    const item5ExpectedTargetPath = path.join(
+      testDownloadPath,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file5.txt'
+    )
+    const item6ExpectedTargetPath = path.join(
+      testDownloadPath,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file6.txt'
+    )
+
+    const targetLocations = specification.filesToDownload.map(
+      item => item.targetPath
+    )
+    expect(targetLocations).toContain(item1ExpectedTargetPath)
+    expect(targetLocations).toContain(item2ExpectedTargetPath)
+    expect(targetLocations).toContain(item3ExpectedTargetPath)
+    expect(targetLocations).toContain(item4ExpectedTargetPath)
+    expect(targetLocations).toContain(item5ExpectedTargetPath)
+
+    for (const downloadItem of specification.filesToDownload) {
+      if (downloadItem.targetPath === item1ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file1Path)
+        )
+      } else if (downloadItem.targetPath === item2ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file2Path)
+        )
+      } else if (downloadItem.targetPath === item3ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file3Path)
+        )
+      } else if (downloadItem.targetPath === item4ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file4Path)
+        )
+      } else if (downloadItem.targetPath === item5ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file5Path)
+        )
+      } else {
+        throw new Error('this should never be reached')
+      }
+    }
+
+    expect(specification.directoryStructure.length).toEqual(3)
+    expect(specification.directoryStructure).toContain(testDownloadPath)
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, 'dir1')
+    )
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, 'dir1', 'dir2', 'dir3', 'dir4')
+    )
+
+    expect(specification.emptyFilesToCreate.length).toEqual(1)
+    expect(specification.emptyFilesToCreate).toContain(item6ExpectedTargetPath)
+  })
+
+  it('Download Specification - Relative Path with no root directory', () => {
+    const testDownloadPath = path.join('some', 'destination', 'folder')
+
+    const specification = getDownloadSpecification(
+      artifact1Name,
+      artifactContainerEntries,
+      testDownloadPath,
+      false
+    )
+
+    expect(specification.rootDownloadLocation).toEqual(testDownloadPath)
+    expect(specification.filesToDownload.length).toEqual(5)
+
+    const item1ExpectedTargetPath = path.join(testDownloadPath, 'file1.txt')
+    const item2ExpectedTargetPath = path.join(testDownloadPath, 'file2.txt')
+    const item3ExpectedTargetPath = path.join(
+      testDownloadPath,
+      'dir1',
+      'file3.txt'
+    )
+    const item4ExpectedTargetPath = path.join(
+      testDownloadPath,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file4.txt'
+    )
+    const item5ExpectedTargetPath = path.join(
+      testDownloadPath,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file5.txt'
+    )
+    const item6ExpectedTargetPath = path.join(
+      testDownloadPath,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file6.txt'
+    )
+
+    const targetLocations = specification.filesToDownload.map(
+      item => item.targetPath
+    )
+    expect(targetLocations).toContain(item1ExpectedTargetPath)
+    expect(targetLocations).toContain(item2ExpectedTargetPath)
+    expect(targetLocations).toContain(item3ExpectedTargetPath)
+    expect(targetLocations).toContain(item4ExpectedTargetPath)
+    expect(targetLocations).toContain(item5ExpectedTargetPath)
+
+    for (const downloadItem of specification.filesToDownload) {
+      if (downloadItem.targetPath === item1ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file1Path)
+        )
+      } else if (downloadItem.targetPath === item2ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file2Path)
+        )
+      } else if (downloadItem.targetPath === item3ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file3Path)
+        )
+      } else if (downloadItem.targetPath === item4ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file4Path)
+        )
+      } else if (downloadItem.targetPath === item5ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file5Path)
+        )
+      } else {
+        throw new Error('this should never be reached')
+      }
+    }
+
+    expect(specification.directoryStructure.length).toEqual(3)
+    expect(specification.directoryStructure).toContain(testDownloadPath)
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, 'dir1')
+    )
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, 'dir1', 'dir2', 'dir3', 'dir4')
+    )
+
+    expect(specification.emptyFilesToCreate.length).toEqual(1)
+    expect(specification.emptyFilesToCreate).toContain(item6ExpectedTargetPath)
+  })
+
+  it('Download Specification - Absolute Path with root directory', () => {
+    const testDownloadPath = path.join(
+      __dirname,
+      'some',
+      'destination',
+      'folder'
+    )
+
+    const specification = getDownloadSpecification(
+      artifact1Name,
+      artifactContainerEntries,
+      testDownloadPath,
+      true
+    )
+
+    expect(specification.rootDownloadLocation).toEqual(
+      path.join(testDownloadPath, artifact1Name)
+    )
+    expect(specification.filesToDownload.length).toEqual(5)
+
+    const item1ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'file1.txt'
+    )
+    const item2ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'file2.txt'
+    )
+    const item3ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'dir1',
+      'file3.txt'
+    )
+    const item4ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file4.txt'
+    )
+    const item5ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file5.txt'
+    )
+    const item6ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file6.txt'
+    )
+
+    const targetLocations = specification.filesToDownload.map(
+      item => item.targetPath
+    )
+    expect(targetLocations).toContain(item1ExpectedTargetPath)
+    expect(targetLocations).toContain(item2ExpectedTargetPath)
+    expect(targetLocations).toContain(item3ExpectedTargetPath)
+    expect(targetLocations).toContain(item4ExpectedTargetPath)
+    expect(targetLocations).toContain(item5ExpectedTargetPath)
+
+    for (const downloadItem of specification.filesToDownload) {
+      if (downloadItem.targetPath === item1ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file1Path)
+        )
+      } else if (downloadItem.targetPath === item2ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file2Path)
+        )
+      } else if (downloadItem.targetPath === item3ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file3Path)
+        )
+      } else if (downloadItem.targetPath === item4ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file4Path)
+        )
+      } else if (downloadItem.targetPath === item5ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file5Path)
+        )
+      } else {
+        throw new Error('this should never be reached')
+      }
+    }
+
+    expect(specification.directoryStructure.length).toEqual(3)
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, artifact1Name)
+    )
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, dir1Path)
+    )
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, dir4Path)
+    )
+
+    expect(specification.emptyFilesToCreate.length).toEqual(1)
+    expect(specification.emptyFilesToCreate).toContain(item6ExpectedTargetPath)
+  })
+
+  it('Download Specification - Relative Path with root directory', () => {
+    const testDownloadPath = path.join('some', 'destination', 'folder')
+
+    const specification = getDownloadSpecification(
+      artifact1Name,
+      artifactContainerEntries,
+      testDownloadPath,
+      true
+    )
+
+    expect(specification.rootDownloadLocation).toEqual(
+      path.join(testDownloadPath, artifact1Name)
+    )
+    expect(specification.filesToDownload.length).toEqual(5)
+
+    const item1ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'file1.txt'
+    )
+    const item2ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'file2.txt'
+    )
+    const item3ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'dir1',
+      'file3.txt'
+    )
+    const item4ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file4.txt'
+    )
+    const item5ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file5.txt'
+    )
+    const item6ExpectedTargetPath = path.join(
+      testDownloadPath,
+      artifact1Name,
+      'dir1',
+      'dir2',
+      'dir3',
+      'dir4',
+      'file6.txt'
+    )
+
+    const targetLocations = specification.filesToDownload.map(
+      item => item.targetPath
+    )
+    expect(targetLocations).toContain(item1ExpectedTargetPath)
+    expect(targetLocations).toContain(item2ExpectedTargetPath)
+    expect(targetLocations).toContain(item3ExpectedTargetPath)
+    expect(targetLocations).toContain(item4ExpectedTargetPath)
+    expect(targetLocations).toContain(item5ExpectedTargetPath)
+
+    for (const downloadItem of specification.filesToDownload) {
+      if (downloadItem.targetPath === item1ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file1Path)
+        )
+      } else if (downloadItem.targetPath === item2ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file2Path)
+        )
+      } else if (downloadItem.targetPath === item3ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file3Path)
+        )
+      } else if (downloadItem.targetPath === item4ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file4Path)
+        )
+      } else if (downloadItem.targetPath === item5ExpectedTargetPath) {
+        expect(downloadItem.sourceLocation).toEqual(
+          createContentLocation(file5Path)
+        )
+      } else {
+        throw new Error('this should never be reached')
+      }
+    }
+
+    expect(specification.directoryStructure.length).toEqual(3)
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, artifact1Name)
+    )
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, dir1Path)
+    )
+    expect(specification.directoryStructure).toContain(
+      path.join(testDownloadPath, dir4Path)
+    )
+
+    expect(specification.emptyFilesToCreate.length).toEqual(1)
+    expect(specification.emptyFilesToCreate).toContain(item6ExpectedTargetPath)
+  })
+})
@@ -0,0 +1,490 @@
+import * as core from '@actions/core'
+import * as http from 'http'
+import * as io from '../../io/src/io'
+import * as net from 'net'
+import * as path from 'path'
+import * as configVariables from '../src/internal/config-variables'
+import {promises as fs} from 'fs'
+import {DownloadItem} from '../src/internal/download-specification'
+import {HttpClient, HttpClientResponse} from '@actions/http-client'
+import {DownloadHttpClient} from '../src/internal/download-http-client'
+import {
+  ListArtifactsResponse,
+  QueryArtifactResponse
+} from '../src/internal/contracts'
+import * as stream from 'stream'
+import {gzip} from 'zlib'
+import {promisify} from 'util'
+
+const root = path.join(__dirname, '_temp', 'artifact-download-tests')
+const defaultEncoding = 'utf8'
+
+jest.mock('../src/internal/config-variables')
+jest.mock('@actions/http-client')
+
+describe('Download Tests', () => {
+  beforeAll(async () => {
+    await io.rmRF(root)
+    await fs.mkdir(path.join(root), {
+      recursive: true
+    })
+
+    // mock all output so that there is less noise when running tests
+    jest.spyOn(console, 'log').mockImplementation(() => {})
+    jest.spyOn(core, 'debug').mockImplementation(() => {})
+    jest.spyOn(core, 'info').mockImplementation(() => {})
+    jest.spyOn(core, 'warning').mockImplementation(() => {})
+    jest.spyOn(core, 'error').mockImplementation(() => {})
+  })
+
+  /**
+   * Test Listing Artifacts
+   */
+  it('List Artifacts - Success', async () => {
+    setupSuccessfulListArtifactsResponse()
+    const downloadHttpClient = new DownloadHttpClient()
+    const artifacts = await downloadHttpClient.listArtifacts()
+    expect(artifacts.count).toEqual(2)
+
+    const artifactNames = artifacts.value.map(item => item.name)
+    expect(artifactNames).toContain('artifact1-name')
+    expect(artifactNames).toContain('artifact2-name')
+
+    for (const artifact of artifacts.value) {
+      if (artifact.name === 'artifact1-name') {
+        expect(artifact.url).toEqual(
+          `${configVariables.getRuntimeUrl()}_apis/pipelines/1/runs/1/artifacts?artifactName=artifact1-name`
+        )
+      } else if (artifact.name === 'artifact2-name') {
+        expect(artifact.url).toEqual(
+          `${configVariables.getRuntimeUrl()}_apis/pipelines/1/runs/1/artifacts?artifactName=artifact2-name`
+        )
+      } else {
+        throw new Error(
+          'Invalid artifact combination. This should never be reached'
+        )
+      }
+    }
+  })
+
+  it('List Artifacts - Failure', async () => {
+    setupFailedResponse()
+    const downloadHttpClient = new DownloadHttpClient()
+    expect(downloadHttpClient.listArtifacts()).rejects.toThrow(
+      'List Artifacts failed: Artifact service responded with 500'
+    )
+  })
+
+  /**
+   * Test Container Items
+   */
+  it('Container Items - Success', async () => {
+    setupSuccessfulContainerItemsResponse()
+    const downloadHttpClient = new DownloadHttpClient()
+    const response = await downloadHttpClient.getContainerItems(
+      'artifact-name',
+      configVariables.getRuntimeUrl()
+    )
+    expect(response.count).toEqual(2)
+
+    const itemPaths = response.value.map(item => item.path)
+    expect(itemPaths).toContain('artifact-name')
+    expect(itemPaths).toContain('artifact-name/file1.txt')
+
+    for (const containerEntry of response.value) {
+      if (containerEntry.path === 'artifact-name') {
+        expect(containerEntry.itemType).toEqual('folder')
+      } else if (containerEntry.path === 'artifact-name/file1.txt') {
+        expect(containerEntry.itemType).toEqual('file')
+      } else {
+        throw new Error(
+          'Invalid container combination. This should never be reached'
+        )
+      }
+    }
+  })
+
+  it('Container Items - Failure', async () => {
+    setupFailedResponse()
+    const downloadHttpClient = new DownloadHttpClient()
+    expect(
+      downloadHttpClient.getContainerItems(
+        'artifact-name',
+        configVariables.getRuntimeUrl()
+      )
+    ).rejects.toThrow(
+      `Get Container Items failed: Artifact service responded with 500`
+    )
+  })
+
+  it('Test downloading an individual artifact with gzip', async () => {
+    const fileContents = Buffer.from(
+      'gzip worked on the first try\n',
+      defaultEncoding
+    )
+    const targetPath = path.join(root, 'FileA.txt')
+
+    setupDownloadItemResponse(fileContents, true, 200, false, false)
+    const downloadHttpClient = new DownloadHttpClient()
+
+    const items: DownloadItem[] = []
+    items.push({
+      sourceLocation: `${configVariables.getRuntimeUrl()}_apis/resources/Containers/13?itemPath=my-artifact%2FFileA.txt`,
+      targetPath
+    })
+
+    await expect(
+      downloadHttpClient.downloadSingleArtifact(items)
+    ).resolves.not.toThrow()
+
+    await checkDestinationFile(targetPath, fileContents)
+  })
+
+  it('Test downloading an individual artifact without gzip', async () => {
+    const fileContents = Buffer.from(
+      'plaintext worked on the first try\n',
+      defaultEncoding
+    )
+    const targetPath = path.join(root, 'FileB.txt')
+
+    setupDownloadItemResponse(fileContents, false, 200, false, false)
+    const downloadHttpClient = new DownloadHttpClient()
+
+    const items: DownloadItem[] = []
+    items.push({
+      sourceLocation: `${configVariables.getRuntimeUrl()}_apis/resources/Containers/13?itemPath=my-artifact%2FFileB.txt`,
+      targetPath
+    })
+
+    await expect(
+      downloadHttpClient.downloadSingleArtifact(items)
+    ).resolves.not.toThrow()
+
+    await checkDestinationFile(targetPath, fileContents)
+  })
+
+  it('Test retryable status codes during artifact download', async () => {
+    // The first http response should return a retryable status call while the subsequent call should return a 200 so
+    // the download should successfully finish
+    const retryableStatusCodes = [429, 502, 503, 504]
+    for (const statusCode of retryableStatusCodes) {
+      const fileContents = Buffer.from('try, try again\n', defaultEncoding)
+      const targetPath = path.join(root, `FileC-${statusCode}.txt`)
+
+      setupDownloadItemResponse(fileContents, false, statusCode, false, true)
+      const downloadHttpClient = new DownloadHttpClient()
+
+      const items: DownloadItem[] = []
+      items.push({
+        sourceLocation: `${configVariables.getRuntimeUrl()}_apis/resources/Containers/13?itemPath=my-artifact%2FFileC.txt`,
+        targetPath
+      })
+
+      await expect(
+        downloadHttpClient.downloadSingleArtifact(items)
+      ).resolves.not.toThrow()
+
+      await checkDestinationFile(targetPath, fileContents)
+    }
+  })
+
+  it('Test retry on truncated response with gzip', async () => {
+    const fileContents = Buffer.from(
+      'Sometimes gunzip fails on the first try\n',
+      defaultEncoding
+    )
+    const targetPath = path.join(root, 'FileD.txt')
+
+    setupDownloadItemResponse(fileContents, true, 200, true, true)
+    const downloadHttpClient = new DownloadHttpClient()
+
+    const items: DownloadItem[] = []
+    items.push({
+      sourceLocation: `${configVariables.getRuntimeUrl()}_apis/resources/Containers/13?itemPath=my-artifact%2FFileD.txt`,
+      targetPath
+    })
+
+    await expect(
+      downloadHttpClient.downloadSingleArtifact(items)
+    ).resolves.not.toThrow()
+
+    await checkDestinationFile(targetPath, fileContents)
+  })
+
+  it('Test retry on truncated response without gzip', async () => {
+    const fileContents = Buffer.from(
+      'You have to inspect the content-length header to know if you got everything\n',
+      defaultEncoding
+    )
+    const targetPath = path.join(root, 'FileE.txt')
+
+    setupDownloadItemResponse(fileContents, false, 200, true, true)
+    const downloadHttpClient = new DownloadHttpClient()
+
+    const items: DownloadItem[] = []
+    items.push({
+      sourceLocation: `${configVariables.getRuntimeUrl()}_apis/resources/Containers/13?itemPath=my-artifact%2FFileD.txt`,
+      targetPath
+    })
+
+    await expect(
+      downloadHttpClient.downloadSingleArtifact(items)
+    ).resolves.not.toThrow()
+
+    await checkDestinationFile(targetPath, fileContents)
+  })
+
+  /**
+   * Helper used to setup mocking for the HttpClient
+   */
+  async function emptyMockReadBody(): Promise<string> {
+    return new Promise(resolve => {
+      resolve()
+    })
+  }
+
+  /**
+   * Setups up HTTP GET response for a successful listArtifacts() call
+   */
+  function setupSuccessfulListArtifactsResponse(): void {
+    jest.spyOn(HttpClient.prototype, 'get').mockImplementationOnce(async () => {
+      const mockMessage = new http.IncomingMessage(new net.Socket())
+      let mockReadBody = emptyMockReadBody
+
+      mockMessage.statusCode = 201
+      const response: ListArtifactsResponse = {
+        count: 2,
+        value: [
+          {
+            containerId: '13',
+            size: -1,
+            signedContent: 'false',
+            fileContainerResourceUrl: `${configVariables.getRuntimeUrl()}_apis/resources/Containers/13`,
+            type: 'actions_storage',
+            name: 'artifact1-name',
+            url: `${configVariables.getRuntimeUrl()}_apis/pipelines/1/runs/1/artifacts?artifactName=artifact1-name`
+          },
+          {
+            containerId: '13',
+            size: -1,
+            signedContent: 'false',
+            fileContainerResourceUrl: `${configVariables.getRuntimeUrl()}_apis/resources/Containers/13`,
+            type: 'actions_storage',
+            name: 'artifact2-name',
+            url: `${configVariables.getRuntimeUrl()}_apis/pipelines/1/runs/1/artifacts?artifactName=artifact2-name`
+          }
+        ]
+      }
+      const returnData: string = JSON.stringify(response, null, 2)
+      mockReadBody = async function(): Promise<string> {
+        return new Promise(resolve => {
+          resolve(returnData)
+        })
+      }
+
+      return new Promise<HttpClientResponse>(resolve => {
+        resolve({
+          message: mockMessage,
+          readBody: mockReadBody
+        })
+      })
+    })
+  }
+
+  /**
+   * Setups up HTTP GET response for downloading items
+   * @param isGzip is the downloaded item gzip encoded
+   * @param firstHttpResponseCode the http response code that should be returned
+   */
+  function setupDownloadItemResponse(
+    fileContents: Buffer,
+    isGzip: boolean,
+    firstHttpResponseCode: number,
+    truncateFirstResponse: boolean,
+    retryExpected: boolean
+  ): void {
+    const spyInstance = jest
+      .spyOn(HttpClient.prototype, 'get')
+      .mockImplementationOnce(async () => {
+        if (firstHttpResponseCode === 200) {
+          const fullResponse = await constructResponse(isGzip, fileContents)
+          const actualResponse = truncateFirstResponse
+            ? fullResponse.subarray(0, 3)
+            : fullResponse
+
+          return {
+            message: getDownloadResponseMessage(
+              firstHttpResponseCode,
+              isGzip,
+              fullResponse.length,
+              actualResponse
+            ),
+            readBody: emptyMockReadBody
+          }
+        } else {
+          return {
+            message: getDownloadResponseMessage(
+              firstHttpResponseCode,
+              false,
+              0,
+              null
+            ),
+            readBody: emptyMockReadBody
+          }
+        }
+      })
+
+    // set up a second mock only if we expect a retry. Otherwise this mock will affect other tests.
+    if (retryExpected) {
+      spyInstance.mockImplementationOnce(async () => {
+        // chained response, if the HTTP GET function gets called again, return a successful response
+        const fullResponse = await constructResponse(isGzip, fileContents)
+        return {
+          message: getDownloadResponseMessage(
+            200,
+            isGzip,
+            fullResponse.length,
+            fullResponse
+          ),
+          readBody: emptyMockReadBody
+        }
+      })
+    }
+  }
+
+  async function constructResponse(
+    isGzip: boolean,
+    plaintext: Buffer | string
+  ): Promise<Buffer> {
+    if (isGzip) {
+      return <Buffer>await promisify(gzip)(plaintext)
+    } else if (typeof plaintext === 'string') {
+      return Buffer.from(plaintext, defaultEncoding)
+    } else {
+      return plaintext
+    }
+  }
+
+  function getDownloadResponseMessage(
+    httpResponseCode: number,
+    isGzip: boolean,
+    contentLength: number,
+    response: Buffer | null
+  ): http.IncomingMessage {
+    let readCallCount = 0
+    const mockMessage = <http.IncomingMessage>new stream.Readable({
+      read(size) {
+        switch (readCallCount++) {
+          case 0:
+            if (!!response && response.byteLength > size) {
+              throw new Error(
+                `test response larger than requested size (${size})`
+              )
+            }
+            this.push(response)
+            break
+
+          default:
+            // end the stream
+            this.push(null)
+            break
+        }
+      }
+    })
+
+    mockMessage.statusCode = httpResponseCode
+    mockMessage.headers = {
+      'content-length': contentLength.toString()
+    }
+
+    if (isGzip) {
+      mockMessage.headers['content-encoding'] = 'gzip'
+    }
+
+    return mockMessage
+  }
+
+  /**
+   * Setups up HTTP GET response when querying for container items
+   */
+  function setupSuccessfulContainerItemsResponse(): void {
+    jest.spyOn(HttpClient.prototype, 'get').mockImplementationOnce(async () => {
+      const mockMessage = new http.IncomingMessage(new net.Socket())
+      let mockReadBody = emptyMockReadBody
+
+      mockMessage.statusCode = 201
+      const response: QueryArtifactResponse = {
+        count: 2,
+        value: [
+          {
+            containerId: 10000,
+            scopeIdentifier: '00000000-0000-0000-0000-000000000000',
+            path: 'artifact-name',
+            itemType: 'folder',
+            status: 'created',
+            dateCreated: '2020-02-06T22:13:35.373Z',
+            dateLastModified: '2020-02-06T22:13:35.453Z',
+            createdBy: '82f0bf89-6e55-4e5a-b8b6-f75eb992578c',
+            lastModifiedBy: '82f0bf89-6e55-4e5a-b8b6-f75eb992578c',
+            itemLocation: `${configVariables.getRuntimeUrl()}/_apis/resources/Containers/10000?itemPath=artifact-name&metadata=True`,
+            contentLocation: `${configVariables.getRuntimeUrl()}/_apis/resources/Containers/10000?itemPath=artifact-name`,
+            contentId: ''
+          },
+          {
+            containerId: 10000,
+            scopeIdentifier: '00000000-0000-0000-0000-000000000000',
+            path: 'artifact-name/file1.txt',
+            itemType: 'file',
+            status: 'created',
+            dateCreated: '2020-02-06T22:13:35.373Z',
+            dateLastModified: '2020-02-06T22:13:35.453Z',
+            createdBy: '82f0bf89-6e55-4e5a-b8b6-f75eb992578c',
+            lastModifiedBy: '82f0bf89-6e55-4e5a-b8b6-f75eb992578c',
+            itemLocation: `${configVariables.getRuntimeUrl()}/_apis/resources/Containers/10000?itemPath=artifact-name%2Ffile1.txt&metadata=True`,
+            contentLocation: `${configVariables.getRuntimeUrl()}/_apis/resources/Containers/10000?itemPath=artifact-name%2Ffile1.txt`,
+            contentId: ''
+          }
+        ]
+      }
+      const returnData: string = JSON.stringify(response, null, 2)
+      mockReadBody = async function(): Promise<string> {
+        return new Promise(resolve => {
+          resolve(returnData)
+        })
+      }
+
+      return new Promise<HttpClientResponse>(resolve => {
+        resolve({
+          message: mockMessage,
+          readBody: mockReadBody
+        })
+      })
+    })
+  }
+
+  /**
+   * Setups up HTTP GET response for a generic failed request
+   */
+  function setupFailedResponse(): void {
+    jest.spyOn(HttpClient.prototype, 'get').mockImplementationOnce(async () => {
+      const mockMessage = new http.IncomingMessage(new net.Socket())
+      mockMessage.statusCode = 500
+      return new Promise<HttpClientResponse>(resolve => {
+        resolve({
+          message: mockMessage,
+          readBody: emptyMockReadBody
+        })
+      })
+    })
+  }
+
+  async function checkDestinationFile(
+    targetPath: string,
+    expectedContents: Buffer
+  ): Promise<void> {
+    const fileContents = await fs.readFile(targetPath)
+
+    expect(fileContents.byteLength).toEqual(expectedContents.byteLength)
+    expect(fileContents.equals(expectedContents)).toBeTruthy()
+  }
+})
@@ -1,79 +0,0 @@
-import {
-  validateArtifactName,
-  validateFilePath
-} from '../src/internal/upload/path-and-artifact-name-validation'
-
-import * as core from '@actions/core'
-
-describe('Path and artifact name validation', () => {
-  beforeAll(() => {
-    // mock all output so that there is less noise when running tests
-    jest.spyOn(console, 'log').mockImplementation(() => {})
-    jest.spyOn(core, 'debug').mockImplementation(() => {})
-    jest.spyOn(core, 'info').mockImplementation(() => {})
-    jest.spyOn(core, 'warning').mockImplementation(() => {})
-  })
-
-  it('Check Artifact Name for any invalid characters', () => {
-    const invalidNames = [
-      'my\\artifact',
-      'my/artifact',
-      'my"artifact',
-      'my:artifact',
-      'my<artifact',
-      'my>artifact',
-      'my|artifact',
-      'my*artifact',
-      'my?artifact',
-      ''
-    ]
-    for (const invalidName of invalidNames) {
-      expect(() => {
-        validateArtifactName(invalidName)
-      }).toThrow()
-    }
-
-    const validNames = [
-      'my-normal-artifact',
-      'myNormalArtifact',
-      'm¥ñðrmålÄr†ï£å¢†'
-    ]
-    for (const validName of validNames) {
-      expect(() => {
-        validateArtifactName(validName)
-      }).not.toThrow()
-    }
-  })
-
-  it('Check Artifact File Path for any invalid characters', () => {
-    const invalidNames = [
-      'some/invalid"artifact/path',
-      'some/invalid:artifact/path',
-      'some/invalid<artifact/path',
-      'some/invalid>artifact/path',
-      'some/invalid|artifact/path',
-      'some/invalid*artifact/path',
-      'some/invalid?artifact/path',
-      'some/invalid\rartifact/path',
-      'some/invalid\nartifact/path',
-      'some/invalid\r\nartifact/path',
-      ''
-    ]
-    for (const invalidName of invalidNames) {
-      expect(() => {
-        validateFilePath(invalidName)
-      }).toThrow()
-    }
-
-    const validNames = [
-      'my/perfectly-normal/artifact-path',
-      'my/perfectly\\Normal/Artifact-path',
-      'm¥/ñðrmål/Är†ï£å¢†'
-    ]
-    for (const validName of validNames) {
-      expect(() => {
-        validateFilePath(validName)
-      }).not.toThrow()
-    }
-  })
-})
@@ -1,65 +0,0 @@
-import {Timestamp} from '../src/generated'
-import * as retention from '../src/internal/upload/retention'
-
-describe('retention', () => {
-  beforeEach(() => {
-    delete process.env['GITHUB_RETENTION_DAYS']
-  })
-  it('should return the inputted retention days if it is less than the max retention days', () => {
-    // setup
-    const mockDate = new Date('2020-01-01')
-    jest.useFakeTimers().setSystemTime(mockDate)
-    process.env['GITHUB_RETENTION_DAYS'] = '90'
-
-    const exp = retention.getExpiration(30)
-
-    expect(exp).toBeDefined()
-    if (exp) {
-      const expDate = Timestamp.toDate(exp)
-      const expected = new Date()
-      expected.setDate(expected.getDate() + 30)
-
-      expect(expDate).toEqual(expected)
-    }
-  })
-
-  it('should return the max retention days if the inputted retention days is greater than the max retention days', () => {
-    // setup
-    const mockDate = new Date('2020-01-01')
-    jest.useFakeTimers().setSystemTime(mockDate)
-    process.env['GITHUB_RETENTION_DAYS'] = '90'
-
-    const exp = retention.getExpiration(120)
-
-    expect(exp).toBeDefined()
-    if (exp) {
-      const expDate = Timestamp.toDate(exp) // we check whether exp is defined above
-      const expected = new Date()
-      expected.setDate(expected.getDate() + 90)
-
-      expect(expDate).toEqual(expected)
-    }
-  })
-
-  it('should return undefined if the inputted retention days is undefined', () => {
-    const exp = retention.getExpiration()
-    expect(exp).toBeUndefined()
-  })
-
-  it('should return the inputted retention days if there is no max retention days', () => {
-    // setup
-    const mockDate = new Date('2020-01-01')
-    jest.useFakeTimers().setSystemTime(mockDate)
-
-    const exp = retention.getExpiration(30)
-
-    expect(exp).toBeDefined()
-    if (exp) {
-      const expDate = Timestamp.toDate(exp) // we check whether exp is defined above
-      const expected = new Date()
-      expected.setDate(expected.getDate() + 30)
-
-      expect(expDate).toEqual(expected)
-    }
-  })
-})
@@ -0,0 +1,114 @@
+import * as http from 'http'
+import * as net from 'net'
+import * as core from '@actions/core'
+import * as configVariables from '../src/internal/config-variables'
+import {retry} from '../src/internal/requestUtils'
+import {IHttpClientResponse} from '@actions/http-client/interfaces'
+import {HttpClientResponse} from '@actions/http-client'
+
+jest.mock('../src/internal/config-variables')
+
+interface ITestResult {
+  responseCode: number
+  errorMessage: string | null
+}
+
+async function testRetry(
+  responseCodes: number[],
+  expectedResult: ITestResult
+): Promise<void> {
+  const reverse = responseCodes.reverse() // Reverse responses since we pop from end
+  if (expectedResult.errorMessage) {
+    // we expect some exception to be thrown
+    expect(
+      retry(
+        'test',
+        async () => handleResponse(reverse.pop()),
+        new Map(), // extra error message for any particular http codes
+        configVariables.getRetryLimit()
+      )
+    ).rejects.toThrow(expectedResult.errorMessage)
+  } else {
+    // we expect a correct status code to be returned
+    const actualResult = await retry(
+      'test',
+      async () => handleResponse(reverse.pop()),
+      new Map(), // extra error message for any particular http codes
+      configVariables.getRetryLimit()
+    )
+    expect(actualResult.message.statusCode).toEqual(expectedResult.responseCode)
+  }
+}
+
+async function handleResponse(
+  testResponseCode: number | undefined
+): Promise<IHttpClientResponse> {
+  if (!testResponseCode) {
+    throw new Error(
+      'Test incorrectly set up. reverse.pop() was called too many times so not enough test response codes were supplied'
+    )
+  }
+
+  return setupSingleMockResponse(testResponseCode)
+}
+
+beforeAll(async () => {
+  // mock all output so that there is less noise when running tests
+  jest.spyOn(console, 'log').mockImplementation(() => {})
+  jest.spyOn(core, 'debug').mockImplementation(() => {})
+  jest.spyOn(core, 'info').mockImplementation(() => {})
+  jest.spyOn(core, 'warning').mockImplementation(() => {})
+  jest.spyOn(core, 'error').mockImplementation(() => {})
+})
+
+/**
+ * Helpers used to setup mocking for the HttpClient
+ */
+async function emptyMockReadBody(): Promise<string> {
+  return new Promise(resolve => {
+    resolve()
+  })
+}
+
+async function setupSingleMockResponse(
+  statusCode: number
+): Promise<IHttpClientResponse> {
+  const mockMessage = new http.IncomingMessage(new net.Socket())
+  const mockReadBody = emptyMockReadBody
+  mockMessage.statusCode = statusCode
+  return new Promise<HttpClientResponse>(resolve => {
+    resolve({
+      message: mockMessage,
+      readBody: mockReadBody
+    })
+  })
+}
+
+test('retry works on successful response', async () => {
+  await testRetry([200], {
+    responseCode: 200,
+    errorMessage: null
+  })
+})
+
+test('retry works after retryable status code', async () => {
+  await testRetry([503, 200], {
+    responseCode: 200,
+    errorMessage: null
+  })
+})
+
+test('retry fails after exhausting retries', async () => {
+  // __mocks__/config-variables caps the max retry count in tests to 2
+  await testRetry([503, 503, 200], {
+    responseCode: 200,
+    errorMessage: 'test failed: Artifact service responded with 503'
+  })
+})
+
+test('retry fails after non-retryable status code', async () => {
+  await testRetry([500, 200], {
+    responseCode: 500,
+    errorMessage: 'test failed: Artifact service responded with 500'
+  })
+})
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+path="$1"
+expectedContent="$2"
+
+if [ "$path" == "" ]; then
+    echo "File path not provided"
+    exit 1
+fi
+
+if [ "$expectedContent" == "" ]; then
+    echo "Expected file contents not provided"
+    exit 1
+fi
+
+if [ ! -f "$path" ]; then
+    echo "Expected file $path does not exist"
+    exit 1
+fi
+
+actualContent=$(cat $path)
+if [ "$actualContent" != "$expectedContent" ];then
+    echo "File contents are not correct, expected $expectedContent, received $actualContent"
+    exit 1
+fi
@@ -1,362 +0,0 @@
-import * as core from '@actions/core'
-import * as uploadZipSpecification from '../src/internal/upload/upload-zip-specification'
-import * as zip from '../src/internal/upload/zip'
-import * as util from '../src/internal/shared/util'
-import * as retention from '../src/internal/upload/retention'
-import * as config from '../src/internal/shared/config'
-import {Timestamp, ArtifactServiceClientJSON} from '../src/generated'
-import * as blobUpload from '../src/internal/upload/blob-upload'
-import {uploadArtifact} from '../src/internal/upload/upload-artifact'
-
-describe('upload-artifact', () => {
-  beforeEach(() => {
-    // mock all output so that there is less noise when running tests
-    jest.spyOn(console, 'log').mockImplementation(() => {})
-    jest.spyOn(core, 'debug').mockImplementation(() => {})
-    jest.spyOn(core, 'info').mockImplementation(() => {})
-    jest.spyOn(core, 'warning').mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    jest.restoreAllMocks()
-  })
-
-  it('should successfully upload an artifact', () => {
-    const mockDate = new Date('2020-01-01')
-    jest
-      .spyOn(uploadZipSpecification, 'validateRootDirectory')
-      .mockReturnValue()
-    jest
-      .spyOn(uploadZipSpecification, 'getUploadZipSpecification')
-      .mockReturnValue([
-        {
-          sourcePath: '/home/user/files/plz-upload/file1.txt',
-          destinationPath: 'file1.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/file2.txt',
-          destinationPath: 'file2.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/dir/file3.txt',
-          destinationPath: 'dir/file3.txt'
-        }
-      ])
-
-    jest
-      .spyOn(zip, 'createZipUploadStream')
-      .mockReturnValue(Promise.resolve(new zip.ZipUploadStream(1)))
-    jest.spyOn(util, 'getBackendIdsFromToken').mockReturnValue({
-      workflowRunBackendId: '1234',
-      workflowJobRunBackendId: '5678'
-    })
-    jest
-      .spyOn(retention, 'getExpiration')
-      .mockReturnValue(Timestamp.fromDate(mockDate))
-    jest
-      .spyOn(ArtifactServiceClientJSON.prototype, 'CreateArtifact')
-      .mockReturnValue(
-        Promise.resolve({
-          ok: true,
-          signedUploadUrl: 'https://signed-upload-url.com'
-        })
-      )
-    jest.spyOn(blobUpload, 'uploadZipToBlobStorage').mockReturnValue(
-      Promise.resolve({
-        isSuccess: true,
-        uploadSize: 1234,
-        sha256Hash: 'test-sha256-hash'
-      })
-    )
-    jest
-      .spyOn(ArtifactServiceClientJSON.prototype, 'FinalizeArtifact')
-      .mockReturnValue(Promise.resolve({ok: true, artifactId: '1'}))
-
-    // ArtifactHttpClient mocks
-    jest.spyOn(config, 'getRuntimeToken').mockReturnValue('test-token')
-    jest
-      .spyOn(config, 'getResultsServiceUrl')
-      .mockReturnValue('https://test-url.com')
-
-    const uploadResp = uploadArtifact(
-      'test-artifact',
-      [
-        '/home/user/files/plz-upload/file1.txt',
-        '/home/user/files/plz-upload/file2.txt',
-        '/home/user/files/plz-upload/dir/file3.txt'
-      ],
-      '/home/user/files/plz-upload'
-    )
-
-    expect(uploadResp).resolves.toEqual({success: true, size: 1234, id: 1})
-  })
-
-  it('should throw an error if the root directory is invalid', () => {
-    jest
-      .spyOn(uploadZipSpecification, 'validateRootDirectory')
-      .mockImplementation(() => {
-        throw new Error('Invalid root directory')
-      })
-
-    const uploadResp = uploadArtifact(
-      'test-artifact',
-      [
-        '/home/user/files/plz-upload/file1.txt',
-        '/home/user/files/plz-upload/file2.txt',
-        '/home/user/files/plz-upload/dir/file3.txt'
-      ],
-      '/home/user/files/plz-upload'
-    )
-
-    expect(uploadResp).rejects.toThrow('Invalid root directory')
-  })
-
-  it('should return false if there are no files to upload', () => {
-    jest
-      .spyOn(uploadZipSpecification, 'validateRootDirectory')
-      .mockReturnValue()
-    jest
-      .spyOn(uploadZipSpecification, 'getUploadZipSpecification')
-      .mockReturnValue([])
-
-    const uploadResp = uploadArtifact(
-      'test-artifact',
-      [
-        '/home/user/files/plz-upload/file1.txt',
-        '/home/user/files/plz-upload/file2.txt',
-        '/home/user/files/plz-upload/dir/file3.txt'
-      ],
-      '/home/user/files/plz-upload'
-    )
-    expect(uploadResp).resolves.toEqual({success: false})
-  })
-
-  it('should return false if no backend IDs are found', () => {
-    jest
-      .spyOn(uploadZipSpecification, 'validateRootDirectory')
-      .mockReturnValue()
-    jest
-      .spyOn(uploadZipSpecification, 'getUploadZipSpecification')
-      .mockReturnValue([
-        {
-          sourcePath: '/home/user/files/plz-upload/file1.txt',
-          destinationPath: 'file1.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/file2.txt',
-          destinationPath: 'file2.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/dir/file3.txt',
-          destinationPath: 'dir/file3.txt'
-        }
-      ])
-
-    jest
-      .spyOn(zip, 'createZipUploadStream')
-      .mockReturnValue(Promise.resolve(new zip.ZipUploadStream(1)))
-    jest
-      .spyOn(util, 'getBackendIdsFromToken')
-      .mockReturnValue({workflowRunBackendId: '', workflowJobRunBackendId: ''})
-
-    const uploadResp = uploadArtifact(
-      'test-artifact',
-      [
-        '/home/user/files/plz-upload/file1.txt',
-        '/home/user/files/plz-upload/file2.txt',
-        '/home/user/files/plz-upload/dir/file3.txt'
-      ],
-      '/home/user/files/plz-upload'
-    )
-
-    expect(uploadResp).resolves.toEqual({success: false})
-  })
-
-  it('should return false if the creation request fails', () => {
-    const mockDate = new Date('2020-01-01')
-    jest
-      .spyOn(uploadZipSpecification, 'validateRootDirectory')
-      .mockReturnValue()
-    jest
-      .spyOn(uploadZipSpecification, 'getUploadZipSpecification')
-      .mockReturnValue([
-        {
-          sourcePath: '/home/user/files/plz-upload/file1.txt',
-          destinationPath: 'file1.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/file2.txt',
-          destinationPath: 'file2.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/dir/file3.txt',
-          destinationPath: 'dir/file3.txt'
-        }
-      ])
-
-    jest
-      .spyOn(zip, 'createZipUploadStream')
-      .mockReturnValue(Promise.resolve(new zip.ZipUploadStream(1)))
-    jest.spyOn(util, 'getBackendIdsFromToken').mockReturnValue({
-      workflowRunBackendId: '1234',
-      workflowJobRunBackendId: '5678'
-    })
-    jest
-      .spyOn(retention, 'getExpiration')
-      .mockReturnValue(Timestamp.fromDate(mockDate))
-    jest
-      .spyOn(ArtifactServiceClientJSON.prototype, 'CreateArtifact')
-      .mockReturnValue(Promise.resolve({ok: false, signedUploadUrl: ''}))
-
-    // ArtifactHttpClient mocks
-    jest.spyOn(config, 'getRuntimeToken').mockReturnValue('test-token')
-    jest
-      .spyOn(config, 'getResultsServiceUrl')
-      .mockReturnValue('https://test-url.com')
-
-    const uploadResp = uploadArtifact(
-      'test-artifact',
-      [
-        '/home/user/files/plz-upload/file1.txt',
-        '/home/user/files/plz-upload/file2.txt',
-        '/home/user/files/plz-upload/dir/file3.txt'
-      ],
-      '/home/user/files/plz-upload'
-    )
-
-    expect(uploadResp).resolves.toEqual({success: false})
-  })
-
-  it('should return false if blob storage upload is unsuccessful', () => {
-    const mockDate = new Date('2020-01-01')
-    jest
-      .spyOn(uploadZipSpecification, 'validateRootDirectory')
-      .mockReturnValue()
-    jest
-      .spyOn(uploadZipSpecification, 'getUploadZipSpecification')
-      .mockReturnValue([
-        {
-          sourcePath: '/home/user/files/plz-upload/file1.txt',
-          destinationPath: 'file1.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/file2.txt',
-          destinationPath: 'file2.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/dir/file3.txt',
-          destinationPath: 'dir/file3.txt'
-        }
-      ])
-
-    jest
-      .spyOn(zip, 'createZipUploadStream')
-      .mockReturnValue(Promise.resolve(new zip.ZipUploadStream(1)))
-    jest.spyOn(util, 'getBackendIdsFromToken').mockReturnValue({
-      workflowRunBackendId: '1234',
-      workflowJobRunBackendId: '5678'
-    })
-    jest
-      .spyOn(retention, 'getExpiration')
-      .mockReturnValue(Timestamp.fromDate(mockDate))
-    jest
-      .spyOn(ArtifactServiceClientJSON.prototype, 'CreateArtifact')
-      .mockReturnValue(
-        Promise.resolve({
-          ok: true,
-          signedUploadUrl: 'https://signed-upload-url.com'
-        })
-      )
-    jest
-      .spyOn(blobUpload, 'uploadZipToBlobStorage')
-      .mockReturnValue(Promise.resolve({isSuccess: false}))
-
-    // ArtifactHttpClient mocks
-    jest.spyOn(config, 'getRuntimeToken').mockReturnValue('test-token')
-    jest
-      .spyOn(config, 'getResultsServiceUrl')
-      .mockReturnValue('https://test-url.com')
-
-    const uploadResp = uploadArtifact(
-      'test-artifact',
-      [
-        '/home/user/files/plz-upload/file1.txt',
-        '/home/user/files/plz-upload/file2.txt',
-        '/home/user/files/plz-upload/dir/file3.txt'
-      ],
-      '/home/user/files/plz-upload'
-    )
-
-    expect(uploadResp).resolves.toEqual({success: false})
-  })
-
-  it('should return false if finalize artifact fails', () => {
-    const mockDate = new Date('2020-01-01')
-    jest
-      .spyOn(uploadZipSpecification, 'validateRootDirectory')
-      .mockReturnValue()
-    jest
-      .spyOn(uploadZipSpecification, 'getUploadZipSpecification')
-      .mockReturnValue([
-        {
-          sourcePath: '/home/user/files/plz-upload/file1.txt',
-          destinationPath: 'file1.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/file2.txt',
-          destinationPath: 'file2.txt'
-        },
-        {
-          sourcePath: '/home/user/files/plz-upload/dir/file3.txt',
-          destinationPath: 'dir/file3.txt'
-        }
-      ])
-
-    jest
-      .spyOn(zip, 'createZipUploadStream')
-      .mockReturnValue(Promise.resolve(new zip.ZipUploadStream(1)))
-    jest.spyOn(util, 'getBackendIdsFromToken').mockReturnValue({
-      workflowRunBackendId: '1234',
-      workflowJobRunBackendId: '5678'
-    })
-    jest
-      .spyOn(retention, 'getExpiration')
-      .mockReturnValue(Timestamp.fromDate(mockDate))
-    jest
-      .spyOn(ArtifactServiceClientJSON.prototype, 'CreateArtifact')
-      .mockReturnValue(
-        Promise.resolve({
-          ok: true,
-          signedUploadUrl: 'https://signed-upload-url.com'
-        })
-      )
-    jest.spyOn(blobUpload, 'uploadZipToBlobStorage').mockReturnValue(
-      Promise.resolve({
-        isSuccess: true,
-        uploadSize: 1234,
-        sha256Hash: 'test-sha256-hash'
-      })
-    )
-    jest
-      .spyOn(ArtifactServiceClientJSON.prototype, 'FinalizeArtifact')
-      .mockReturnValue(Promise.resolve({ok: false, artifactId: ''}))
-
-    // ArtifactHttpClient mocks
-    jest.spyOn(config, 'getRuntimeToken').mockReturnValue('test-token')
-    jest
-      .spyOn(config, 'getResultsServiceUrl')
-      .mockReturnValue('https://test-url.com')
-
-    const uploadResp = uploadArtifact(
-      'test-artifact',
-      [
-        '/home/user/files/plz-upload/file1.txt',
-        '/home/user/files/plz-upload/file2.txt',
-        '/home/user/files/plz-upload/dir/file3.txt'
-      ],
-      '/home/user/files/plz-upload'
-    )
-
-    expect(uploadResp).resolves.toEqual({success: false})
-  })
-})
@@ -2,11 +2,9 @@ import * as io from '../../io/src/io'
 import * as path from 'path'
 import {promises as fs} from 'fs'
 import * as core from '@actions/core'
-import {
-  getUploadZipSpecification,
-  validateRootDirectory
-} from '../src/internal/upload/upload-zip-specification'
+import {getUploadSpecification} from '../src/internal/upload-specification'

+const artifactName = 'my-artifact'
 const root = path.join(__dirname, '_temp', 'upload-specification')
 const goodItem1Path = path.join(
  root,
@@ -127,28 +125,31 @@ describe('Search', () => {
      'upload-specification-invalid'
    )
    expect(() => {
-      validateRootDirectory(invalidRootDirectory)
-    }).toThrow(
-      `The provided rootDirectory ${invalidRootDirectory} does not exist`
-    )
+      getUploadSpecification(
+        artifactName,
+        invalidRootDirectory,
+        artifactFilesToUpload
+      )
+    }).toThrow(`Provided rootDirectory ${invalidRootDirectory} does not exist`)
  })

  it('Upload Specification - Fail invalid rootDirectory', async () => {
    expect(() => {
-      validateRootDirectory(goodItem1Path)
+      getUploadSpecification(artifactName, goodItem1Path, artifactFilesToUpload)
    }).toThrow(
-      `The provided rootDirectory ${goodItem1Path} is not a valid directory`
+      `Provided rootDirectory ${goodItem1Path} is not a valid directory`
    )
  })

  it('Upload Specification - File does not exist', async () => {
    const fakeFilePath = path.join(
+      artifactName,
      'folder-a',
      'folder-b',
      'non-existent-file.txt'
    )
    expect(() => {
-      getUploadZipSpecification([fakeFilePath], root)
+      getUploadSpecification(artifactName, root, [fakeFilePath])
    }).toThrow(`File ${fakeFilePath} does not exist`)
  })

@@ -161,20 +162,21 @@ describe('Search', () => {
      goodItem5Path
    ]
    expect(() => {
-      getUploadZipSpecification(artifactFiles, folderADirectory)
+      getUploadSpecification(artifactName, folderADirectory, artifactFiles)
    }).toThrow(
      `The rootDirectory: ${folderADirectory} is not a parent directory of the file: ${goodItem5Path}`
    )
  })

  it('Upload Specification - Success', async () => {
-    const specifications = getUploadZipSpecification(
-      artifactFilesToUpload,
-      root
+    const specifications = getUploadSpecification(
+      artifactName,
+      root,
+      artifactFilesToUpload
    )
    expect(specifications.length).toEqual(7)

-    const absolutePaths = specifications.map(item => item.sourcePath)
+    const absolutePaths = specifications.map(item => item.absoluteFilePath)
    expect(absolutePaths).toContain(goodItem1Path)
    expect(absolutePaths).toContain(goodItem2Path)
    expect(absolutePaths).toContain(goodItem3Path)
@@ -184,38 +186,45 @@ describe('Search', () => {
    expect(absolutePaths).toContain(amazingFileInFolderHPath)

    for (const specification of specifications) {
-      if (specification.sourcePath === goodItem1Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-a', 'folder-b', 'folder-c', 'good-item1.txt')
-        )
-      } else if (specification.sourcePath === goodItem2Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-d', 'good-item2.txt')
-        )
-      } else if (specification.sourcePath === goodItem3Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-d', 'good-item3.txt')
-        )
-      } else if (specification.sourcePath === goodItem4Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-d', 'good-item4.txt')
-        )
-      } else if (specification.sourcePath === goodItem5Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/good-item5.txt')
-        )
-      } else if (specification.sourcePath === extraFileInFolderCPath) {
-        expect(specification.destinationPath).toEqual(
+      if (specification.absoluteFilePath === goodItem1Path) {
+        expect(specification.uploadFilePath).toEqual(
          path.join(
-            '/folder-a',
+            artifactName,
+            'folder-a',
+            'folder-b',
+            'folder-c',
+            'good-item1.txt'
+          )
+        )
+      } else if (specification.absoluteFilePath === goodItem2Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item2.txt')
+        )
+      } else if (specification.absoluteFilePath === goodItem3Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item3.txt')
+        )
+      } else if (specification.absoluteFilePath === goodItem4Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item4.txt')
+        )
+      } else if (specification.absoluteFilePath === goodItem5Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'good-item5.txt')
+        )
+      } else if (specification.absoluteFilePath === extraFileInFolderCPath) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(
+            artifactName,
+            'folder-a',
            'folder-b',
            'folder-c',
            'extra-file-in-folder-c.txt'
          )
        )
-      } else if (specification.sourcePath === amazingFileInFolderHPath) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-h', 'amazing-item.txt')
+      } else if (specification.absoluteFilePath === amazingFileInFolderHPath) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-h', 'amazing-item.txt')
        )
      } else {
        throw new Error(
@@ -227,13 +236,14 @@ describe('Search', () => {

  it('Upload Specification - Success with extra slash', async () => {
    const rootWithSlash = `${root}/`
-    const specifications = getUploadZipSpecification(
-      artifactFilesToUpload,
-      rootWithSlash
+    const specifications = getUploadSpecification(
+      artifactName,
+      rootWithSlash,
+      artifactFilesToUpload
    )
    expect(specifications.length).toEqual(7)

-    const absolutePaths = specifications.map(item => item.sourcePath)
+    const absolutePaths = specifications.map(item => item.absoluteFilePath)
    expect(absolutePaths).toContain(goodItem1Path)
    expect(absolutePaths).toContain(goodItem2Path)
    expect(absolutePaths).toContain(goodItem3Path)
@@ -243,38 +253,45 @@ describe('Search', () => {
    expect(absolutePaths).toContain(amazingFileInFolderHPath)

    for (const specification of specifications) {
-      if (specification.sourcePath === goodItem1Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-a', 'folder-b', 'folder-c', 'good-item1.txt')
-        )
-      } else if (specification.sourcePath === goodItem2Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-d', 'good-item2.txt')
-        )
-      } else if (specification.sourcePath === goodItem3Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-d', 'good-item3.txt')
-        )
-      } else if (specification.sourcePath === goodItem4Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-d', 'good-item4.txt')
-        )
-      } else if (specification.sourcePath === goodItem5Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/good-item5.txt')
-        )
-      } else if (specification.sourcePath === extraFileInFolderCPath) {
-        expect(specification.destinationPath).toEqual(
+      if (specification.absoluteFilePath === goodItem1Path) {
+        expect(specification.uploadFilePath).toEqual(
          path.join(
-            '/folder-a',
+            artifactName,
+            'folder-a',
+            'folder-b',
+            'folder-c',
+            'good-item1.txt'
+          )
+        )
+      } else if (specification.absoluteFilePath === goodItem2Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item2.txt')
+        )
+      } else if (specification.absoluteFilePath === goodItem3Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item3.txt')
+        )
+      } else if (specification.absoluteFilePath === goodItem4Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item4.txt')
+        )
+      } else if (specification.absoluteFilePath === goodItem5Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'good-item5.txt')
+        )
+      } else if (specification.absoluteFilePath === extraFileInFolderCPath) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(
+            artifactName,
+            'folder-a',
            'folder-b',
            'folder-c',
            'extra-file-in-folder-c.txt'
          )
        )
-      } else if (specification.sourcePath === amazingFileInFolderHPath) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-h', 'amazing-item.txt')
+      } else if (specification.absoluteFilePath === amazingFileInFolderHPath) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-h', 'amazing-item.txt')
        )
      } else {
        throw new Error(
@@ -284,23 +301,47 @@ describe('Search', () => {
    }
  })

-  it('Upload Specification - Empty Directories are included', async () => {
+  it('Upload Specification - Directories should not be included', async () => {
    const folderEPath = path.join(root, 'folder-a', 'folder-b', 'folder-e')
-    const filesWithDirectory = [goodItem1Path, folderEPath]
-    const specifications = getUploadZipSpecification(filesWithDirectory, root)
-    expect(specifications.length).toEqual(2)
-    const absolutePaths = specifications.map(item => item.sourcePath)
+    const filesWithDirectory = [
+      goodItem1Path,
+      goodItem4Path,
+      folderEPath,
+      badItem3Path
+    ]
+    const specifications = getUploadSpecification(
+      artifactName,
+      root,
+      filesWithDirectory
+    )
+    expect(specifications.length).toEqual(3)
+    const absolutePaths = specifications.map(item => item.absoluteFilePath)
    expect(absolutePaths).toContain(goodItem1Path)
-    expect(absolutePaths).toContain(null)
+    expect(absolutePaths).toContain(goodItem4Path)
+    expect(absolutePaths).toContain(badItem3Path)

    for (const specification of specifications) {
-      if (specification.sourcePath === goodItem1Path) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-a', 'folder-b', 'folder-c', 'good-item1.txt')
+      if (specification.absoluteFilePath === goodItem1Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(
+            artifactName,
+            'folder-a',
+            'folder-b',
+            'folder-c',
+            'good-item1.txt'
+          )
        )
-      } else if (specification.sourcePath === null) {
-        expect(specification.destinationPath).toEqual(
-          path.join('/folder-a', 'folder-b', 'folder-e')
+      } else if (specification.absoluteFilePath === goodItem2Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item2.txt')
+        )
+      } else if (specification.absoluteFilePath === goodItem4Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item4.txt')
+        )
+      } else if (specification.absoluteFilePath === badItem3Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-f', 'bad-item3.txt')
        )
      } else {
        throw new Error(
@@ -0,0 +1,494 @@
+import * as http from 'http'
+import * as io from '../../io/src/io'
+import * as net from 'net'
+import * as path from 'path'
+import {UploadHttpClient} from '../src/internal/upload-http-client'
+import * as core from '@actions/core'
+import {promises as fs} from 'fs'
+import {getRuntimeUrl} from '../src/internal/config-variables'
+import {HttpClient, HttpClientResponse} from '@actions/http-client'
+import {
+  ArtifactResponse,
+  PatchArtifactSizeSuccessResponse
+} from '../src/internal/contracts'
+import {UploadSpecification} from '../src/internal/upload-specification'
+import {getArtifactUrl} from '../src/internal/utils'
+import {UploadOptions} from '../src/internal/upload-options'
+
+const root = path.join(__dirname, '_temp', 'artifact-upload')
+const file1Path = path.join(root, 'file1.txt')
+const file2Path = path.join(root, 'file2.txt')
+const file3Path = path.join(root, 'folder1', 'file3.txt')
+const file4Path = path.join(root, 'folder1', 'file4.txt')
+const file5Path = path.join(root, 'folder1', 'folder2', 'folder3', 'file5.txt')
+
+let file1Size = 0
+let file2Size = 0
+let file3Size = 0
+let file4Size = 0
+let file5Size = 0
+
+jest.mock('../src/internal/config-variables')
+jest.mock('@actions/http-client')
+
+describe('Upload Tests', () => {
+  beforeAll(async () => {
+    // mock all output so that there is less noise when running tests
+    jest.spyOn(console, 'log').mockImplementation(() => {})
+    jest.spyOn(core, 'debug').mockImplementation(() => {})
+    jest.spyOn(core, 'info').mockImplementation(() => {})
+    jest.spyOn(core, 'warning').mockImplementation(() => {})
+    jest.spyOn(core, 'error').mockImplementation(() => {})
+
+    // setup mocking for calls that got through the HttpClient
+    setupHttpClientMock()
+
+    // clear temp directory and create files that will be "uploaded"
+    await io.rmRF(root)
+    await fs.mkdir(path.join(root, 'folder1', 'folder2', 'folder3'), {
+      recursive: true
+    })
+    await fs.writeFile(file1Path, 'this is file 1')
+    await fs.writeFile(file2Path, 'this is file 2')
+    await fs.writeFile(file3Path, 'this is file 3')
+    await fs.writeFile(file4Path, 'this is file 4')
+    await fs.writeFile(file5Path, 'this is file 5')
+    /*
+      Directory structure for files that get created:
+      root/
+        file1.txt
+        file2.txt
+        folder1/
+          file3.txt
+          file4.txt
+          folder2/
+            folder3/
+              file5.txt
+    */
+
+    file1Size = (await fs.stat(file1Path)).size
+    file2Size = (await fs.stat(file2Path)).size
+    file3Size = (await fs.stat(file3Path)).size
+    file4Size = (await fs.stat(file4Path)).size
+    file5Size = (await fs.stat(file5Path)).size
+  })
+
+  /**
+   * Artifact Creation Tests
+   */
+  it('Create Artifact - Success', async () => {
+    const artifactName = 'valid-artifact-name'
+    const uploadHttpClient = new UploadHttpClient()
+    const response = await uploadHttpClient.createArtifactInFileContainer(
+      artifactName
+    )
+    expect(response.containerId).toEqual('13')
+    expect(response.size).toEqual(-1)
+    expect(response.signedContent).toEqual('false')
+    expect(response.fileContainerResourceUrl).toEqual(
+      `${getRuntimeUrl()}_apis/resources/Containers/13`
+    )
+    expect(response.type).toEqual('actions_storage')
+    expect(response.name).toEqual(artifactName)
+    expect(response.url).toEqual(
+      `${getRuntimeUrl()}_apis/pipelines/1/runs/1/artifacts?artifactName=${artifactName}`
+    )
+  })
+
+  it('Create Artifact - Failure', async () => {
+    const artifactName = 'invalid-artifact-name'
+    const uploadHttpClient = new UploadHttpClient()
+    expect(
+      uploadHttpClient.createArtifactInFileContainer(artifactName)
+    ).rejects.toEqual(
+      new Error(
+        `Create Artifact Container failed: The artifact name invalid-artifact-name is not valid. Request URL ${getArtifactUrl()}`
+      )
+    )
+  })
+
+  it('Create Artifact - Retention Less Than Min Value Error', async () => {
+    const artifactName = 'valid-artifact-name'
+    const options: UploadOptions = {
+      retentionDays: -1
+    }
+    const uploadHttpClient = new UploadHttpClient()
+    expect(
+      uploadHttpClient.createArtifactInFileContainer(artifactName, options)
+    ).rejects.toEqual(new Error('Invalid retention, minimum value is 1.'))
+  })
+
+  it('Create Artifact - Storage Quota Error', async () => {
+    const artifactName = 'storage-quota-hit'
+    const uploadHttpClient = new UploadHttpClient()
+    expect(
+      uploadHttpClient.createArtifactInFileContainer(artifactName)
+    ).rejects.toEqual(
+      new Error(
+        'Create Artifact Container failed: Artifact storage quota has been hit. Unable to upload any new artifacts'
+      )
+    )
+  })
+
+  /**
+   * Artifact Upload Tests
+   */
+  it('Upload Artifact - Success', async () => {
+    /**
+     * Normally search.findFilesToUpload() would be used for providing information about what to upload. These tests however
+     * focuses solely on the upload APIs so searchResult[] will be hard-coded
+     */
+    const artifactName = 'successful-artifact'
+    const uploadSpecification: UploadSpecification[] = [
+      {
+        absoluteFilePath: file1Path,
+        uploadFilePath: `${artifactName}/file1.txt`
+      },
+      {
+        absoluteFilePath: file2Path,
+        uploadFilePath: `${artifactName}/file2.txt`
+      },
+      {
+        absoluteFilePath: file3Path,
+        uploadFilePath: `${artifactName}/folder1/file3.txt`
+      },
+      {
+        absoluteFilePath: file4Path,
+        uploadFilePath: `${artifactName}/folder1/file4.txt`
+      },
+      {
+        absoluteFilePath: file5Path,
+        uploadFilePath: `${artifactName}/folder1/folder2/folder3/file5.txt`
+      }
+    ]
+
+    const expectedTotalSize =
+      file1Size + file2Size + file3Size + file4Size + file5Size
+    const uploadUrl = `${getRuntimeUrl()}_apis/resources/Containers/13`
+    const uploadHttpClient = new UploadHttpClient()
+    const uploadResult = await uploadHttpClient.uploadArtifactToFileContainer(
+      uploadUrl,
+      uploadSpecification
+    )
+    expect(uploadResult.failedItems.length).toEqual(0)
+    expect(uploadResult.uploadSize).toEqual(expectedTotalSize)
+  })
+
+  it('Upload Artifact - Failed Single File Upload', async () => {
+    const uploadSpecification: UploadSpecification[] = [
+      {
+        absoluteFilePath: file1Path,
+        uploadFilePath: `this-file-upload-will-fail`
+      }
+    ]
+
+    const uploadUrl = `${getRuntimeUrl()}_apis/resources/Containers/13`
+    const uploadHttpClient = new UploadHttpClient()
+    const uploadResult = await uploadHttpClient.uploadArtifactToFileContainer(
+      uploadUrl,
+      uploadSpecification
+    )
+    expect(uploadResult.failedItems.length).toEqual(1)
+    expect(uploadResult.uploadSize).toEqual(0)
+  })
+
+  it('Upload Artifact - Partial Upload Continue On Error', async () => {
+    const artifactName = 'partial-artifact'
+    const uploadSpecification: UploadSpecification[] = [
+      {
+        absoluteFilePath: file1Path,
+        uploadFilePath: `${artifactName}/file1.txt`
+      },
+      {
+        absoluteFilePath: file2Path,
+        uploadFilePath: `${artifactName}/file2.txt`
+      },
+      {
+        absoluteFilePath: file3Path,
+        uploadFilePath: `${artifactName}/folder1/file3.txt`
+      },
+      {
+        absoluteFilePath: file4Path,
+        uploadFilePath: `this-file-upload-will-fail`
+      },
+      {
+        absoluteFilePath: file5Path,
+        uploadFilePath: `${artifactName}/folder1/folder2/folder3/file5.txt`
+      }
+    ]
+
+    const expectedPartialSize = file1Size + file2Size + file4Size + file5Size
+    const uploadUrl = `${getRuntimeUrl()}_apis/resources/Containers/13`
+    const uploadHttpClient = new UploadHttpClient()
+    const uploadResult = await uploadHttpClient.uploadArtifactToFileContainer(
+      uploadUrl,
+      uploadSpecification,
+      {continueOnError: true}
+    )
+    expect(uploadResult.failedItems.length).toEqual(1)
+    expect(uploadResult.uploadSize).toEqual(expectedPartialSize)
+  })
+
+  it('Upload Artifact - Partial Upload Fail Fast', async () => {
+    const artifactName = 'partial-artifact'
+    const uploadSpecification: UploadSpecification[] = [
+      {
+        absoluteFilePath: file1Path,
+        uploadFilePath: `${artifactName}/file1.txt`
+      },
+      {
+        absoluteFilePath: file2Path,
+        uploadFilePath: `${artifactName}/file2.txt`
+      },
+      {
+        absoluteFilePath: file3Path,
+        uploadFilePath: `${artifactName}/folder1/file3.txt`
+      },
+      {
+        absoluteFilePath: file4Path,
+        uploadFilePath: `this-file-upload-will-fail`
+      },
+      {
+        absoluteFilePath: file5Path,
+        uploadFilePath: `${artifactName}/folder1/folder2/folder3/file5.txt`
+      }
+    ]
+
+    const expectedPartialSize = file1Size + file2Size + file3Size
+    const uploadUrl = `${getRuntimeUrl()}_apis/resources/Containers/13`
+    const uploadHttpClient = new UploadHttpClient()
+    const uploadResult = await uploadHttpClient.uploadArtifactToFileContainer(
+      uploadUrl,
+      uploadSpecification,
+      {continueOnError: false}
+    )
+    expect(uploadResult.failedItems.length).toEqual(2)
+    expect(uploadResult.uploadSize).toEqual(expectedPartialSize)
+  })
+
+  it('Upload Artifact - Failed upload with no options', async () => {
+    const artifactName = 'partial-artifact'
+    const uploadSpecification: UploadSpecification[] = [
+      {
+        absoluteFilePath: file1Path,
+        uploadFilePath: `${artifactName}/file1.txt`
+      },
+      {
+        absoluteFilePath: file2Path,
+        uploadFilePath: `${artifactName}/file2.txt`
+      },
+      {
+        absoluteFilePath: file3Path,
+        uploadFilePath: `${artifactName}/folder1/file3.txt`
+      },
+      {
+        absoluteFilePath: file4Path,
+        uploadFilePath: `this-file-upload-will-fail`
+      },
+      {
+        absoluteFilePath: file5Path,
+        uploadFilePath: `${artifactName}/folder1/folder2/folder3/file5.txt`
+      }
+    ]
+
+    const expectedPartialSize = file1Size + file2Size + file3Size + file5Size
+    const uploadUrl = `${getRuntimeUrl()}_apis/resources/Containers/13`
+    const uploadHttpClient = new UploadHttpClient()
+    const uploadResult = await uploadHttpClient.uploadArtifactToFileContainer(
+      uploadUrl,
+      uploadSpecification
+    )
+    expect(uploadResult.failedItems.length).toEqual(1)
+    expect(uploadResult.uploadSize).toEqual(expectedPartialSize)
+  })
+
+  it('Upload Artifact - Failed upload with empty options', async () => {
+    const artifactName = 'partial-artifact'
+    const uploadSpecification: UploadSpecification[] = [
+      {
+        absoluteFilePath: file1Path,
+        uploadFilePath: `${artifactName}/file1.txt`
+      },
+      {
+        absoluteFilePath: file2Path,
+        uploadFilePath: `${artifactName}/file2.txt`
+      },
+      {
+        absoluteFilePath: file3Path,
+        uploadFilePath: `${artifactName}/folder1/file3.txt`
+      },
+      {
+        absoluteFilePath: file4Path,
+        uploadFilePath: `this-file-upload-will-fail`
+      },
+      {
+        absoluteFilePath: file5Path,
+        uploadFilePath: `${artifactName}/folder1/folder2/folder3/file5.txt`
+      }
+    ]
+
+    const expectedPartialSize = file1Size + file2Size + file3Size + file5Size
+    const uploadUrl = `${getRuntimeUrl()}_apis/resources/Containers/13`
+    const uploadHttpClient = new UploadHttpClient()
+    const uploadResult = await uploadHttpClient.uploadArtifactToFileContainer(
+      uploadUrl,
+      uploadSpecification,
+      {}
+    )
+    expect(uploadResult.failedItems.length).toEqual(1)
+    expect(uploadResult.uploadSize).toEqual(expectedPartialSize)
+  })
+
+  /**
+   * Artifact Association Tests
+   */
+  it('Associate Artifact - Success', async () => {
+    const uploadHttpClient = new UploadHttpClient()
+    expect(async () => {
+      uploadHttpClient.patchArtifactSize(130, 'my-artifact')
+    }).not.toThrow()
+  })
+
+  it('Associate Artifact - Not Found', async () => {
+    const uploadHttpClient = new UploadHttpClient()
+    expect(
+      uploadHttpClient.patchArtifactSize(100, 'non-existent-artifact')
+    ).rejects.toThrow(
+      'An Artifact with the name non-existent-artifact was not found'
+    )
+  })
+
+  it('Associate Artifact - Error', async () => {
+    const uploadHttpClient = new UploadHttpClient()
+    expect(
+      uploadHttpClient.patchArtifactSize(-2, 'my-artifact')
+    ).rejects.toThrow(
+      'Finalize artifact upload failed: Artifact service responded with 400'
+    )
+  })
+
+  /**
+   * Helpers used to setup mocking for the HttpClient
+   */
+  async function emptyMockReadBody(): Promise<string> {
+    return new Promise(resolve => {
+      resolve()
+    })
+  }
+
+  function setupHttpClientMock(): void {
+    /**
+     * Mocks Post calls that are used during Artifact Creation tests
+     *
+     * Simulates success and non-success status codes depending on the artifact name along with an appropriate
+     * payload that represents an expected response
+     */
+    jest
+      .spyOn(HttpClient.prototype, 'post')
+      .mockImplementation(async (requestdata, data) => {
+        // parse the input data and use the provided artifact name as part of the response
+        const inputData = JSON.parse(data)
+        const mockMessage = new http.IncomingMessage(new net.Socket())
+        let mockReadBody = emptyMockReadBody
+
+        if (inputData.Name === 'invalid-artifact-name') {
+          mockMessage.statusCode = 400
+        } else if (inputData.Name === 'storage-quota-hit') {
+          mockMessage.statusCode = 403
+        } else {
+          mockMessage.statusCode = 201
+          const response: ArtifactResponse = {
+            containerId: '13',
+            size: -1,
+            signedContent: 'false',
+            fileContainerResourceUrl: `${getRuntimeUrl()}_apis/resources/Containers/13`,
+            type: 'actions_storage',
+            name: inputData.Name,
+            url: `${getRuntimeUrl()}_apis/pipelines/1/runs/1/artifacts?artifactName=${
+              inputData.Name
+            }`
+          }
+          const returnData: string = JSON.stringify(response, null, 2)
+          mockReadBody = async function(): Promise<string> {
+            return new Promise(resolve => {
+              resolve(returnData)
+            })
+          }
+        }
+        return new Promise<HttpClientResponse>(resolve => {
+          resolve({
+            message: mockMessage,
+            readBody: mockReadBody
+          })
+        })
+      })
+
+    /**
+     * Mocks SendStream calls that are made during Artifact Upload tests
+     *
+     * A 500 response is used to simulate a failed upload stream. The uploadUrl can be set to
+     * include 'fail' to specify that the upload should fail
+     */
+    jest
+      .spyOn(HttpClient.prototype, 'sendStream')
+      .mockImplementation(async (verb, requestUrl) => {
+        const mockMessage = new http.IncomingMessage(new net.Socket())
+        mockMessage.statusCode = 200
+        if (requestUrl.includes('fail')) {
+          mockMessage.statusCode = 500
+        }
+
+        return new Promise<HttpClientResponse>(resolve => {
+          resolve({
+            message: mockMessage,
+            readBody: emptyMockReadBody
+          })
+        })
+      })
+
+    /**
+     * Mocks Patch calls that are made during Artifact Association tests
+     *
+     * Simulates success and non-success status codes depending on the input size along with an appropriate
+     * payload that represents an expected response
+     */
+    jest
+      .spyOn(HttpClient.prototype, 'patch')
+      .mockImplementation(async (requestdata, data) => {
+        const inputData = JSON.parse(data)
+        const mockMessage = new http.IncomingMessage(new net.Socket())
+
+        // Get the name from the end of requestdata. Will be something like https://www.example.com/_apis/pipelines/workflows/15/artifacts?api-version=6.0-preview&artifactName=my-artifact
+        const artifactName = requestdata.split('=')[2]
+        let mockReadBody = emptyMockReadBody
+        if (inputData.Size < 1) {
+          mockMessage.statusCode = 400
+        } else if (artifactName === 'non-existent-artifact') {
+          mockMessage.statusCode = 404
+        } else {
+          mockMessage.statusCode = 200
+          const response: PatchArtifactSizeSuccessResponse = {
+            containerId: 13,
+            size: inputData.Size,
+            signedContent: 'false',
+            type: 'actions_storage',
+            name: artifactName,
+            url: `${getRuntimeUrl()}_apis/pipelines/1/runs/1/artifacts?artifactName=${artifactName}`,
+            uploadUrl: `${getRuntimeUrl()}_apis/resources/Containers/13`
+          }
+          const returnData: string = JSON.stringify(response, null, 2)
+          mockReadBody = async function(): Promise<string> {
+            return new Promise(resolve => {
+              resolve(returnData)
+            })
+          }
+        }
+        return new Promise<HttpClientResponse>(resolve => {
+          resolve({
+            message: mockMessage,
+            readBody: mockReadBody
+          })
+        })
+      })
+  }
+})
@@ -1,62 +1,282 @@
-import * as config from '../src/internal/shared/config'
-import * as util from '../src/internal/shared/util'
+import * as fs from 'fs'
+import * as io from '../../io/src/io'
+import * as path from 'path'
+import * as utils from '../src/internal/utils'
+import * as core from '@actions/core'
+import {HttpCodes} from '@actions/http-client'
+import {
+  getRuntimeUrl,
+  getWorkFlowRunId,
+  getInitialRetryIntervalInMilliseconds,
+  getRetryMultiplier
+} from '../src/internal/config-variables'

-describe('get-backend-ids-from-token', () => {
-  it('should return backend ids when the token is valid', () => {
-    jest
-      .spyOn(config, 'getRuntimeToken')
-      .mockReturnValue(
-        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwic2NwIjoiQWN0aW9ucy5FeGFtcGxlIEFjdGlvbnMuQW5vdGhlckV4YW1wbGU6dGVzdCBBY3Rpb25zLlJlc3VsdHM6Y2U3ZjU0YzctNjFjNy00YWFlLTg4N2YtMzBkYTQ3NWY1ZjFhOmNhMzk1MDg1LTA0MGEtNTI2Yi0yY2U4LWJkYzg1ZjY5Mjc3NCIsImlhdCI6MTUxNjIzOTAyMn0.XYnI_wHPBlUi1mqYveJnnkJhp4dlFjqxzRmISPsqfw8'
+jest.mock('../src/internal/config-variables')
+
+describe('Utils', () => {
+  beforeAll(() => {
+    // mock all output so that there is less noise when running tests
+    jest.spyOn(console, 'log').mockImplementation(() => {})
+    jest.spyOn(core, 'debug').mockImplementation(() => {})
+    jest.spyOn(core, 'info').mockImplementation(() => {})
+    jest.spyOn(core, 'warning').mockImplementation(() => {})
+  })
+
+  it('Check exponential retry range', () => {
+    // No retries should return the initial retry interval
+    const retryWaitTime0 = utils.getExponentialRetryTimeInMilliseconds(0)
+    expect(retryWaitTime0).toEqual(getInitialRetryIntervalInMilliseconds())
+
+    const testMinMaxRange = (retryCount: number): void => {
+      const retryWaitTime = utils.getExponentialRetryTimeInMilliseconds(
+        retryCount
      )
+      const minRange =
+        getInitialRetryIntervalInMilliseconds() *
+        getRetryMultiplier() *
+        retryCount
+      const maxRange = minRange * getRetryMultiplier()

-    const backendIds = util.getBackendIdsFromToken()
-    expect(backendIds.workflowRunBackendId).toBe(
-      'ce7f54c7-61c7-4aae-887f-30da475f5f1a'
-    )
-    expect(backendIds.workflowJobRunBackendId).toBe(
-      'ca395085-040a-526b-2ce8-bdc85f692774'
+      expect(retryWaitTime).toBeGreaterThanOrEqual(minRange)
+      expect(retryWaitTime).toBeLessThan(maxRange)
+    }
+
+    for (let i = 1; i < 10; i++) {
+      testMinMaxRange(i)
+    }
+  })
+
+  it('Check Artifact Name for any invalid characters', () => {
+    const invalidNames = [
+      'my\\artifact',
+      'my/artifact',
+      'my"artifact',
+      'my:artifact',
+      'my<artifact',
+      'my>artifact',
+      'my|artifact',
+      'my*artifact',
+      'my?artifact',
+      ''
+    ]
+    for (const invalidName of invalidNames) {
+      expect(() => {
+        utils.checkArtifactName(invalidName)
+      }).toThrow()
+    }
+
+    const validNames = [
+      'my-normal-artifact',
+      'myNormalArtifact',
+      'm¥ñðrmålÄr†ï£å¢†'
+    ]
+    for (const validName of validNames) {
+      expect(() => {
+        utils.checkArtifactName(validName)
+      }).not.toThrow()
+    }
+  })
+
+  it('Check Artifact File Path for any invalid characters', () => {
+    const invalidNames = [
+      'some/invalid"artifact/path',
+      'some/invalid:artifact/path',
+      'some/invalid<artifact/path',
+      'some/invalid>artifact/path',
+      'some/invalid|artifact/path',
+      'some/invalid*artifact/path',
+      'some/invalid?artifact/path',
+      ''
+    ]
+    for (const invalidName of invalidNames) {
+      expect(() => {
+        utils.checkArtifactFilePath(invalidName)
+      }).toThrow()
+    }
+
+    const validNames = [
+      'my/perfectly-normal/artifact-path',
+      'my/perfectly\\Normal/Artifact-path',
+      'm¥/ñðrmål/Är†ï£å¢†'
+    ]
+    for (const validName of validNames) {
+      expect(() => {
+        utils.checkArtifactFilePath(validName)
+      }).not.toThrow()
+    }
+  })
+
+  it('Test negative artifact retention throws', () => {
+    expect(() => {
+      utils.getProperRetention(-1, undefined)
+    }).toThrow()
+  })
+
+  it('Test no setting specified takes artifact retention input', () => {
+    expect(utils.getProperRetention(180, undefined)).toEqual(180)
+  })
+
+  it('Test artifact retention must conform to max allowed', () => {
+    expect(utils.getProperRetention(180, '45')).toEqual(45)
+  })
+
+  it('Test constructing artifact URL', () => {
+    const runtimeUrl = getRuntimeUrl()
+    const runId = getWorkFlowRunId()
+    const artifactUrl = utils.getArtifactUrl()
+    expect(artifactUrl).toEqual(
+      `${runtimeUrl}_apis/pipelines/workflows/${runId}/artifacts?api-version=${utils.getApiVersion()}`
    )
  })

-  it("should throw an error when the token doesn't have the right scope", () => {
-    jest
-      .spyOn(config, 'getRuntimeToken')
-      .mockReturnValue(
-        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwic2NwIjoiQWN0aW9ucy5FeGFtcGxlIEFjdGlvbnMuQW5vdGhlckV4YW1wbGU6dGVzdCIsImlhdCI6MTUxNjIzOTAyMn0.K0IEoULZteGevF38G94xiaA8zcZ5UlKWfGfqE6q3dhw'
-      )
+  it('Test constructing upload headers with all optional parameters', () => {
+    const contentType = 'application/octet-stream'
+    const size = 24
+    const uncompressedLength = 100
+    const range = 'bytes 0-199/200'
+    const headers = utils.getUploadHeaders(
+      contentType,
+      true,
+      true,
+      uncompressedLength,
+      size,
+      range
+    )
+    expect(Object.keys(headers).length).toEqual(8)
+    expect(headers['Accept']).toEqual(
+      `application/json;api-version=${utils.getApiVersion()}`
+    )
+    expect(headers['Content-Type']).toEqual(contentType)
+    expect(headers['Connection']).toEqual('Keep-Alive')
+    expect(headers['Keep-Alive']).toEqual('10')
+    expect(headers['Content-Encoding']).toEqual('gzip')
+    expect(headers['x-tfs-filelength']).toEqual(uncompressedLength)
+    expect(headers['Content-Length']).toEqual(size)
+    expect(headers['Content-Range']).toEqual(range)
+  })

-    expect(util.getBackendIdsFromToken).toThrowError(
-      'Failed to get backend IDs: The provided JWT token is invalid'
+  it('Test constructing upload headers with only required parameter', () => {
+    const headers = utils.getUploadHeaders('application/octet-stream')
+    expect(Object.keys(headers).length).toEqual(2)
+    expect(headers['Accept']).toEqual(
+      `application/json;api-version=${utils.getApiVersion()}`
+    )
+    expect(headers['Content-Type']).toEqual('application/octet-stream')
+  })
+
+  it('Test constructing download headers with all optional parameters', () => {
+    const contentType = 'application/json'
+    const headers = utils.getDownloadHeaders(contentType, true, true)
+    expect(Object.keys(headers).length).toEqual(5)
+    expect(headers['Content-Type']).toEqual(contentType)
+    expect(headers['Connection']).toEqual('Keep-Alive')
+    expect(headers['Keep-Alive']).toEqual('10')
+    expect(headers['Accept-Encoding']).toEqual('gzip')
+    expect(headers['Accept']).toEqual(
+      `application/octet-stream;api-version=${utils.getApiVersion()}`
    )
  })

-  it('should throw an error when the token has a malformed scope', () => {
-    jest
-      .spyOn(config, 'getRuntimeToken')
-      .mockReturnValue(
-        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwic2NwIjoiQWN0aW9ucy5FeGFtcGxlIEFjdGlvbnMuQW5vdGhlckV4YW1wbGU6dGVzdCBBY3Rpb25zLlJlc3VsdHM6Y2U3ZjU0YzctNjFjNy00YWFlLTg4N2YtMzBkYTQ3NWY1ZjFhIiwiaWF0IjoxNTE2MjM5MDIyfQ.7D0_LRfRFRZFImHQ7GxH2S6ZyFjjZ5U0ujjGCfle1XE'
-      )
-
-    expect(util.getBackendIdsFromToken).toThrowError(
-      'Failed to get backend IDs: The provided JWT token is invalid'
+  it('Test constructing download headers with only required parameter', () => {
+    const headers = utils.getDownloadHeaders('application/octet-stream')
+    expect(Object.keys(headers).length).toEqual(2)
+    expect(headers['Content-Type']).toEqual('application/octet-stream')
+    // check for default accept type
+    expect(headers['Accept']).toEqual(
+      `application/json;api-version=${utils.getApiVersion()}`
    )
  })

-  it('should throw an error when the token is in an invalid format', () => {
-    jest.spyOn(config, 'getRuntimeToken').mockReturnValue('token')
-
-    expect(util.getBackendIdsFromToken).toThrowError('Invalid token specified')
+  it('Test Success Status Code', () => {
+    expect(utils.isSuccessStatusCode(HttpCodes.OK)).toEqual(true)
+    expect(utils.isSuccessStatusCode(201)).toEqual(true)
+    expect(utils.isSuccessStatusCode(299)).toEqual(true)
+    expect(utils.isSuccessStatusCode(HttpCodes.NotFound)).toEqual(false)
+    expect(utils.isSuccessStatusCode(HttpCodes.BadGateway)).toEqual(false)
+    expect(utils.isSuccessStatusCode(HttpCodes.Forbidden)).toEqual(false)
  })

-  it("should throw an error when the token doesn't have the right field", () => {
-    jest
-      .spyOn(config, 'getRuntimeToken')
-      .mockReturnValue(
-        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'
-      )
-
-    expect(util.getBackendIdsFromToken).toThrowError(
-      'Failed to get backend IDs: The provided JWT token is invalid'
+  it('Test Retry Status Code', () => {
+    expect(utils.isRetryableStatusCode(HttpCodes.BadGateway)).toEqual(true)
+    expect(utils.isRetryableStatusCode(HttpCodes.ServiceUnavailable)).toEqual(
+      true
    )
+    expect(utils.isRetryableStatusCode(HttpCodes.GatewayTimeout)).toEqual(true)
+    expect(utils.isRetryableStatusCode(HttpCodes.TooManyRequests)).toEqual(true)
+    expect(utils.isRetryableStatusCode(HttpCodes.OK)).toEqual(false)
+    expect(utils.isRetryableStatusCode(HttpCodes.NotFound)).toEqual(false)
+    expect(utils.isRetryableStatusCode(HttpCodes.Forbidden)).toEqual(false)
+    expect(utils.isRetryableStatusCode(413)).toEqual(true) // Payload Too Large
+  })
+
+  it('Test Throttled Status Code', () => {
+    expect(utils.isThrottledStatusCode(HttpCodes.TooManyRequests)).toEqual(true)
+    expect(utils.isThrottledStatusCode(HttpCodes.InternalServerError)).toEqual(
+      false
+    )
+    expect(utils.isThrottledStatusCode(HttpCodes.BadGateway)).toEqual(false)
+    expect(utils.isThrottledStatusCode(HttpCodes.ServiceUnavailable)).toEqual(
+      false
+    )
+  })
+
+  it('Test Forbidden Status Code', () => {
+    expect(utils.isForbiddenStatusCode(HttpCodes.Forbidden)).toEqual(true)
+    expect(utils.isForbiddenStatusCode(HttpCodes.InternalServerError)).toEqual(
+      false
+    )
+    expect(utils.isForbiddenStatusCode(HttpCodes.TooManyRequests)).toEqual(
+      false
+    )
+    expect(utils.isForbiddenStatusCode(HttpCodes.OK)).toEqual(false)
+  })
+
+  it('Test Creating Artifact Directories', async () => {
+    const root = path.join(__dirname, '_temp', 'artifact-download')
+    // remove directory before starting
+    await io.rmRF(root)
+
+    const directory1 = path.join(root, 'folder2', 'folder3')
+    const directory2 = path.join(directory1, 'folder1')
+
+    // Initially should not exist
+    await expect(fs.promises.access(directory1)).rejects.not.toBeUndefined()
+    await expect(fs.promises.access(directory2)).rejects.not.toBeUndefined()
+    const directoryStructure = [directory1, directory2]
+    await utils.createDirectoriesForArtifact(directoryStructure)
+    // directories should now be created
+    await expect(fs.promises.access(directory1)).resolves.toEqual(undefined)
+    await expect(fs.promises.access(directory2)).resolves.toEqual(undefined)
+  })
+
+  it('Test Creating Empty Files', async () => {
+    const root = path.join(__dirname, '_temp', 'empty-files')
+    await io.rmRF(root)
+
+    const emptyFile1 = path.join(root, 'emptyFile1')
+    const directoryToCreate = path.join(root, 'folder1')
+    const emptyFile2 = path.join(directoryToCreate, 'emptyFile2')
+
+    // empty files should only be created after the directory structure is fully setup
+    // ensure they are first created by using the createDirectoriesForArtifact method
+    const directoryStructure = [root, directoryToCreate]
+    await utils.createDirectoriesForArtifact(directoryStructure)
+    await expect(fs.promises.access(root)).resolves.toEqual(undefined)
+    await expect(fs.promises.access(directoryToCreate)).resolves.toEqual(
+      undefined
+    )
+
+    await expect(fs.promises.access(emptyFile1)).rejects.not.toBeUndefined()
+    await expect(fs.promises.access(emptyFile2)).rejects.not.toBeUndefined()
+
+    const emptyFilesToCreate = [emptyFile1, emptyFile2]
+    await utils.createEmptyFilesForArtifact(emptyFilesToCreate)
+
+    await expect(fs.promises.access(emptyFile1)).resolves.toEqual(undefined)
+    const size1 = (await fs.promises.stat(emptyFile1)).size
+    expect(size1).toEqual(0)
+    await expect(fs.promises.access(emptyFile2)).resolves.toEqual(undefined)
+    const size2 = (await fs.promises.stat(emptyFile2)).size
+    expect(size2).toEqual(0)
  })
 })
@@ -0,0 +1,53 @@
+# Additional Information
+
+Extra information 
+- [Non-Supported Characters](#Non-Supported-Characters)
+- [Permission loss](#Permission-Loss)
+- [Considerations](#Considerations)
+- [Compression](#Is-my-artifact-compressed)
+
+## Non-Supported Characters
+
+When uploading an artifact, the inputted `name` parameter along with the files specified in `files` cannot contain any of the following characters. They will be rejected by the server if attempted to be sent over and the upload will fail. These characters are not allowed due to limitations and restrictions with certain file systems such as NTFS. To maintain platform-agnostic behavior, all characters that are not supported by an individual filesystem/platform will not be supported on all filesystems/platforms.
+
+- "
+- :
+- <
+- \>
+- |
+- \*
+- ?
+
+In addition to the aforementioned characters, the inputted `name` also cannot include the following
+- \
+- /
+
+
+## Permission Loss
+
+File permissions are not maintained between uploaded and downloaded artifacts. If file permissions are something that need to be maintained (such as an executable), consider archiving all of the files using something like `tar` and then uploading the single archive. After downloading the artifact, you can `un-tar` the individual file and permissions will be preserved.
+
+```js
+const artifact = require('@actions/artifact');
+const artifactClient = artifact.create()
+const artifactName = 'my-artifact';
+const files = [
+    '/home/user/files/plz-upload/my-archive.tgz',
+]
+const rootDirectory = '/home/user/files/plz-upload'
+const uploadResult = await artifactClient.uploadArtifact(artifactName, files, rootDirectory)
+```
+
+## Considerations
+
+During upload, each file is uploaded concurrently in 4MB chunks using a separate HTTPS connection per file. Chunked uploads are used so that in the event of a failure (which is entirely possible because the internet is not perfect), the upload can be retried. If there is an error, a retry will be attempted after a certain period of time.
+
+Uploading will be generally be faster if there are fewer files that are larger in size vs if there are lots of smaller files. Depending on the types and quantities of files being uploaded, it might be beneficial to separately compress and archive everything into a single archive (using something like `tar` or `zip`) before starting and artifact upload to speed things up.
+
+## Is my artifact compressed?
+
+GZip is used internally to compress individual files before starting an upload. Compression helps reduce the total amount of data that must be uploaded and stored while helping to speed up uploads (this performance benefit is significant especially on self hosted runners). If GZip does not reduce the size of the file that is being uploaded, the original file is uploaded as-is.
+
+Compression using GZip also helps speed up artifact download as part of a workflow. Header information is used to determine if an individual file was uploaded using GZip and if necessary, decompression is used. 
+
+When downloading an artifact from the GitHub UI (this differs from downloading an artifact during a workflow), a single Zip file is dynamically created that contains all of the files uploaded as part of an artifact. Any files that were uploaded using GZip will be decompressed on the server before being added to the Zip file with the remaining files.
@@ -1 +0,0 @@
-Docs will be added here once development of version `2.0.0` has finished
@@ -0,0 +1,57 @@
+# Implementation Details
+
+Warning: Implementation details may change at any time without notice. This is meant to serve as a reference to help users understand the package.
+
+## Upload/Compression flow
+
+![image](https://user-images.githubusercontent.com/16109154/79765587-19522b00-8327-11ea-9679-410bb10e1b13.png)
+
+During artifact upload, gzip is used to compress individual files that then get uploaded. This is used to minimize the amount of data that gets uploaded which reduces the total amount of HTTP calls (upload happens in 4MB chunks). This results in considerably faster uploads with huge performance implications especially on self-hosted runners.
+
+If a file is less than 64KB in size, a passthrough stream (readable and writable) is used to convert an in-memory buffer into a readable stream without any extra streams or pipping.
+
+## Retry Logic when downloading an individual file
+
+![image](https://user-images.githubusercontent.com/16109154/78555461-5be71400-780d-11ea-9abd-b05b77a95a3f.png)
+
+## Proxy support
+
+This package uses the `@actions/http-client` NPM package internally which supports proxied requests out of the box.
+
+## HttpManager
+
+### `keep-alive` header
+
+When an HTTP call is made to upload or download an individual file, the server will close the HTTP connection after the upload/download is complete and respond with a header indicating `Connection: close`.
+
+[HTTP closed connection header information](https://tools.ietf.org/html/rfc2616#section-14.10)
+
+TCP connections are sometimes not immediately closed by the node client (Windows might hold on to the port for an extra period of time before actually releasing it for example) and a large amount of closed connections can cause port exhaustion before ports get released and are available again.
+
+VMs hosted by GitHub Actions have 1024 available ports so uploading 1000+ files very quickly can cause port exhaustion if connections get closed immediately. This can start to cause strange undefined behavior and timeouts.
+
+In order for connections to not close immediately, the `keep-alive` header is used to indicate to the server that the connection should stay open. If a `keep-alive` header is used, the connection needs to be disposed of by calling `dispose()` in the `HttpClient`. 
+
+[`keep-alive` header information](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Keep-Alive)
+[@actions/http-client client disposal](https://github.com/actions/http-client/blob/04e5ad73cd3fd1f5610a32116b0759eddf6570d2/index.ts#L292)
+
+
+### Multiple HTTP clients
+
+During an artifact upload or download, files are concurrently uploaded or downloaded using `async/await`. When an error or retry is encountered, the `HttpClient` that made a call is disposed of and a new one is created. If a single `HttpClient` was used for all HTTP calls and it had to be disposed, it could inadvertently effect any other calls that could be concurrently happening.
+
+Any other concurrent uploads or downloads should be left untouched. Because of this, each concurrent upload or download gets its own `HttpClient`. The `http-manager` is used to manage all available clients and each concurrent upload or download maintains a `httpClientIndex` that keep track of which client should be used (and potentially disposed and recycled if necessary)
+
+### Potential resource leaks
+
+When an HTTP response is received, it consists of two parts
+- `message`
+- `body`
+
+The `message` contains information such as the response code and header information and it is available immediately. The body however is not available immediately and it can be read by calling `await response.readBody()`.
+
+TCP connections consist of an input and output buffer to manage what is sent and received across a connection. If the body is not read (even if its contents are not needed) the buffers can stay in use even after `dispose()` gets called on the `HttpClient`. The buffers get released automatically after a certain period of time, but in order for them to be explicitly cleared, `readBody()` is always called.
+
+### Non Concurrent calls
+
+Both `upload-http-client` and `download-http-client` do not instantiate or create any HTTP clients (the `HttpManager` has that responsibility). If an HTTP call has to be made that does not require the `keep-alive` header (such as when calling `listArtifacts` or `patchArtifactSize`), the first `HttpClient` in the `HttpManager` is used. The number of available clients is equal to the upload or download concurrency and there will always be at least one available.
@@ -1,6 +1,6 @@
 {
  "name": "@actions/artifact",
-  "version": "2.0.0",
+  "version": "0.5.1",
  "preview": true,
  "description": "Actions artifact lib",
  "keywords": [
@@ -10,8 +10,8 @@
  ],
  "homepage": "https://github.com/actions/toolkit/tree/main/packages/artifact",
  "license": "MIT",
-  "main": "lib/artifact.js",
-  "types": "lib/artifact.d.ts",
+  "main": "lib/artifact-client.js",
+  "types": "lib/artifact-client.d.ts",
  "directories": {
    "lib": "lib",
    "test": "__tests__"
@@ -31,32 +31,19 @@
  "scripts": {
    "audit-moderate": "npm install && npm audit --json --audit-level=moderate > audit.json",
    "test": "echo \"Error: run tests from root\" && exit 1",
-    "bootstrap": "cd ../../ && npm run bootstrap",
-    "tsc-run": "tsc",
-    "tsc": "npm run bootstrap && npm run tsc-run"
+    "tsc": "tsc"
  },
  "bugs": {
    "url": "https://github.com/actions/toolkit/issues"
  },
  "dependencies": {
-    "@actions/core": "^1.10.0",
-    "@actions/github": "^5.1.1",
-    "@actions/http-client": "^2.1.0",
-    "@azure/storage-blob": "^12.15.0",
-    "@octokit/core": "^3.5.1",
-    "@octokit/plugin-request-log": "^1.0.4",
-    "@octokit/plugin-retry": "^3.0.9",
-    "@octokit/request-error": "^5.0.0",
-    "@protobuf-ts/plugin": "^2.2.3-alpha.1",
-    "@types/unzipper": "^0.10.6",
-    "archiver": "^5.3.1",
-    "crypto": "^1.0.1",
-    "jwt-decode": "^3.1.2",
-    "twirp-ts": "^2.5.0",
-    "unzipper": "^0.10.14"
+    "@actions/core": "^1.2.6",
+    "@actions/http-client": "^1.0.11",
+    "@types/tmp": "^0.1.0",
+    "tmp": "^0.1.0",
+    "tmp-promise": "^2.0.2"
  },
  "devDependencies": {
-    "@types/archiver": "^5.3.2",
-    "typescript": "^5.2.2"
+    "typescript": "^3.8.3"
  }
 }
@@ -0,0 +1,20 @@
+import {UploadOptions} from './internal/upload-options'
+import {UploadResponse} from './internal/upload-response'
+import {DownloadOptions} from './internal/download-options'
+import {DownloadResponse} from './internal/download-response'
+import {ArtifactClient, DefaultArtifactClient} from './internal/artifact-client'
+
+export {
+  ArtifactClient,
+  UploadResponse,
+  UploadOptions,
+  DownloadResponse,
+  DownloadOptions
+}
+
+/**
+ * Constructs an ArtifactClient
+ */
+export function create(): ArtifactClient {
+  return DefaultArtifactClient.create()
+}
@@ -1,11 +0,0 @@
-import {ArtifactClient, Client} from './internal/client'
-
-/**
- * Exported functionality that we want to expose for any users of @actions/artifact
- */
-export * from './internal/shared/interfaces'
-export {ArtifactClient}
-
-export function create(): ArtifactClient {
-  return Client.create()
-}
@@ -1,277 +0,0 @@
-// @generated by protobuf-ts 2.9.1 with parameter long_type_string,client_none,generate_dependencies
-// @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
-// tslint:disable
-//
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import { WireType } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from "@protobuf-ts/runtime";
-import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import type { PartialMessage } from "@protobuf-ts/runtime";
-import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
-import { typeofJsonValue } from "@protobuf-ts/runtime";
-import type { JsonValue } from "@protobuf-ts/runtime";
-import type { JsonReadOptions } from "@protobuf-ts/runtime";
-import type { JsonWriteOptions } from "@protobuf-ts/runtime";
-import { PbLong } from "@protobuf-ts/runtime";
-import { MessageType } from "@protobuf-ts/runtime";
-/**
- * A Timestamp represents a point in time independent of any time zone
- * or calendar, represented as seconds and fractions of seconds at
- * nanosecond resolution in UTC Epoch time. It is encoded using the
- * Proleptic Gregorian Calendar which extends the Gregorian calendar
- * backwards to year one. It is encoded assuming all minutes are 60
- * seconds long, i.e. leap seconds are "smeared" so that no leap second
- * table is needed for interpretation. Range is from
- * 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
- * By restricting to that range, we ensure that we can convert to
- * and from  RFC 3339 date strings.
- * See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
- *
- * # Examples
- *
- * Example 1: Compute Timestamp from POSIX `time()`.
- *
- *     Timestamp timestamp;
- *     timestamp.set_seconds(time(NULL));
- *     timestamp.set_nanos(0);
- *
- * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
- *
- *     struct timeval tv;
- *     gettimeofday(&tv, NULL);
- *
- *     Timestamp timestamp;
- *     timestamp.set_seconds(tv.tv_sec);
- *     timestamp.set_nanos(tv.tv_usec * 1000);
- *
- * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
- *
- *     FILETIME ft;
- *     GetSystemTimeAsFileTime(&ft);
- *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
- *
- *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
- *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
- *     Timestamp timestamp;
- *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
- *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
- *
- * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
- *
- *     long millis = System.currentTimeMillis();
- *
- *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
- *         .setNanos((int) ((millis % 1000) * 1000000)).build();
- *
- *
- * Example 5: Compute Timestamp from current time in Python.
- *
- *     timestamp = Timestamp()
- *     timestamp.GetCurrentTime()
- *
- * # JSON Mapping
- *
- * In JSON format, the Timestamp type is encoded as a string in the
- * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
- * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
- * where {year} is always expressed using four digits while {month}, {day},
- * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
- * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
- * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
- * is required. A proto3 JSON serializer should always use UTC (as indicated by
- * "Z") when printing the Timestamp type and a proto3 JSON parser should be
- * able to accept both UTC and other timezones (as indicated by an offset).
- *
- * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
- * 01:30 UTC on January 15, 2017.
- *
- * In JavaScript, one can convert a Date object to this format using the
- * standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
- * method. In Python, a standard `datetime.datetime` object can be converted
- * to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
- * with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
- * can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
- * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--
- * ) to obtain a formatter capable of generating timestamps in this format.
- *
- *
- *
- * @generated from protobuf message google.protobuf.Timestamp
- */
-export interface Timestamp {
-    /**
-     * Represents seconds of UTC time since Unix epoch
-     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-     * 9999-12-31T23:59:59Z inclusive.
-     *
-     * @generated from protobuf field: int64 seconds = 1;
-     */
-    seconds: string;
-    /**
-     * Non-negative fractions of a second at nanosecond resolution. Negative
-     * second values with fractions must still have non-negative nanos values
-     * that count forward in time. Must be from 0 to 999,999,999
-     * inclusive.
-     *
-     * @generated from protobuf field: int32 nanos = 2;
-     */
-    nanos: number;
-}
-// @generated message type with reflection information, may provide speed optimized methods
-class Timestamp$Type extends MessageType<Timestamp> {
-    constructor() {
-        super("google.protobuf.Timestamp", [
-            { no: 1, name: "seconds", kind: "scalar", T: 3 /*ScalarType.INT64*/ },
-            { no: 2, name: "nanos", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
-        ]);
-    }
-    /**
-     * Creates a new `Timestamp` for the current time.
-     */
-    now(): Timestamp {
-        const msg = this.create();
-        const ms = Date.now();
-        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toString();
-        msg.nanos = (ms % 1000) * 1000000;
-        return msg;
-    }
-    /**
-     * Converts a `Timestamp` to a JavaScript Date.
-     */
-    toDate(message: Timestamp): Date {
-        return new Date(PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1000000));
-    }
-    /**
-     * Converts a JavaScript Date to a `Timestamp`.
-     */
-    fromDate(date: Date): Timestamp {
-        const msg = this.create();
-        const ms = date.getTime();
-        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toString();
-        msg.nanos = (ms % 1000) * 1000000;
-        return msg;
-    }
-    /**
-     * In JSON format, the `Timestamp` type is encoded as a string
-     * in the RFC 3339 format.
-     */
-    internalJsonWrite(message: Timestamp, options: JsonWriteOptions): JsonValue {
-        let ms = PbLong.from(message.seconds).toNumber() * 1000;
-        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
-            throw new Error("Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
-        if (message.nanos < 0)
-            throw new Error("Unable to encode invalid Timestamp to JSON. Nanos must not be negative.");
-        let z = "Z";
-        if (message.nanos > 0) {
-            let nanosStr = (message.nanos + 1000000000).toString().substring(1);
-            if (nanosStr.substring(3) === "000000")
-                z = "." + nanosStr.substring(0, 3) + "Z";
-            else if (nanosStr.substring(6) === "000")
-                z = "." + nanosStr.substring(0, 6) + "Z";
-            else
-                z = "." + nanosStr + "Z";
-        }
-        return new Date(ms).toISOString().replace(".000Z", z);
-    }
-    /**
-     * In JSON format, the `Timestamp` type is encoded as a string
-     * in the RFC 3339 format.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Timestamp): Timestamp {
-        if (typeof json !== "string")
-            throw new Error("Unable to parse Timestamp from JSON " + typeofJsonValue(json) + ".");
-        let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
-        if (!matches)
-            throw new Error("Unable to parse Timestamp from JSON. Invalid format.");
-        let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
-        if (Number.isNaN(ms))
-            throw new Error("Unable to parse Timestamp from JSON. Invalid value.");
-        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
-            throw new globalThis.Error("Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
-        if (!target)
-            target = this.create();
-        target.seconds = PbLong.from(ms / 1000).toString();
-        target.nanos = 0;
-        if (matches[7])
-            target.nanos = (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000);
-        return target;
-    }
-    create(value?: PartialMessage<Timestamp>): Timestamp {
-        const message = { seconds: "0", nanos: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<Timestamp>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Timestamp): Timestamp {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* int64 seconds */ 1:
-                    message.seconds = reader.int64().toString();
-                    break;
-                case /* int32 nanos */ 2:
-                    message.nanos = reader.int32();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: Timestamp, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* int64 seconds = 1; */
-        if (message.seconds !== "0")
-            writer.tag(1, WireType.Varint).int64(message.seconds);
-        /* int32 nanos = 2; */
-        if (message.nanos !== 0)
-            writer.tag(2, WireType.Varint).int32(message.nanos);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.Timestamp
- */
-export const Timestamp = new Timestamp$Type();
@@ -1,748 +0,0 @@
-// @generated by protobuf-ts 2.9.1 with parameter long_type_string,client_none,generate_dependencies
-// @generated from protobuf file "google/protobuf/wrappers.proto" (package "google.protobuf", syntax proto3)
-// tslint:disable
-//
-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-//
-// Wrappers for primitive (non-message) types. These types are useful
-// for embedding primitives in the `google.protobuf.Any` type and for places
-// where we need to distinguish between the absence of a primitive
-// typed field and its default value.
-//
-import { ScalarType } from "@protobuf-ts/runtime";
-import { LongType } from "@protobuf-ts/runtime";
-import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import { WireType } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from "@protobuf-ts/runtime";
-import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import type { PartialMessage } from "@protobuf-ts/runtime";
-import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
-import type { JsonValue } from "@protobuf-ts/runtime";
-import type { JsonReadOptions } from "@protobuf-ts/runtime";
-import type { JsonWriteOptions } from "@protobuf-ts/runtime";
-import { MessageType } from "@protobuf-ts/runtime";
-/**
- * Wrapper message for `double`.
- *
- * The JSON representation for `DoubleValue` is JSON number.
- *
- * @generated from protobuf message google.protobuf.DoubleValue
- */
-export interface DoubleValue {
-    /**
-     * The double value.
-     *
-     * @generated from protobuf field: double value = 1;
-     */
-    value: number;
-}
-/**
- * Wrapper message for `float`.
- *
- * The JSON representation for `FloatValue` is JSON number.
- *
- * @generated from protobuf message google.protobuf.FloatValue
- */
-export interface FloatValue {
-    /**
-     * The float value.
-     *
-     * @generated from protobuf field: float value = 1;
-     */
-    value: number;
-}
-/**
- * Wrapper message for `int64`.
- *
- * The JSON representation for `Int64Value` is JSON string.
- *
- * @generated from protobuf message google.protobuf.Int64Value
- */
-export interface Int64Value {
-    /**
-     * The int64 value.
-     *
-     * @generated from protobuf field: int64 value = 1;
-     */
-    value: string;
-}
-/**
- * Wrapper message for `uint64`.
- *
- * The JSON representation for `UInt64Value` is JSON string.
- *
- * @generated from protobuf message google.protobuf.UInt64Value
- */
-export interface UInt64Value {
-    /**
-     * The uint64 value.
-     *
-     * @generated from protobuf field: uint64 value = 1;
-     */
-    value: string;
-}
-/**
- * Wrapper message for `int32`.
- *
- * The JSON representation for `Int32Value` is JSON number.
- *
- * @generated from protobuf message google.protobuf.Int32Value
- */
-export interface Int32Value {
-    /**
-     * The int32 value.
-     *
-     * @generated from protobuf field: int32 value = 1;
-     */
-    value: number;
-}
-/**
- * Wrapper message for `uint32`.
- *
- * The JSON representation for `UInt32Value` is JSON number.
- *
- * @generated from protobuf message google.protobuf.UInt32Value
- */
-export interface UInt32Value {
-    /**
-     * The uint32 value.
-     *
-     * @generated from protobuf field: uint32 value = 1;
-     */
-    value: number;
-}
-/**
- * Wrapper message for `bool`.
- *
- * The JSON representation for `BoolValue` is JSON `true` and `false`.
- *
- * @generated from protobuf message google.protobuf.BoolValue
- */
-export interface BoolValue {
-    /**
-     * The bool value.
-     *
-     * @generated from protobuf field: bool value = 1;
-     */
-    value: boolean;
-}
-/**
- * Wrapper message for `string`.
- *
- * The JSON representation for `StringValue` is JSON string.
- *
- * @generated from protobuf message google.protobuf.StringValue
- */
-export interface StringValue {
-    /**
-     * The string value.
-     *
-     * @generated from protobuf field: string value = 1;
-     */
-    value: string;
-}
-/**
- * Wrapper message for `bytes`.
- *
- * The JSON representation for `BytesValue` is JSON string.
- *
- * @generated from protobuf message google.protobuf.BytesValue
- */
-export interface BytesValue {
-    /**
-     * The bytes value.
-     *
-     * @generated from protobuf field: bytes value = 1;
-     */
-    value: Uint8Array;
-}
-// @generated message type with reflection information, may provide speed optimized methods
-class DoubleValue$Type extends MessageType<DoubleValue> {
-    constructor() {
-        super("google.protobuf.DoubleValue", [
-            { no: 1, name: "value", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ }
-        ]);
-    }
-    /**
-     * Encode `DoubleValue` to JSON number.
-     */
-    internalJsonWrite(message: DoubleValue, options: JsonWriteOptions): JsonValue {
-        return this.refJsonWriter.scalar(2, message.value, "value", false, true);
-    }
-    /**
-     * Decode `DoubleValue` from JSON number.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: DoubleValue): DoubleValue {
-        if (!target)
-            target = this.create();
-        target.value = this.refJsonReader.scalar(json, 1, undefined, "value") as number;
-        return target;
-    }
-    create(value?: PartialMessage<DoubleValue>): DoubleValue {
-        const message = { value: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<DoubleValue>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DoubleValue): DoubleValue {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* double value */ 1:
-                    message.value = reader.double();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: DoubleValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* double value = 1; */
-        if (message.value !== 0)
-            writer.tag(1, WireType.Bit64).double(message.value);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.DoubleValue
- */
-export const DoubleValue = new DoubleValue$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class FloatValue$Type extends MessageType<FloatValue> {
-    constructor() {
-        super("google.protobuf.FloatValue", [
-            { no: 1, name: "value", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
-        ]);
-    }
-    /**
-     * Encode `FloatValue` to JSON number.
-     */
-    internalJsonWrite(message: FloatValue, options: JsonWriteOptions): JsonValue {
-        return this.refJsonWriter.scalar(1, message.value, "value", false, true);
-    }
-    /**
-     * Decode `FloatValue` from JSON number.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: FloatValue): FloatValue {
-        if (!target)
-            target = this.create();
-        target.value = this.refJsonReader.scalar(json, 1, undefined, "value") as number;
-        return target;
-    }
-    create(value?: PartialMessage<FloatValue>): FloatValue {
-        const message = { value: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<FloatValue>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FloatValue): FloatValue {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* float value */ 1:
-                    message.value = reader.float();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: FloatValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* float value = 1; */
-        if (message.value !== 0)
-            writer.tag(1, WireType.Bit32).float(message.value);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.FloatValue
- */
-export const FloatValue = new FloatValue$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class Int64Value$Type extends MessageType<Int64Value> {
-    constructor() {
-        super("google.protobuf.Int64Value", [
-            { no: 1, name: "value", kind: "scalar", T: 3 /*ScalarType.INT64*/ }
-        ]);
-    }
-    /**
-     * Encode `Int64Value` to JSON string.
-     */
-    internalJsonWrite(message: Int64Value, options: JsonWriteOptions): JsonValue {
-        return this.refJsonWriter.scalar(ScalarType.INT64, message.value, "value", false, true);
-    }
-    /**
-     * Decode `Int64Value` from JSON string.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Int64Value): Int64Value {
-        if (!target)
-            target = this.create();
-        target.value = this.refJsonReader.scalar(json, ScalarType.INT64, LongType.STRING, "value") as any;
-        return target;
-    }
-    create(value?: PartialMessage<Int64Value>): Int64Value {
-        const message = { value: "0" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<Int64Value>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Int64Value): Int64Value {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* int64 value */ 1:
-                    message.value = reader.int64().toString();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: Int64Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* int64 value = 1; */
-        if (message.value !== "0")
-            writer.tag(1, WireType.Varint).int64(message.value);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.Int64Value
- */
-export const Int64Value = new Int64Value$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class UInt64Value$Type extends MessageType<UInt64Value> {
-    constructor() {
-        super("google.protobuf.UInt64Value", [
-            { no: 1, name: "value", kind: "scalar", T: 4 /*ScalarType.UINT64*/ }
-        ]);
-    }
-    /**
-     * Encode `UInt64Value` to JSON string.
-     */
-    internalJsonWrite(message: UInt64Value, options: JsonWriteOptions): JsonValue {
-        return this.refJsonWriter.scalar(ScalarType.UINT64, message.value, "value", false, true);
-    }
-    /**
-     * Decode `UInt64Value` from JSON string.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: UInt64Value): UInt64Value {
-        if (!target)
-            target = this.create();
-        target.value = this.refJsonReader.scalar(json, ScalarType.UINT64, LongType.STRING, "value") as any;
-        return target;
-    }
-    create(value?: PartialMessage<UInt64Value>): UInt64Value {
-        const message = { value: "0" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<UInt64Value>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UInt64Value): UInt64Value {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* uint64 value */ 1:
-                    message.value = reader.uint64().toString();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: UInt64Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* uint64 value = 1; */
-        if (message.value !== "0")
-            writer.tag(1, WireType.Varint).uint64(message.value);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.UInt64Value
- */
-export const UInt64Value = new UInt64Value$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class Int32Value$Type extends MessageType<Int32Value> {
-    constructor() {
-        super("google.protobuf.Int32Value", [
-            { no: 1, name: "value", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
-        ]);
-    }
-    /**
-     * Encode `Int32Value` to JSON string.
-     */
-    internalJsonWrite(message: Int32Value, options: JsonWriteOptions): JsonValue {
-        return this.refJsonWriter.scalar(5, message.value, "value", false, true);
-    }
-    /**
-     * Decode `Int32Value` from JSON string.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Int32Value): Int32Value {
-        if (!target)
-            target = this.create();
-        target.value = this.refJsonReader.scalar(json, 5, undefined, "value") as number;
-        return target;
-    }
-    create(value?: PartialMessage<Int32Value>): Int32Value {
-        const message = { value: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<Int32Value>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Int32Value): Int32Value {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* int32 value */ 1:
-                    message.value = reader.int32();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: Int32Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* int32 value = 1; */
-        if (message.value !== 0)
-            writer.tag(1, WireType.Varint).int32(message.value);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.Int32Value
- */
-export const Int32Value = new Int32Value$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class UInt32Value$Type extends MessageType<UInt32Value> {
-    constructor() {
-        super("google.protobuf.UInt32Value", [
-            { no: 1, name: "value", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
-        ]);
-    }
-    /**
-     * Encode `UInt32Value` to JSON string.
-     */
-    internalJsonWrite(message: UInt32Value, options: JsonWriteOptions): JsonValue {
-        return this.refJsonWriter.scalar(13, message.value, "value", false, true);
-    }
-    /**
-     * Decode `UInt32Value` from JSON string.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: UInt32Value): UInt32Value {
-        if (!target)
-            target = this.create();
-        target.value = this.refJsonReader.scalar(json, 13, undefined, "value") as number;
-        return target;
-    }
-    create(value?: PartialMessage<UInt32Value>): UInt32Value {
-        const message = { value: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<UInt32Value>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UInt32Value): UInt32Value {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* uint32 value */ 1:
-                    message.value = reader.uint32();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: UInt32Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* uint32 value = 1; */
-        if (message.value !== 0)
-            writer.tag(1, WireType.Varint).uint32(message.value);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.UInt32Value
- */
-export const UInt32Value = new UInt32Value$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class BoolValue$Type extends MessageType<BoolValue> {
-    constructor() {
-        super("google.protobuf.BoolValue", [
-            { no: 1, name: "value", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
-        ]);
-    }
-    /**
-     * Encode `BoolValue` to JSON bool.
-     */
-    internalJsonWrite(message: BoolValue, options: JsonWriteOptions): JsonValue {
-        return message.value;
-    }
-    /**
-     * Decode `BoolValue` from JSON bool.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: BoolValue): BoolValue {
-        if (!target)
-            target = this.create();
-        target.value = this.refJsonReader.scalar(json, 8, undefined, "value") as boolean;
-        return target;
-    }
-    create(value?: PartialMessage<BoolValue>): BoolValue {
-        const message = { value: false };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<BoolValue>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BoolValue): BoolValue {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* bool value */ 1:
-                    message.value = reader.bool();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: BoolValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* bool value = 1; */
-        if (message.value !== false)
-            writer.tag(1, WireType.Varint).bool(message.value);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.BoolValue
- */
-export const BoolValue = new BoolValue$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class StringValue$Type extends MessageType<StringValue> {
-    constructor() {
-        super("google.protobuf.StringValue", [
-            { no: 1, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
-        ]);
-    }
-    /**
-     * Encode `StringValue` to JSON string.
-     */
-    internalJsonWrite(message: StringValue, options: JsonWriteOptions): JsonValue {
-        return message.value;
-    }
-    /**
-     * Decode `StringValue` from JSON string.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: StringValue): StringValue {
-        if (!target)
-            target = this.create();
-        target.value = this.refJsonReader.scalar(json, 9, undefined, "value") as string;
-        return target;
-    }
-    create(value?: PartialMessage<StringValue>): StringValue {
-        const message = { value: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<StringValue>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StringValue): StringValue {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* string value */ 1:
-                    message.value = reader.string();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: StringValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* string value = 1; */
-        if (message.value !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.value);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.StringValue
- */
-export const StringValue = new StringValue$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class BytesValue$Type extends MessageType<BytesValue> {
-    constructor() {
-        super("google.protobuf.BytesValue", [
-            { no: 1, name: "value", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
-        ]);
-    }
-    /**
-     * Encode `BytesValue` to JSON string.
-     */
-    internalJsonWrite(message: BytesValue, options: JsonWriteOptions): JsonValue {
-        return this.refJsonWriter.scalar(12, message.value, "value", false, true);
-    }
-    /**
-     * Decode `BytesValue` from JSON string.
-     */
-    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: BytesValue): BytesValue {
-        if (!target)
-            target = this.create();
-        target.value = this.refJsonReader.scalar(json, 12, undefined, "value") as Uint8Array;
-        return target;
-    }
-    create(value?: PartialMessage<BytesValue>): BytesValue {
-        const message = { value: new Uint8Array(0) };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<BytesValue>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BytesValue): BytesValue {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* bytes value */ 1:
-                    message.value = reader.bytes();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: BytesValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* bytes value = 1; */
-        if (message.value.length)
-            writer.tag(1, WireType.LengthDelimited).bytes(message.value);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message google.protobuf.BytesValue
- */
-export const BytesValue = new BytesValue$Type();
@@ -1,4 +0,0 @@
-export * from './google/protobuf/timestamp'
-export * from './google/protobuf/wrappers'
-export * from './results/api/v1/artifact'
-export * from './results/api/v1/artifact.twirp'
@@ -1,357 +0,0 @@
-// @generated by protobuf-ts 2.9.1 with parameter long_type_string,client_none,generate_dependencies
-// @generated from protobuf file "results/api/v1/artifact.proto" (package "github.actions.results.api.v1", syntax proto3)
-// tslint:disable
-import { ServiceType } from "@protobuf-ts/runtime-rpc";
-import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import { WireType } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from "@protobuf-ts/runtime";
-import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import type { PartialMessage } from "@protobuf-ts/runtime";
-import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
-import { MessageType } from "@protobuf-ts/runtime";
-import { StringValue } from "../../../google/protobuf/wrappers";
-import { Timestamp } from "../../../google/protobuf/timestamp";
-/**
- * @generated from protobuf message github.actions.results.api.v1.CreateArtifactRequest
- */
-export interface CreateArtifactRequest {
-    /**
-     * @generated from protobuf field: string workflow_run_backend_id = 1;
-     */
-    workflowRunBackendId: string;
-    /**
-     * @generated from protobuf field: string workflow_job_run_backend_id = 2;
-     */
-    workflowJobRunBackendId: string;
-    /**
-     * @generated from protobuf field: string name = 3;
-     */
-    name: string;
-    /**
-     * @generated from protobuf field: google.protobuf.Timestamp expires_at = 4;
-     */
-    expiresAt?: Timestamp;
-    /**
-     * @generated from protobuf field: int32 version = 5;
-     */
-    version: number;
-}
-/**
- * @generated from protobuf message github.actions.results.api.v1.CreateArtifactResponse
- */
-export interface CreateArtifactResponse {
-    /**
-     * @generated from protobuf field: bool ok = 1;
-     */
-    ok: boolean;
-    /**
-     * @generated from protobuf field: string signed_upload_url = 2;
-     */
-    signedUploadUrl: string;
-}
-/**
- * @generated from protobuf message github.actions.results.api.v1.FinalizeArtifactRequest
- */
-export interface FinalizeArtifactRequest {
-    /**
-     * @generated from protobuf field: string workflow_run_backend_id = 1;
-     */
-    workflowRunBackendId: string;
-    /**
-     * @generated from protobuf field: string workflow_job_run_backend_id = 2;
-     */
-    workflowJobRunBackendId: string;
-    /**
-     * @generated from protobuf field: string name = 3;
-     */
-    name: string;
-    /**
-     * @generated from protobuf field: int64 size = 4;
-     */
-    size: string;
-    /**
-     * @generated from protobuf field: google.protobuf.StringValue hash = 5;
-     */
-    hash?: StringValue; // optional
-}
-/**
- * @generated from protobuf message github.actions.results.api.v1.FinalizeArtifactResponse
- */
-export interface FinalizeArtifactResponse {
-    /**
-     * @generated from protobuf field: bool ok = 1;
-     */
-    ok: boolean;
-    /**
-     * @generated from protobuf field: int64 artifact_id = 2;
-     */
-    artifactId: string;
-}
-// @generated message type with reflection information, may provide speed optimized methods
-class CreateArtifactRequest$Type extends MessageType<CreateArtifactRequest> {
-    constructor() {
-        super("github.actions.results.api.v1.CreateArtifactRequest", [
-            { no: 1, name: "workflow_run_backend_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 2, name: "workflow_job_run_backend_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 3, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 4, name: "expires_at", kind: "message", T: () => Timestamp },
-            { no: 5, name: "version", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
-        ]);
-    }
-    create(value?: PartialMessage<CreateArtifactRequest>): CreateArtifactRequest {
-        const message = { workflowRunBackendId: "", workflowJobRunBackendId: "", name: "", version: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<CreateArtifactRequest>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CreateArtifactRequest): CreateArtifactRequest {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* string workflow_run_backend_id */ 1:
-                    message.workflowRunBackendId = reader.string();
-                    break;
-                case /* string workflow_job_run_backend_id */ 2:
-                    message.workflowJobRunBackendId = reader.string();
-                    break;
-                case /* string name */ 3:
-                    message.name = reader.string();
-                    break;
-                case /* google.protobuf.Timestamp expires_at */ 4:
-                    message.expiresAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.expiresAt);
-                    break;
-                case /* int32 version */ 5:
-                    message.version = reader.int32();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: CreateArtifactRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* string workflow_run_backend_id = 1; */
-        if (message.workflowRunBackendId !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.workflowRunBackendId);
-        /* string workflow_job_run_backend_id = 2; */
-        if (message.workflowJobRunBackendId !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.workflowJobRunBackendId);
-        /* string name = 3; */
-        if (message.name !== "")
-            writer.tag(3, WireType.LengthDelimited).string(message.name);
-        /* google.protobuf.Timestamp expires_at = 4; */
-        if (message.expiresAt)
-            Timestamp.internalBinaryWrite(message.expiresAt, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
-        /* int32 version = 5; */
-        if (message.version !== 0)
-            writer.tag(5, WireType.Varint).int32(message.version);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message github.actions.results.api.v1.CreateArtifactRequest
- */
-export const CreateArtifactRequest = new CreateArtifactRequest$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class CreateArtifactResponse$Type extends MessageType<CreateArtifactResponse> {
-    constructor() {
-        super("github.actions.results.api.v1.CreateArtifactResponse", [
-            { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
-            { no: 2, name: "signed_upload_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
-        ]);
-    }
-    create(value?: PartialMessage<CreateArtifactResponse>): CreateArtifactResponse {
-        const message = { ok: false, signedUploadUrl: "" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<CreateArtifactResponse>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CreateArtifactResponse): CreateArtifactResponse {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* bool ok */ 1:
-                    message.ok = reader.bool();
-                    break;
-                case /* string signed_upload_url */ 2:
-                    message.signedUploadUrl = reader.string();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: CreateArtifactResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* bool ok = 1; */
-        if (message.ok !== false)
-            writer.tag(1, WireType.Varint).bool(message.ok);
-        /* string signed_upload_url = 2; */
-        if (message.signedUploadUrl !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.signedUploadUrl);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message github.actions.results.api.v1.CreateArtifactResponse
- */
-export const CreateArtifactResponse = new CreateArtifactResponse$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class FinalizeArtifactRequest$Type extends MessageType<FinalizeArtifactRequest> {
-    constructor() {
-        super("github.actions.results.api.v1.FinalizeArtifactRequest", [
-            { no: 1, name: "workflow_run_backend_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 2, name: "workflow_job_run_backend_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 3, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 4, name: "size", kind: "scalar", T: 3 /*ScalarType.INT64*/ },
-            { no: 5, name: "hash", kind: "message", T: () => StringValue }
-        ]);
-    }
-    create(value?: PartialMessage<FinalizeArtifactRequest>): FinalizeArtifactRequest {
-        const message = { workflowRunBackendId: "", workflowJobRunBackendId: "", name: "", size: "0" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<FinalizeArtifactRequest>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FinalizeArtifactRequest): FinalizeArtifactRequest {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* string workflow_run_backend_id */ 1:
-                    message.workflowRunBackendId = reader.string();
-                    break;
-                case /* string workflow_job_run_backend_id */ 2:
-                    message.workflowJobRunBackendId = reader.string();
-                    break;
-                case /* string name */ 3:
-                    message.name = reader.string();
-                    break;
-                case /* int64 size */ 4:
-                    message.size = reader.int64().toString();
-                    break;
-                case /* google.protobuf.StringValue hash */ 5:
-                    message.hash = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.hash);
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: FinalizeArtifactRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* string workflow_run_backend_id = 1; */
-        if (message.workflowRunBackendId !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.workflowRunBackendId);
-        /* string workflow_job_run_backend_id = 2; */
-        if (message.workflowJobRunBackendId !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.workflowJobRunBackendId);
-        /* string name = 3; */
-        if (message.name !== "")
-            writer.tag(3, WireType.LengthDelimited).string(message.name);
-        /* int64 size = 4; */
-        if (message.size !== "0")
-            writer.tag(4, WireType.Varint).int64(message.size);
-        /* google.protobuf.StringValue hash = 5; */
-        if (message.hash)
-            StringValue.internalBinaryWrite(message.hash, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message github.actions.results.api.v1.FinalizeArtifactRequest
- */
-export const FinalizeArtifactRequest = new FinalizeArtifactRequest$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class FinalizeArtifactResponse$Type extends MessageType<FinalizeArtifactResponse> {
-    constructor() {
-        super("github.actions.results.api.v1.FinalizeArtifactResponse", [
-            { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
-            { no: 2, name: "artifact_id", kind: "scalar", T: 3 /*ScalarType.INT64*/ }
-        ]);
-    }
-    create(value?: PartialMessage<FinalizeArtifactResponse>): FinalizeArtifactResponse {
-        const message = { ok: false, artifactId: "0" };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
-        if (value !== undefined)
-            reflectionMergePartial<FinalizeArtifactResponse>(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FinalizeArtifactResponse): FinalizeArtifactResponse {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* bool ok */ 1:
-                    message.ok = reader.bool();
-                    break;
-                case /* int64 artifact_id */ 2:
-                    message.artifactId = reader.int64().toString();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message: FinalizeArtifactResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* bool ok = 1; */
-        if (message.ok !== false)
-            writer.tag(1, WireType.Varint).bool(message.ok);
-        /* int64 artifact_id = 2; */
-        if (message.artifactId !== "0")
-            writer.tag(2, WireType.Varint).int64(message.artifactId);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message github.actions.results.api.v1.FinalizeArtifactResponse
- */
-export const FinalizeArtifactResponse = new FinalizeArtifactResponse$Type();
-/**
- * @generated ServiceType for protobuf service github.actions.results.api.v1.ArtifactService
- */
-export const ArtifactService = new ServiceType("github.actions.results.api.v1.ArtifactService", [
-    { name: "CreateArtifact", options: {}, I: CreateArtifactRequest, O: CreateArtifactResponse },
-    { name: "FinalizeArtifact", options: {}, I: FinalizeArtifactRequest, O: FinalizeArtifactResponse }
-]);
@@ -1,437 +0,0 @@
-import {
-  TwirpContext,
-  TwirpServer,
-  RouterEvents,
-  TwirpError,
-  TwirpErrorCode,
-  Interceptor,
-  TwirpContentType,
-  chainInterceptors
-} from 'twirp-ts'
-import {
-  CreateArtifactRequest,
-  CreateArtifactResponse,
-  FinalizeArtifactRequest,
-  FinalizeArtifactResponse
-} from './artifact'
-
-//==================================//
-//          Client Code             //
-//==================================//
-
-interface Rpc {
-  request(
-    service: string,
-    method: string,
-    contentType: 'application/json' | 'application/protobuf',
-    data: object | Uint8Array
-  ): Promise<object | Uint8Array>
-}
-
-export interface ArtifactServiceClient {
-  CreateArtifact(
-    request: CreateArtifactRequest
-  ): Promise<CreateArtifactResponse>
-  FinalizeArtifact(
-    request: FinalizeArtifactRequest
-  ): Promise<FinalizeArtifactResponse>
-}
-
-export class ArtifactServiceClientJSON implements ArtifactServiceClient {
-  private readonly rpc: Rpc
-  constructor(rpc: Rpc) {
-    this.rpc = rpc
-    this.CreateArtifact.bind(this)
-    this.FinalizeArtifact.bind(this)
-  }
-  CreateArtifact(
-    request: CreateArtifactRequest
-  ): Promise<CreateArtifactResponse> {
-    const data = CreateArtifactRequest.toJson(request, {
-      useProtoFieldName: true,
-      emitDefaultValues: false
-    })
-    const promise = this.rpc.request(
-      'github.actions.results.api.v1.ArtifactService',
-      'CreateArtifact',
-      'application/json',
-      data as object
-    )
-    return promise.then(data =>
-      CreateArtifactResponse.fromJson(data as any, {ignoreUnknownFields: true})
-    )
-  }
-
-  FinalizeArtifact(
-    request: FinalizeArtifactRequest
-  ): Promise<FinalizeArtifactResponse> {
-    const data = FinalizeArtifactRequest.toJson(request, {
-      useProtoFieldName: true,
-      emitDefaultValues: false
-    })
-    const promise = this.rpc.request(
-      'github.actions.results.api.v1.ArtifactService',
-      'FinalizeArtifact',
-      'application/json',
-      data as object
-    )
-    return promise.then(data =>
-      FinalizeArtifactResponse.fromJson(data as any, {
-        ignoreUnknownFields: true
-      })
-    )
-  }
-}
-
-export class ArtifactServiceClientProtobuf implements ArtifactServiceClient {
-  private readonly rpc: Rpc
-  constructor(rpc: Rpc) {
-    this.rpc = rpc
-    this.CreateArtifact.bind(this)
-    this.FinalizeArtifact.bind(this)
-  }
-  CreateArtifact(
-    request: CreateArtifactRequest
-  ): Promise<CreateArtifactResponse> {
-    const data = CreateArtifactRequest.toBinary(request)
-    const promise = this.rpc.request(
-      'github.actions.results.api.v1.ArtifactService',
-      'CreateArtifact',
-      'application/protobuf',
-      data
-    )
-    return promise.then(data =>
-      CreateArtifactResponse.fromBinary(data as Uint8Array)
-    )
-  }
-
-  FinalizeArtifact(
-    request: FinalizeArtifactRequest
-  ): Promise<FinalizeArtifactResponse> {
-    const data = FinalizeArtifactRequest.toBinary(request)
-    const promise = this.rpc.request(
-      'github.actions.results.api.v1.ArtifactService',
-      'FinalizeArtifact',
-      'application/protobuf',
-      data
-    )
-    return promise.then(data =>
-      FinalizeArtifactResponse.fromBinary(data as Uint8Array)
-    )
-  }
-}
-
-//==================================//
-//          Server Code             //
-//==================================//
-
-export interface ArtifactServiceTwirp<T extends TwirpContext = TwirpContext> {
-  CreateArtifact(
-    ctx: T,
-    request: CreateArtifactRequest
-  ): Promise<CreateArtifactResponse>
-  FinalizeArtifact(
-    ctx: T,
-    request: FinalizeArtifactRequest
-  ): Promise<FinalizeArtifactResponse>
-}
-
-export enum ArtifactServiceMethod {
-  CreateArtifact = 'CreateArtifact',
-  FinalizeArtifact = 'FinalizeArtifact'
-}
-
-export const ArtifactServiceMethodList = [
-  ArtifactServiceMethod.CreateArtifact,
-  ArtifactServiceMethod.FinalizeArtifact
-]
-
-export function createArtifactServiceServer<
-  T extends TwirpContext = TwirpContext
->(service: ArtifactServiceTwirp<T>) {
-  return new TwirpServer<ArtifactServiceTwirp, T>({
-    service,
-    packageName: 'github.actions.results.api.v1',
-    serviceName: 'ArtifactService',
-    methodList: ArtifactServiceMethodList,
-    matchRoute: matchArtifactServiceRoute
-  })
-}
-
-function matchArtifactServiceRoute<T extends TwirpContext = TwirpContext>(
-  method: string,
-  events: RouterEvents<T>
-) {
-  switch (method) {
-    case 'CreateArtifact':
-      return async (
-        ctx: T,
-        service: ArtifactServiceTwirp,
-        data: Buffer,
-        interceptors?: Interceptor<
-          T,
-          CreateArtifactRequest,
-          CreateArtifactResponse
-        >[]
-      ) => {
-        ctx = {...ctx, methodName: 'CreateArtifact'}
-        await events.onMatch(ctx)
-        return handleArtifactServiceCreateArtifactRequest(
-          ctx,
-          service,
-          data,
-          interceptors
-        )
-      }
-    case 'FinalizeArtifact':
-      return async (
-        ctx: T,
-        service: ArtifactServiceTwirp,
-        data: Buffer,
-        interceptors?: Interceptor<
-          T,
-          FinalizeArtifactRequest,
-          FinalizeArtifactResponse
-        >[]
-      ) => {
-        ctx = {...ctx, methodName: 'FinalizeArtifact'}
-        await events.onMatch(ctx)
-        return handleArtifactServiceFinalizeArtifactRequest(
-          ctx,
-          service,
-          data,
-          interceptors
-        )
-      }
-    default:
-      events.onNotFound()
-      const msg = `no handler found`
-      throw new TwirpError(TwirpErrorCode.BadRoute, msg)
-  }
-}
-
-function handleArtifactServiceCreateArtifactRequest<
-  T extends TwirpContext = TwirpContext
->(
-  ctx: T,
-  service: ArtifactServiceTwirp,
-  data: Buffer,
-  interceptors?: Interceptor<T, CreateArtifactRequest, CreateArtifactResponse>[]
-): Promise<string | Uint8Array> {
-  switch (ctx.contentType) {
-    case TwirpContentType.JSON:
-      return handleArtifactServiceCreateArtifactJSON<T>(
-        ctx,
-        service,
-        data,
-        interceptors
-      )
-    case TwirpContentType.Protobuf:
-      return handleArtifactServiceCreateArtifactProtobuf<T>(
-        ctx,
-        service,
-        data,
-        interceptors
-      )
-    default:
-      const msg = 'unexpected Content-Type'
-      throw new TwirpError(TwirpErrorCode.BadRoute, msg)
-  }
-}
-
-function handleArtifactServiceFinalizeArtifactRequest<
-  T extends TwirpContext = TwirpContext
->(
-  ctx: T,
-  service: ArtifactServiceTwirp,
-  data: Buffer,
-  interceptors?: Interceptor<
-    T,
-    FinalizeArtifactRequest,
-    FinalizeArtifactResponse
-  >[]
-): Promise<string | Uint8Array> {
-  switch (ctx.contentType) {
-    case TwirpContentType.JSON:
-      return handleArtifactServiceFinalizeArtifactJSON<T>(
-        ctx,
-        service,
-        data,
-        interceptors
-      )
-    case TwirpContentType.Protobuf:
-      return handleArtifactServiceFinalizeArtifactProtobuf<T>(
-        ctx,
-        service,
-        data,
-        interceptors
-      )
-    default:
-      const msg = 'unexpected Content-Type'
-      throw new TwirpError(TwirpErrorCode.BadRoute, msg)
-  }
-}
-async function handleArtifactServiceCreateArtifactJSON<
-  T extends TwirpContext = TwirpContext
->(
-  ctx: T,
-  service: ArtifactServiceTwirp,
-  data: Buffer,
-  interceptors?: Interceptor<T, CreateArtifactRequest, CreateArtifactResponse>[]
-) {
-  let request: CreateArtifactRequest
-  let response: CreateArtifactResponse
-
-  try {
-    const body = JSON.parse(data.toString() || '{}')
-    request = CreateArtifactRequest.fromJson(body, {ignoreUnknownFields: true})
-  } catch (e) {
-    if (e instanceof Error) {
-      const msg = 'the json request could not be decoded'
-      throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true)
-    }
-  }
-
-  if (interceptors && interceptors.length > 0) {
-    const interceptor = chainInterceptors(...interceptors) as Interceptor<
-      T,
-      CreateArtifactRequest,
-      CreateArtifactResponse
-    >
-    response = await interceptor(ctx, request!, (ctx, inputReq) => {
-      return service.CreateArtifact(ctx, inputReq)
-    })
-  } else {
-    response = await service.CreateArtifact(ctx, request!)
-  }
-
-  return JSON.stringify(
-    CreateArtifactResponse.toJson(response, {
-      useProtoFieldName: true,
-      emitDefaultValues: false
-    }) as string
-  )
-}
-
-async function handleArtifactServiceFinalizeArtifactJSON<
-  T extends TwirpContext = TwirpContext
->(
-  ctx: T,
-  service: ArtifactServiceTwirp,
-  data: Buffer,
-  interceptors?: Interceptor<
-    T,
-    FinalizeArtifactRequest,
-    FinalizeArtifactResponse
-  >[]
-) {
-  let request: FinalizeArtifactRequest
-  let response: FinalizeArtifactResponse
-
-  try {
-    const body = JSON.parse(data.toString() || '{}')
-    request = FinalizeArtifactRequest.fromJson(body, {
-      ignoreUnknownFields: true
-    })
-  } catch (e) {
-    if (e instanceof Error) {
-      const msg = 'the json request could not be decoded'
-      throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true)
-    }
-  }
-
-  if (interceptors && interceptors.length > 0) {
-    const interceptor = chainInterceptors(...interceptors) as Interceptor<
-      T,
-      FinalizeArtifactRequest,
-      FinalizeArtifactResponse
-    >
-    response = await interceptor(ctx, request!, (ctx, inputReq) => {
-      return service.FinalizeArtifact(ctx, inputReq)
-    })
-  } else {
-    response = await service.FinalizeArtifact(ctx, request!)
-  }
-
-  return JSON.stringify(
-    FinalizeArtifactResponse.toJson(response, {
-      useProtoFieldName: true,
-      emitDefaultValues: false
-    }) as string
-  )
-}
-async function handleArtifactServiceCreateArtifactProtobuf<
-  T extends TwirpContext = TwirpContext
->(
-  ctx: T,
-  service: ArtifactServiceTwirp,
-  data: Buffer,
-  interceptors?: Interceptor<T, CreateArtifactRequest, CreateArtifactResponse>[]
-) {
-  let request: CreateArtifactRequest
-  let response: CreateArtifactResponse
-
-  try {
-    request = CreateArtifactRequest.fromBinary(data)
-  } catch (e) {
-    if (e instanceof Error) {
-      const msg = 'the protobuf request could not be decoded'
-      throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true)
-    }
-  }
-
-  if (interceptors && interceptors.length > 0) {
-    const interceptor = chainInterceptors(...interceptors) as Interceptor<
-      T,
-      CreateArtifactRequest,
-      CreateArtifactResponse
-    >
-    response = await interceptor(ctx, request!, (ctx, inputReq) => {
-      return service.CreateArtifact(ctx, inputReq)
-    })
-  } else {
-    response = await service.CreateArtifact(ctx, request!)
-  }
-
-  return Buffer.from(CreateArtifactResponse.toBinary(response))
-}
-
-async function handleArtifactServiceFinalizeArtifactProtobuf<
-  T extends TwirpContext = TwirpContext
->(
-  ctx: T,
-  service: ArtifactServiceTwirp,
-  data: Buffer,
-  interceptors?: Interceptor<
-    T,
-    FinalizeArtifactRequest,
-    FinalizeArtifactResponse
-  >[]
-) {
-  let request: FinalizeArtifactRequest
-  let response: FinalizeArtifactResponse
-
-  try {
-    request = FinalizeArtifactRequest.fromBinary(data)
-  } catch (e) {
-    if (e instanceof Error) {
-      const msg = 'the protobuf request could not be decoded'
-      throw new TwirpError(TwirpErrorCode.Malformed, msg).withCause(e, true)
-    }
-  }
-
-  if (interceptors && interceptors.length > 0) {
-    const interceptor = chainInterceptors(...interceptors) as Interceptor<
-      T,
-      FinalizeArtifactRequest,
-      FinalizeArtifactResponse
-    >
-    response = await interceptor(ctx, request!, (ctx, inputReq) => {
-      return service.FinalizeArtifact(ctx, inputReq)
-    })
-  } else {
-    response = await service.FinalizeArtifact(ctx, request!)
-  }
-
-  return Buffer.from(FinalizeArtifactResponse.toBinary(response))
-}
@@ -0,0 +1,51 @@
+/**
+ *  Mocks default limits for easier testing
+ */
+export function getUploadFileConcurrency(): number {
+  return 1
+}
+
+export function getUploadChunkConcurrency(): number {
+  return 1
+}
+
+export function getUploadChunkSize(): number {
+  return 4 * 1024 * 1024 // 4 MB Chunks
+}
+
+export function getRetryLimit(): number {
+  return 2
+}
+
+export function getRetryMultiplier(): number {
+  return 1.5
+}
+
+export function getInitialRetryIntervalInMilliseconds(): number {
+  return 10
+}
+
+export function getDownloadFileConcurrency(): number {
+  return 1
+}
+
+/**
+ * Mocks the 'ACTIONS_RUNTIME_TOKEN', 'ACTIONS_RUNTIME_URL' and 'GITHUB_RUN_ID' env variables
+ * that are only available from a node context on the runner. This allows for tests to run
+ * locally without the env variables actually being set
+ */
+export function getRuntimeToken(): string {
+  return 'totally-valid-token'
+}
+
+export function getRuntimeUrl(): string {
+  return 'https://www.example.com/'
+}
+
+export function getWorkFlowRunId(): string {
+  return '15'
+}
+
+export function getRetentionDays(): string | undefined {
+  return '45'
+}
@@ -0,0 +1,254 @@
+import * as core from '@actions/core'
+import {
+  UploadSpecification,
+  getUploadSpecification
+} from './upload-specification'
+import {UploadHttpClient} from './upload-http-client'
+import {UploadResponse} from './upload-response'
+import {UploadOptions} from './upload-options'
+import {DownloadOptions} from './download-options'
+import {DownloadResponse} from './download-response'
+import {
+  checkArtifactName,
+  createDirectoriesForArtifact,
+  createEmptyFilesForArtifact
+} from './utils'
+import {DownloadHttpClient} from './download-http-client'
+import {getDownloadSpecification} from './download-specification'
+import {getWorkSpaceDirectory} from './config-variables'
+import {normalize, resolve} from 'path'
+
+export interface ArtifactClient {
+  /**
+   * Uploads an artifact
+   *
+   * @param name the name of the artifact, required
+   * @param files a list of absolute or relative paths that denote what files should be uploaded
+   * @param rootDirectory an absolute or relative file path that denotes the root parent directory of the files being uploaded
+   * @param options extra options for customizing the upload behavior
+   * @returns single UploadInfo object
+   */
+  uploadArtifact(
+    name: string,
+    files: string[],
+    rootDirectory: string,
+    options?: UploadOptions
+  ): Promise<UploadResponse>
+
+  /**
+   * Downloads a single artifact associated with a run
+   *
+   * @param name the name of the artifact being downloaded
+   * @param path optional path that denotes where the artifact will be downloaded to
+   * @param options extra options that allow for the customization of the download behavior
+   */
+  downloadArtifact(
+    name: string,
+    path?: string,
+    options?: DownloadOptions
+  ): Promise<DownloadResponse>
+
+  /**
+   * Downloads all artifacts associated with a run. Because there are multiple artifacts being downloaded, a folder will be created for each one in the specified or default directory
+   * @param path optional path that denotes where the artifacts will be downloaded to
+   */
+  downloadAllArtifacts(path?: string): Promise<DownloadResponse[]>
+}
+
+export class DefaultArtifactClient implements ArtifactClient {
+  /**
+   * Constructs a DefaultArtifactClient
+   */
+  static create(): DefaultArtifactClient {
+    return new DefaultArtifactClient()
+  }
+
+  /**
+   * Uploads an artifact
+   */
+  async uploadArtifact(
+    name: string,
+    files: string[],
+    rootDirectory: string,
+    options?: UploadOptions | undefined
+  ): Promise<UploadResponse> {
+    checkArtifactName(name)
+
+    // Get specification for the files being uploaded
+    const uploadSpecification: UploadSpecification[] = getUploadSpecification(
+      name,
+      rootDirectory,
+      files
+    )
+    const uploadResponse: UploadResponse = {
+      artifactName: name,
+      artifactItems: [],
+      size: 0,
+      failedItems: []
+    }
+
+    const uploadHttpClient = new UploadHttpClient()
+
+    if (uploadSpecification.length === 0) {
+      core.warning(`No files found that can be uploaded`)
+    } else {
+      // Create an entry for the artifact in the file container
+      const response = await uploadHttpClient.createArtifactInFileContainer(
+        name,
+        options
+      )
+      if (!response.fileContainerResourceUrl) {
+        core.debug(response.toString())
+        throw new Error(
+          'No URL provided by the Artifact Service to upload an artifact to'
+        )
+      }
+      core.debug(`Upload Resource URL: ${response.fileContainerResourceUrl}`)
+
+      // Upload each of the files that were found concurrently
+      const uploadResult = await uploadHttpClient.uploadArtifactToFileContainer(
+        response.fileContainerResourceUrl,
+        uploadSpecification,
+        options
+      )
+
+      // Update the size of the artifact to indicate we are done uploading
+      // The uncompressed size is used for display when downloading a zip of the artifact from the UI
+      await uploadHttpClient.patchArtifactSize(uploadResult.totalSize, name)
+
+      core.info(
+        `Finished uploading artifact ${name}. Reported size is ${uploadResult.uploadSize} bytes. There were ${uploadResult.failedItems.length} items that failed to upload`
+      )
+
+      uploadResponse.artifactItems = uploadSpecification.map(
+        item => item.absoluteFilePath
+      )
+      uploadResponse.size = uploadResult.uploadSize
+      uploadResponse.failedItems = uploadResult.failedItems
+    }
+    return uploadResponse
+  }
+
+  async downloadArtifact(
+    name: string,
+    path?: string | undefined,
+    options?: DownloadOptions | undefined
+  ): Promise<DownloadResponse> {
+    const downloadHttpClient = new DownloadHttpClient()
+
+    const artifacts = await downloadHttpClient.listArtifacts()
+    if (artifacts.count === 0) {
+      throw new Error(
+        `Unable to find any artifacts for the associated workflow`
+      )
+    }
+
+    const artifactToDownload = artifacts.value.find(artifact => {
+      return artifact.name === name
+    })
+    if (!artifactToDownload) {
+      throw new Error(`Unable to find an artifact with the name: ${name}`)
+    }
+
+    const items = await downloadHttpClient.getContainerItems(
+      artifactToDownload.name,
+      artifactToDownload.fileContainerResourceUrl
+    )
+
+    if (!path) {
+      path = getWorkSpaceDirectory()
+    }
+    path = normalize(path)
+    path = resolve(path)
+
+    // During upload, empty directories are rejected by the remote server so there should be no artifacts that consist of only empty directories
+    const downloadSpecification = getDownloadSpecification(
+      name,
+      items.value,
+      path,
+      options?.createArtifactFolder || false
+    )
+
+    if (downloadSpecification.filesToDownload.length === 0) {
+      core.info(
+        `No downloadable files were found for the artifact: ${artifactToDownload.name}`
+      )
+    } else {
+      // Create all necessary directories recursively before starting any download
+      await createDirectoriesForArtifact(
+        downloadSpecification.directoryStructure
+      )
+      core.info('Directory structure has been setup for the artifact')
+      await createEmptyFilesForArtifact(
+        downloadSpecification.emptyFilesToCreate
+      )
+      await downloadHttpClient.downloadSingleArtifact(
+        downloadSpecification.filesToDownload
+      )
+    }
+
+    return {
+      artifactName: name,
+      downloadPath: downloadSpecification.rootDownloadLocation
+    }
+  }
+
+  async downloadAllArtifacts(
+    path?: string | undefined
+  ): Promise<DownloadResponse[]> {
+    const downloadHttpClient = new DownloadHttpClient()
+
+    const response: DownloadResponse[] = []
+    const artifacts = await downloadHttpClient.listArtifacts()
+    if (artifacts.count === 0) {
+      core.info('Unable to find any artifacts for the associated workflow')
+      return response
+    }
+
+    if (!path) {
+      path = getWorkSpaceDirectory()
+    }
+    path = normalize(path)
+    path = resolve(path)
+
+    let downloadedArtifacts = 0
+    while (downloadedArtifacts < artifacts.count) {
+      const currentArtifactToDownload = artifacts.value[downloadedArtifacts]
+      downloadedArtifacts += 1
+
+      // Get container entries for the specific artifact
+      const items = await downloadHttpClient.getContainerItems(
+        currentArtifactToDownload.name,
+        currentArtifactToDownload.fileContainerResourceUrl
+      )
+
+      const downloadSpecification = getDownloadSpecification(
+        currentArtifactToDownload.name,
+        items.value,
+        path,
+        true
+      )
+      if (downloadSpecification.filesToDownload.length === 0) {
+        core.info(
+          `No downloadable files were found for any artifact ${currentArtifactToDownload.name}`
+        )
+      } else {
+        await createDirectoriesForArtifact(
+          downloadSpecification.directoryStructure
+        )
+        await createEmptyFilesForArtifact(
+          downloadSpecification.emptyFilesToCreate
+        )
+        await downloadHttpClient.downloadSingleArtifact(
+          downloadSpecification.filesToDownload
+        )
+      }
+
+      response.push({
+        artifactName: currentArtifactToDownload.name,
+        downloadPath: downloadSpecification.rootDownloadLocation
+      })
+    }
+    return response
+  }
+}
@@ -1,257 +0,0 @@
-import {warning} from '@actions/core'
-import {isGhes} from './shared/config'
-import {
-  UploadOptions,
-  UploadResponse,
-  DownloadArtifactOptions,
-  GetArtifactResponse,
-  ListArtifactsResponse,
-  DownloadArtifactResponse
-} from './shared/interfaces'
-import {uploadArtifact} from './upload/upload-artifact'
-import {downloadArtifact} from './download/download-artifact'
-import {getArtifact} from './find/get-artifact'
-import {listArtifacts} from './find/list-artifacts'
-
-export interface ArtifactClient {
-  /**
-   * Uploads an artifact
-   *
-   * @param name The name of the artifact, required
-   * @param files A list of absolute or relative paths that denote what files should be uploaded
-   * @param rootDirectory An absolute or relative file path that denotes the root parent directory of the files being uploaded
-   * @param options Extra options for customizing the upload behavior
-   * @returns single UploadResponse object
-   */
-  uploadArtifact(
-    name: string,
-    files: string[],
-    rootDirectory: string,
-    options?: UploadOptions
-  ): Promise<UploadResponse>
-
-  /**
-   * Lists all artifacts that are part of a workflow run.
-   *
-   * This calls the public List-Artifacts API https://docs.github.com/en/rest/actions/artifacts?apiVersion=2022-11-28#list-workflow-run-artifacts
-   * Due to paginated responses from the public API. This function will return at most 1000 artifacts per workflow run (100 per page * maximum 10 calls)
-   *
-   * @param workflowRunId The workflow run id that the artifact belongs to
-   * @param repositoryOwner The owner of the repository that the artifact belongs to
-   * @param repositoryName The name of the repository that the artifact belongs to
-   * @param token A token with the appropriate permission to the repository to list artifacts
-   * @returns ListArtifactResponse object
-   */
-  listArtifacts(
-    workflowRunId: number,
-    repositoryOwner: string,
-    repositoryName: string,
-    token: string
-  ): Promise<ListArtifactsResponse>
-
-  /**
-   * Finds an artifact by name given a repository and workflow run id.
-   *
-   * This calls the public List-Artifacts API with a name filter https://docs.github.com/en/rest/actions/artifacts?apiVersion=2022-11-28#list-workflow-run-artifacts
-   * @actions/artifact > 2.0.0 does not allow for creating multiple artifacts with the same name in the same workflow run.
-   * It is possible to have multiple artifacts with the same name in the same workflow run by using old versions of upload-artifact (v1,v2 and v3) or @actions/artifact < v2.0.0
-   * If there are multiple artifacts with the same name in the same workflow run this function will return the first artifact that matches the name.
-   *
-   * @param artifactName The name of the artifact to find
-   * @param workflowRunId The workflow run id that the artifact belongs to
-   * @param repositoryOwner The owner of the repository that the artifact belongs to
-   * @param repositoryName The name of the repository that the artifact belongs to
-   * @param token A token with the appropriate permission to the repository to find the artifact
-   */
-  getArtifact(
-    artifactName: string,
-    workflowRunId: number,
-    repositoryOwner: string,
-    repositoryName: string,
-    token: string
-  ): Promise<GetArtifactResponse>
-
-  /**
-   * Downloads an artifact and unzips the content
-   *
-   * @param artifactId The name of the artifact to download
-   * @param repositoryOwner The owner of the repository that the artifact belongs to
-   * @param repositoryName The name of the repository that the artifact belongs to
-   * @param token A token with the appropriate permission to the repository to download the artifact
-   * @param options Extra options that allow for the customization of the download behavior
-   * @returns single DownloadArtifactResponse object
-   */
-  downloadArtifact(
-    artifactId: number,
-    repositoryOwner: string,
-    repositoryName: string,
-    token: string,
-    options?: DownloadArtifactOptions
-  ): Promise<DownloadArtifactResponse>
-}
-
-export class Client implements ArtifactClient {
-  /**
-   * Constructs a Client
-   */
-  static create(): Client {
-    return new Client()
-  }
-
-  /**
-   * Upload Artifact
-   */
-  async uploadArtifact(
-    name: string,
-    files: string[],
-    rootDirectory: string,
-    options?: UploadOptions | undefined
-  ): Promise<UploadResponse> {
-    if (isGhes()) {
-      warning(
-        `@actions/artifact v2.0.0+ and upload-artifact@v4+ are not currently supported on GHES.`
-      )
-      return {
-        success: false
-      }
-    }
-
-    try {
-      return uploadArtifact(name, files, rootDirectory, options)
-    } catch (error) {
-      warning(
-        `Artifact upload failed with error: ${error}.
-
-Errors can be temporary, so please try again and optionally run the action with debug mode enabled for more information.
-
-If the error persists, please check whether Actions is operating normally at [https://githubstatus.com](https://www.githubstatus.com).`
-      )
-      return {
-        success: false
-      }
-    }
-  }
-
-  /**
-   * Download Artifact
-   */
-  async downloadArtifact(
-    artifactId: number,
-    repositoryOwner: string,
-    repositoryName: string,
-    token: string,
-    options?: DownloadArtifactOptions
-  ): Promise<DownloadArtifactResponse> {
-    if (isGhes()) {
-      warning(
-        `@actions/artifact v2.0.0+ and download-artifact@v4+ are not currently supported on GHES.`
-      )
-      return {
-        success: false
-      }
-    }
-
-    try {
-      return downloadArtifact(
-        artifactId,
-        repositoryOwner,
-        repositoryName,
-        token,
-        options
-      )
-    } catch (error) {
-      warning(
-        `Artifact download failed with error: ${error}.
-
-Errors can be temporary, so please try again and optionally run the action with debug mode enabled for more information.
-
-If the error persists, please check whether Actions and API requests are operating normally at [https://githubstatus.com](https://www.githubstatus.com).`
-      )
-
-      return {
-        success: false
-      }
-    }
-  }
-
-  /**
-   * List Artifacts
-   */
-  async listArtifacts(
-    workflowRunId: number,
-    repositoryOwner: string,
-    repositoryName: string,
-    token: string
-  ): Promise<ListArtifactsResponse> {
-    if (isGhes()) {
-      warning(
-        `@actions/artifact v2.0.0+ and download-artifact@v4+ are not currently supported on GHES.`
-      )
-      return {
-        artifacts: []
-      }
-    }
-
-    try {
-      return listArtifacts(
-        workflowRunId,
-        repositoryOwner,
-        repositoryName,
-        token
-      )
-    } catch (error: unknown) {
-      warning(
-        `Listing Artifacts failed with error: ${error}.
-
-Errors can be temporary, so please try again and optionally run the action with debug mode enabled for more information.
-
-If the error persists, please check whether Actions and API requests are operating normally at [https://githubstatus.com](https://www.githubstatus.com).`
-      )
-
-      return {
-        artifacts: []
-      }
-    }
-  }
-
-  /**
-   * Get Artifact
-   */
-  async getArtifact(
-    artifactName: string,
-    workflowRunId: number,
-    repositoryOwner: string,
-    repositoryName: string,
-    token: string
-  ): Promise<GetArtifactResponse> {
-    if (isGhes()) {
-      warning(
-        `@actions/artifact v2.0.0+ and download-artifact@v4+ are not currently supported on GHES.`
-      )
-      return {
-        success: false
-      }
-    }
-
-    try {
-      return getArtifact(
-        artifactName,
-        workflowRunId,
-        repositoryOwner,
-        repositoryName,
-        token
-      )
-    } catch (error: unknown) {
-      warning(
-        `Fetching Artifact failed with error: ${error}.
-
-Errors can be temporary, so please try again and optionally run the action with debug mode enabled for more information.
-
-If the error persists, please check whether Actions and API requests are operating normally at [https://githubstatus.com](https://www.githubstatus.com).`
-      )
-      return {
-        success: false
-      }
-    }
-  }
-}
@@ -0,0 +1,67 @@
+// The number of concurrent uploads that happens at the same time
+export function getUploadFileConcurrency(): number {
+  return 2
+}
+
+// When uploading large files that can't be uploaded with a single http call, this controls
+// the chunk size that is used during upload
+export function getUploadChunkSize(): number {
+  return 8 * 1024 * 1024 // 8 MB Chunks
+}
+
+// The maximum number of retries that can be attempted before an upload or download fails
+export function getRetryLimit(): number {
+  return 5
+}
+
+// With exponential backoff, the larger the retry count, the larger the wait time before another attempt
+// The retry multiplier controls by how much the backOff time increases depending on the number of retries
+export function getRetryMultiplier(): number {
+  return 1.5
+}
+
+// The initial wait time if an upload or download fails and a retry is being attempted for the first time
+export function getInitialRetryIntervalInMilliseconds(): number {
+  return 3000
+}
+
+// The number of concurrent downloads that happens at the same time
+export function getDownloadFileConcurrency(): number {
+  return 2
+}
+
+export function getRuntimeToken(): string {
+  const token = process.env['ACTIONS_RUNTIME_TOKEN']
+  if (!token) {
+    throw new Error('Unable to get ACTIONS_RUNTIME_TOKEN env variable')
+  }
+  return token
+}
+
+export function getRuntimeUrl(): string {
+  const runtimeUrl = process.env['ACTIONS_RUNTIME_URL']
+  if (!runtimeUrl) {
+    throw new Error('Unable to get ACTIONS_RUNTIME_URL env variable')
+  }
+  return runtimeUrl
+}
+
+export function getWorkFlowRunId(): string {
+  const workFlowRunId = process.env['GITHUB_RUN_ID']
+  if (!workFlowRunId) {
+    throw new Error('Unable to get GITHUB_RUN_ID env variable')
+  }
+  return workFlowRunId
+}
+
+export function getWorkSpaceDirectory(): string {
+  const workspaceDirectory = process.env['GITHUB_WORKSPACE']
+  if (!workspaceDirectory) {
+    throw new Error('Unable to get GITHUB_WORKSPACE env variable')
+  }
+  return workspaceDirectory
+}
+
+export function getRetentionDays(): string | undefined {
+  return process.env['GITHUB_RETENTION_DAYS']
+}
@@ -0,0 +1,64 @@
+export interface ArtifactResponse {
+  containerId: string
+  size: number
+  signedContent: string
+  fileContainerResourceUrl: string
+  type: string
+  name: string
+  url: string
+}
+
+export interface CreateArtifactParameters {
+  Type: string
+  Name: string
+  RetentionDays?: number
+}
+
+export interface PatchArtifactSize {
+  Size: number
+}
+
+export interface PatchArtifactSizeSuccessResponse {
+  containerId: number
+  size: number
+  signedContent: string
+  type: string
+  name: string
+  url: string
+  uploadUrl: string
+}
+
+export interface UploadResults {
+  uploadSize: number
+  totalSize: number
+  failedItems: string[]
+}
+
+export interface ListArtifactsResponse {
+  count: number
+  value: ArtifactResponse[]
+}
+
+export interface QueryArtifactResponse {
+  count: number
+  value: ContainerEntry[]
+}
+
+export interface ContainerEntry {
+  containerId: number
+  scopeIdentifier: string
+  path: string
+  itemType: string
+  status: string
+  fileLength?: number
+  fileEncoding?: number
+  fileType?: number
+  dateCreated: string
+  dateLastModified: string
+  createdBy: string
+  lastModifiedBy: string
+  itemLocation: string
+  contentLocation: string
+  fileId?: number
+  contentId: string
+}
@@ -0,0 +1,358 @@
+import * as fs from 'fs'
+import * as core from '@actions/core'
+import * as zlib from 'zlib'
+import {
+  getArtifactUrl,
+  getDownloadHeaders,
+  isSuccessStatusCode,
+  isRetryableStatusCode,
+  isThrottledStatusCode,
+  getExponentialRetryTimeInMilliseconds,
+  tryGetRetryAfterValueTimeInMilliseconds,
+  displayHttpDiagnostics,
+  getFileSize,
+  rmFile,
+  sleep
+} from './utils'
+import {URL} from 'url'
+import {StatusReporter} from './status-reporter'
+import {performance} from 'perf_hooks'
+import {ListArtifactsResponse, QueryArtifactResponse} from './contracts'
+import {IHttpClientResponse} from '@actions/http-client/interfaces'
+import {HttpManager} from './http-manager'
+import {DownloadItem} from './download-specification'
+import {getDownloadFileConcurrency, getRetryLimit} from './config-variables'
+import {IncomingHttpHeaders} from 'http'
+import {retryHttpClientRequest} from './requestUtils'
+
+export class DownloadHttpClient {
+  // http manager is used for concurrent connections when downloading multiple files at once
+  private downloadHttpManager: HttpManager
+  private statusReporter: StatusReporter
+
+  constructor() {
+    this.downloadHttpManager = new HttpManager(
+      getDownloadFileConcurrency(),
+      '@actions/artifact-download'
+    )
+    // downloads are usually significantly faster than uploads so display status information every second
+    this.statusReporter = new StatusReporter(1000)
+  }
+
+  /**
+   * Gets a list of all artifacts that are in a specific container
+   */
+  async listArtifacts(): Promise<ListArtifactsResponse> {
+    const artifactUrl = getArtifactUrl()
+
+    // use the first client from the httpManager, `keep-alive` is not used so the connection will close immediately
+    const client = this.downloadHttpManager.getClient(0)
+    const headers = getDownloadHeaders('application/json')
+    const response = await retryHttpClientRequest('List Artifacts', async () =>
+      client.get(artifactUrl, headers)
+    )
+    const body: string = await response.readBody()
+    return JSON.parse(body)
+  }
+
+  /**
+   * Fetches a set of container items that describe the contents of an artifact
+   * @param artifactName the name of the artifact
+   * @param containerUrl the artifact container URL for the run
+   */
+  async getContainerItems(
+    artifactName: string,
+    containerUrl: string
+  ): Promise<QueryArtifactResponse> {
+    // the itemPath search parameter controls which containers will be returned
+    const resourceUrl = new URL(containerUrl)
+    resourceUrl.searchParams.append('itemPath', artifactName)
+
+    // use the first client from the httpManager, `keep-alive` is not used so the connection will close immediately
+    const client = this.downloadHttpManager.getClient(0)
+    const headers = getDownloadHeaders('application/json')
+    const response = await retryHttpClientRequest(
+      'Get Container Items',
+      async () => client.get(resourceUrl.toString(), headers)
+    )
+    const body: string = await response.readBody()
+    return JSON.parse(body)
+  }
+
+  /**
+   * Concurrently downloads all the files that are part of an artifact
+   * @param downloadItems information about what items to download and where to save them
+   */
+  async downloadSingleArtifact(downloadItems: DownloadItem[]): Promise<void> {
+    const DOWNLOAD_CONCURRENCY = getDownloadFileConcurrency()
+    // limit the number of files downloaded at a single time
+    core.debug(`Download file concurrency is set to ${DOWNLOAD_CONCURRENCY}`)
+    const parallelDownloads = [...new Array(DOWNLOAD_CONCURRENCY).keys()]
+    let currentFile = 0
+    let downloadedFiles = 0
+
+    core.info(
+      `Total number of files that will be downloaded: ${downloadItems.length}`
+    )
+
+    this.statusReporter.setTotalNumberOfFilesToProcess(downloadItems.length)
+    this.statusReporter.start()
+
+    await Promise.all(
+      parallelDownloads.map(async index => {
+        while (currentFile < downloadItems.length) {
+          const currentFileToDownload = downloadItems[currentFile]
+          currentFile += 1
+
+          const startTime = performance.now()
+          await this.downloadIndividualFile(
+            index,
+            currentFileToDownload.sourceLocation,
+            currentFileToDownload.targetPath
+          )
+
+          if (core.isDebug()) {
+            core.debug(
+              `File: ${++downloadedFiles}/${downloadItems.length}. ${
+                currentFileToDownload.targetPath
+              } took ${(performance.now() - startTime).toFixed(
+                3
+              )} milliseconds to finish downloading`
+            )
+          }
+
+          this.statusReporter.incrementProcessedCount()
+        }
+      })
+    )
+      .catch(error => {
+        throw new Error(`Unable to download the artifact: ${error}`)
+      })
+      .finally(() => {
+        this.statusReporter.stop()
+        // safety dispose all connections
+        this.downloadHttpManager.disposeAndReplaceAllClients()
+      })
+  }
+
+  /**
+   * Downloads an individual file
+   * @param httpClientIndex the index of the http client that is used to make all of the calls
+   * @param artifactLocation origin location where a file will be downloaded from
+   * @param downloadPath destination location for the file being downloaded
+   */
+  private async downloadIndividualFile(
+    httpClientIndex: number,
+    artifactLocation: string,
+    downloadPath: string
+  ): Promise<void> {
+    let retryCount = 0
+    const retryLimit = getRetryLimit()
+    let destinationStream = fs.createWriteStream(downloadPath)
+    const headers = getDownloadHeaders('application/json', true, true)
+
+    // a single GET request is used to download a file
+    const makeDownloadRequest = async (): Promise<IHttpClientResponse> => {
+      const client = this.downloadHttpManager.getClient(httpClientIndex)
+      return await client.get(artifactLocation, headers)
+    }
+
+    // check the response headers to determine if the file was compressed using gzip
+    const isGzip = (incomingHeaders: IncomingHttpHeaders): boolean => {
+      return (
+        'content-encoding' in incomingHeaders &&
+        incomingHeaders['content-encoding'] === 'gzip'
+      )
+    }
+
+    // Increments the current retry count and then checks if the retry limit has been reached
+    // If there have been too many retries, fail so the download stops. If there is a retryAfterValue value provided,
+    // it will be used
+    const backOff = async (retryAfterValue?: number): Promise<void> => {
+      retryCount++
+      if (retryCount > retryLimit) {
+        return Promise.reject(
+          new Error(
+            `Retry limit has been reached. Unable to download ${artifactLocation}`
+          )
+        )
+      } else {
+        this.downloadHttpManager.disposeAndReplaceClient(httpClientIndex)
+        if (retryAfterValue) {
+          // Back off by waiting the specified time denoted by the retry-after header
+          core.info(
+            `Backoff due to too many requests, retry #${retryCount}. Waiting for ${retryAfterValue} milliseconds before continuing the download`
+          )
+          await sleep(retryAfterValue)
+        } else {
+          // Back off using an exponential value that depends on the retry count
+          const backoffTime = getExponentialRetryTimeInMilliseconds(retryCount)
+          core.info(
+            `Exponential backoff for retry #${retryCount}. Waiting for ${backoffTime} milliseconds before continuing the download`
+          )
+          await sleep(backoffTime)
+        }
+        core.info(
+          `Finished backoff for retry #${retryCount}, continuing with download`
+        )
+      }
+    }
+
+    const isAllBytesReceived = (
+      expected?: string,
+      received?: number
+    ): boolean => {
+      // be lenient, if any input is missing, assume success, i.e. not truncated
+      if (
+        !expected ||
+        !received ||
+        process.env['ACTIONS_ARTIFACT_SKIP_DOWNLOAD_VALIDATION']
+      ) {
+        core.info('Skipping download validation.')
+        return true
+      }
+
+      return parseInt(expected) === received
+    }
+
+    const resetDestinationStream = async (
+      fileDownloadPath: string
+    ): Promise<void> => {
+      destinationStream.close()
+      await rmFile(fileDownloadPath)
+      destinationStream = fs.createWriteStream(fileDownloadPath)
+    }
+
+    // keep trying to download a file until a retry limit has been reached
+    while (retryCount <= retryLimit) {
+      let response: IHttpClientResponse
+      try {
+        response = await makeDownloadRequest()
+        if (core.isDebug()) {
+          displayHttpDiagnostics(response)
+        }
+      } catch (error) {
+        // if an error is caught, it is usually indicative of a timeout so retry the download
+        core.info('An error occurred while attempting to download a file')
+        // eslint-disable-next-line no-console
+        console.log(error)
+
+        // increment the retryCount and use exponential backoff to wait before making the next request
+        await backOff()
+        continue
+      }
+
+      let forceRetry = false
+      if (isSuccessStatusCode(response.message.statusCode)) {
+        // The body contains the contents of the file however calling response.readBody() causes all the content to be converted to a string
+        // which can cause some gzip encoded data to be lost
+        // Instead of using response.readBody(), response.message is a readableStream that can be directly used to get the raw body contents
+        try {
+          const isGzipped = isGzip(response.message.headers)
+          await this.pipeResponseToFile(response, destinationStream, isGzipped)
+
+          if (
+            isGzipped ||
+            isAllBytesReceived(
+              response.message.headers['content-length'],
+              await getFileSize(downloadPath)
+            )
+          ) {
+            return
+          } else {
+            forceRetry = true
+          }
+        } catch (error) {
+          // retry on error, most likely streams were corrupted
+          forceRetry = true
+        }
+      }
+
+      if (forceRetry || isRetryableStatusCode(response.message.statusCode)) {
+        core.info(
+          `A ${response.message.statusCode} response code has been received while attempting to download an artifact`
+        )
+        resetDestinationStream(downloadPath)
+        // if a throttled status code is received, try to get the retryAfter header value, else differ to standard exponential backoff
+        isThrottledStatusCode(response.message.statusCode)
+          ? await backOff(
+              tryGetRetryAfterValueTimeInMilliseconds(response.message.headers)
+            )
+          : await backOff()
+      } else {
+        // Some unexpected response code, fail immediately and stop the download
+        displayHttpDiagnostics(response)
+        return Promise.reject(
+          new Error(
+            `Unexpected http ${response.message.statusCode} during download for ${artifactLocation}`
+          )
+        )
+      }
+    }
+  }
+
+  /**
+   * Pipes the response from downloading an individual file to the appropriate destination stream while decoding gzip content if necessary
+   * @param response the http response received when downloading a file
+   * @param destinationStream the stream where the file should be written to
+   * @param isGzip a boolean denoting if the content is compressed using gzip and if we need to decode it
+   */
+  async pipeResponseToFile(
+    response: IHttpClientResponse,
+    destinationStream: fs.WriteStream,
+    isGzip: boolean
+  ): Promise<void> {
+    await new Promise((resolve, reject) => {
+      if (isGzip) {
+        const gunzip = zlib.createGunzip()
+        response.message
+          .on('error', error => {
+            core.error(
+              `An error occurred while attempting to read the response stream`
+            )
+            gunzip.close()
+            destinationStream.close()
+            reject(error)
+          })
+          .pipe(gunzip)
+          .on('error', error => {
+            core.error(
+              `An error occurred while attempting to decompress the response stream`
+            )
+            destinationStream.close()
+            reject(error)
+          })
+          .pipe(destinationStream)
+          .on('close', () => {
+            resolve()
+          })
+          .on('error', error => {
+            core.error(
+              `An error occurred while writing a downloaded file to ${destinationStream.path}`
+            )
+            reject(error)
+          })
+      } else {
+        response.message
+          .on('error', error => {
+            core.error(
+              `An error occurred while attempting to read the response stream`
+            )
+            destinationStream.close()
+            reject(error)
+          })
+          .pipe(destinationStream)
+          .on('close', () => {
+            resolve()
+          })
+          .on('error', error => {
+            core.error(
+              `An error occurred while writing a downloaded file to ${destinationStream.path}`
+            )
+            reject(error)
+          })
+      }
+    })
+    return
+  }
+}
@@ -0,0 +1,7 @@
+export interface DownloadOptions {
+  /**
+   * Specifies if a folder is created for the artifact that is downloaded (contents downloaded into this folder),
+   * defaults to false if not specified
+   * */
+  createArtifactFolder?: boolean
+}
@@ -0,0 +1,11 @@
+export interface DownloadResponse {
+  /**
+   * The name of the artifact that was downloaded
+   */
+  artifactName: string
+
+  /**
+   * The full Path to where the artifact was downloaded
+   */
+  downloadPath: string
+}
@@ -0,0 +1,87 @@
+import * as path from 'path'
+import {ContainerEntry} from './contracts'
+
+export interface DownloadSpecification {
+  // root download location for the artifact
+  rootDownloadLocation: string
+
+  // directories that need to be created for all the items in the artifact
+  directoryStructure: string[]
+
+  // empty files that are part of the artifact that don't require any downloading
+  emptyFilesToCreate: string[]
+
+  // individual files that need to be downloaded as part of the artifact
+  filesToDownload: DownloadItem[]
+}
+
+export interface DownloadItem {
+  // Url that denotes where to download the item from
+  sourceLocation: string
+
+  // Information about where the file should be downloaded to
+  targetPath: string
+}
+
+/**
+ * Creates a specification for a set of files that will be downloaded
+ * @param artifactName the name of the artifact
+ * @param artifactEntries a set of container entries that describe that files that make up an artifact
+ * @param downloadPath the path where the artifact will be downloaded to
+ * @param includeRootDirectory specifies if there should be an extra directory (denoted by the artifact name) where the artifact files should be downloaded to
+ */
+export function getDownloadSpecification(
+  artifactName: string,
+  artifactEntries: ContainerEntry[],
+  downloadPath: string,
+  includeRootDirectory: boolean
+): DownloadSpecification {
+  // use a set for the directory paths so that there are no duplicates
+  const directories = new Set<string>()
+
+  const specifications: DownloadSpecification = {
+    rootDownloadLocation: includeRootDirectory
+      ? path.join(downloadPath, artifactName)
+      : downloadPath,
+    directoryStructure: [],
+    emptyFilesToCreate: [],
+    filesToDownload: []
+  }
+
+  for (const entry of artifactEntries) {
+    // Ignore artifacts in the container that don't begin with the same name
+    if (
+      entry.path.startsWith(`${artifactName}/`) ||
+      entry.path.startsWith(`${artifactName}\\`)
+    ) {
+      // normalize all separators to the local OS
+      const normalizedPathEntry = path.normalize(entry.path)
+      // entry.path always starts with the artifact name, if includeRootDirectory is false, remove the name from the beginning of the path
+      const filePath = path.join(
+        downloadPath,
+        includeRootDirectory
+          ? normalizedPathEntry
+          : normalizedPathEntry.replace(artifactName, '')
+      )
+
+      // Case insensitive folder structure maintained in the backend, not every folder is created so the 'folder'
+      // itemType cannot be relied upon. The file must be used to determine the directory structure
+      if (entry.itemType === 'file') {
+        // Get the directories that we need to create from the filePath for each individual file
+        directories.add(path.dirname(filePath))
+        if (entry.fileLength === 0) {
+          // An empty file was uploaded, create the empty files locally so that no extra http calls are made
+          specifications.emptyFilesToCreate.push(filePath)
+        } else {
+          specifications.filesToDownload.push({
+            sourceLocation: entry.contentLocation,
+            targetPath: filePath
+          })
+        }
+      }
+    }
+  }
+
+  specifications.directoryStructure = Array.from(directories)
+  return specifications
+}
@@ -1,101 +0,0 @@
-import fs from 'fs/promises'
-import * as github from '@actions/github'
-import * as core from '@actions/core'
-import * as httpClient from '@actions/http-client'
-import unzipper from 'unzipper'
-import {
-  DownloadArtifactOptions,
-  DownloadArtifactResponse
-} from '../shared/interfaces'
-import {getUserAgentString} from '../shared/user-agent'
-import {getGitHubWorkspaceDir} from '../shared/config'
-
-const scrubQueryParameters = (url: string): string => {
-  const parsed = new URL(url)
-  parsed.search = ''
-  return parsed.toString()
-}
-
-async function exists(path: string): Promise<boolean> {
-  try {
-    await fs.access(path)
-    return true
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      return false
-    } else {
-      throw error
-    }
-  }
-}
-
-async function streamExtract(url: string, directory: string): Promise<void> {
-  const client = new httpClient.HttpClient(getUserAgentString())
-  const response = await client.get(url)
-
-  if (response.message.statusCode !== 200) {
-    throw new Error(
-      `Unexpected HTTP response from blob storage: ${response.message.statusCode} ${response.message.statusMessage}`
-    )
-  }
-
-  return response.message.pipe(unzipper.Extract({path: directory})).promise()
-}
-
-export async function downloadArtifact(
-  artifactId: number,
-  repositoryOwner: string,
-  repositoryName: string,
-  token: string,
-  options?: DownloadArtifactOptions
-): Promise<DownloadArtifactResponse> {
-  const downloadPath = options?.path || getGitHubWorkspaceDir()
-
-  if (!(await exists(downloadPath))) {
-    core.debug(
-      `Artifact destination folder does not exist, creating: ${downloadPath}`
-    )
-    await fs.mkdir(downloadPath, {recursive: true})
-  } else {
-    core.debug(`Artifact destination folder already exists: ${downloadPath}`)
-  }
-
-  const api = github.getOctokit(token)
-
-  core.info(
-    `Downloading artifact '${artifactId}' from '${repositoryOwner}/${repositoryName}'`
-  )
-
-  const {headers, status} = await api.rest.actions.downloadArtifact({
-    owner: repositoryOwner,
-    repo: repositoryName,
-    artifact_id: artifactId,
-    archive_format: 'zip',
-    request: {
-      redirect: 'manual'
-    }
-  })
-
-  if (status !== 302) {
-    throw new Error(`Unable to download artifact. Unexpected status: ${status}`)
-  }
-
-  const {location} = headers
-  if (!location) {
-    throw new Error(`Unable to redirect to artifact download url`)
-  }
-
-  core.info(
-    `Redirecting to blob download url: ${scrubQueryParameters(location)}`
-  )
-
-  try {
-    core.info(`Starting download of artifact to: ${downloadPath}`)
-    await streamExtract(location, downloadPath)
-    core.info(`Artifact download completed successfully.`)
-  } catch (error) {
-    throw new Error(`Unable to download and extract artifact: ${error.message}`)
-  }
-
-  return {success: true, downloadPath}
-}
@@ -1,69 +0,0 @@
-import {GetArtifactResponse} from '../shared/interfaces'
-import {getOctokit} from '@actions/github'
-import {getUserAgentString} from '../shared/user-agent'
-import {defaults as defaultGitHubOptions} from '@actions/github/lib/utils'
-import {getRetryOptions} from './retry-options'
-import {requestLog} from '@octokit/plugin-request-log'
-import {retry} from '@octokit/plugin-retry'
-import * as core from '@actions/core'
-import {OctokitOptions} from '@octokit/core/dist-types/types'
-
-export async function getArtifact(
-  artifactName: string,
-  workflowRunId: number,
-  repositoryOwner: string,
-  repositoryName: string,
-  token: string
-): Promise<GetArtifactResponse> {
-  const [retryOpts, requestOpts] = getRetryOptions(defaultGitHubOptions)
-
-  const opts: OctokitOptions = {
-    log: undefined,
-    userAgent: getUserAgentString(),
-    previews: undefined,
-    retry: retryOpts,
-    request: requestOpts
-  }
-
-  const github = getOctokit(token, opts, retry, requestLog)
-
-  const getArtifactResp = await github.request(
-    'GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts{?name}',
-    {
-      owner: repositoryOwner,
-      repo: repositoryName,
-      run_id: workflowRunId,
-      name: artifactName
-    }
-  )
-
-  if (getArtifactResp.status !== 200) {
-    core.warning(`non-200 response from GitHub API: ${getArtifactResp.status}`)
-    return {
-      success: false
-    }
-  }
-
-  if (getArtifactResp.data.artifacts.length === 0) {
-    core.warning('no artifacts found')
-    return {
-      success: false
-    }
-  }
-
-  if (getArtifactResp.data.artifacts.length > 1) {
-    core.warning(
-      'more than one artifact found for a single name, returning first'
-    )
-  }
-
-  return {
-    success: true,
-    artifact: {
-      name: getArtifactResp.data.artifacts[0].name,
-      id: getArtifactResp.data.artifacts[0].id,
-      url: getArtifactResp.data.artifacts[0].url,
-      size: getArtifactResp.data.artifacts[0].size_in_bytes
-    }
-  }
-}
@@ -1,103 +0,0 @@
-import {info, warning, debug} from '@actions/core'
-import {getOctokit} from '@actions/github'
-import {ListArtifactsResponse, Artifact} from '../shared/interfaces'
-import {getUserAgentString} from '../shared/user-agent'
-import {getRetryOptions} from './retry-options'
-import {defaults as defaultGitHubOptions} from '@actions/github/lib/utils'
-import {requestLog} from '@octokit/plugin-request-log'
-import {retry} from '@octokit/plugin-retry'
-import {OctokitOptions} from '@octokit/core/dist-types/types'
-
-// Limiting to 1000 for perf reasons
-const maximumArtifactCount = 1000
-const paginationCount = 100
-const maxNumberOfPages = maximumArtifactCount / paginationCount
-
-export async function listArtifacts(
-  workflowRunId: number,
-  repositoryOwner: string,
-  repositoryName: string,
-  token: string
-): Promise<ListArtifactsResponse> {
-  info(
-    `Fetching artifact list for workflow run ${workflowRunId} in repository ${repositoryOwner}/${repositoryName}`
-  )
-
-  const artifacts: Artifact[] = []
-  const [retryOpts, requestOpts] = getRetryOptions(defaultGitHubOptions)
-
-  const opts: OctokitOptions = {
-    log: undefined,
-    userAgent: getUserAgentString(),
-    previews: undefined,
-    retry: retryOpts,
-    request: requestOpts
-  }
-
-  const github = getOctokit(token, opts, retry, requestLog)
-
-  let currentPageNumber = 1
-  const {data: listArtifactResponse} =
-    await github.rest.actions.listWorkflowRunArtifacts({
-      owner: repositoryOwner,
-      repo: repositoryName,
-      run_id: workflowRunId,
-      per_page: paginationCount,
-      page: currentPageNumber
-    })
-
-  let numberOfPages = Math.ceil(
-    listArtifactResponse.total_count / paginationCount
-  )
-  const totalArtifactCount = listArtifactResponse.total_count
-  if (totalArtifactCount > maximumArtifactCount) {
-    warning(
-      `Workflow run ${workflowRunId} has more than 1000 artifacts. Results will be incomplete as only the first ${maximumArtifactCount} artifacts will be returned`
-    )
-    numberOfPages = maxNumberOfPages
-  }
-
-  // Iterate over the first page
-  for (const artifact of listArtifactResponse.artifacts) {
-    artifacts.push({
-      name: artifact.name,
-      id: artifact.id,
-      url: artifact.url,
-      size: artifact.size_in_bytes
-    })
-  }
-
-  // Iterate over any remaining pages
-  for (
-    currentPageNumber;
-    currentPageNumber < numberOfPages;
-    currentPageNumber++
-  ) {
-    currentPageNumber++
-    debug(`Fetching page ${currentPageNumber} of artifact list`)
-
-    const {data: listArtifactResponse} =
-      await github.rest.actions.listWorkflowRunArtifacts({
-        owner: repositoryOwner,
-        repo: repositoryName,
-        run_id: workflowRunId,
-        per_page: paginationCount,
-        page: currentPageNumber
-      })
-
-    for (const artifact of listArtifactResponse.artifacts) {
-      artifacts.push({
-        name: artifact.name,
-        id: artifact.id,
-        url: artifact.url,
-        size: artifact.size_in_bytes
-      })
-    }
-  }
-
-  info(`Finished fetching artifact list`)
-
-  return {
-    artifacts
-  }
-}
@@ -1,48 +0,0 @@
-import * as core from '@actions/core'
-import {OctokitOptions} from '@octokit/core/dist-types/types'
-import {RequestRequestOptions} from '@octokit/types'
-
-export type RetryOptions = {
-  doNotRetry?: number[]
-  enabled?: boolean
-}
-
-// Defaults for fetching artifacts
-const defaultMaxRetryNumber = 5
-const defaultExemptStatusCodes = [400, 401, 403, 404, 422] // https://github.com/octokit/plugin-retry.js/blob/9a2443746c350b3beedec35cf26e197ea318a261/src/index.ts#L14
-
-export function getRetryOptions(
-  defaultOptions: OctokitOptions,
-  retries: number = defaultMaxRetryNumber,
-  exemptStatusCodes: number[] = defaultExemptStatusCodes
-): [RetryOptions, RequestRequestOptions | undefined] {
-  if (retries <= 0) {
-    return [{enabled: false}, defaultOptions.request]
-  }
-
-  const retryOptions: RetryOptions = {
-    enabled: true
-  }
-
-  if (exemptStatusCodes.length > 0) {
-    retryOptions.doNotRetry = exemptStatusCodes
-  }
-
-  // The GitHub type has some defaults for `options.request`
-  // see: https://github.com/actions/toolkit/blob/4fbc5c941a57249b19562015edbd72add14be93d/packages/github/src/utils.ts#L15
-  // We pass these in here so they are not overridden.
-  const requestOptions: RequestRequestOptions = {
-    ...defaultOptions.request,
-    retries
-  }
-
-  core.debug(
-    `GitHub client configured with: (retries: ${
-      requestOptions.retries
-    }, retry-exempt-status-code: ${
-      retryOptions.doNotRetry ?? 'octokit default: [400, 401, 403, 404, 422]'
-    })`
-  )
-
-  return [retryOptions, requestOptions]
-}
@@ -0,0 +1,35 @@
+import {HttpClient} from '@actions/http-client/index'
+import {createHttpClient} from './utils'
+
+/**
+ * Used for managing http clients during either upload or download
+ */
+export class HttpManager {
+  private clients: HttpClient[]
+  private userAgent: string
+
+  constructor(clientCount: number, userAgent: string) {
+    if (clientCount < 1) {
+      throw new Error('There must be at least one client')
+    }
+    this.userAgent = userAgent
+    this.clients = new Array(clientCount).fill(createHttpClient(userAgent))
+  }
+
+  getClient(index: number): HttpClient {
+    return this.clients[index]
+  }
+
+  // client disposal is necessary if a keep-alive connection is used to properly close the connection
+  // for more information see: https://github.com/actions/http-client/blob/04e5ad73cd3fd1f5610a32116b0759eddf6570d2/index.ts#L292
+  disposeAndReplaceClient(index: number): void {
+    this.clients[index].dispose()
+    this.clients[index] = createHttpClient(this.userAgent)
+  }
+
+  disposeAndReplaceAllClients(): void {
+    for (const [index] of this.clients.entries()) {
+      this.disposeAndReplaceClient(index)
+    }
+  }
+}
@@ -0,0 +1,79 @@
+import {IHttpClientResponse} from '@actions/http-client/interfaces'
+import {
+  isRetryableStatusCode,
+  isSuccessStatusCode,
+  sleep,
+  getExponentialRetryTimeInMilliseconds,
+  displayHttpDiagnostics
+} from './utils'
+import * as core from '@actions/core'
+import {getRetryLimit} from './config-variables'
+
+export async function retry(
+  name: string,
+  operation: () => Promise<IHttpClientResponse>,
+  customErrorMessages: Map<number, string>,
+  maxAttempts: number
+): Promise<IHttpClientResponse> {
+  let response: IHttpClientResponse | undefined = undefined
+  let statusCode: number | undefined = undefined
+  let isRetryable = false
+  let errorMessage = ''
+  let customErrorInformation: string | undefined = undefined
+  let attempt = 1
+
+  while (attempt <= maxAttempts) {
+    try {
+      response = await operation()
+      statusCode = response.message.statusCode
+
+      if (isSuccessStatusCode(statusCode)) {
+        return response
+      }
+
+      // Extra error information that we want to display if a particular response code is hit
+      if (statusCode) {
+        customErrorInformation = customErrorMessages.get(statusCode)
+      }
+
+      isRetryable = isRetryableStatusCode(statusCode)
+      errorMessage = `Artifact service responded with ${statusCode}`
+    } catch (error) {
+      isRetryable = true
+      errorMessage = error.message
+    }
+
+    if (!isRetryable) {
+      core.info(`${name} - Error is not retryable`)
+      if (response) {
+        displayHttpDiagnostics(response)
+      }
+      break
+    }
+
+    core.info(
+      `${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`
+    )
+
+    await sleep(getExponentialRetryTimeInMilliseconds(attempt))
+    attempt++
+  }
+
+  if (response) {
+    displayHttpDiagnostics(response)
+  }
+
+  if (customErrorInformation) {
+    throw Error(`${name} failed: ${customErrorInformation}`)
+  }
+  throw Error(`${name} failed: ${errorMessage}`)
+}
+
+export async function retryHttpClientRequest<T>(
+  name: string,
+  method: () => Promise<IHttpClientResponse>,
+  customErrorMessages: Map<number, string> = new Map(),
+  maxAttempts = getRetryLimit()
+): Promise<IHttpClientResponse> {
+  return await retry(name, method, customErrorMessages, maxAttempts)
+}
@@ -1,173 +0,0 @@
-import {HttpClient, HttpClientResponse, HttpCodes} from '@actions/http-client'
-import {BearerCredentialHandler} from '@actions/http-client/lib/auth'
-import {info, debug} from '@actions/core'
-import {ArtifactServiceClientJSON} from '../../generated'
-import {getResultsServiceUrl, getRuntimeToken} from './config'
-
-// The twirp http client must implement this interface
-interface Rpc {
-  request(
-    service: string,
-    method: string,
-    contentType: 'application/json' | 'application/protobuf',
-    data: object | Uint8Array
-  ): Promise<object | Uint8Array>
-}
-
-class ArtifactHttpClient implements Rpc {
-  private httpClient: HttpClient
-  private baseUrl: string
-  private maxAttempts = 5
-  private baseRetryIntervalMilliseconds = 3000
-  private retryMultiplier = 1.5
-
-  constructor(
-    userAgent: string,
-    maxAttempts?: number,
-    baseRetryIntervalMilliseconds?: number,
-    retryMultiplier?: number
-  ) {
-    const token = getRuntimeToken()
-    this.baseUrl = getResultsServiceUrl()
-    if (maxAttempts) {
-      this.maxAttempts = maxAttempts
-    }
-    if (baseRetryIntervalMilliseconds) {
-      this.baseRetryIntervalMilliseconds = baseRetryIntervalMilliseconds
-    }
-    if (retryMultiplier) {
-      this.retryMultiplier = retryMultiplier
-    }
-
-    this.httpClient = new HttpClient(userAgent, [
-      new BearerCredentialHandler(token)
-    ])
-  }
-
-  // This function satisfies the Rpc interface. It is compatible with the JSON
-  // JSON generated client.
-  async request(
-    service: string,
-    method: string,
-    contentType: 'application/json' | 'application/protobuf',
-    data: object | Uint8Array
-  ): Promise<object | Uint8Array> {
-    const url = `${this.baseUrl}/twirp/${service}/${method}`
-    debug(`Requesting ${url}`)
-    const headers = {
-      'Content-Type': contentType
-    }
-    try {
-      const response = await this.retryableRequest(async () =>
-        this.httpClient.post(url, JSON.stringify(data), headers)
-      )
-      const body = await response.readBody()
-      return JSON.parse(body)
-    } catch (error) {
-      throw new Error(`Failed to ${method}: ${error.message}`)
-    }
-  }
-
-  async retryableRequest(
-    operation: () => Promise<HttpClientResponse>
-  ): Promise<HttpClientResponse> {
-    let attempt = 0
-    let errorMessage = ''
-    while (attempt < this.maxAttempts) {
-      let isRetryable = false
-
-      try {
-        const response = await operation()
-        const statusCode = response.message.statusCode
-
-        if (this.isSuccessStatusCode(statusCode)) {
-          return response
-        }
-
-        isRetryable = this.isRetryableHttpStatusCode(statusCode)
-        errorMessage = `Failed request: (${statusCode}) ${response.message.statusMessage}`
-      } catch (error) {
-        isRetryable = true
-        errorMessage = error.message
-      }
-
-      if (!isRetryable) {
-        throw new Error(`Received non-retryable error: ${errorMessage}`)
-      }
-
-      if (attempt + 1 === this.maxAttempts) {
-        throw new Error(
-          `Failed to make request after ${this.maxAttempts} attempts: ${errorMessage}`
-        )
-      }
-
-      const retryTimeMilliseconds =
-        this.getExponentialRetryTimeMilliseconds(attempt)
-      info(
-        `Attempt ${attempt + 1} of ${
-          this.maxAttempts
-        } failed with error: ${errorMessage}. Retrying request in ${retryTimeMilliseconds} ms...`
-      )
-      await this.sleep(retryTimeMilliseconds)
-      attempt++
-    }
-
-    throw new Error(`Request failed`)
-  }
-
-  isSuccessStatusCode(statusCode?: number): boolean {
-    if (!statusCode) return false
-    return statusCode >= 200 && statusCode < 300
-  }
-
-  isRetryableHttpStatusCode(statusCode?: number): boolean {
-    if (!statusCode) return false
-
-    const retryableStatusCodes = [
-      HttpCodes.BadGateway,
-      HttpCodes.GatewayTimeout,
-      HttpCodes.InternalServerError,
-      HttpCodes.ServiceUnavailable,
-      HttpCodes.TooManyRequests,
-      413 // Payload Too Large
-    ]
-
-    return retryableStatusCodes.includes(statusCode)
-  }
-
-  async sleep(milliseconds: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, milliseconds))
-  }
-
-  getExponentialRetryTimeMilliseconds(attempt: number): number {
-    if (attempt < 0) {
-      throw new Error('attempt should be a positive integer')
-    }
-
-    if (attempt === 0) {
-      return this.baseRetryIntervalMilliseconds
-    }
-
-    const minTime =
-      this.baseRetryIntervalMilliseconds * this.retryMultiplier ** attempt
-    const maxTime = minTime * this.retryMultiplier
-
-    // returns a random number between minTime and maxTime (exclusive)
-    return Math.trunc(Math.random() * (maxTime - minTime) + minTime)
-  }
-}
-
-export function createArtifactTwirpClient(
-  type: 'upload' | 'download',
-  maxAttempts?: number,
-  baseRetryIntervalMilliseconds?: number,
-  retryMultiplier?: number
-): ArtifactServiceClientJSON {
-  const client = new ArtifactHttpClient(
-    `@actions/artifact-${type}`,
-    maxAttempts,
-    baseRetryIntervalMilliseconds,
-    retryMultiplier
-  )
-  return new ArtifactServiceClientJSON(client)
-}
@@ -1,36 +0,0 @@
-// Used for controlling the highWaterMark value of the zip that is being streamed
-// The same value is used as the chunk size that is use during upload to blob storage
-export function getUploadChunkSize(): number {
-  return 8 * 1024 * 1024 // 8 MB Chunks
-}
-
-export function getRuntimeToken(): string {
-  const token = process.env['ACTIONS_RUNTIME_TOKEN']
-  if (!token) {
-    throw new Error('Unable to get the ACTIONS_RUNTIME_TOKEN env variable')
-  }
-  return token
-}
-
-export function getResultsServiceUrl(): string {
-  const resultsUrl = process.env['ACTIONS_RESULTS_URL']
-  if (!resultsUrl) {
-    throw new Error('Unable to get the ACTIONS_RESULTS_URL env variable')
-  }
-  return resultsUrl
-}
-
-export function isGhes(): boolean {
-  const ghUrl = new URL(
-    process.env['GITHUB_SERVER_URL'] || 'https://github.com'
-  )
-  return ghUrl.hostname.toUpperCase() !== 'GITHUB.COM'
-}
-
-export function getGitHubWorkspaceDir(): string {
-  const ghWorkspaceDir = process.env['GITHUB_WORKSPACE']
-  if (!ghWorkspaceDir) {
-    throw new Error('Unable to get the GITHUB_WORKSPACE env variable')
-  }
-  return ghWorkspaceDir
-}
@@ -1,121 +0,0 @@
-/*****************************************************************************
- *                                                                           *
- *                            UploadArtifact                                 *
- *                                                                           *
- *****************************************************************************/
-export interface UploadResponse {
-  /**
-   * Denotes if an artifact was successfully uploaded
-   */
-  success: boolean
-
-  /**
-   * Total size of the artifact in bytes. Not provided if no artifact was uploaded
-   */
-  size?: number
-
-  /**
-   * The id of the artifact that was created. Not provided if no artifact was uploaded
-   * This ID can be used as input to other APIs to download, delete or get more information about an artifact: https://docs.github.com/en/rest/actions/artifacts
-   */
-  id?: number
-}
-
-export interface UploadOptions {
-  /**
-   * Duration after which artifact will expire in days.
-   *
-   * By default artifact expires after 90 days:
-   * https://docs.github.com/en/actions/configuring-and-managing-workflows/persisting-workflow-data-using-artifacts#downloading-and-deleting-artifacts-after-a-workflow-run-is-complete
-   *
-   * Use this option to override the default expiry.
-   *
-   * Min value: 1
-   * Max value: 90 unless changed by repository setting
-   *
-   * If this is set to a greater value than the retention settings allowed, the retention on artifacts
-   * will be reduced to match the max value allowed on server, and the upload process will continue. An
-   * input of 0 assumes default retention setting.
-   */
-  retentionDays?: number
-}
-
-/*****************************************************************************
- *                                                                           *
- *                              GetArtifact                                  *
- *                                                                           *
- *****************************************************************************/
-
-export interface GetArtifactResponse {
-  /**
-   * If an artifact was found
-   */
-  success: boolean
-
-  /**
-   * Metadata about the artifact that was found
-   */
-  artifact?: Artifact
-}
-
-/*****************************************************************************
- *                                                                           *
- *                             ListArtifact                                  *
- *                                                                           *
- *****************************************************************************/
-export interface ListArtifactsResponse {
-  /**
-   * A list of artifacts that were found
-   */
-  artifacts: Artifact[]
-}
-
-/*****************************************************************************
- *                                                                           *
- *                           DownloadArtifact                                *
- *                                                                           *
- *****************************************************************************/
-export interface DownloadArtifactResponse {
-  /**
-   * If the artifact download was successful
-   */
-  success: boolean
-  /**
-   * The path where the artifact was downloaded to
-   */
-  downloadPath?: string
-}
-
-export interface DownloadArtifactOptions {
-  /**
-   * Denotes where the artifact will be downloaded to. If not specified then the artifact is download to GITHUB_WORKSPACE
-   */
-  path?: string
-}
-
-/*****************************************************************************
- *                                                                           *
- *                                 Shared                                    *
- *                                                                           *
- *****************************************************************************/
-export interface Artifact {
-  /**
-   * The name of the artifact
-   */
-  name: string
-
-  /**
-   * The ID of the artifact
-   */
-  id: number
-
-  /**
-   * The URL of the artifact
-   */
-  url: string
-
-  /**
-   * The size of the artifact in bytes
-   */
-  size: number
-}
@@ -1,9 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
-const packageJson = require('../../../package.json')
-
-/**
- * Ensure that this User Agent String is used in all HTTP calls so that we can monitor telemetry between different versions of this package
- */
-export function getUserAgentString(): string {
-  return `@actions/artifact-${packageJson.version}`
-}
@@ -1,65 +0,0 @@
-import {getRuntimeToken} from './config'
-import jwt_decode from 'jwt-decode'
-
-export interface BackendIds {
-  workflowRunBackendId: string
-  workflowJobRunBackendId: string
-}
-
-interface ActionsToken {
-  scp: string
-}
-
-const InvalidJwtError = new Error(
-  'Failed to get backend IDs: The provided JWT token is invalid'
-)
-
-// uses the JWT token claims to get the
-// workflow run and workflow job run backend ids
-export function getBackendIdsFromToken(): BackendIds {
-  const token = getRuntimeToken()
-  const decoded = jwt_decode<ActionsToken>(token)
-  if (!decoded.scp) {
-    throw InvalidJwtError
-  }
-
-  /*
-   * example decoded:
-   * {
-   *   scp: "Actions.ExampleScope Actions.Results:ce7f54c7-61c7-4aae-887f-30da475f5f1a:ca395085-040a-526b-2ce8-bdc85f692774"
-   * }
-   */
-
-  const scpParts = decoded.scp.split(' ')
-  if (scpParts.length === 0) {
-    throw InvalidJwtError
-  }
-  /*
-   * example scpParts:
-   * ["Actions.ExampleScope", "Actions.Results:ce7f54c7-61c7-4aae-887f-30da475f5f1a:ca395085-040a-526b-2ce8-bdc85f692774"]
-   */
-
-  for (const scopes of scpParts) {
-    const scopeParts = scopes.split(':')
-    /*
-     * example scopeParts:
-     * ["Actions.Results", "ce7f54c7-61c7-4aae-887f-30da475f5f1a", "ca395085-040a-526b-2ce8-bdc85f692774"]
-     */
-    if (scopeParts.length !== 3) {
-      // not the Actions.Results scope
-      continue
-    }
-
-    if (scopeParts[0] !== 'Actions.Results') {
-      // not the Actions.Results scope
-      continue
-    }
-
-    return {
-      workflowRunBackendId: scopeParts[1],
-      workflowJobRunBackendId: scopeParts[2]
-    }
-  }
-
-  throw InvalidJwtError
-}
@@ -0,0 +1,92 @@
+import {info} from '@actions/core'
+
+/**
+ * Status Reporter that displays information about the progress/status of an artifact that is being uploaded or downloaded
+ *
+ * Variable display time that can be adjusted using the displayFrequencyInMilliseconds variable
+ * The total status of the upload/download gets displayed according to this value
+ * If there is a large file that is being uploaded, extra information about the individual status can also be displayed using the updateLargeFileStatus function
+ */
+
+export class StatusReporter {
+  private totalNumberOfFilesToProcess = 0
+  private processedCount = 0
+  private displayFrequencyInMilliseconds: number
+  private largeFiles = new Map<string, string>()
+  private totalFileStatus: NodeJS.Timeout | undefined
+  private largeFileStatus: NodeJS.Timeout | undefined
+
+  constructor(displayFrequencyInMilliseconds: number) {
+    this.totalFileStatus = undefined
+    this.largeFileStatus = undefined
+    this.displayFrequencyInMilliseconds = displayFrequencyInMilliseconds
+  }
+
+  setTotalNumberOfFilesToProcess(fileTotal: number): void {
+    this.totalNumberOfFilesToProcess = fileTotal
+  }
+
+  start(): void {
+    // displays information about the total upload/download status
+    this.totalFileStatus = setInterval(() => {
+      // display 1 decimal place without any rounding
+      const percentage = this.formatPercentage(
+        this.processedCount,
+        this.totalNumberOfFilesToProcess
+      )
+      info(
+        `Total file count: ${
+          this.totalNumberOfFilesToProcess
+        } ---- Processed file #${this.processedCount} (${percentage.slice(
+          0,
+          percentage.indexOf('.') + 2
+        )}%)`
+      )
+    }, this.displayFrequencyInMilliseconds)
+
+    // displays extra information about any large files that take a significant amount of time to upload or download every 1 second
+    this.largeFileStatus = setInterval(() => {
+      for (const value of Array.from(this.largeFiles.values())) {
+        info(value)
+      }
+      // delete all entries in the map after displaying the information so it will not be displayed again unless explicitly added
+      this.largeFiles.clear()
+    }, 1000)
+  }
+
+  // if there is a large file that is being uploaded in chunks, this is used to display extra information about the status of the upload
+  updateLargeFileStatus(
+    fileName: string,
+    numerator: number,
+    denominator: number
+  ): void {
+    // display 1 decimal place without any rounding
+    const percentage = this.formatPercentage(numerator, denominator)
+    const displayInformation = `Uploading ${fileName} (${percentage.slice(
+      0,
+      percentage.indexOf('.') + 2
+    )}%)`
+
+    // any previously added display information should be overwritten for the specific large file because a map is being used
+    this.largeFiles.set(fileName, displayInformation)
+  }
+
+  stop(): void {
+    if (this.totalFileStatus) {
+      clearInterval(this.totalFileStatus)
+    }
+
+    if (this.largeFileStatus) {
+      clearInterval(this.largeFileStatus)
+    }
+  }
+
+  incrementProcessedCount(): void {
+    this.processedCount++
+  }
+
+  private formatPercentage(numerator: number, denominator: number): string {
+    // toFixed() rounds, so use extra precision to display accurate information even though 4 decimal places are not displayed
+    return ((numerator / denominator) * 100).toFixed(4).toString()
+  }
+}
@@ -0,0 +1,53 @@
+import * as fs from 'fs'
+import * as zlib from 'zlib'
+import {promisify} from 'util'
+const stat = promisify(fs.stat)
+
+/**
+ * Creates a Gzip compressed file of an original file at the provided temporary filepath location
+ * @param {string} originalFilePath filepath of whatever will be compressed. The original file will be unmodified
+ * @param {string} tempFilePath the location of where the Gzip file will be created
+ * @returns the size of gzip file that gets created
+ */
+export async function createGZipFileOnDisk(
+  originalFilePath: string,
+  tempFilePath: string
+): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const inputStream = fs.createReadStream(originalFilePath)
+    const gzip = zlib.createGzip()
+    const outputStream = fs.createWriteStream(tempFilePath)
+    inputStream.pipe(gzip).pipe(outputStream)
+    outputStream.on('finish', async () => {
+      // wait for stream to finish before calculating the size which is needed as part of the Content-Length header when starting an upload
+      const size = (await stat(tempFilePath)).size
+      resolve(size)
+    })
+    outputStream.on('error', error => {
+      // eslint-disable-next-line no-console
+      console.log(error)
+      reject
+    })
+  })
+}
+
+/**
+ * Creates a GZip file in memory using a buffer. Should be used for smaller files to reduce disk I/O
+ * @param originalFilePath the path to the original file that is being GZipped
+ * @returns a buffer with the GZip file
+ */
+export async function createGZipFileInBuffer(
+  originalFilePath: string
+): Promise<Buffer> {
+  return new Promise(async resolve => {
+    const inputStream = fs.createReadStream(originalFilePath)
+    const gzip = zlib.createGzip()
+    inputStream.pipe(gzip)
+    // read stream into buffer, using experimental async iterators see https://github.com/nodejs/readable-stream/issues/403#issuecomment-479069043
+    const chunks = []
+    for await (const chunk of gzip) {
+      chunks.push(chunk)
+    }
+    resolve(Buffer.concat(chunks))
+  })
+}
@@ -0,0 +1,538 @@
+import * as fs from 'fs'
+import * as core from '@actions/core'
+import * as tmp from 'tmp-promise'
+import * as stream from 'stream'
+import {
+  ArtifactResponse,
+  CreateArtifactParameters,
+  PatchArtifactSize,
+  UploadResults
+} from './contracts'
+import {
+  getArtifactUrl,
+  getContentRange,
+  getUploadHeaders,
+  isRetryableStatusCode,
+  isSuccessStatusCode,
+  isThrottledStatusCode,
+  displayHttpDiagnostics,
+  getExponentialRetryTimeInMilliseconds,
+  tryGetRetryAfterValueTimeInMilliseconds,
+  getProperRetention,
+  sleep
+} from './utils'
+import {
+  getUploadChunkSize,
+  getUploadFileConcurrency,
+  getRetryLimit,
+  getRetentionDays
+} from './config-variables'
+import {promisify} from 'util'
+import {URL} from 'url'
+import {performance} from 'perf_hooks'
+import {StatusReporter} from './status-reporter'
+import {HttpCodes} from '@actions/http-client'
+import {IHttpClientResponse} from '@actions/http-client/interfaces'
+import {HttpManager} from './http-manager'
+import {UploadSpecification} from './upload-specification'
+import {UploadOptions} from './upload-options'
+import {createGZipFileOnDisk, createGZipFileInBuffer} from './upload-gzip'
+import {retryHttpClientRequest} from './requestUtils'
+const stat = promisify(fs.stat)
+
+export class UploadHttpClient {
+  private uploadHttpManager: HttpManager
+  private statusReporter: StatusReporter
+
+  constructor() {
+    this.uploadHttpManager = new HttpManager(
+      getUploadFileConcurrency(),
+      '@actions/artifact-upload'
+    )
+    this.statusReporter = new StatusReporter(10000)
+  }
+
+  /**
+   * Creates a file container for the new artifact in the remote blob storage/file service
+   * @param {string} artifactName Name of the artifact being created
+   * @returns The response from the Artifact Service if the file container was successfully created
+   */
+  async createArtifactInFileContainer(
+    artifactName: string,
+    options?: UploadOptions | undefined
+  ): Promise<ArtifactResponse> {
+    const parameters: CreateArtifactParameters = {
+      Type: 'actions_storage',
+      Name: artifactName
+    }
+
+    // calculate retention period
+    if (options && options.retentionDays) {
+      const maxRetentionStr = getRetentionDays()
+      parameters.RetentionDays = getProperRetention(
+        options.retentionDays,
+        maxRetentionStr
+      )
+    }
+
+    const data: string = JSON.stringify(parameters, null, 2)
+    const artifactUrl = getArtifactUrl()
+
+    // use the first client from the httpManager, `keep-alive` is not used so the connection will close immediately
+    const client = this.uploadHttpManager.getClient(0)
+    const headers = getUploadHeaders('application/json', false)
+
+    // Extra information to display when a particular HTTP code is returned
+    // If a 403 is returned when trying to create a file container, the customer has exceeded
+    // their storage quota so no new artifact containers can be created
+    const customErrorMessages: Map<number, string> = new Map([
+      [
+        HttpCodes.Forbidden,
+        'Artifact storage quota has been hit. Unable to upload any new artifacts'
+      ],
+      [
+        HttpCodes.BadRequest,
+        `The artifact name ${artifactName} is not valid. Request URL ${artifactUrl}`
+      ]
+    ])
+
+    const response = await retryHttpClientRequest(
+      'Create Artifact Container',
+      async () => client.post(artifactUrl, data, headers),
+      customErrorMessages
+    )
+    const body: string = await response.readBody()
+    return JSON.parse(body)
+  }
+
+  /**
+   * Concurrently upload all of the files in chunks
+   * @param {string} uploadUrl Base Url for the artifact that was created
+   * @param {SearchResult[]} filesToUpload A list of information about the files being uploaded
+   * @returns The size of all the files uploaded in bytes
+   */
+  async uploadArtifactToFileContainer(
+    uploadUrl: string,
+    filesToUpload: UploadSpecification[],
+    options?: UploadOptions
+  ): Promise<UploadResults> {
+    const FILE_CONCURRENCY = getUploadFileConcurrency()
+    const MAX_CHUNK_SIZE = getUploadChunkSize()
+    core.debug(
+      `File Concurrency: ${FILE_CONCURRENCY}, and Chunk Size: ${MAX_CHUNK_SIZE}`
+    )
+
+    const parameters: UploadFileParameters[] = []
+    // by default, file uploads will continue if there is an error unless specified differently in the options
+    let continueOnError = true
+    if (options) {
+      if (options.continueOnError === false) {
+        continueOnError = false
+      }
+    }
+
+    // prepare the necessary parameters to upload all the files
+    for (const file of filesToUpload) {
+      const resourceUrl = new URL(uploadUrl)
+      resourceUrl.searchParams.append('itemPath', file.uploadFilePath)
+      parameters.push({
+        file: file.absoluteFilePath,
+        resourceUrl: resourceUrl.toString(),
+        maxChunkSize: MAX_CHUNK_SIZE,
+        continueOnError
+      })
+    }
+
+    const parallelUploads = [...new Array(FILE_CONCURRENCY).keys()]
+    const failedItemsToReport: string[] = []
+    let currentFile = 0
+    let completedFiles = 0
+    let uploadFileSize = 0
+    let totalFileSize = 0
+    let abortPendingFileUploads = false
+
+    this.statusReporter.setTotalNumberOfFilesToProcess(filesToUpload.length)
+    this.statusReporter.start()
+
+    // only allow a certain amount of files to be uploaded at once, this is done to reduce potential errors
+    await Promise.all(
+      parallelUploads.map(async index => {
+        while (currentFile < filesToUpload.length) {
+          const currentFileParameters = parameters[currentFile]
+          currentFile += 1
+          if (abortPendingFileUploads) {
+            failedItemsToReport.push(currentFileParameters.file)
+            continue
+          }
+
+          const startTime = performance.now()
+          const uploadFileResult = await this.uploadFileAsync(
+            index,
+            currentFileParameters
+          )
+
+          if (core.isDebug()) {
+            core.debug(
+              `File: ${++completedFiles}/${filesToUpload.length}. ${
+                currentFileParameters.file
+              } took ${(performance.now() - startTime).toFixed(
+                3
+              )} milliseconds to finish upload`
+            )
+          }
+
+          uploadFileSize += uploadFileResult.successfulUploadSize
+          totalFileSize += uploadFileResult.totalSize
+          if (uploadFileResult.isSuccess === false) {
+            failedItemsToReport.push(currentFileParameters.file)
+            if (!continueOnError) {
+              // fail fast
+              core.error(`aborting artifact upload`)
+              abortPendingFileUploads = true
+            }
+          }
+          this.statusReporter.incrementProcessedCount()
+        }
+      })
+    )
+
+    this.statusReporter.stop()
+    // done uploading, safety dispose all connections
+    this.uploadHttpManager.disposeAndReplaceAllClients()
+
+    core.info(`Total size of all the files uploaded is ${uploadFileSize} bytes`)
+    return {
+      uploadSize: uploadFileSize,
+      totalSize: totalFileSize,
+      failedItems: failedItemsToReport
+    }
+  }
+
+  /**
+   * Asynchronously uploads a file. The file is compressed and uploaded using GZip if it is determined to save space.
+   * If the upload file is bigger than the max chunk size it will be uploaded via multiple calls
+   * @param {number} httpClientIndex The index of the httpClient that is being used to make all of the calls
+   * @param {UploadFileParameters} parameters Information about the file that needs to be uploaded
+   * @returns The size of the file that was uploaded in bytes along with any failed uploads
+   */
+  private async uploadFileAsync(
+    httpClientIndex: number,
+    parameters: UploadFileParameters
+  ): Promise<UploadFileResult> {
+    const totalFileSize: number = (await stat(parameters.file)).size
+    let offset = 0
+    let isUploadSuccessful = true
+    let failedChunkSizes = 0
+    let uploadFileSize = 0
+    let isGzip = true
+
+    // the file that is being uploaded is less than 64k in size, to increase throughput and to minimize disk I/O
+    // for creating a new GZip file, an in-memory buffer is used for compression
+    if (totalFileSize < 65536) {
+      const buffer = await createGZipFileInBuffer(parameters.file)
+
+      //An open stream is needed in the event of a failure and we need to retry. If a NodeJS.ReadableStream is directly passed in,
+      // it will not properly get reset to the start of the stream if a chunk upload needs to be retried
+      let openUploadStream: () => NodeJS.ReadableStream
+
+      if (totalFileSize < buffer.byteLength) {
+        // compression did not help with reducing the size, use a readable stream from the original file for upload
+        openUploadStream = () => fs.createReadStream(parameters.file)
+        isGzip = false
+        uploadFileSize = totalFileSize
+      } else {
+        // create a readable stream using a PassThrough stream that is both readable and writable
+        openUploadStream = () => {
+          const passThrough = new stream.PassThrough()
+          passThrough.end(buffer)
+          return passThrough
+        }
+        uploadFileSize = buffer.byteLength
+      }
+
+      const result = await this.uploadChunk(
+        httpClientIndex,
+        parameters.resourceUrl,
+        openUploadStream,
+        0,
+        uploadFileSize - 1,
+        uploadFileSize,
+        isGzip,
+        totalFileSize
+      )
+
+      if (!result) {
+        // chunk failed to upload
+        isUploadSuccessful = false
+        failedChunkSizes += uploadFileSize
+        core.warning(`Aborting upload for ${parameters.file} due to failure`)
+      }
+
+      return {
+        isSuccess: isUploadSuccessful,
+        successfulUploadSize: uploadFileSize - failedChunkSizes,
+        totalSize: totalFileSize
+      }
+    } else {
+      // the file that is being uploaded is greater than 64k in size, a temporary file gets created on disk using the
+      // npm tmp-promise package and this file gets used to create a GZipped file
+      const tempFile = await tmp.file()
+
+      // create a GZip file of the original file being uploaded, the original file should not be modified in any way
+      uploadFileSize = await createGZipFileOnDisk(
+        parameters.file,
+        tempFile.path
+      )
+
+      let uploadFilePath = tempFile.path
+
+      // compression did not help with size reduction, use the original file for upload and delete the temp GZip file
+      if (totalFileSize < uploadFileSize) {
+        uploadFileSize = totalFileSize
+        uploadFilePath = parameters.file
+        isGzip = false
+      }
+
+      let abortFileUpload = false
+      // upload only a single chunk at a time
+      while (offset < uploadFileSize) {
+        const chunkSize = Math.min(
+          uploadFileSize - offset,
+          parameters.maxChunkSize
+        )
+
+        // if an individual file is greater than 100MB (1024*1024*100) in size, display extra information about the upload status
+        if (uploadFileSize > 104857600) {
+          this.statusReporter.updateLargeFileStatus(
+            parameters.file,
+            offset,
+            uploadFileSize
+          )
+        }
+
+        const start = offset
+        const end = offset + chunkSize - 1
+        offset += parameters.maxChunkSize
+
+        if (abortFileUpload) {
+          // if we don't want to continue in the event of an error, any pending upload chunks will be marked as failed
+          failedChunkSizes += chunkSize
+          continue
+        }
+
+        const result = await this.uploadChunk(
+          httpClientIndex,
+          parameters.resourceUrl,
+          () =>
+            fs.createReadStream(uploadFilePath, {
+              start,
+              end,
+              autoClose: false
+            }),
+          start,
+          end,
+          uploadFileSize,
+          isGzip,
+          totalFileSize
+        )
+
+        if (!result) {
+          // Chunk failed to upload, report as failed and do not continue uploading any more chunks for the file. It is possible that part of a chunk was
+          // successfully uploaded so the server may report a different size for what was uploaded
+          isUploadSuccessful = false
+          failedChunkSizes += chunkSize
+          core.warning(`Aborting upload for ${parameters.file} due to failure`)
+          abortFileUpload = true
+        }
+      }
+
+      // Delete the temporary file that was created as part of the upload. If the temp file does not get manually deleted by
+      // calling cleanup, it gets removed when the node process exits. For more info see: https://www.npmjs.com/package/tmp-promise#about
+      await tempFile.cleanup()
+
+      return {
+        isSuccess: isUploadSuccessful,
+        successfulUploadSize: uploadFileSize - failedChunkSizes,
+        totalSize: totalFileSize
+      }
+    }
+  }
+
+  /**
+   * Uploads a chunk of an individual file to the specified resourceUrl. If the upload fails and the status code
+   * indicates a retryable status, we try to upload the chunk as well
+   * @param {number} httpClientIndex The index of the httpClient being used to make all the necessary calls
+   * @param {string} resourceUrl Url of the resource that the chunk will be uploaded to
+   * @param {NodeJS.ReadableStream} openStream Stream of the file that will be uploaded
+   * @param {number} start Starting byte index of file that the chunk belongs to
+   * @param {number} end Ending byte index of file that the chunk belongs to
+   * @param {number} uploadFileSize Total size of the file in bytes that is being uploaded
+   * @param {boolean} isGzip Denotes if we are uploading a Gzip compressed stream
+   * @param {number} totalFileSize Original total size of the file that is being uploaded
+   * @returns if the chunk was successfully uploaded
+   */
+  private async uploadChunk(
+    httpClientIndex: number,
+    resourceUrl: string,
+    openStream: () => NodeJS.ReadableStream,
+    start: number,
+    end: number,
+    uploadFileSize: number,
+    isGzip: boolean,
+    totalFileSize: number
+  ): Promise<boolean> {
+    // prepare all the necessary headers before making any http call
+    const headers = getUploadHeaders(
+      'application/octet-stream',
+      true,
+      isGzip,
+      totalFileSize,
+      end - start + 1,
+      getContentRange(start, end, uploadFileSize)
+    )
+
+    const uploadChunkRequest = async (): Promise<IHttpClientResponse> => {
+      const client = this.uploadHttpManager.getClient(httpClientIndex)
+      return await client.sendStream('PUT', resourceUrl, openStream(), headers)
+    }
+
+    let retryCount = 0
+    const retryLimit = getRetryLimit()
+
+    // Increments the current retry count and then checks if the retry limit has been reached
+    // If there have been too many retries, fail so the download stops
+    const incrementAndCheckRetryLimit = (
+      response?: IHttpClientResponse
+    ): boolean => {
+      retryCount++
+      if (retryCount > retryLimit) {
+        if (response) {
+          displayHttpDiagnostics(response)
+        }
+        core.info(
+          `Retry limit has been reached for chunk at offset ${start} to ${resourceUrl}`
+        )
+        return true
+      }
+      return false
+    }
+
+    const backOff = async (retryAfterValue?: number): Promise<void> => {
+      this.uploadHttpManager.disposeAndReplaceClient(httpClientIndex)
+      if (retryAfterValue) {
+        core.info(
+          `Backoff due to too many requests, retry #${retryCount}. Waiting for ${retryAfterValue} milliseconds before continuing the upload`
+        )
+        await sleep(retryAfterValue)
+      } else {
+        const backoffTime = getExponentialRetryTimeInMilliseconds(retryCount)
+        core.info(
+          `Exponential backoff for retry #${retryCount}. Waiting for ${backoffTime} milliseconds before continuing the upload at offset ${start}`
+        )
+        await sleep(backoffTime)
+      }
+      core.info(
+        `Finished backoff for retry #${retryCount}, continuing with upload`
+      )
+      return
+    }
+
+    // allow for failed chunks to be retried multiple times
+    while (retryCount <= retryLimit) {
+      let response: IHttpClientResponse
+
+      try {
+        response = await uploadChunkRequest()
+      } catch (error) {
+        // if an error is caught, it is usually indicative of a timeout so retry the upload
+        core.info(
+          `An error has been caught http-client index ${httpClientIndex}, retrying the upload`
+        )
+        // eslint-disable-next-line no-console
+        console.log(error)
+
+        if (incrementAndCheckRetryLimit()) {
+          return false
+        }
+        await backOff()
+        continue
+      }
+
+      // Always read the body of the response. There is potential for a resource leak if the body is not read which will
+      // result in the connection remaining open along with unintended consequences when trying to dispose of the client
+      await response.readBody()
+
+      if (isSuccessStatusCode(response.message.statusCode)) {
+        return true
+      } else if (isRetryableStatusCode(response.message.statusCode)) {
+        core.info(
+          `A ${response.message.statusCode} status code has been received, will attempt to retry the upload`
+        )
+        if (incrementAndCheckRetryLimit(response)) {
+          return false
+        }
+        isThrottledStatusCode(response.message.statusCode)
+          ? await backOff(
+              tryGetRetryAfterValueTimeInMilliseconds(response.message.headers)
+            )
+          : await backOff()
+      } else {
+        core.error(
+          `Unexpected response. Unable to upload chunk to ${resourceUrl}`
+        )
+        displayHttpDiagnostics(response)
+        return false
+      }
+    }
+    return false
+  }
+
+  /**
+   * Updates the size of the artifact from -1 which was initially set when the container was first created for the artifact.
+   * Updating the size indicates that we are done uploading all the contents of the artifact
+   */
+  async patchArtifactSize(size: number, artifactName: string): Promise<void> {
+    const resourceUrl = new URL(getArtifactUrl())
+    resourceUrl.searchParams.append('artifactName', artifactName)
+
+    const parameters: PatchArtifactSize = {Size: size}
+    const data: string = JSON.stringify(parameters, null, 2)
+    core.debug(`URL is ${resourceUrl.toString()}`)
+
+    // use the first client from the httpManager, `keep-alive` is not used so the connection will close immediately
+    const client = this.uploadHttpManager.getClient(0)
+    const headers = getUploadHeaders('application/json', false)
+
+    // Extra information to display when a particular HTTP code is returned
+    const customErrorMessages: Map<number, string> = new Map([
+      [
+        HttpCodes.NotFound,
+        `An Artifact with the name ${artifactName} was not found`
+      ]
+    ])
+
+    // TODO retry for all possible response codes, the artifact upload is pretty much complete so it at all costs we should try to finish this
+    const response = await retryHttpClientRequest(
+      'Finalize artifact upload',
+      async () => client.patch(resourceUrl.toString(), data, headers),
+      customErrorMessages
+    )
+    await response.readBody()
+    core.debug(
+      `Artifact ${artifactName} has been successfully uploaded, total size in bytes: ${size}`
+    )
+  }
+}
+
+interface UploadFileParameters {
+  file: string
+  resourceUrl: string
+  maxChunkSize: number
+  continueOnError: boolean
+}
+
+interface UploadFileResult {
+  isSuccess: boolean
+  successfulUploadSize: number
+  totalSize: number
+}
@@ -0,0 +1,35 @@
+export interface UploadOptions {
+  /**
+   * Indicates if the artifact upload should continue if file or chunk fails to upload from any error.
+   * If there is a error during upload, a partial artifact will always be associated and available for
+   * download at the end. The size reported will be the amount of storage that the user or org will be
+   * charged for the partial artifact. Defaults to true if not specified
+   *
+   * If set to false, and an error is encountered, all other uploads will stop and any files or chunks
+   * that were queued will not be attempted to be uploaded. The partial artifact available will only
+   * include files and chunks up until the failure
+   *
+   * If set to true and an error is encountered, the failed file will be skipped and ignored and all
+   * other queued files will be attempted to be uploaded. The partial artifact at the end will have all
+   * files with the exception of the problematic files(s)/chunks(s) that failed to upload
+   *
+   */
+  continueOnError?: boolean
+
+  /**
+   * Duration after which artifact will expire in days.
+   *
+   * By default artifact expires after 90 days:
+   * https://docs.github.com/en/actions/configuring-and-managing-workflows/persisting-workflow-data-using-artifacts#downloading-and-deleting-artifacts-after-a-workflow-run-is-complete
+   *
+   * Use this option to override the default expiry.
+   *
+   * Min value: 1
+   * Max value: 90 unless changed by repository setting
+   *
+   * If this is set to a greater value than the retention settings allowed, the retention on artifacts
+   * will be reduced to match the max value allowed on server, and the upload process will continue. An
+   * input of 0 assumes default retention setting.
+   */
+  retentionDays?: number
+}
@@ -0,0 +1,22 @@
+export interface UploadResponse {
+  /**
+   * The name of the artifact that was uploaded
+   */
+  artifactName: string
+
+  /**
+   * A list of all items that are meant to be uploaded as part of the artifact
+   */
+  artifactItems: string[]
+
+  /**
+   * Total size of the artifact in bytes that was uploaded
+   */
+  size: number
+
+  /**
+   * A list of items that were not uploaded as part of the artifact (includes queued items that were not uploaded if
+   * continueOnError is set to false). This is a subset of artifactItems.
+   */
+  failedItems: string[]
+}
@@ -0,0 +1,95 @@
+import * as fs from 'fs'
+import {debug} from '@actions/core'
+import {join, normalize, resolve} from 'path'
+import {checkArtifactName, checkArtifactFilePath} from './utils'
+
+export interface UploadSpecification {
+  absoluteFilePath: string
+  uploadFilePath: string
+}
+
+/**
+ * Creates a specification that describes how each file that is part of the artifact will be uploaded
+ * @param artifactName the name of the artifact being uploaded. Used during upload to denote where the artifact is stored on the server
+ * @param rootDirectory an absolute file path that denotes the path that should be removed from the beginning of each artifact file
+ * @param artifactFiles a list of absolute file paths that denote what should be uploaded as part of the artifact
+ */
+export function getUploadSpecification(
+  artifactName: string,
+  rootDirectory: string,
+  artifactFiles: string[]
+): UploadSpecification[] {
+  checkArtifactName(artifactName)
+
+  const specifications: UploadSpecification[] = []
+
+  if (!fs.existsSync(rootDirectory)) {
+    throw new Error(`Provided rootDirectory ${rootDirectory} does not exist`)
+  }
+  if (!fs.lstatSync(rootDirectory).isDirectory()) {
+    throw new Error(
+      `Provided rootDirectory ${rootDirectory} is not a valid directory`
+    )
+  }
+  // Normalize and resolve, this allows for either absolute or relative paths to be used
+  rootDirectory = normalize(rootDirectory)
+  rootDirectory = resolve(rootDirectory)
+
+  /*
+     Example to demonstrate behavior
+     
+     Input:
+       artifactName: my-artifact
+       rootDirectory: '/home/user/files/plz-upload'
+       artifactFiles: [
+         '/home/user/files/plz-upload/file1.txt',
+         '/home/user/files/plz-upload/file2.txt',
+         '/home/user/files/plz-upload/dir/file3.txt'
+       ]
+     
+     Output:
+       specifications: [
+         ['/home/user/files/plz-upload/file1.txt', 'my-artifact/file1.txt'],
+         ['/home/user/files/plz-upload/file1.txt', 'my-artifact/file2.txt'],
+         ['/home/user/files/plz-upload/file1.txt', 'my-artifact/dir/file3.txt']
+       ]
+  */
+  for (let file of artifactFiles) {
+    if (!fs.existsSync(file)) {
+      throw new Error(`File ${file} does not exist`)
+    }
+    if (!fs.lstatSync(file).isDirectory()) {
+      // Normalize and resolve, this allows for either absolute or relative paths to be used
+      file = normalize(file)
+      file = resolve(file)
+      if (!file.startsWith(rootDirectory)) {
+        throw new Error(
+          `The rootDirectory: ${rootDirectory} is not a parent directory of the file: ${file}`
+        )
+      }
+
+      // Check for forbidden characters in file paths that will be rejected during upload
+      const uploadPath = file.replace(rootDirectory, '')
+      checkArtifactFilePath(uploadPath)
+
+      /*
+        uploadFilePath denotes where the file will be uploaded in the file container on the server. During a run, if multiple artifacts are uploaded, they will all
+        be saved in the same container. The artifact name is used as the root directory in the container to separate and distinguish uploaded artifacts
+
+        path.join handles all the following cases and would return 'artifact-name/file-to-upload.txt
+          join('artifact-name/', 'file-to-upload.txt')
+          join('artifact-name/', '/file-to-upload.txt')
+          join('artifact-name', 'file-to-upload.txt')
+          join('artifact-name', '/file-to-upload.txt')
+      */
+      specifications.push({
+        absoluteFilePath: file,
+        uploadFilePath: join(artifactName, uploadPath)
+      })
+    } else {
+      // Directories are rejected by the server during upload
+      debug(`Removing ${file} from rawSearchResults because it is a directory`)
+    }
+  }
+  return specifications
+}
@@ -1,96 +0,0 @@
-import {BlobClient, BlockBlobUploadStreamOptions} from '@azure/storage-blob'
-import {TransferProgressEvent} from '@azure/core-http'
-import {ZipUploadStream} from './zip'
-import {getUploadChunkSize} from '../shared/config'
-import * as core from '@actions/core'
-import * as crypto from 'crypto'
-import * as stream from 'stream'
-
-export interface BlobUploadResponse {
-  /**
-   * If the upload was successful or not
-   */
-  isSuccess: boolean
-
-  /**
-   * The total reported upload size in bytes. Empty if the upload failed
-   */
-  uploadSize?: number
-
-  /**
-   * The SHA256 hash of the uploaded file. Empty if the upload failed
-   */
-  sha256Hash?: string
-}
-
-export async function uploadZipToBlobStorage(
-  authenticatedUploadURL: string,
-  zipUploadStream: ZipUploadStream
-): Promise<BlobUploadResponse> {
-  let uploadByteCount = 0
-
-  const maxBuffers = 5
-  const bufferSize = getUploadChunkSize()
-  const blobClient = new BlobClient(authenticatedUploadURL)
-  const blockBlobClient = blobClient.getBlockBlobClient()
-
-  core.debug(
-    `Uploading artifact zip to blob storage with maxBuffers: ${maxBuffers}, bufferSize: ${bufferSize}`
-  )
-
-  const uploadCallback = (progress: TransferProgressEvent): void => {
-    core.info(`Uploaded bytes ${progress.loadedBytes}`)
-    uploadByteCount = progress.loadedBytes
-  }
-
-  const options: BlockBlobUploadStreamOptions = {
-    blobHTTPHeaders: {blobContentType: 'zip'},
-    onProgress: uploadCallback
-  }
-
-  let sha256Hash: string | undefined = undefined
-  const uploadStream = new stream.PassThrough()
-  const hashStream = crypto.createHash('sha256')
-
-  zipUploadStream.pipe(uploadStream) // This stream is used for the upload
-  zipUploadStream.pipe(hashStream).setEncoding('hex') // This stream is used to compute a hash of the zip content that gets used. Integrity check
-
-  try {
-    core.info('Beginning upload of artifact content to blob storage')
-
-    await blockBlobClient.uploadStream(
-      uploadStream,
-      bufferSize,
-      maxBuffers,
-      options
-    )
-
-    core.info('Finished uploading artifact content to blob storage!')
-
-    hashStream.end()
-    sha256Hash = hashStream.read() as string
-    core.info(`SHA256 hash of uploaded artifact zip is ${sha256Hash}`)
-  } catch (error) {
-    core.warning(
-      `Failed to upload artifact zip to blob storage, error: ${error}`
-    )
-    return {
-      isSuccess: false
-    }
-  }
-
-  if (uploadByteCount === 0) {
-    core.warning(
-      `No data was uploaded to blob storage. Reported upload byte count is 0`
-    )
-    return {
-      isSuccess: false
-    }
-  }
-
-  return {
-    isSuccess: true,
-    uploadSize: uploadByteCount,
-    sha256Hash
-  }
-}
@@ -1,82 +0,0 @@
-import {info} from '@actions/core'
-
-/**
- * Invalid characters that cannot be in the artifact name or an uploaded file. Will be rejected
- * from the server if attempted to be sent over. These characters are not allowed due to limitations with certain
- * file systems such as NTFS. To maintain platform-agnostic behavior, all characters that are not supported by an
- * individual filesystem/platform will not be supported on all fileSystems/platforms
- *
- * FilePaths can include characters such as \ and / which are not permitted in the artifact name alone
- */
-const invalidArtifactFilePathCharacters = new Map<string, string>([
-  ['"', ' Double quote "'],
-  [':', ' Colon :'],
-  ['<', ' Less than <'],
-  ['>', ' Greater than >'],
-  ['|', ' Vertical bar |'],
-  ['*', ' Asterisk *'],
-  ['?', ' Question mark ?'],
-  ['\r', ' Carriage return \\r'],
-  ['\n', ' Line feed \\n']
-])
-
-const invalidArtifactNameCharacters = new Map<string, string>([
-  ...invalidArtifactFilePathCharacters,
-  ['\\', ' Backslash \\'],
-  ['/', ' Forward slash /']
-])
-
-/**
- * Validates the name of the artifact to check to make sure there are no illegal characters
- */
-export function validateArtifactName(name: string): void {
-  if (!name) {
-    throw new Error(`Provided artifact name input during validation is empty`)
-  }
-
-  for (const [
-    invalidCharacterKey,
-    errorMessageForCharacter
-  ] of invalidArtifactNameCharacters) {
-    if (name.includes(invalidCharacterKey)) {
-      throw new Error(
-        `The artifact name is not valid: ${name}. Contains the following character: ${errorMessageForCharacter}
-          
-Invalid characters include: ${Array.from(
-          invalidArtifactNameCharacters.values()
-        ).toString()}
-          
-These characters are not allowed in the artifact name due to limitations with certain file systems such as NTFS. To maintain file system agnostic behavior, these characters are intentionally not allowed to prevent potential problems with downloads on different file systems.`
-      )
-    }
-  }
-
-  info(`Artifact name is valid!`)
-}
-
-/**
- * Validates file paths to check for any illegal characters that can cause problems on different file systems
- */
-export function validateFilePath(path: string): void {
-  if (!path) {
-    throw new Error(`Provided file path input during validation is empty`)
-  }
-
-  for (const [
-    invalidCharacterKey,
-    errorMessageForCharacter
-  ] of invalidArtifactFilePathCharacters) {
-    if (path.includes(invalidCharacterKey)) {
-      throw new Error(
-        `The path for one of the files in artifact is not valid: ${path}. Contains the following character: ${errorMessageForCharacter}
-          
-Invalid characters include: ${Array.from(
-          invalidArtifactFilePathCharacters.values()
-        ).toString()}
-          
-The following characters are not allowed in files that are uploaded due to limitations with certain file systems such as NTFS. To maintain file system agnostic behavior, these characters are intentionally not allowed to prevent potential problems with downloads on different file systems.
-          `
-      )
-    }
-  }
-}
@@ -1,34 +0,0 @@
-import {Timestamp} from '../../generated'
-import * as core from '@actions/core'
-
-export function getExpiration(retentionDays?: number): Timestamp | undefined {
-  if (!retentionDays) {
-    return undefined
-  }
-
-  const maxRetentionDays = getRetentionDays()
-  if (maxRetentionDays && maxRetentionDays < retentionDays) {
-    core.warning(
-      `Retention days cannot be greater than the maximum allowed retention set within the repository. Using ${maxRetentionDays} instead.`
-    )
-    retentionDays = maxRetentionDays
-  }
-
-  const expirationDate = new Date()
-  expirationDate.setDate(expirationDate.getDate() + retentionDays)
-
-  return Timestamp.fromDate(expirationDate)
-}
-
-function getRetentionDays(): number | undefined {
-  const retentionDays = process.env['GITHUB_RETENTION_DAYS']
-  if (!retentionDays) {
-    return undefined
-  }
-  const days = parseInt(retentionDays)
-  if (isNaN(days)) {
-    return undefined
-  }
-
-  return days
-}
@@ -1,129 +0,0 @@
-import * as core from '@actions/core'
-import {UploadOptions, UploadResponse} from '../shared/interfaces'
-import {getExpiration} from './retention'
-import {validateArtifactName} from './path-and-artifact-name-validation'
-import {createArtifactTwirpClient} from '../shared/artifact-twirp-client'
-import {
-  UploadZipSpecification,
-  getUploadZipSpecification,
-  validateRootDirectory
-} from './upload-zip-specification'
-import {getBackendIdsFromToken} from '../shared/util'
-import {uploadZipToBlobStorage} from './blob-upload'
-import {createZipUploadStream} from './zip'
-import {
-  CreateArtifactRequest,
-  FinalizeArtifactRequest,
-  StringValue
-} from '../../generated'
-
-export async function uploadArtifact(
-  name: string,
-  files: string[],
-  rootDirectory: string,
-  options?: UploadOptions | undefined
-): Promise<UploadResponse> {
-  validateArtifactName(name)
-  validateRootDirectory(rootDirectory)
-
-  const zipSpecification: UploadZipSpecification[] = getUploadZipSpecification(
-    files,
-    rootDirectory
-  )
-  if (zipSpecification.length === 0) {
-    core.warning(`No files were found to upload`)
-    return {
-      success: false
-    }
-  }
-
-  const zipUploadStream = await createZipUploadStream(zipSpecification)
-
-  // get the IDs needed for the artifact creation
-  const backendIds = getBackendIdsFromToken()
-  if (!backendIds.workflowRunBackendId || !backendIds.workflowJobRunBackendId) {
-    core.warning(
-      `Failed to get the necessary backend ids which are required to create the artifact`
-    )
-    return {
-      success: false
-    }
-  }
-  core.debug(`Workflow Run Backend ID: ${backendIds.workflowRunBackendId}`)
-  core.debug(
-    `Workflow Job Run Backend ID: ${backendIds.workflowJobRunBackendId}`
-  )
-
-  // create the artifact client
-  const artifactClient = createArtifactTwirpClient('upload')
-
-  // create the artifact
-  const createArtifactReq: CreateArtifactRequest = {
-    workflowRunBackendId: backendIds.workflowRunBackendId,
-    workflowJobRunBackendId: backendIds.workflowJobRunBackendId,
-    name,
-    version: 4
-  }
-
-  // if there is a retention period, add it to the request
-  const expiresAt = getExpiration(options?.retentionDays)
-  if (expiresAt) {
-    createArtifactReq.expiresAt = expiresAt
-  }
-
-  const createArtifactResp =
-    await artifactClient.CreateArtifact(createArtifactReq)
-  if (!createArtifactResp.ok) {
-    core.warning(`Failed to create artifact`)
-    return {
-      success: false
-    }
-  }
-
-  // Upload zip to blob storage
-  const uploadResult = await uploadZipToBlobStorage(
-    createArtifactResp.signedUploadUrl,
-    zipUploadStream
-  )
-  if (uploadResult.isSuccess === false) {
-    return {
-      success: false
-    }
-  }
-
-  // finalize the artifact
-  const finalizeArtifactReq: FinalizeArtifactRequest = {
-    workflowRunBackendId: backendIds.workflowRunBackendId,
-    workflowJobRunBackendId: backendIds.workflowJobRunBackendId,
-    name,
-    size: uploadResult.uploadSize ? uploadResult.uploadSize.toString() : '0'
-  }
-
-  if (uploadResult.sha256Hash) {
-    finalizeArtifactReq.hash = StringValue.create({
-      value: `sha256:${uploadResult.sha256Hash}`
-    })
-  }
-
-  core.info(`Finalizing artifact upload`)
-
-  const finalizeArtifactResp =
-    await artifactClient.FinalizeArtifact(finalizeArtifactReq)
-  if (!finalizeArtifactResp.ok) {
-    core.warning(`Failed to finalize artifact`)
-    return {
-      success: false
-    }
-  }
-
-  const artifactId = BigInt(finalizeArtifactResp.artifactId)
-  core.info(
-    `Artifact ${name}.zip successfully finalized. Artifact ID ${artifactId}`
-  )
-
-  return {
-    success: true,
-    size: uploadResult.uploadSize,
-    id: Number(artifactId)
-  }
-}
@@ -1,111 +0,0 @@
-import * as fs from 'fs'
-import {info} from '@actions/core'
-import {normalize, resolve} from 'path'
-import {validateFilePath} from './path-and-artifact-name-validation'
-
-export interface UploadZipSpecification {
-  /**
-   * An absolute source path that points to a file that will be added to a zip. Null if creating a new directory
-   */
-  sourcePath: string | null
-
-  /**
-   * The destination path in a zip for a file
-   */
-  destinationPath: string
-}
-
-/**
- * Checks if a root directory exists and is valid
- * @param rootDirectory an absolute root directory path common to all input files that that will be trimmed from the final zip structure
- */
-export function validateRootDirectory(rootDirectory: string): void {
-  if (!fs.existsSync(rootDirectory)) {
-    throw new Error(
-      `The provided rootDirectory ${rootDirectory} does not exist`
-    )
-  }
-  if (!fs.statSync(rootDirectory).isDirectory()) {
-    throw new Error(
-      `The provided rootDirectory ${rootDirectory} is not a valid directory`
-    )
-  }
-  info(`Root directory input is valid!`)
-}
-
-/**
- * Creates a specification that describes how a zip file will be created for a set of input files
- * @param filesToZip a list of file that should be included in the zip
- * @param rootDirectory an absolute root directory path common to all input files that that will be trimmed from the final zip structure
- */
-export function getUploadZipSpecification(
-  filesToZip: string[],
-  rootDirectory: string
-): UploadZipSpecification[] {
-  const specification: UploadZipSpecification[] = []
-
-  // Normalize and resolve, this allows for either absolute or relative paths to be used
-  rootDirectory = normalize(rootDirectory)
-  rootDirectory = resolve(rootDirectory)
-
-  /*
-     Example
-     
-     Input:
-       rootDirectory: '/home/user/files/plz-upload'
-       artifactFiles: [
-         '/home/user/files/plz-upload/file1.txt',
-         '/home/user/files/plz-upload/file2.txt',
-         '/home/user/files/plz-upload/dir/file3.txt'
-       ]
-     
-     Output:
-       specifications: [
-         ['/home/user/files/plz-upload/file1.txt', '/file1.txt'],
-         ['/home/user/files/plz-upload/file1.txt', '/file2.txt'],
-         ['/home/user/files/plz-upload/file1.txt', '/dir/file3.txt']
-       ]
-
-      The final zip that is later uploaded will look like this:
-
-      my-artifact.zip
-        - file.txt
-        - file2.txt
-        - dir/
-          - file3.txt
-  */
-  for (let file of filesToZip) {
-    if (!fs.existsSync(file)) {
-      throw new Error(`File ${file} does not exist`)
-    }
-    if (!fs.statSync(file).isDirectory()) {
-      // Normalize and resolve, this allows for either absolute or relative paths to be used
-      file = normalize(file)
-      file = resolve(file)
-      if (!file.startsWith(rootDirectory)) {
-        throw new Error(
-          `The rootDirectory: ${rootDirectory} is not a parent directory of the file: ${file}`
-        )
-      }
-
-      // Check for forbidden characters in file paths that may cause ambiguous behavior if downloaded on different file systems
-      const uploadPath = file.replace(rootDirectory, '')
-      validateFilePath(uploadPath)
-
-      specification.push({
-        sourcePath: file,
-        destinationPath: uploadPath
-      })
-    } else {
-      // Empty directory
-      const directoryPath = file.replace(rootDirectory, '')
-      validateFilePath(directoryPath)
-
-      specification.push({
-        sourcePath: null,
-        destinationPath: directoryPath
-      })
-    }
-  }
-  return specification
-}
@@ -1,97 +0,0 @@
-import * as stream from 'stream'
-import * as archiver from 'archiver'
-import * as core from '@actions/core'
-import {createReadStream} from 'fs'
-import {UploadZipSpecification} from './upload-zip-specification'
-import {getUploadChunkSize} from '../shared/config'
-
-// Custom stream transformer so we can set the highWaterMark property
-// See https://github.com/nodejs/node/issues/8855
-export class ZipUploadStream extends stream.Transform {
-  constructor(bufferSize: number) {
-    super({
-      highWaterMark: bufferSize
-    })
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _transform(chunk: any, enc: any, cb: any): void {
-    cb(null, chunk)
-  }
-}
-
-export async function createZipUploadStream(
-  uploadSpecification: UploadZipSpecification[]
-): Promise<ZipUploadStream> {
-  const zip = archiver.create('zip', {
-    zlib: {level: 9} // Sets the compression level.
-    // Available options are 0-9
-    // 0 => no compression
-    // 1 => fastest with low compression
-    // 9 => highest compression ratio but the slowest
-  })
-
-  // register callbacks for various events during the zip lifecycle
-  zip.on('error', zipErrorCallback)
-  zip.on('warning', zipWarningCallback)
-  zip.on('finish', zipFinishCallback)
-  zip.on('end', zipEndCallback)
-
-  for (const file of uploadSpecification) {
-    if (file.sourcePath !== null) {
-      // Add a normal file to the zip
-      zip.append(createReadStream(file.sourcePath), {
-        name: file.destinationPath
-      })
-    } else {
-      // Add a directory to the zip
-      zip.append('', {name: file.destinationPath})
-    }
-  }
-
-  const bufferSize = getUploadChunkSize()
-  const zipUploadStream = new ZipUploadStream(bufferSize)
-
-  core.debug(
-    `Zip write high watermark value ${zipUploadStream.writableHighWaterMark}`
-  )
-  core.debug(
-    `Zip read high watermark value ${zipUploadStream.readableHighWaterMark}`
-  )
-
-  zip.pipe(zipUploadStream)
-  zip.finalize()
-
-  return zipUploadStream
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const zipErrorCallback = (error: any): void => {
-  core.error('An error has occurred while creating the zip file for upload')
-  core.info(error)
-
-  throw new Error('An error has occurred during zip creation for the artifact')
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const zipWarningCallback = (error: any): void => {
-  if (error.code === 'ENOENT') {
-    core.warning(
-      'ENOENT warning during artifact zip creation. No such file or directory'
-    )
-    core.info(error)
-  } else {
-    core.warning(
-      `A non-blocking warning has occurred during artifact zip creation: ${error.code}`
-    )
-    core.info(error)
-  }
-}
-
-const zipFinishCallback = (): void => {
-  core.debug('Zip stream for upload has finished.')
-}
-
-const zipEndCallback = (): void => {
-  core.debug('Zip stream for upload has ended.')
-}
@@ -0,0 +1,341 @@
+import {debug, info, warning} from '@actions/core'
+import {promises as fs} from 'fs'
+import {HttpCodes, HttpClient} from '@actions/http-client'
+import {BearerCredentialHandler} from '@actions/http-client/auth'
+import {IHeaders, IHttpClientResponse} from '@actions/http-client/interfaces'
+import {IncomingHttpHeaders} from 'http'
+import {
+  getRuntimeToken,
+  getRuntimeUrl,
+  getWorkFlowRunId,
+  getRetryMultiplier,
+  getInitialRetryIntervalInMilliseconds
+} from './config-variables'
+
+/**
+ * Returns a retry time in milliseconds that exponentially gets larger
+ * depending on the amount of retries that have been attempted
+ */
+export function getExponentialRetryTimeInMilliseconds(
+  retryCount: number
+): number {
+  if (retryCount < 0) {
+    throw new Error('RetryCount should not be negative')
+  } else if (retryCount === 0) {
+    return getInitialRetryIntervalInMilliseconds()
+  }
+
+  const minTime =
+    getInitialRetryIntervalInMilliseconds() * getRetryMultiplier() * retryCount
+  const maxTime = minTime * getRetryMultiplier()
+
+  // returns a random number between the minTime (inclusive) and the maxTime (exclusive)
+  return Math.random() * (maxTime - minTime) + minTime
+}
+
+/**
+ * Parses a env variable that is a number
+ */
+export function parseEnvNumber(key: string): number | undefined {
+  const value = Number(process.env[key])
+  if (Number.isNaN(value) || value < 0) {
+    return undefined
+  }
+  return value
+}
+
+/**
+ * Various utility functions to help with the necessary API calls
+ */
+export function getApiVersion(): string {
+  return '6.0-preview'
+}
+
+export function isSuccessStatusCode(statusCode?: number): boolean {
+  if (!statusCode) {
+    return false
+  }
+  return statusCode >= 200 && statusCode < 300
+}
+
+export function isForbiddenStatusCode(statusCode?: number): boolean {
+  if (!statusCode) {
+    return false
+  }
+  return statusCode === HttpCodes.Forbidden
+}
+
+export function isRetryableStatusCode(statusCode: number | undefined): boolean {
+  if (!statusCode) {
+    return false
+  }
+
+  const retryableStatusCodes = [
+    HttpCodes.BadGateway,
+    HttpCodes.ServiceUnavailable,
+    HttpCodes.GatewayTimeout,
+    HttpCodes.TooManyRequests,
+    413 // Payload Too Large
+  ]
+  return retryableStatusCodes.includes(statusCode)
+}
+
+export function isThrottledStatusCode(statusCode?: number): boolean {
+  if (!statusCode) {
+    return false
+  }
+  return statusCode === HttpCodes.TooManyRequests
+}
+
+/**
+ * Attempts to get the retry-after value from a set of http headers. The retry time
+ * is originally denoted in seconds, so if present, it is converted to milliseconds
+ * @param headers all the headers received when making an http call
+ */
+export function tryGetRetryAfterValueTimeInMilliseconds(
+  headers: IncomingHttpHeaders
+): number | undefined {
+  if (headers['retry-after']) {
+    const retryTime = Number(headers['retry-after'])
+    if (!isNaN(retryTime)) {
+      info(`Retry-After header is present with a value of ${retryTime}`)
+      return retryTime * 1000
+    }
+    info(
+      `Returned retry-after header value: ${retryTime} is non-numeric and cannot be used`
+    )
+    return undefined
+  }
+  info(
+    `No retry-after header was found. Dumping all headers for diagnostic purposes`
+  )
+  // eslint-disable-next-line no-console
+  console.log(headers)
+  return undefined
+}
+
+export function getContentRange(
+  start: number,
+  end: number,
+  total: number
+): string {
+  // Format: `bytes start-end/fileSize
+  // start and end are inclusive
+  // For a 200 byte chunk starting at byte 0:
+  // Content-Range: bytes 0-199/200
+  return `bytes ${start}-${end}/${total}`
+}
+
+/**
+ * Sets all the necessary headers when downloading an artifact
+ * @param {string} contentType the type of content being uploaded
+ * @param {boolean} isKeepAlive is the same connection being used to make multiple calls
+ * @param {boolean} acceptGzip can we accept a gzip encoded response
+ * @param {string} acceptType the type of content that we can accept
+ * @returns appropriate headers to make a specific http call during artifact download
+ */
+export function getDownloadHeaders(
+  contentType: string,
+  isKeepAlive?: boolean,
+  acceptGzip?: boolean
+): IHeaders {
+  const requestOptions: IHeaders = {}
+
+  if (contentType) {
+    requestOptions['Content-Type'] = contentType
+  }
+  if (isKeepAlive) {
+    requestOptions['Connection'] = 'Keep-Alive'
+    // keep alive for at least 10 seconds before closing the connection
+    requestOptions['Keep-Alive'] = '10'
+  }
+  if (acceptGzip) {
+    // if we are expecting a response with gzip encoding, it should be using an octet-stream in the accept header
+    requestOptions['Accept-Encoding'] = 'gzip'
+    requestOptions[
+      'Accept'
+    ] = `application/octet-stream;api-version=${getApiVersion()}`
+  } else {
+    // default to application/json if we are not working with gzip content
+    requestOptions['Accept'] = `application/json;api-version=${getApiVersion()}`
+  }
+
+  return requestOptions
+}
+
+/**
+ * Sets all the necessary headers when uploading an artifact
+ * @param {string} contentType the type of content being uploaded
+ * @param {boolean} isKeepAlive is the same connection being used to make multiple calls
+ * @param {boolean} isGzip is the connection being used to upload GZip compressed content
+ * @param {number} uncompressedLength the original size of the content if something is being uploaded that has been compressed
+ * @param {number} contentLength the length of the content that is being uploaded
+ * @param {string} contentRange the range of the content that is being uploaded
+ * @returns appropriate headers to make a specific http call during artifact upload
+ */
+export function getUploadHeaders(
+  contentType: string,
+  isKeepAlive?: boolean,
+  isGzip?: boolean,
+  uncompressedLength?: number,
+  contentLength?: number,
+  contentRange?: string
+): IHeaders {
+  const requestOptions: IHeaders = {}
+  requestOptions['Accept'] = `application/json;api-version=${getApiVersion()}`
+  if (contentType) {
+    requestOptions['Content-Type'] = contentType
+  }
+  if (isKeepAlive) {
+    requestOptions['Connection'] = 'Keep-Alive'
+    // keep alive for at least 10 seconds before closing the connection
+    requestOptions['Keep-Alive'] = '10'
+  }
+  if (isGzip) {
+    requestOptions['Content-Encoding'] = 'gzip'
+    requestOptions['x-tfs-filelength'] = uncompressedLength
+  }
+  if (contentLength) {
+    requestOptions['Content-Length'] = contentLength
+  }
+  if (contentRange) {
+    requestOptions['Content-Range'] = contentRange
+  }
+
+  return requestOptions
+}
+
+export function createHttpClient(userAgent: string): HttpClient {
+  return new HttpClient(userAgent, [
+    new BearerCredentialHandler(getRuntimeToken())
+  ])
+}
+
+export function getArtifactUrl(): string {
+  const artifactUrl = `${getRuntimeUrl()}_apis/pipelines/workflows/${getWorkFlowRunId()}/artifacts?api-version=${getApiVersion()}`
+  debug(`Artifact Url: ${artifactUrl}`)
+  return artifactUrl
+}
+
+/**
+ * Uh oh! Something might have gone wrong during either upload or download. The IHtttpClientResponse object contains information
+ * about the http call that was made by the actions http client. This information might be useful to display for diagnostic purposes, but
+ * this entire object is really big and most of the information is not really useful. This function takes the response object and displays only
+ * the information that we want.
+ *
+ * Certain information such as the TLSSocket and the Readable state are not really useful for diagnostic purposes so they can be avoided.
+ * Other information such as the headers, the response code and message might be useful, so this is displayed.
+ */
+export function displayHttpDiagnostics(response: IHttpClientResponse): void {
+  info(
+    `##### Begin Diagnostic HTTP information #####
+Status Code: ${response.message.statusCode}
+Status Message: ${response.message.statusMessage}
+Header Information: ${JSON.stringify(response.message.headers, undefined, 2)}
+###### End Diagnostic HTTP information ######`
+  )
+}
+
+/**
+ * Invalid characters that cannot be in the artifact name or an uploaded file. Will be rejected
+ * from the server if attempted to be sent over. These characters are not allowed due to limitations with certain
+ * file systems such as NTFS. To maintain platform-agnostic behavior, all characters that are not supported by an
+ * individual filesystem/platform will not be supported on all fileSystems/platforms
+ *
+ * FilePaths can include characters such as \ and / which are not permitted in the artifact name alone
+ */
+const invalidArtifactFilePathCharacters = ['"', ':', '<', '>', '|', '*', '?']
+const invalidArtifactNameCharacters = [
+  ...invalidArtifactFilePathCharacters,
+  '\\',
+  '/'
+]
+
+/**
+ * Scans the name of the artifact to make sure there are no illegal characters
+ */
+export function checkArtifactName(name: string): void {
+  if (!name) {
+    throw new Error(`Artifact name: ${name}, is incorrectly provided`)
+  }
+
+  for (const invalidChar of invalidArtifactNameCharacters) {
+    if (name.includes(invalidChar)) {
+      throw new Error(
+        `Artifact name is not valid: ${name}. Contains character: "${invalidChar}". Invalid artifact name characters include: ${invalidArtifactNameCharacters.toString()}.`
+      )
+    }
+  }
+}
+
+/**
+ * Scans the name of the filePath used to make sure there are no illegal characters
+ */
+export function checkArtifactFilePath(path: string): void {
+  if (!path) {
+    throw new Error(`Artifact path: ${path}, is incorrectly provided`)
+  }
+
+  for (const invalidChar of invalidArtifactFilePathCharacters) {
+    if (path.includes(invalidChar)) {
+      throw new Error(
+        `Artifact path is not valid: ${path}. Contains character: "${invalidChar}". Invalid characters include: ${invalidArtifactFilePathCharacters.toString()}.`
+      )
+    }
+  }
+}
+
+export async function createDirectoriesForArtifact(
+  directories: string[]
+): Promise<void> {
+  for (const directory of directories) {
+    await fs.mkdir(directory, {
+      recursive: true
+    })
+  }
+}
+
+export async function createEmptyFilesForArtifact(
+  emptyFilesToCreate: string[]
+): Promise<void> {
+  for (const filePath of emptyFilesToCreate) {
+    await (await fs.open(filePath, 'w')).close()
+  }
+}
+
+export async function getFileSize(filePath: string): Promise<number> {
+  const stats = await fs.stat(filePath)
+  debug(
+    `${filePath} size:(${stats.size}) blksize:(${stats.blksize}) blocks:(${stats.blocks})`
+  )
+  return stats.size
+}
+
+export async function rmFile(filePath: string): Promise<void> {
+  await fs.unlink(filePath)
+}
+
+export function getProperRetention(
+  retentionInput: number,
+  retentionSetting: string | undefined
+): number {
+  if (retentionInput < 0) {
+    throw new Error('Invalid retention, minimum value is 1.')
+  }
+
+  let retention = retentionInput
+  if (retentionSetting) {
+    const maxRetention = parseInt(retentionSetting)
+    if (!isNaN(maxRetention) && maxRetention < retention) {
+      warning(
+        `Retention days is greater than the max value allowed by the repository setting, reduce retention to ${maxRetention} days`
+      )
+      retention = maxRetention
+    }
+  }
+  return retention
+}
+
+export async function sleep(milliseconds: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, milliseconds))
+}
@@ -3,18 +3,9 @@
  "compilerOptions": {
    "baseUrl": "./",
    "outDir": "./lib",
-    "rootDir": "./src",
-    "paths": {
-      "@actions/core": [
-        "../core"
-      ],
-      "@actions/http-client": [
-        "../http-client"
-      ]
-    },
-    "useUnknownInCatchVariables": false,
+    "rootDir": "./src"
  },
  "include": [
    "./src"
  ]
-}
+}
@@ -2,17 +2,17 @@

 > Functions necessary for caching dependencies and build outputs to improve workflow execution time.

-See ["Caching dependencies to speed up workflows"](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows) for how caching works.
+See ["Caching dependencies to speed up workflows"](https://help.github.com/github/automating-your-workflow-with-github-actions/caching-dependencies-to-speed-up-workflows) for how caching works.

-Note that GitHub will remove any cache entries that have not been accessed in over 7 days. There is no limit on the number of caches you can store, but the total size of all caches in a repository is limited to 10 GB. If you exceed this limit, GitHub will save your cache but will begin evicting caches until the total size is less than 10 GB.
+Note that GitHub will remove any cache entries that have not been accessed in over 7 days. There is no limit on the number of caches you can store, but the total size of all caches in a repository is limited to 5 GB. If you exceed this limit, GitHub will save your cache but will begin evicting caches until the total size is less than 5 GB.

 ## Usage

-This package is used by the v2+ versions of our first party cache action. You can find an example implementation in the cache repo [here](https://github.com/actions/cache).
+This package is used by the v2+ versions of our first party cache action. You can find an example implementation in the cache repo [here](https://github.com/actions/cache). 

 #### Save Cache

-Saves a cache containing the files in `paths` using the `key` provided. The files would be compressed using zstandard compression algorithm if zstd is installed, otherwise gzip is used. Function returns the cache id if the cache was saved succesfully and throws an error if cache upload fails.
+Saves a cache containing the files in `paths` using the `key` provided. The files would be compressed using zstandard compression algorithm if zstd is installed, otherwise gzip is used. Function returns the cache id if the cache was saved succesfully and throws an error if cache upload fails. 

 ```js
 const cache = require('@actions/cache');
@@ -26,7 +26,7 @@ const cacheId = await cache.saveCache(paths, key)

 #### Restore Cache

-Restores a cache based on `key` and `restoreKeys` to the `paths` provided. Function returns the cache key for cache hit and returns undefined if cache not found.
+Restores a cache based on `key` and `restoreKeys` to the `paths` provided. Function returns the cache key for cache hit and returns undefined if cache not found. 

 ```js
 const cache = require('@actions/cache');
@@ -42,10 +42,3 @@ const restoreKeys = [
 const cacheKey = await cache.restoreCache(paths, key, restoreKeys)
 ```

-##### Cache segment restore timeout
-
-A cache gets downloaded in multiple segments of fixed sizes (now `128MB` to fail-fast, previously `1GB` for a `32-bit` runner and `2GB` for a `64-bit` runner were used). Sometimes, a segment download gets stuck which causes the workflow job to be stuck forever and fail. Version `v3.0.4` of cache package introduces a segment download timeout. The segment download timeout will allow the segment download to get aborted and hence allow the job to proceed with a cache miss.
-
-Default value of this timeout is 10 minutes (starting `v3.2.1` and higher, previously 60 minutes in versions between `v.3.0.4` and `v3.2.0`, both included) and can be customized by specifying an [environment variable](https://docs.github.com/en/actions/learn-github-actions/environment-variables) named `SEGMENT_DOWNLOAD_TIMEOUT_MINS` with timeout value in minutes.
-
-
@@ -5,162 +5,38 @@
 - Initial release

 ### 0.2.0
-
 - Fixes issues with the zstd compression algorithm on Windows and Ubuntu 16.04 [#469](https://github.com/actions/toolkit/pull/469)

 ### 0.2.1
-
 - Fix to await async function getCompressionMethod

 ### 1.0.0
-
 - Downloads Azure-hosted caches using the Azure SDK for speed and reliability
 - Displays download progress
 - Includes changes that break compatibility with earlier versions, including:
  - `retry`, `retryTypedResponse`, and `retryHttpClientResponse` moved from `cacheHttpClient` to `requestUtils`

 ### 1.0.1
-
 - Fix bug in downloading large files (> 2 GBs) with the Azure SDK

 ### 1.0.2
-
 - Use posix archive format to add support for some tools

 ### 1.0.3
-
 - Use http-client v1.0.9
 - Fixes error handling so retries are not attempted on non-retryable errors (409 Conflict, for example)
 - Adds 5 second delay between retry attempts

 ### 1.0.4
-
 - Use @actions/core v1.2.6
 - Fixes uploadChunk to throw an error if any unsuccessful response code is received

 ### 1.0.5
-
 - Fix to ensure Windows cache paths get resolved correctly

 ### 1.0.6
-
 - Make caching more verbose [#650](https://github.com/actions/toolkit/pull/650)
 - Use GNU tar on macOS if available [#701](https://github.com/actions/toolkit/pull/701)

 ### 1.0.7
-
 - Fixes permissions issue extracting archives with GNU tar on macOS ([issue](https://github.com/actions/cache/issues/527))
-
-### 1.0.8
-
- Increase the allowed artifact cache size from 5GB to 10GB ([issue](https://github.com/actions/cache/discussions/497))
-
-### 1.0.9
-
- Use @azure/ms-rest-js v2.6.0
- Use @azure/storage-blob v12.8.0
-
-### 1.0.10
-
- Update `lockfileVersion` to `v2` in `package-lock.json [#1022](https://github.com/actions/toolkit/pull/1022)
-
-### 1.0.11
-
- Fix file downloads > 2GB([issue](https://github.com/actions/cache/issues/773))
-
-### 2.0.0
-
- Added support to check if Actions cache service feature is available or not [#1028](https://github.com/actions/toolkit/pull/1028)
-
-### 2.0.3
-
- Update to v2.0.0 of `@actions/http-client`
-
-### 2.0.4
-
- Update to v2.0.1 of `@actions/http-client` [#1087](https://github.com/actions/toolkit/pull/1087)
-
-### 2.0.5
-
- Fix to avoid saving empty cache when no files are available for caching. ([issue](https://github.com/actions/cache/issues/624))
-
-### 2.0.6
-
- Fix `Tar failed with error: The process '/usr/bin/tar' failed with exit code 1` issue when temp directory where tar is getting created is actually the subdirectory of the path mentioned by the user for caching. ([issue](https://github.com/actions/cache/issues/689))
-
-### 3.0.0
-
- Updated actions/cache to suppress Actions cache server error and log warning for those error  [#1122](https://github.com/actions/toolkit/pull/1122)
-
-### 3.0.1
-
- Fix [#833](https://github.com/actions/cache/issues/833) - cache doesn't work with github workspace directory.
- Fix [#809](https://github.com/actions/cache/issues/809) `zstd -d: no such file or directory` error on AWS self-hosted runners.
-
-### 3.0.2
-
- Added 1 hour timeout for the download stuck issue [#810](https://github.com/actions/cache/issues/810).
-
-### 3.0.3
-
- Bug fixes for download stuck issue [#810](https://github.com/actions/cache/issues/810).
-
-### 3.0.4
-
- Fix zstd not working for windows on gnu tar in issues [#888](https://github.com/actions/cache/issues/888) and [#891](https://github.com/actions/cache/issues/891).
- Allowing users to provide a custom timeout as input for aborting download of a cache segment using an environment variable `SEGMENT_DOWNLOAD_TIMEOUT_MINS`. Default is 60 minutes.
-
-### 3.0.5
-
- Update `@actions/cache` to use `@actions/core@^1.10.0`
-
-### 3.0.6
-
- Added `@azure/abort-controller` to dependencies to fix compatibility issue with ESM [#1208](https://github.com/actions/toolkit/issues/1208)
-
-### 3.1.0-beta.1
-
- Update actions/cache on windows to use gnu tar and zstd by default and fallback to bsdtar and zstd if gnu tar is not available. ([issue](https://github.com/actions/cache/issues/984))
-
-### 3.1.0-beta.2
-
- Added support for fallback to gzip to restore old caches on windows.
-
-### 3.1.0-beta.3
-
- Bug Fixes for fallback to gzip to restore old caches on windows and bsdtar if gnutar is not available.
-
-### 3.1.0
-
- Update actions/cache on windows to use gnu tar and zstd by default
- Update actions/cache on windows to fallback to bsdtar and zstd if gnu tar is not available.
- Added support for fallback to gzip to restore old caches on windows.
-
-### 3.1.1
-
- Reverted changes in 3.1.0 to fix issue with symlink restoration on windows.
- Added support for verbose logging about cache version during cache miss.
-
-### 3.1.2
-
- Fix issue with symlink restoration on windows.
-
-### 3.1.3
-
- Fix to prevent from setting MYSYS environement variable globally [#1329](https://github.com/actions/toolkit/pull/1329).
-
-### 3.1.4
-
- Fix zstd not being used due to `zstd --version` output change in zstd 1.5.4 release. See [#1353](https://github.com/actions/toolkit/pull/1353).
-
-### 3.2.0
-
- Add `lookupOnly` to cache restore `DownloadOptions`.
-
-### 3.2.1
-
- Updated @azure/storage-blob to `v12.13.0`
-
-### 3.2.2
-
- Add new default cache download method to improve performance and reduce hangs [#1484](https://github.com/actions/toolkit/pull/1484)
@@ -3,10 +3,10 @@
 const fs = require('fs');
 const os = require('os');
 const filePath = process.env[`GITHUB_ENV`]
-fs.appendFileSync(filePath, `ACTIONS_RUNTIME_TOKEN=${process.env.ACTIONS_RUNTIME_TOKEN}${os.EOL}`, {
+fs.appendFileSync(filePath, `ACTIONS_RUNTIME_URL=${process.env.ACTIONS_RUNTIME_URL}${os.EOL}`, {
    encoding: 'utf8'
 })
-fs.appendFileSync(filePath, `ACTIONS_CACHE_URL=${process.env.ACTIONS_CACHE_URL}${os.EOL}`, {
+fs.appendFileSync(filePath, `ACTIONS_RUNTIME_TOKEN=${process.env.ACTIONS_RUNTIME_TOKEN}${os.EOL}`, {
    encoding: 'utf8'
 })
 fs.appendFileSync(filePath, `GITHUB_RUN_ID=${process.env.GITHUB_RUN_ID}${os.EOL}`, {
@@ -1,14 +0,0 @@
-import * as cache from '../src/cache'
-
-test('isFeatureAvailable returns true if server url is set', () => {
-  try {
-    process.env['ACTIONS_CACHE_URL'] = 'http://cache.com'
-    expect(cache.isFeatureAvailable()).toBe(true)
-  } finally {
-    delete process.env['ACTIONS_CACHE_URL']
-  }
-})
-
-test('isFeatureAvailable returns false if server url is not set', () => {
-  expect(cache.isFeatureAvailable()).toBe(false)
-})
@@ -7,7 +7,7 @@ jest.mock('../src/internal/downloadUtils')

 test('getCacheVersion with one path returns version', async () => {
  const paths = ['node_modules']
-  const result = getCacheVersion(paths, undefined, true)
+  const result = getCacheVersion(paths)
  expect(result).toEqual(
    'b3e0c6cb5ecf32614eeb2997d905b9c297046d7cbf69062698f25b14b4cb0985'
  )
@@ -15,7 +15,7 @@ test('getCacheVersion with one path returns version', async () => {

 test('getCacheVersion with multiple paths returns version', async () => {
  const paths = ['node_modules', 'dist']
-  const result = getCacheVersion(paths, undefined, true)
+  const result = getCacheVersion(paths)
  expect(result).toEqual(
    '165c3053bc646bf0d4fac17b1f5731caca6fe38e0e464715c0c3c6b6318bf436'
  )
@@ -23,33 +23,22 @@ test('getCacheVersion with multiple paths returns version', async () => {

 test('getCacheVersion with zstd compression returns version', async () => {
  const paths = ['node_modules']
-  const result = getCacheVersion(paths, CompressionMethod.Zstd, true)
+  const result = getCacheVersion(paths, CompressionMethod.Zstd)

  expect(result).toEqual(
    '273877e14fd65d270b87a198edbfa2db5a43de567c9a548d2a2505b408befe24'
  )
 })

-test('getCacheVersion with gzip compression returns version', async () => {
+test('getCacheVersion with gzip compression does not change vesion', async () => {
  const paths = ['node_modules']
-  const result = getCacheVersion(paths, CompressionMethod.Gzip, true)
+  const result = getCacheVersion(paths, CompressionMethod.Gzip)

  expect(result).toEqual(
-    '470e252814dbffc9524891b17cf4e5749b26c1b5026e63dd3f00972db2393117'
+    'b3e0c6cb5ecf32614eeb2997d905b9c297046d7cbf69062698f25b14b4cb0985'
  )
 })

-test('getCacheVersion with enableCrossOsArchive as false returns version on windows', async () => {
-  if (process.platform === 'win32') {
-    const paths = ['node_modules']
-    const result = getCacheVersion(paths)
-
-    expect(result).toEqual(
-      '2db19d6596dc34f51f0043120148827a264863f5c6ac857569c2af7119bad14e'
-    )
-  }
-})
-
 test('downloadCache uses http-client for non-Azure URLs', async () => {
  const downloadCacheHttpClientMock = jest.spyOn(
    downloadUtils,
@@ -84,24 +73,18 @@ test('downloadCache uses storage SDK for Azure storage URLs', async () => {
    'downloadCacheStorageSDK'
  )

-  const downloadCacheHttpClientConcurrentMock = jest.spyOn(
-    downloadUtils,
-    'downloadCacheHttpClientConcurrent'
-  )
-
  const archiveLocation = 'http://foo.blob.core.windows.net/bar/baz'
  const archivePath = '/foo/bar'

  await downloadCache(archiveLocation, archivePath)

-  expect(downloadCacheHttpClientConcurrentMock).toHaveBeenCalledTimes(1)
-  expect(downloadCacheHttpClientConcurrentMock).toHaveBeenCalledWith(
+  expect(downloadCacheStorageSDKMock).toHaveBeenCalledTimes(1)
+  expect(downloadCacheStorageSDKMock).toHaveBeenCalledWith(
    archiveLocation,
    archivePath,
    getDownloadOptions()
  )

-  expect(downloadCacheStorageSDKMock).toHaveBeenCalledTimes(0)
  expect(downloadCacheHttpClientMock).toHaveBeenCalledTimes(0)
 })

@@ -115,26 +98,20 @@ test('downloadCache passes options to download methods', async () => {
    'downloadCacheStorageSDK'
  )

-  const downloadCacheHttpClientConcurrentMock = jest.spyOn(
-    downloadUtils,
-    'downloadCacheHttpClientConcurrent'
-  )
-
  const archiveLocation = 'http://foo.blob.core.windows.net/bar/baz'
  const archivePath = '/foo/bar'
  const options: DownloadOptions = {downloadConcurrency: 4}

  await downloadCache(archiveLocation, archivePath, options)

-  expect(downloadCacheHttpClientConcurrentMock).toHaveBeenCalledTimes(1)
-  expect(downloadCacheHttpClientConcurrentMock).toHaveBeenCalled()
-  expect(downloadCacheHttpClientConcurrentMock).toHaveBeenCalledWith(
+  expect(downloadCacheStorageSDKMock).toHaveBeenCalledTimes(1)
+  expect(downloadCacheStorageSDKMock).toHaveBeenCalled()
+  expect(downloadCacheStorageSDKMock).toHaveBeenCalledWith(
    archiveLocation,
    archivePath,
    getDownloadOptions(options)
  )

-  expect(downloadCacheStorageSDKMock).toHaveBeenCalledTimes(0)
  expect(downloadCacheHttpClientMock).toHaveBeenCalledTimes(0)
 })

@@ -150,10 +127,7 @@ test('downloadCache uses http-client when overridden', async () => {

  const archiveLocation = 'http://foo.blob.core.windows.net/bar/baz'
  const archivePath = '/foo/bar'
-  const options: DownloadOptions = {
-    useAzureSdk: false,
-    concurrentBlobDownloads: false
-  }
+  const options: DownloadOptions = {useAzureSdk: false}

  await downloadCache(archiveLocation, archivePath, options)

@@ -32,9 +32,3 @@ test('assertDefined throws if undefined', () => {
 test('assertDefined returns value', () => {
  expect(cacheUtils.assertDefined('test', 5)).toBe(5)
 })
-
-test('resolvePaths works on github workspace directory', async () => {
-  const workspace = process.env['GITHUB_WORKSPACE'] ?? '.'
-  const paths = await cacheUtils.resolvePaths([workspace])
-  expect(paths.length).toBeGreaterThan(0)
-})
@@ -87,7 +87,7 @@ test('download progress tracked correctly', () => {
  expect(progress.isDone()).toBe(true)
 })

-test('display timer works correctly', done => {
+test('display timer works correctly', () => {
  const progress = new DownloadProgress(1000)

  const infoMock = jest.spyOn(core, 'info')
@@ -103,7 +103,6 @@ test('display timer works correctly', done => {
  const test2 = (): void => {
    check()
    expect(progress.timeoutHandle).toBeUndefined()
-    done()
  }

  // Validate the progress is displayed, stop the timer, and call test2.
@@ -113,7 +112,7 @@ test('display timer works correctly', done => {
    progress.stopDisplayTimer()
    progress.setReceivedBytes(1000)

-    setTimeout(() => test2(), 500)
+    setTimeout(() => test2(), 100)
  }

  // Start the timer, update the received bytes, and call test1.
@@ -123,7 +122,7 @@ test('display timer works correctly', done => {

    progress.setReceivedBytes(500)

-    setTimeout(() => test1(), 500)
+    setTimeout(() => test1(), 100)
  }

  start()
@@ -5,12 +5,9 @@ import {
  getUploadOptions
 } from '../src/options'

-const useAzureSdk = false
-const concurrentBlobDownloads = true
+const useAzureSdk = true
 const downloadConcurrency = 8
 const timeoutInMs = 30000
-const segmentTimeoutInMs = 600000
-const lookupOnly = false
 const uploadConcurrency = 4
 const uploadChunkSize = 32 * 1024 * 1024

@@ -19,22 +16,16 @@ test('getDownloadOptions sets defaults', async () => {

  expect(actualOptions).toEqual({
    useAzureSdk,
-    concurrentBlobDownloads,
    downloadConcurrency,
-    timeoutInMs,
-    segmentTimeoutInMs,
-    lookupOnly
+    timeoutInMs
  })
 })

 test('getDownloadOptions overrides all settings', async () => {
  const expectedOptions: DownloadOptions = {
-    useAzureSdk: true,
-    concurrentBlobDownloads: false,
+    useAzureSdk: false,
    downloadConcurrency: 14,
-    timeoutInMs: 20000,
-    segmentTimeoutInMs: 3600000,
-    lookupOnly: true
+    timeoutInMs: 20000
  }

  const actualOptions = getDownloadOptions(expectedOptions)
@@ -61,23 +52,3 @@ test('getUploadOptions overrides all settings', async () => {

  expect(actualOptions).toEqual(expectedOptions)
 })
-
-test('getDownloadOptions overrides download timeout minutes', async () => {
-  const expectedOptions: DownloadOptions = {
-    useAzureSdk: false,
-    downloadConcurrency: 14,
-    timeoutInMs: 20000,
-    segmentTimeoutInMs: 3600000,
-    lookupOnly: true
-  }
-  process.env.SEGMENT_DOWNLOAD_TIMEOUT_MINS = '10'
-  const actualOptions = getDownloadOptions(expectedOptions)
-
-  expect(actualOptions.useAzureSdk).toEqual(expectedOptions.useAzureSdk)
-  expect(actualOptions.downloadConcurrency).toEqual(
-    expectedOptions.downloadConcurrency
-  )
-  expect(actualOptions.timeoutInMs).toEqual(expectedOptions.timeoutInMs)
-  expect(actualOptions.segmentTimeoutInMs).toEqual(600000)
-  expect(actualOptions.lookupOnly).toEqual(expectedOptions.lookupOnly)
-})
@@ -1,6 +1,5 @@
-import {retry, retryTypedResponse} from '../src/internal/requestUtils'
+import {retry} from '../src/internal/requestUtils'
 import {HttpClientError} from '@actions/http-client'
-import * as requestUtils from '../src/internal/requestUtils'

 interface ITestResponse {
  statusCode: number
@@ -31,6 +30,7 @@ async function handleResponse(
  response: ITestResponse | undefined
 ): Promise<ITestResponse> {
  if (!response) {
+    // eslint-disable-next-line no-undef
    fail('Retry method called too many times')
  }

@@ -146,34 +146,3 @@ test('retry converts errors to response object', async () => {
    null
  )
 })
-
-test('retryTypedResponse gives an error with error message', async () => {
-  const httpClientError = new HttpClientError(
-    'The cache filesize must be between 0 and 10 * 1024 * 1024 bytes',
-    400
-  )
-  jest.spyOn(requestUtils, 'retry').mockReturnValue(
-    new Promise(resolve => {
-      resolve(httpClientError)
-    })
-  )
-  try {
-    await retryTypedResponse<string>(
-      'reserveCache',
-      async () =>
-        new Promise(resolve => {
-          resolve({
-            statusCode: 400,
-            result: '',
-            headers: {},
-            error: httpClientError
-          })
-        })
-    )
-  } catch (error) {
-    expect(error).toHaveProperty(
-      'message',
-      'The cache filesize must be between 0 and 10 * 1024 * 1024 bytes'
-    )
-  }
-})
@@ -18,6 +18,7 @@ beforeAll(() => {
  jest.spyOn(core, 'warning').mockImplementation(() => {})
  jest.spyOn(core, 'error').mockImplementation(() => {})

+  // eslint-disable-next-line @typescript-eslint/promise-function-async
  jest.spyOn(cacheUtils, 'getCacheFileName').mockImplementation(cm => {
    const actualUtils = jest.requireActual('../src/internal/cacheUtils')
    return actualUtils.getCacheFileName(cm)
@@ -73,17 +74,13 @@ test('restore with no cache found', async () => {
 test('restore with server error should fail', async () => {
  const paths = ['node_modules']
  const key = 'node-test'
-  const logWarningMock = jest.spyOn(core, 'warning')

  jest.spyOn(cacheHttpClient, 'getCacheEntry').mockImplementation(() => {
    throw new Error('HTTP Error Occurred')
  })

-  const cacheKey = await restoreCache(paths, key)
-  expect(cacheKey).toBe(undefined)
-  expect(logWarningMock).toHaveBeenCalledTimes(1)
-  expect(logWarningMock).toHaveBeenCalledWith(
-    'Failed to restore: HTTP Error Occurred'
+  await expect(restoreCache(paths, key)).rejects.toThrowError(
+    'HTTP Error Occurred'
  )
 })

@@ -142,8 +139,7 @@ test('restore with gzip compressed cache found', async () => {

  expect(cacheKey).toBe(key)
  expect(getCacheMock).toHaveBeenCalledWith([key], paths, {
-    compressionMethod: compression,
-    enableCrossOsArchive: false
+    compressionMethod: compression
  })
  expect(createTempDirectoryMock).toHaveBeenCalledTimes(1)
  expect(downloadCacheMock).toHaveBeenCalledWith(
@@ -202,8 +198,7 @@ test('restore with zstd compressed cache found', async () => {

  expect(cacheKey).toBe(key)
  expect(getCacheMock).toHaveBeenCalledWith([key], paths, {
-    compressionMethod: compression,
-    enableCrossOsArchive: false
+    compressionMethod: compression
  })
  expect(createTempDirectoryMock).toHaveBeenCalledTimes(1)
  expect(downloadCacheMock).toHaveBeenCalledWith(
@@ -260,8 +255,7 @@ test('restore with cache found for restore key', async () => {

  expect(cacheKey).toBe(restoreKey)
  expect(getCacheMock).toHaveBeenCalledWith([key, restoreKey], paths, {
-    compressionMethod: compression,
-    enableCrossOsArchive: false
+    compressionMethod: compression
  })
  expect(createTempDirectoryMock).toHaveBeenCalledTimes(1)
  expect(downloadCacheMock).toHaveBeenCalledWith(
@@ -276,39 +270,3 @@ test('restore with cache found for restore key', async () => {
  expect(extractTarMock).toHaveBeenCalledWith(archivePath, compression)
  expect(getCompressionMock).toHaveBeenCalledTimes(1)
 })
-
-test('restore with dry run', async () => {
-  const paths = ['node_modules']
-  const key = 'node-test'
-  const options = {lookupOnly: true}
-
-  const cacheEntry: ArtifactCacheEntry = {
-    cacheKey: key,
-    scope: 'refs/heads/main',
-    archiveLocation: 'www.actionscache.test/download'
-  }
-  const getCacheMock = jest.spyOn(cacheHttpClient, 'getCacheEntry')
-  getCacheMock.mockImplementation(async () => {
-    return Promise.resolve(cacheEntry)
-  })
-
-  const createTempDirectoryMock = jest.spyOn(cacheUtils, 'createTempDirectory')
-  const downloadCacheMock = jest.spyOn(cacheHttpClient, 'downloadCache')
-
-  const compression = CompressionMethod.Gzip
-  const getCompressionMock = jest
-    .spyOn(cacheUtils, 'getCompressionMethod')
-    .mockReturnValue(Promise.resolve(compression))
-
-  const cacheKey = await restoreCache(paths, key, undefined, options)
-
-  expect(cacheKey).toBe(key)
-  expect(getCompressionMock).toHaveBeenCalledTimes(1)
-  expect(getCacheMock).toHaveBeenCalledWith([key], paths, {
-    compressionMethod: compression,
-    enableCrossOsArchive: false
-  })
-  // creating a tempDir and downloading the cache are skipped
-  expect(createTempDirectoryMock).toHaveBeenCalledTimes(0)
-  expect(downloadCacheMock).toHaveBeenCalledTimes(0)
-})
@@ -5,12 +5,6 @@ import * as cacheHttpClient from '../src/internal/cacheHttpClient'
 import * as cacheUtils from '../src/internal/cacheUtils'
 import {CacheFilename, CompressionMethod} from '../src/internal/constants'
 import * as tar from '../src/internal/tar'
-import {TypedResponse} from '@actions/http-client/lib/interfaces'
-import {
-  ReserveCacheResponse,
-  ITypedResponseWithError
-} from '../src/internal/contracts'
-import {HttpClientError} from '@actions/http-client'

 jest.mock('../src/internal/cacheHttpClient')
 jest.mock('../src/internal/cacheUtils')
@@ -22,13 +16,17 @@ beforeAll(() => {
  jest.spyOn(core, 'info').mockImplementation(() => {})
  jest.spyOn(core, 'warning').mockImplementation(() => {})
  jest.spyOn(core, 'error').mockImplementation(() => {})
+
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
  jest.spyOn(cacheUtils, 'getCacheFileName').mockImplementation(cm => {
    const actualUtils = jest.requireActual('../src/internal/cacheUtils')
    return actualUtils.getCacheFileName(cm)
  })
+
  jest.spyOn(cacheUtils, 'resolvePaths').mockImplementation(async filePaths => {
    return filePaths.map(x => path.resolve(x))
  })
+
  jest.spyOn(cacheUtils, 'createTempDirectory').mockImplementation(async () => {
    return Promise.resolve('/foo/bar')
  })
@@ -48,9 +46,8 @@ test('save with large cache outputs should fail', async () => {
  const cachePaths = [path.resolve(filePath)]

  const createTarMock = jest.spyOn(tar, 'createTar')
-  const logWarningMock = jest.spyOn(core, 'warning')

-  const cacheSize = 11 * 1024 * 1024 * 1024 //~11GB, over the 10GB limit
+  const cacheSize = 6 * 1024 * 1024 * 1024 //~6GB, over the 5GB limit
  jest
    .spyOn(cacheUtils, 'getArchiveFileSizeInBytes')
    .mockReturnValueOnce(cacheSize)
@@ -59,11 +56,8 @@ test('save with large cache outputs should fail', async () => {
    .spyOn(cacheUtils, 'getCompressionMethod')
    .mockReturnValueOnce(Promise.resolve(compression))

-  const cacheId = await saveCache([filePath], primaryKey)
-  expect(cacheId).toBe(-1)
-  expect(logWarningMock).toHaveBeenCalledTimes(1)
-  expect(logWarningMock).toHaveBeenCalledWith(
-    'Failed to save: Cache size of ~11264 MB (11811160064 B) is over the 10GB limit, not saving cache.'
+  await expect(saveCache([filePath], primaryKey)).rejects.toThrowError(
+    'Cache size of ~6144 MB (6442450944 B) is over the 5GB limit, not saving cache.'
  )

  const archiveFolder = '/foo/bar'
@@ -77,120 +71,14 @@ test('save with large cache outputs should fail', async () => {
  expect(getCompressionMock).toHaveBeenCalledTimes(1)
 })

-test('save with large cache outputs should fail in GHES with error message', async () => {
-  const filePath = 'node_modules'
-  const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
-  const cachePaths = [path.resolve(filePath)]
-
-  const createTarMock = jest.spyOn(tar, 'createTar')
-  const logWarningMock = jest.spyOn(core, 'warning')
-
-  const cacheSize = 11 * 1024 * 1024 * 1024 //~11GB, over the 10GB limit
-  jest
-    .spyOn(cacheUtils, 'getArchiveFileSizeInBytes')
-    .mockReturnValueOnce(cacheSize)
-  const compression = CompressionMethod.Gzip
-  const getCompressionMock = jest
-    .spyOn(cacheUtils, 'getCompressionMethod')
-    .mockReturnValueOnce(Promise.resolve(compression))
-
-  jest.spyOn(cacheUtils, 'isGhes').mockReturnValueOnce(true)
-
-  const reserveCacheMock = jest
-    .spyOn(cacheHttpClient, 'reserveCache')
-    .mockImplementation(async () => {
-      const response: ITypedResponseWithError<ReserveCacheResponse> = {
-        statusCode: 400,
-        result: null,
-        headers: {},
-        error: new HttpClientError(
-          'The cache filesize must be between 0 and 1073741824 bytes',
-          400
-        )
-      }
-      return response
-    })
-
-  const cacheId = await saveCache([filePath], primaryKey)
-  expect(cacheId).toBe(-1)
-  expect(logWarningMock).toHaveBeenCalledTimes(1)
-  expect(logWarningMock).toHaveBeenCalledWith(
-    'Failed to save: The cache filesize must be between 0 and 1073741824 bytes'
-  )
-
-  const archiveFolder = '/foo/bar'
-  expect(reserveCacheMock).toHaveBeenCalledTimes(1)
-  expect(createTarMock).toHaveBeenCalledTimes(1)
-  expect(createTarMock).toHaveBeenCalledWith(
-    archiveFolder,
-    cachePaths,
-    compression
-  )
-  expect(getCompressionMock).toHaveBeenCalledTimes(1)
-})
-
-test('save with large cache outputs should fail in GHES without error message', async () => {
-  const filePath = 'node_modules'
-  const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
-  const cachePaths = [path.resolve(filePath)]
-
-  const createTarMock = jest.spyOn(tar, 'createTar')
-  const logWarningMock = jest.spyOn(core, 'warning')
-
-  const cacheSize = 11 * 1024 * 1024 * 1024 //~11GB, over the 10GB limit
-  jest
-    .spyOn(cacheUtils, 'getArchiveFileSizeInBytes')
-    .mockReturnValueOnce(cacheSize)
-  const compression = CompressionMethod.Gzip
-  const getCompressionMock = jest
-    .spyOn(cacheUtils, 'getCompressionMethod')
-    .mockReturnValueOnce(Promise.resolve(compression))
-
-  jest.spyOn(cacheUtils, 'isGhes').mockReturnValueOnce(true)
-
-  const reserveCacheMock = jest
-    .spyOn(cacheHttpClient, 'reserveCache')
-    .mockImplementation(async () => {
-      const response: ITypedResponseWithError<ReserveCacheResponse> = {
-        statusCode: 400,
-        result: null,
-        headers: {}
-      }
-      return response
-    })
-
-  const cacheId = await saveCache([filePath], primaryKey)
-  expect(cacheId).toBe(-1)
-  expect(logWarningMock).toHaveBeenCalledTimes(1)
-  expect(logWarningMock).toHaveBeenCalledWith(
-    'Failed to save: Cache size of ~11264 MB (11811160064 B) is over the data cap limit, not saving cache.'
-  )
-
-  const archiveFolder = '/foo/bar'
-  expect(reserveCacheMock).toHaveBeenCalledTimes(1)
-  expect(createTarMock).toHaveBeenCalledTimes(1)
-  expect(createTarMock).toHaveBeenCalledWith(
-    archiveFolder,
-    cachePaths,
-    compression
-  )
-  expect(getCompressionMock).toHaveBeenCalledTimes(1)
-})
-
 test('save with reserve cache failure should fail', async () => {
  const paths = ['node_modules']
  const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
-  const logInfoMock = jest.spyOn(core, 'info')

  const reserveCacheMock = jest
    .spyOn(cacheHttpClient, 'reserveCache')
    .mockImplementation(async () => {
-      const response: TypedResponse<ReserveCacheResponse> = {
-        statusCode: 500,
-        result: null,
-        headers: {}
-      }
-      return response
+      return -1
    })

  const createTarMock = jest.spyOn(tar, 'createTar')
@@ -200,20 +88,14 @@ test('save with reserve cache failure should fail', async () => {
    .spyOn(cacheUtils, 'getCompressionMethod')
    .mockReturnValueOnce(Promise.resolve(compression))

-  const cacheId = await saveCache(paths, primaryKey)
-  expect(cacheId).toBe(-1)
-  expect(logInfoMock).toHaveBeenCalledTimes(1)
-  expect(logInfoMock).toHaveBeenCalledWith(
-    `Failed to save: Unable to reserve cache with key ${primaryKey}, another job may be creating this cache. More details: undefined`
+  await expect(saveCache(paths, primaryKey)).rejects.toThrowError(
+    `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
  )
-
  expect(reserveCacheMock).toHaveBeenCalledTimes(1)
  expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, paths, {
-    cacheSize: undefined,
-    compressionMethod: compression,
-    enableCrossOsArchive: false
+    compressionMethod: compression
  })
-  expect(createTarMock).toHaveBeenCalledTimes(1)
+  expect(createTarMock).toHaveBeenCalledTimes(0)
  expect(saveCacheMock).toHaveBeenCalledTimes(0)
  expect(getCompressionMock).toHaveBeenCalledTimes(1)
 })
@@ -222,17 +104,12 @@ test('save with server error should fail', async () => {
  const filePath = 'node_modules'
  const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
  const cachePaths = [path.resolve(filePath)]
-  const logWarningMock = jest.spyOn(core, 'warning')
+
  const cacheId = 4
  const reserveCacheMock = jest
    .spyOn(cacheHttpClient, 'reserveCache')
    .mockImplementation(async () => {
-      const response: TypedResponse<ReserveCacheResponse> = {
-        statusCode: 500,
-        result: {cacheId},
-        headers: {}
-      }
-      return response
+      return cacheId
    })

  const createTarMock = jest.spyOn(tar, 'createTar')
@@ -247,26 +124,24 @@ test('save with server error should fail', async () => {
    .spyOn(cacheUtils, 'getCompressionMethod')
    .mockReturnValueOnce(Promise.resolve(compression))

-  await saveCache([filePath], primaryKey)
-  expect(logWarningMock).toHaveBeenCalledTimes(1)
-  expect(logWarningMock).toHaveBeenCalledWith(
-    'Failed to save: HTTP Error Occurred'
+  await expect(saveCache([filePath], primaryKey)).rejects.toThrowError(
+    'HTTP Error Occurred'
  )
-
  expect(reserveCacheMock).toHaveBeenCalledTimes(1)
  expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, [filePath], {
-    cacheSize: undefined,
-    compressionMethod: compression,
-    enableCrossOsArchive: false
+    compressionMethod: compression
  })
+
  const archiveFolder = '/foo/bar'
  const archiveFile = path.join(archiveFolder, CacheFilename.Zstd)
+
  expect(createTarMock).toHaveBeenCalledTimes(1)
  expect(createTarMock).toHaveBeenCalledWith(
    archiveFolder,
    cachePaths,
    compression
  )
+
  expect(saveCacheMock).toHaveBeenCalledTimes(1)
  expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archiveFile, undefined)
  expect(getCompressionMock).toHaveBeenCalledTimes(1)
@@ -281,12 +156,7 @@ test('save with valid inputs uploads a cache', async () => {
  const reserveCacheMock = jest
    .spyOn(cacheHttpClient, 'reserveCache')
    .mockImplementation(async () => {
-      const response: TypedResponse<ReserveCacheResponse> = {
-        statusCode: 500,
-        result: {cacheId},
-        headers: {}
-      }
-      return response
+      return cacheId
    })
  const createTarMock = jest.spyOn(tar, 'createTar')

@@ -300,30 +170,20 @@ test('save with valid inputs uploads a cache', async () => {

  expect(reserveCacheMock).toHaveBeenCalledTimes(1)
  expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, [filePath], {
-    cacheSize: undefined,
-    compressionMethod: compression,
-    enableCrossOsArchive: false
+    compressionMethod: compression
  })
+
  const archiveFolder = '/foo/bar'
  const archiveFile = path.join(archiveFolder, CacheFilename.Zstd)
+
  expect(createTarMock).toHaveBeenCalledTimes(1)
  expect(createTarMock).toHaveBeenCalledWith(
    archiveFolder,
    cachePaths,
    compression
  )
+
  expect(saveCacheMock).toHaveBeenCalledTimes(1)
  expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archiveFile, undefined)
  expect(getCompressionMock).toHaveBeenCalledTimes(1)
 })
-
-test('save with non existing path should not save cache', async () => {
-  const path = 'node_modules'
-  const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
-  jest.spyOn(cacheUtils, 'resolvePaths').mockImplementation(async () => {
-    return []
-  })
-  await expect(saveCache([path], primaryKey)).rejects.toThrowError(
-    `Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`
-  )
-})
@@ -1,14 +1,7 @@
 import * as exec from '@actions/exec'
 import * as io from '@actions/io'
 import * as path from 'path'
-import {
-  CacheFilename,
-  CompressionMethod,
-  GnuTarPathOnWindows,
-  ManifestFilename,
-  SystemTarPathOnWindows,
-  TarFilename
-} from '../src/internal/constants'
+import {CacheFilename, CompressionMethod} from '../src/internal/constants'
 import * as tar from '../src/internal/tar'
 import * as utils from '../src/internal/cacheUtils'
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -20,9 +13,7 @@ jest.mock('@actions/io')
 const IS_WINDOWS = process.platform === 'win32'
 const IS_MAC = process.platform === 'darwin'

-const defaultTarPath = IS_MAC ? 'gtar' : 'tar'
-
-const defaultEnv = {MSYS: 'winsymlinks:nativestrict'}
+const defaultTarPath = process.platform === 'darwin' ? 'gtar' : 'tar'

 function getTempDir(): string {
  return path.join(__dirname, '_temp', 'tar')
@@ -37,10 +28,6 @@ beforeAll(async () => {
  await jest.requireActual('@actions/io').rmRF(getTempDir())
 })

-beforeEach(async () => {
-  jest.restoreAllMocks()
-})
-
 afterAll(async () => {
  delete process.env['GITHUB_WORKSPACE']
  await jest.requireActual('@actions/io').rmRF(getTempDir())
@@ -54,15 +41,16 @@ test('zstd extract tar', async () => {
    ? `${process.env['windir']}\\fakepath\\cache.tar`
    : 'cache.tar'
  const workspace = process.env['GITHUB_WORKSPACE']
-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath

  await tar.extractTar(archivePath, CompressionMethod.Zstd)

  expect(mkdirMock).toHaveBeenCalledWith(workspace)
  expect(execMock).toHaveBeenCalledTimes(1)
  expect(execMock).toHaveBeenCalledWith(
+    `"${defaultTarPath}"`,
    [
-      `"${tarPath}"`,
+      '--use-compress-program',
+      'zstd -d --long=30',
      '-xf',
      IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
      '-P',
@@ -70,70 +58,11 @@ test('zstd extract tar', async () => {
      IS_WINDOWS ? workspace?.replace(/\\/g, '/') : workspace
    ]
      .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat([
-        '--use-compress-program',
-        IS_WINDOWS ? '"zstd -d --long=30"' : 'unzstd --long=30'
-      ])
-      .join(' '),
-    undefined,
-    {
-      cwd: undefined,
-      env: expect.objectContaining(defaultEnv)
-    }
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
+    {cwd: undefined}
  )
 })

-test('zstd extract tar with windows BSDtar', async () => {
-  if (IS_WINDOWS) {
-    const mkdirMock = jest.spyOn(io, 'mkdirP')
-    const execMock = jest.spyOn(exec, 'exec')
-    jest
-      .spyOn(utils, 'getGnuTarPathOnWindows')
-      .mockReturnValue(Promise.resolve(''))
-
-    const archivePath = `${process.env['windir']}\\fakepath\\cache.tar`
-    const workspace = process.env['GITHUB_WORKSPACE']
-    const tarPath = SystemTarPathOnWindows
-
-    await tar.extractTar(archivePath, CompressionMethod.Zstd)
-
-    expect(mkdirMock).toHaveBeenCalledWith(workspace)
-    expect(execMock).toHaveBeenCalledTimes(2)
-
-    expect(execMock).toHaveBeenNthCalledWith(
-      1,
-      [
-        'zstd -d --long=30 --force -o',
-        TarFilename.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/')
-      ].join(' '),
-      undefined,
-      {
-        cwd: undefined,
-        env: expect.objectContaining(defaultEnv)
-      }
-    )
-
-    expect(execMock).toHaveBeenNthCalledWith(
-      2,
-      [
-        `"${tarPath}"`,
-        '-xf',
-        TarFilename.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P',
-        '-C',
-        workspace?.replace(/\\/g, '/')
-      ].join(' '),
-      undefined,
-      {
-        cwd: undefined,
-        env: expect.objectContaining(defaultEnv)
-      }
-    )
-  }
-})
-
 test('gzip extract tar', async () => {
  const mkdirMock = jest.spyOn(io, 'mkdirP')
  const execMock = jest.spyOn(exec, 'exec')
@@ -145,58 +74,51 @@ test('gzip extract tar', async () => {
  await tar.extractTar(archivePath, CompressionMethod.Gzip)

  expect(mkdirMock).toHaveBeenCalledWith(workspace)
-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
+  const tarPath = IS_WINDOWS
+    ? `${process.env['windir']}\\System32\\tar.exe`
+    : defaultTarPath
  expect(execMock).toHaveBeenCalledTimes(1)
  expect(execMock).toHaveBeenCalledWith(
+    `"${tarPath}"`,
    [
-      `"${tarPath}"`,
+      '-z',
      '-xf',
      IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
      '-P',
      '-C',
      IS_WINDOWS ? workspace?.replace(/\\/g, '/') : workspace
-    ]
-      .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat(['-z'])
-      .join(' '),
-    undefined,
-    {
-      cwd: undefined,
-      env: expect.objectContaining(defaultEnv)
-    }
+    ].concat(IS_MAC ? ['--delay-directory-restore'] : []),
+    {cwd: undefined}
  )
 })

-test('gzip extract GNU tar on windows with GNUtar in path', async () => {
+test('gzip extract GNU tar on windows', async () => {
  if (IS_WINDOWS) {
-    // GNU tar present in path but not at default location
-    jest
-      .spyOn(utils, 'getGnuTarPathOnWindows')
-      .mockReturnValue(Promise.resolve('tar'))
+    jest.spyOn(fs, 'existsSync').mockReturnValueOnce(false)
+
+    const isGnuMock = jest
+      .spyOn(utils, 'isGnuTarInstalled')
+      .mockReturnValue(Promise.resolve(true))
    const execMock = jest.spyOn(exec, 'exec')
    const archivePath = `${process.env['windir']}\\fakepath\\cache.tar`
    const workspace = process.env['GITHUB_WORKSPACE']

    await tar.extractTar(archivePath, CompressionMethod.Gzip)

+    expect(isGnuMock).toHaveBeenCalledTimes(1)
    expect(execMock).toHaveBeenCalledTimes(1)
    expect(execMock).toHaveBeenCalledWith(
+      `"tar"`,
      [
-        `"tar"`,
+        '-z',
        '-xf',
        archivePath.replace(/\\/g, '/'),
        '-P',
        '-C',
        workspace?.replace(/\\/g, '/'),
-        '--force-local',
-        '-z'
-      ].join(' '),
-      undefined,
-      {
-        cwd: undefined,
-        env: expect.objectContaining(defaultEnv)
-      }
+        '--force-local'
+      ],
+      {cwd: undefined}
    )
  }
 })
@@ -212,99 +134,29 @@ test('zstd create tar', async () => {

  await tar.createTar(archiveFolder, sourceDirectories, CompressionMethod.Zstd)

-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
-
  expect(execMock).toHaveBeenCalledTimes(1)
  expect(execMock).toHaveBeenCalledWith(
+    `"${defaultTarPath}"`,
    [
-      `"${tarPath}"`,
      '--posix',
+      '--use-compress-program',
+      'zstd -T0 --long=30',
      '-cf',
      IS_WINDOWS ? CacheFilename.Zstd.replace(/\\/g, '/') : CacheFilename.Zstd,
-      '--exclude',
-      IS_WINDOWS ? CacheFilename.Zstd.replace(/\\/g, '/') : CacheFilename.Zstd,
      '-P',
      '-C',
      IS_WINDOWS ? workspace?.replace(/\\/g, '/') : workspace,
      '--files-from',
-      ManifestFilename
+      'manifest.txt'
    ]
      .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat([
-        '--use-compress-program',
-        IS_WINDOWS ? '"zstd -T0 --long=30"' : 'zstdmt --long=30'
-      ])
-      .join(' '),
-    undefined, // args
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
    {
-      cwd: archiveFolder,
-      env: expect.objectContaining(defaultEnv)
+      cwd: archiveFolder
    }
  )
 })

-test('zstd create tar with windows BSDtar', async () => {
-  if (IS_WINDOWS) {
-    const execMock = jest.spyOn(exec, 'exec')
-    jest
-      .spyOn(utils, 'getGnuTarPathOnWindows')
-      .mockReturnValue(Promise.resolve(''))
-
-    const archiveFolder = getTempDir()
-    const workspace = process.env['GITHUB_WORKSPACE']
-    const sourceDirectories = ['~/.npm/cache', `${workspace}/dist`]
-
-    await fs.promises.mkdir(archiveFolder, {recursive: true})
-
-    await tar.createTar(
-      archiveFolder,
-      sourceDirectories,
-      CompressionMethod.Zstd
-    )
-
-    const tarPath = SystemTarPathOnWindows
-
-    expect(execMock).toHaveBeenCalledTimes(2)
-
-    expect(execMock).toHaveBeenNthCalledWith(
-      1,
-      [
-        `"${tarPath}"`,
-        '--posix',
-        '-cf',
-        TarFilename.replace(/\\/g, '/'),
-        '--exclude',
-        TarFilename.replace(/\\/g, '/'),
-        '-P',
-        '-C',
-        workspace?.replace(/\\/g, '/'),
-        '--files-from',
-        ManifestFilename
-      ].join(' '),
-      undefined, // args
-      {
-        cwd: archiveFolder,
-        env: expect.objectContaining(defaultEnv)
-      }
-    )
-
-    expect(execMock).toHaveBeenNthCalledWith(
-      2,
-      [
-        'zstd -T0 --long=30 --force -o',
-        CacheFilename.Zstd.replace(/\\/g, '/'),
-        TarFilename.replace(/\\/g, '/')
-      ].join(' '),
-      undefined, // args
-      {
-        cwd: archiveFolder,
-        env: expect.objectContaining(defaultEnv)
-      }
-    )
-  }
-})
-
 test('gzip create tar', async () => {
  const execMock = jest.spyOn(exec, 'exec')

@@ -316,31 +168,26 @@ test('gzip create tar', async () => {

  await tar.createTar(archiveFolder, sourceDirectories, CompressionMethod.Gzip)

-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
+  const tarPath = IS_WINDOWS
+    ? `${process.env['windir']}\\System32\\tar.exe`
+    : defaultTarPath

  expect(execMock).toHaveBeenCalledTimes(1)
  expect(execMock).toHaveBeenCalledWith(
+    `"${tarPath}"`,
    [
-      `"${tarPath}"`,
      '--posix',
+      '-z',
      '-cf',
      IS_WINDOWS ? CacheFilename.Gzip.replace(/\\/g, '/') : CacheFilename.Gzip,
-      '--exclude',
-      IS_WINDOWS ? CacheFilename.Gzip.replace(/\\/g, '/') : CacheFilename.Gzip,
      '-P',
      '-C',
      IS_WINDOWS ? workspace?.replace(/\\/g, '/') : workspace,
      '--files-from',
-      ManifestFilename
-    ]
-      .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat(['-z'])
-      .join(' '),
-    undefined, // args
+      'manifest.txt'
+    ].concat(IS_MAC ? ['--delay-directory-restore'] : []),
    {
-      cwd: archiveFolder,
-      env: expect.objectContaining(defaultEnv)
+      cwd: archiveFolder
    }
  )
 })
@@ -354,74 +201,22 @@ test('zstd list tar', async () => {

  await tar.listTar(archivePath, CompressionMethod.Zstd)

-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
  expect(execMock).toHaveBeenCalledTimes(1)
  expect(execMock).toHaveBeenCalledWith(
+    `"${defaultTarPath}"`,
    [
-      `"${tarPath}"`,
+      '--use-compress-program',
+      'zstd -d --long=30',
      '-tf',
      IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
      '-P'
    ]
      .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat([
-        '--use-compress-program',
-        IS_WINDOWS ? '"zstd -d --long=30"' : 'unzstd --long=30'
-      ])
-      .join(' '),
-    undefined,
-    {
-      cwd: undefined,
-      env: expect.objectContaining(defaultEnv)
-    }
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
+    {cwd: undefined}
  )
 })

-test('zstd list tar with windows BSDtar', async () => {
-  if (IS_WINDOWS) {
-    const execMock = jest.spyOn(exec, 'exec')
-    jest
-      .spyOn(utils, 'getGnuTarPathOnWindows')
-      .mockReturnValue(Promise.resolve(''))
-    const archivePath = `${process.env['windir']}\\fakepath\\cache.tar`
-
-    await tar.listTar(archivePath, CompressionMethod.Zstd)
-
-    const tarPath = SystemTarPathOnWindows
-    expect(execMock).toHaveBeenCalledTimes(2)
-
-    expect(execMock).toHaveBeenNthCalledWith(
-      1,
-      [
-        'zstd -d --long=30 --force -o',
-        TarFilename.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/')
-      ].join(' '),
-      undefined,
-      {
-        cwd: undefined,
-        env: expect.objectContaining(defaultEnv)
-      }
-    )
-
-    expect(execMock).toHaveBeenNthCalledWith(
-      2,
-      [
-        `"${tarPath}"`,
-        '-tf',
-        TarFilename.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P'
-      ].join(' '),
-      undefined,
-      {
-        cwd: undefined,
-        env: expect.objectContaining(defaultEnv)
-      }
-    )
-  }
-})
-
 test('zstdWithoutLong list tar', async () => {
  const execMock = jest.spyOn(exec, 'exec')

@@ -431,24 +226,19 @@ test('zstdWithoutLong list tar', async () => {

  await tar.listTar(archivePath, CompressionMethod.ZstdWithoutLong)

-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
  expect(execMock).toHaveBeenCalledTimes(1)
  expect(execMock).toHaveBeenCalledWith(
+    `"${defaultTarPath}"`,
    [
-      `"${tarPath}"`,
+      '--use-compress-program',
+      'zstd -d',
      '-tf',
      IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
      '-P'
    ]
      .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat(['--use-compress-program', IS_WINDOWS ? '"zstd -d"' : 'unzstd'])
-      .join(' '),
-    undefined,
-    {
-      cwd: undefined,
-      env: expect.objectContaining(defaultEnv)
-    }
+      .concat(IS_MAC ? ['--delay-directory-restore'] : []),
+    {cwd: undefined}
  )
 })

@@ -460,23 +250,18 @@ test('gzip list tar', async () => {

  await tar.listTar(archivePath, CompressionMethod.Gzip)

-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
+  const tarPath = IS_WINDOWS
+    ? `${process.env['windir']}\\System32\\tar.exe`
+    : defaultTarPath
  expect(execMock).toHaveBeenCalledTimes(1)
  expect(execMock).toHaveBeenCalledWith(
+    `"${tarPath}"`,
    [
-      `"${tarPath}"`,
+      '-z',
      '-tf',
      IS_WINDOWS ? archivePath.replace(/\\/g, '/') : archivePath,
      '-P'
-    ]
-      .concat(IS_WINDOWS ? ['--force-local'] : [])
-      .concat(IS_MAC ? ['--delay-directory-restore'] : [])
-      .concat(['-z'])
-      .join(' '),
-    undefined,
-    {
-      cwd: undefined,
-      env: expect.objectContaining(defaultEnv)
-    }
+    ].concat(IS_MAC ? ['--delay-directory-restore'] : []),
+    {cwd: undefined}
  )
 })
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Luke Tomlinson	c9cab86201	Lint Code Scanning - Action / CodeQL-Build (push) Has been cancelled Details	2021-05-05 16:58:35 -04:00
Luke Tomlinson	fad1bf5141	Strip INPUT_* env variables from subprocesses Code Scanning - Action / CodeQL-Build (push) Has been cancelled Details	2021-05-05 16:48:27 -04:00
				`@@ -1 +0,0 @@`
				Docs will be added here once development of version `2.0.0` has finished