Update action-versioning.md

.eslintignore

@@ -1,4 +1,3 @@
 node_modules/
 packages/*/node_modules/
-packages/*/lib/
-packages/glob/__tests__/_temp
+packages/*/lib/

.eslintrc.json

@@ -1,42 +1,28 @@
 {
   "plugins": ["jest", "@typescript-eslint"],
-  "extends": ["plugin:github/recommended"],
+  "extends": ["plugin:github/es6"],
   "parser": "@typescript-eslint/parser",
   "parserOptions": {
     "ecmaVersion": 9,
     "sourceType": "module",
-    "project": "./tsconfig.eslint.json"
+    "project": "./tsconfig.json"
   },
   "rules": {
     "eslint-comments/no-use": "off",
-    "github/no-then": "off",
     "import/no-namespace": "off",
-    "no-shadow": "off",
     "no-unused-vars": "off",
-    "no-undef": "off",
     "@typescript-eslint/no-unused-vars": "error",
     "@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/camelcase": "error",
+    "@typescript-eslint/class-name-casing": "error",
     "@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/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",
@@ -46,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",
@@ -53,6 +40,7 @@
     "@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",

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,14 +7,6 @@ assignees: ''
 
 ---
 
-Thank you 🙇‍♀ for wanting to create an issue in this repository. Before you do, please ensure you are filing the issue in the right place. Issues should only be opened on if the issue **relates to code in this repository**.  
-
-* If you have found a security issue [please submit it here](https://hackerone.com/github)
-* If you have questions about writing workflows or action files, then please [visit the GitHub Community Forum's Actions Board](https://github.community/t5/GitHub-Actions/bd-p/actions)
-* If you are having an issue or question about GitHub Actions then please [contact customer support](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/about-github-actions#contacting-support)
-
-If your issue is relevant to this repository, please include the information below:
-
 **Describe the bug**
 A clear and concise description of what the bug is.
 

.github/workflows/artifact-tests.yml

@@ -1,95 +0,0 @@
-name: artifact-unit-tests
-on:
-  push:
-    branches:
-      - main
-    paths-ignore:
-      - '**.md'
-  pull_request:
-    paths-ignore:
-      - '**.md'
-
-jobs:
-  build:
-    name: Build
-
-    strategy:
-      matrix:
-        runs-on: [ubuntu-latest, windows-latest, macos-latest]
-      fail-fast: false
-
-    runs-on: ${{ matrix.runs-on }}
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-
-    - name: Set Node.js 16.x
-      uses: actions/setup-node@v3
-      with:
-        node-version: 16.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
-    - name: Install root npm packages
-      run: npm ci
-
-    - name: Compile artifact package
-      run: |
-        npm ci
-        npm run tsc
-      working-directory: packages/artifact
-
-    - name: Set artifact file contents
-      shell: bash
-      run: |
-        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
-        echo "empty-artifact-content=_EMPTY_" >> $GITHUB_ENV
-
-    - name: Create files that will be uploaded
-      run: |
-        mkdir artifact-path
-        echo '${{ env.non-gzip-artifact-content }}' > artifact-path/world.txt
-        echo '${{ env.gzip-artifact-content }}' > artifact-path/gzip.txt
-        touch artifact-path/empty.txt
-
-    # We're using node -e to call the functions directly available in the @actions/artifact package
-    - name: Upload artifacts using uploadArtifact()
-      run: |
-        node -e "Promise.resolve(require('./packages/artifact/lib/artifact-client').create().uploadArtifact('my-artifact-1',['artifact-path/world.txt'], process.argv[1]))" "${{ github.workspace }}"
-        node -e "Promise.resolve(require('./packages/artifact/lib/artifact-client').create().uploadArtifact('my-artifact-2',['artifact-path/gzip.txt'], process.argv[1]))" "${{ github.workspace }}"
-        node -e "Promise.resolve(require('./packages/artifact/lib/artifact-client').create().uploadArtifact('my-artifact-3',['artifact-path/empty.txt'], process.argv[1]))" "${{ github.workspace }}"
-
-    - 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'))"
-        mkdir artifact-3-directory
-        node -e "Promise.resolve(require('./packages/artifact/lib/artifact-client').create().downloadArtifact('my-artifact-3','artifact-3-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 }}"
-        packages/artifact/__tests__/test-artifact-file.sh "artifact-3-directory/artifact-path/empty.txt" "${{ env.empty-artifact-content }}"
-
-    - 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'))"
-
-    - 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 }}"
-        packages/artifact/__tests__/test-artifact-file.sh "multi-artifact-directory/my-artifact-3/artifact-path/empty.txt" "${{ env.empty-artifact-content }}"

.github/workflows/audit.yml

@@ -1,38 +0,0 @@
-name: toolkit-audit
-on:
-  push:
-    branches:
-      - main
-    paths-ignore:
-      - '**.md'
-  pull_request:
-    paths-ignore:
-      - '**.md'
-
-jobs:
-
-  build:
-    name: Audit
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-
-    - name: Set Node.js 16.x
-      uses: actions/setup-node@v3
-      with:
-        node-version: 16.x
-
-    - name: npm install
-      run: npm install
-
-    - name: Bootstrap
-      run: npm run bootstrap
-
-    - name: audit tools (without allow-list)
-      run: npm audit --audit-level=moderate
-
-    - name: audit packages
-      run: npm run audit-all

.github/workflows/cache-tests.yml

@@ -1,91 +0,0 @@
-name: cache-unit-tests
-on:
-  push:
-    branches:
-      - main
-    paths-ignore:
-      - '**.md'
-  pull_request:
-    paths-ignore:
-      - '**.md'
-
-jobs:
-  build:
-    name: Build
-
-    strategy:
-      matrix:
-        runs-on: [ubuntu-latest, windows-latest, macOS-latest]
-      fail-fast: false
-
-    runs-on: ${{ matrix.runs-on }}
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-
-    - name: Set Node.js 16.x
-      uses: actions/setup-node@v3
-      with:
-        node-version: 16.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

.github/workflows/cache-windows-test.yml

@@ -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 12.x
-      uses: actions/setup-node@v1
-      with:
-        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
-    - 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

.github/workflows/codeql.yml

@@ -1,37 +0,0 @@
-name: "Code Scanning - Action"
-
-on:
-  push:
-    branches:    
-      - main
-  pull_request:
-  schedule:
-    - cron: '0 0 * * 0'
-
-jobs:
-  CodeQL-Build:
-
-    strategy:
-      fail-fast: false
-
-
-    # CodeQL runs on ubuntu-latest, windows-latest, and macos-latest
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      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@v1
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

.github/workflows/releases.yml

@@ -1,80 +0,0 @@
-name: Publish NPM
-
-on:
-  workflow_dispatch:
-    inputs:
-      package:
-        required: true
-        description: 'core, artifact, cache, exec, github, glob, http-client, io, tool-cache'
-
-jobs:
-  test:
-    runs-on: macos-latest
-
-    steps:
-      - name: setup repo
-        uses: actions/checkout@v3
-
-      - name: verify package exists
-        run: ls packages/${{ github.event.inputs.package }}
-
-      - name: Set Node.js 16.x
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16.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
-        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
-        with:
-          name: ${{ github.event.inputs.package }}
-
-      - name: setup authentication
-        run: echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" >> .npmrc
-        env:
-          NPM_TOKEN: ${{ secrets.TOKEN }}
-
-      - name: publish
-        run: npm publish *.tgz
-
-      - name: notify slack on failure
-        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:
-          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:
-          SLACK_WEBHOOK: ${{ secrets.SLACK }}
-

.github/workflows/unit-tests.yml

@@ -1,13 +1,11 @@
 name: toolkit-unit-tests
-on:
+on: 
   push:
-    branches:
-      - main
     paths-ignore:
       - '**.md'
   pull_request:
     paths-ignore:
-      - '**.md'
+      - '**.md'     
 
 jobs:
 
@@ -16,19 +14,19 @@ jobs:
 
     strategy:
       matrix:
-        runs-on: [ubuntu-latest, macos-latest, windows-latest]
+        runs-on: [ubuntu-latest, macOS-latest, windows-latest]
       fail-fast: false
 
     runs-on: ${{ matrix.runs-on }}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v1
 
-    - name: Set Node.js 16.x
-      uses: actions/setup-node@v3
+    - name: Set Node.js 12.x
+      uses: actions/setup-node@master
       with:
-        node-version: 16.x
+        node-version: 12.x
 
     - name: npm install
       run: npm install
@@ -40,9 +38,7 @@ jobs:
       run: npm run build
 
     - name: npm test
-      run: npm test -- --runInBand
-      env:
-        GITHUB_TOKEN: ${{ github.token }}
+      run: npm test
 
     - name: Lint
       run: npm run lint

.github/workflows/update-github.yaml

@@ -1,45 +0,0 @@
-name: "UpdateOctokit"
-
-on:
-  workflow_dispatch:
-
-jobs:
-  UpdateOctokit:
-    runs-on: ubuntu-latest
-    if: ${{ github.repository_owner == 'actions' }}
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-    - name: Update Octokit
-      working-directory: packages/github 
-      run: |
-        npx npm-check-updates -u --dep prod
-        npm install
-    - name: Check Status
-      id: status
-      working-directory: packages/github 
-      run: | 
-        if [[ "$(git status --porcelain)" != "" ]]; then 
-        echo "::set-output name=createPR::true"
-        git config --global user.email "github-actions@github.com"
-        git config --global user.name "github-actions[bot]"
-        git checkout -b bots/updateGitHubDependencies-${{github.run_number}}
-        git add .
-        git commit -m "Update Dependencies"
-        git push --set-upstream origin bots/updateGitHubDependencies-${{github.run_number}}
-        fi
-    - name: Create PR
-      if: ${{steps.status.outputs.createPR}}
-      uses: actions/github-script@v6
-      with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
-          script: |
-            github.pulls.create(
-            {
-              base: "main",
-              owner: "${{github.repository_owner}}",
-              repo: "toolkit",
-              title: "Update Octokit dependencies",
-              body: "Update Octokit dependencies",
-              head: "bots/updateGitHubDependencies-${{github.run_number}}"
-            })

.gitignore

@@ -1,7 +1,4 @@
 node_modules/
 packages/*/node_modules/
 packages/*/lib/
-packages/*/__tests__/_temp/
-.DS_Store
-*.xar
-packages/*/audit.json
+packages/*/__tests__/_temp/

CODEOWNERS

@@ -1,4 +0,0 @@
-* @actions/actions-runtime
-
-/packages/artifact/   @actions/artifacts-actions
-/packages/cache/      @actions/actions-cache

LICENSE.md

@@ -1,5 +1,3 @@
-The MIT License (MIT)
-
 Copyright 2019 GitHub
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

README.md

@@ -4,8 +4,7 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/actions/toolkit/actions?query=workflow%3Atoolkit-unit-tests"><img alt="Toolkit unit tests status" src="https://github.com/actions/toolkit/workflows/toolkit-unit-tests/badge.svg"></a>
-  <a href="https://github.com/actions/toolkit/actions?query=workflow%3Atoolkit-audit"><img alt="Toolkit audit status" src="https://github.com/actions/toolkit/workflows/toolkit-audit/badge.svg"></a>
+  <a href="https://github.com/actions/toolkit"><img alt="GitHub Actions status" src="https://github.com/actions/toolkit/workflows/toolkit-unit-tests/badge.svg"></a>
 </p>
 
 
@@ -19,86 +18,48 @@ The GitHub Actions ToolKit provides a set of packages to make creating actions e
 
 ## Packages
 
-:heavy_check_mark: [@actions/core](packages/core)
+:heavy_check_mark: [@actions/core](packages/core) 
 
 Provides functions for inputs, outputs, results, logging, secrets and variables. Read more [here](packages/core)
 
 ```bash
-$ npm install @actions/core
+$ npm install @actions/core --save
 ```
 <br/>
 
-:runner: [@actions/exec](packages/exec)
+:runner: [@actions/exec](packages/exec) 
 
 Provides functions to exec cli tools and process output. Read more [here](packages/exec)
 
 ```bash
-$ npm install @actions/exec
+$ npm install @actions/exec --save
 ```
 <br/>
 
-:ice_cream: [@actions/glob](packages/glob)
+:pencil2: [@actions/io](packages/io) 
 
-Provides functions to search for files matching glob patterns. Read more [here](packages/glob)
+Provides disk i/o functions like cp, mv, rmRF, find etc. Read more [here](packages/io)
 
 ```bash
-$ npm install @actions/glob
+$ npm install @actions/io --save
 ```
 <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)
-
-```bash
-$ npm install @actions/io
-```
-<br/>
-
-:hammer: [@actions/tool-cache](packages/tool-cache)
+:hammer: [@actions/tool-cache](packages/tool-cache) 
 
 Provides functions for downloading and caching tools.  e.g. setup-* actions. Read more [here](packages/tool-cache)
 
-See @actions/cache for caching workflow dependencies.
-
 ```bash
-$ npm install @actions/tool-cache
+$ npm install @actions/tool-cache --save
 ```
 <br/>
 
-:octocat: [@actions/github](packages/github)
+:octocat: [@actions/github](packages/github) 
 
 Provides an Octokit client hydrated with the context that the current action is being run in. Read more [here](packages/github)
 
 ```bash
-$ npm install @actions/github
-```
-<br/>
-
-:floppy_disk: [@actions/artifact](packages/artifact)
-
-Provides functions to interact with actions artifacts. Read more [here](packages/artifact)
-
-```bash
-$ npm install @actions/artifact
-```
-<br/>
-
-:dart: [@actions/cache](packages/cache)
-
-Provides functions to cache dependencies and build outputs to improve workflow execution time. Read more [here](packages/cache)
-
-```bash
-$ npm install @actions/cache
+$ npm install @actions/github --save
 ```
 <br/>
 
@@ -122,12 +83,6 @@ Problem Matchers are a way to scan the output of actions for a specified regex p
 <br/>
 <br/>
 
-:warning: [Proxy Server Support](docs/proxy-support.md)
-
-Self-hosted runners can be configured to run behind proxy servers.
-<br/>
-<br/>
-
 <h3><a href="https://github.com/actions/hello-world-javascript-action">Hello World JavaScript Action</a></h3>
 
 Illustrates how to create a simple hello world javascript action.
@@ -141,23 +96,23 @@ Illustrates how to create a simple hello world javascript action.
 <br/>
 
 <h3><a href="https://github.com/actions/javascript-action">JavaScript Action Walkthrough</a></h3>
-
+ 
 Walkthrough and template for creating a JavaScript Action with tests, linting, workflow, publishing, and versioning.
 
 ```javascript
 async function run() {
-  try {
+  try { 
     const ms = core.getInput('milliseconds');
     console.log(`Waiting ${ms} milliseconds ...`)
     ...
 ```
 ```javascript
 PASS ./index.test.js
-  ✓ throws invalid number
-  ✓ wait 500 ms
+  ✓ throws invalid number 
+  ✓ wait 500 ms 
   ✓ test runs
 
-Test Suites: 1 passed, 1 total
+Test Suites: 1 passed, 1 total    
 Tests:       3 passed, 3 total
 ```
 <br/>
@@ -177,11 +132,11 @@ async function run() {
 ```
 ```javascript
 PASS ./index.test.js
-  ✓ throws invalid number
-  ✓ wait 500 ms
+  ✓ throws invalid number 
+  ✓ wait 500 ms 
   ✓ test runs
 
-Test Suites: 1 passed, 1 total
+Test Suites: 1 passed, 1 total    
 Tests:       3 passed, 3 total
 ```
 <br/>
@@ -214,13 +169,13 @@ const myInput = core.getInput('myInput');
 core.debug(`Hello ${myInput} from inside a container`);
 
 const context = github.context;
-console.log(`We can even get context data, like the repo: ${context.repo.repo}`)
+console.log(`We can even get context data, like the repo: ${context.repo.repo}`)    
 ```
 <br/>
 
 ## Contributing
 
-We welcome contributions.  See [how to contribute](.github/CONTRIBUTING.md).
+We welcome contributions.  See [how to contribute](docs/contribute.md).
 
 ## Code of Conduct
 

docs/action-debugging.md

@@ -1,23 +1,9 @@
 # Debugging
-If the job logs do not provide enough detail on why a job may be failing, some other options exist to assist with troubleshooting.
-
-## Step Debug Logs
-This is the primary way for customers to debug job failures caused by failed steps.
-
-Step debug logs increase the verbosity of a job's logs during and after a job's execution to assist with troubleshooting.
-
-Additional log events with the prefix `::debug::` will now also appear in the job's logs, these log events are provided by the Action's author and the runner process.
-
-### How to Access Step Debug Logs
-This flag can be enabled by [setting the secret](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/creating-and-using-encrypted-secrets#creating-encrypted-secrets) `ACTIONS_STEP_DEBUG` to `true`.
-
-All actions ran while this secret is enabled will show debug events in the [Downloaded Logs](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/managing-a-workflow-run#downloading-logs) and [Web Logs](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/managing-a-workflow-run#viewing-logs-to-diagnose-failures).
+If the build logs do not provide enough detail on why a build may be failing, some other options exist to assist with troubleshooting.
 
 ## Runner Diagnostic Logs
 Runner Diagnostic Logs provide additional log files detailing how the Runner is executing an action.
 
-You need the runner diagnostic logs only if you think there is an infrastructure problem with GitHub Actions and you want the product team to check the logs.
-
 Each file contains different logging information that corresponds to that process:
   * The Runner process coordinates setting up workers to execute jobs.
   * The Worker process executes the job.
@@ -27,5 +13,14 @@ These files contain the prefix `Runner_` or `Worker_` to indicate the log source
 ### How to Access Runner Diagnostic Logs
 These log files are enabled by [setting the secret](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/creating-and-using-encrypted-secrets#creating-encrypted-secrets) `ACTIONS_RUNNER_DEBUG` to `true`. 
 
-All actions ran while this secret is enabled contain additional diagnostic log files in the `runner-diagnostic-logs` folder of the [log archive](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/managing-a-workflow-run#downloading-logs).
+All actions ran while this secret is enabled contain additional diagnostic log files in the `runner-diagnostic-logs` folder of the [log archive](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/managing-a-workflow-run#downloading-logs-and-artifacts).
 
+## Step Debug Logs
+Step debug logs increase the verbosity of a job's logs during and after a job's execution to assist with troubleshooting. 
+
+Additional log events with the prefix `::debug::` will now also appear in the job's logs.
+
+### How to Access Step Debug Logs
+This flag can be enabled by [setting the secret](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/creating-and-using-encrypted-secrets#creating-encrypted-secrets) `ACTIONS_STEP_DEBUG` to `true`.
+
+All actions ran while this secret is enabled will show debug events in the [Downloaded Logs](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/managing-a-workflow-run#downloading-logs-and-artifacts) and [Web Logs](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/managing-a-workflow-run#viewing-logs-to-diagnose-failures).

docs/action-types.md

@@ -32,14 +32,14 @@ jobs:
         os: [ubuntu-16.04, windows-2019]
     runs-on: ${{matrix.os}}
     actions:
-    - uses: actions/setup-node@v3
+    - uses: actions/setup-node@master
       with:
         version: ${{matrix.node}}
     - run: | 
         npm install
     - run: |
         npm test
-    - uses: actions/custom-action@v1
+    - uses: actions/custom-action@master
 ```
 
 JavaScript actions work on any environment that host action runtime is supported on which is currently node 12.  However, a host action that runs a toolset expects the environment that it's running on to have that toolset in its PATH or using a setup-* action to acquire it on demand.

docs/action-versioning.md

@@ -8,25 +8,25 @@ Examples:
 steps:
     - uses: actions/javascript-action@v1        # recommended. starter workflows use this
     - uses: actions/javascript-action@v1.0.0    # if an action offers specific releases 
-    - uses: actions/javascript-action@41775a4da8ffae865553a738ab8ac1cd5a3c0044 # sha
+    - uses: actions/javascript-action@41775a4   # binding to a specific sha 
 ```
 
 # Compatibility
 
 Binding to a major version is the latest of that major version ( e.g. `v1` == "1.*" )
 
-Major versions should guarantee compatibility.  A major version can add net new capabilities but should not break existing input compatibility or break existing workflows. 
+Major versions should guarantee compatibility.  A major version can add new capabilities but should not break existing input compatibility or break existing workflows.
 
-Major version binding allows you to take advantage of bug fixes and critical functionality and security fixes.  The `main` branch has the latest code and is unstable to bind to since changes get committed to main and released to the market place by creating a tag.  In addition, a new major version carrying breaking changes will get implemented in main after branching off the previous major version.
+Major version binding allows you to take advantage of bug fixes and critical functionality and security fixes.  The `master` branch has the latest code and is unstable to bind to. Changes are committed to master before the changes are ready to be released to the marketplace by creating a tag.  In addition, a new major version may break compatibility will get implemented in master after branching off the previous major version.
 
-> Warning: do not reference `main` since that is the latest code and can be carrying breaking changes of the next major version.
+> Warning: do not reference `master` since that is the latest code and may contain breaking changes of the next major version.
 
 ```yaml
 steps:
-    - uses: actions/javascript-action@main  # do not do this
+    - uses: actions/javascript-action@master  # do not do this
 ```
 
-Binding to the immutable full sha1 may offer more reliability.  However, note that the hosted images toolsets (e.g. ubuntu-latest) move forward and if there is a tool breaking issue, actions may react with a patch to a major version to compensate so binding to a specific SHA may prevent you from getting fixes.
+Binding to the immutable sha1 may offer more reliability.  However, note that the hosted images toolsets (e.g. ubuntu-latest) move forward and if there is a tool breaking issue, actions may react with a patch to a major version to compensate so binding to a specific SHA may prevent you from getting fixes.
 
 > Recommendation: bind to major versions to get functionality and fixes but reserve binding to a specific release or SHA as a mitigation strategy for unforeseen breaks. 
 
@@ -34,15 +34,13 @@ Binding to the immutable full sha1 may offer more reliability.  However, note th
 
 1. **Create a GitHub release for each specific version**: Creating a release like [ v1.0.0 ](https://github.com/actions/javascript-action/releases/tag/v1.0.0) allows users to bind back to a specific version if an issue is encountered with the latest major version.  
 
-2. **Publish the specific version to the marketplace**:  When you release a specific version, choose the option to "Publish this Action to the GitHub Marketplace".
-
-<img src="https://user-images.githubusercontent.com/33549821/78670739-36f5ae00-78ac-11ea-9660-57d5687ce520.png" alt="screenshot" height="250"/>
+2. **Publish the specific version to the marketplace**:  When you release a specific version, choose the option to "Publish this release to the GitHub Marketplace".
 
 3. **Make the new release available to those binding to the major version tag**: Move the major version tag (v1, v2, etc.) to point to the ref of the current release. This will act as the stable release for that major version. You should keep this tag updated to the most recent stable minor/patch release.
 
 ```
-git tag -fa v1 -m "Update v1 tag"
-git push origin v1 --force
+git tag --force --annotate -m "Update v1 tag" v1
+git push --force origin v1
 ```
 # Major Versions
 

docs/adrs/0381-glob-module.md

@@ -1,216 +0,0 @@
-# ADR 381: `glob` module
-
-**Date**: 2019-12-05
-
-**Status**: Accepted
-
-## Context
-
-This ADR proposes adding a `glob` function to the toolkit.
-
-First party actions should have a consistent glob experience.
-
-Related to artifact upload/download v2.
-
-## Decision
-
-### New module
-
-Create a new module `@actions/glob` that can be versioned at it's own pace - not tied to `@actions/io`.
-
-### Signature
-
-```js
-/**
- * Constructs a globber from patterns
- *
- * @param patterns  Patterns separated by newlines
- * @param options   Glob options
- */
-export function create(
-  patterns: string,
-  options?: GlobOptions
-): Promise<Globber> {}
-
-/**
- * Used to match files and directories
- */
-export interface Globber {
-  /**
-   * Returns the search path preceding the first glob segment, from each pattern.
-   * Duplicates and descendants of other paths are filtered out.
-   *
-   * Example 1: The patterns `/foo/*` and `/bar/*` returns `/foo` and `/bar`.
-   *
-   * Example 2: The patterns `/foo/*` and `/foo/bar/*` returns `/foo`.
-   */
-  getSearchPaths(): string[]
-
-  /**
-   * Returns files and directories matching the glob patterns.
-   *
-   * Order of the results is not guaranteed.
-   */
-  glob(): Promise<string[]>
-
-  /**
-   * Returns files and directories matching the glob patterns.
-   *
-   * Order of the results is not guaranteed.
-   */
-  globGenerator(): AsyncGenerator<string, void>
-}
-
-/**
- * Options to control globbing behavior
- */
-export interface GlobOptions {
-  /**
-   * Indicates whether to follow symbolic links. Generally should set to false
-   * when deleting files.
-   *
-   * @default true
-   */
-  followSymbolicLinks?: boolean
-
-  /**
-   * Indicates whether directories that match a glob pattern, should implicitly
-   * cause all descendant paths to be matched.
-   *
-   * For example, given the directory `my-dir`, the following glob patterns
-   * would produce the same results: `my-dir/**`, `my-dir/`, `my-dir`
-   *
-   * @default true
-   */
-  implicitDescendants?: boolean
-
-  /**
-   * Indicates whether broken symbolic should be ignored and omitted from the
-   * result set. Otherwise an error will be thrown.
-   *
-   * @default true
-   */
-  omitBrokenSymbolicLinks?: boolean
-}
-```
-
-### Toolkit usage
-
-Example, do not follow symbolic links:
-
-```js
-const patterns = core.getInput('path')
-const globber = glob.create(patterns, {followSymbolicLinks: false})
-const files = globber.glob()
-```
-
-Example, iterator:
-
-```js
-const patterns = core.getInput('path')
-const globber = glob.create(patterns)
-for await (const file of this.globGenerator()) {
-  console.log(file)
-}
-```
-
-### Action usage
-
-Actions should follow symbolic links by default.
-
-Users can opt-out.
-
-Example:
-
-```yaml
-jobs:
-  build:
-    steps:
-      - uses: actions/upload-artifact@v1
-        with:
-          path: |
-            **/*.tar.gz
-            **/*.pkg
-          follow-symbolic-links: false    # opt out, should default to true
-```
-
-### HashFiles function
-
-Hash files should not follow symbolic links by default.
-
-User can opt-in by specifying flag `--follow-symbolic-links`.
-
-Example:
-
-```yaml
-jobs:
-  build:
-    steps:
-      - uses: actions/cache@v1
-        with:
-          hash: ${{ hashFiles('--follow-symbolic-links', '**/package-lock.json') }}
-```
-
-### Glob behavior
-
-Patterns `*`, `?`, `[...]`, `**` (globstar) are supported.
-
-With the following behaviors:
-
-- File names that begin with `.` may be included in the results
-- Case insensitive on Windows
-- Directory separator `/` and `\` both supported on Windows
-
-Note:
-- Refer [here](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html#Pattern-Matching) for more information about Bash glob patterns.
-- Refer [here](https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html) for more information about Bash glob options.
-
-### Tilde expansion
-
-Support basic tilde expansion, for current user HOME replacement only.
-
-For example, on macOS:
-- `~` may expand to `/Users/johndoe`
-- `~/foo` may expand to `/Users/johndoe/foo`
-
-Note:
-- Refer [here](https://www.gnu.org/software/bash/manual/html_node/Tilde-Expansion.html) for more information about Bash tilde expansion.
-- All other forms of tilde expansion are not supported.
-- Use `os.homedir()` to resolve the HOME path
-
-### Root and normalize paths
-
-An unrooted pattern will be rooted using the current working directory, prior to searching. Additionally the search path will be normalized prior to searching (relative pathing removed, slashes normalized on Windows, extra slashes removed).
-
-The two side effects are:
-1. Rooted and normalized paths are always returned
-2. The pattern `**` will include the working directory in the results
-
-These side effects diverge from Bash behavior. Whereas Bash is designed to be a shell, we are designing an API. This decision is intended to improve predictability of the API results.
-
-Note:
-- In Bash, the results are not rooted when the pattern is relative.
-- In Bash, the results are not normalized. For example, the results from `./*` may look like: `./foo ./bar`
-- In Bash, the results from the pattern `**` does not include the working directory. However the results from `/foo/**` would include the directory `/foo`. Also the results from `foo/**` would include the directory `foo`.
-
-## Comments
-
-Patterns that begin with `#` are treated as comments.
-
-## Exclude patterns
-
-Leading `!` changes the meaning of an include pattern to exclude.
-
-Note:
-- Multiple leading `!` flips the meaning.
-
-## Escaping
-
-Wrapping special characters in `[]` can be used to escape literal glob characters in a file name. For example the literal file name `hello[a-z]` can be escaped as `hello[[]a-z]`.
-
-On Linux/macOS `\` is also treated as an escape character.
-
-## Consequences
-
-- Publish new module `@actions/glob`
-- Publish docs for the module (add link from `./README.md` to new doc `./packages/glob/README.md`)

docs/adrs/README.md

@@ -1,19 +0,0 @@
-# ADRs
-
-ADR, short for "Architecture Decision Record" is a way of capturing important architectural decisions, along with their context and consequences.
-
-This folder includes ADRs for the actions toolkit. ADRs are proposed in the form of a pull request, and they commonly follow this format:
-
-* **Title**: short present tense imperative phrase, less than 50 characters, like a git commit message.
-
-* **Status**: proposed, accepted, rejected, deprecated, superseded, etc.
-
-* **Context**: what is the issue that we're seeing that is motivating this decision or change.
-
-* **Decision**: what is the change that we're actually proposing or doing.
-
-* **Consequences**: what becomes easier or more difficult to do because of this change.
-
----
-
-- More information about ADRs can be found [here](https://github.com/joelparkerhenderson/architecture_decision_record).

docs/commands.md

@@ -1,12 +1,43 @@
 # :: Commands
 
-The [core toolkit package](https://github.com/actions/toolkit/tree/main/packages/core) offers a number of convenience functions for
+The [core toolkit package](https://github.com/actions/toolkit/tree/master/packages/core) offers a number of convenience functions for
 setting results, logging, registering secrets and exporting variables across actions. Sometimes, however, its useful to be able to do
 these things in a script or other tool.
 
 To allow this, we provide a special `::` syntax which, if logged to `stdout` on a new line, will allow the runner to perform special behavior on
 your commands. The following commands are all supported:
 
+### Set an environment variable
+
+To set an environment variable for future out of process steps, use `::set-env`:
+
+```sh
+echo "::set-env name=FOO::BAR"
+```
+
+Running `$FOO` in a future step will now return `BAR`
+
+This is wrapped by the core exportVariable method which sets for future steps but also updates the variable for this step
+
+```javascript
+export function exportVariable(name: string, val: string): void {}
+```
+
+### PATH Manipulation
+
+To prepend a string to PATH, use `::addPath`:
+
+```sh
+echo "::add-path::BAR"
+```
+
+Running `$PATH` in a future step will now return `BAR:{Previous Path}`;
+
+This is wrapped by the core addPath method:
+```javascript
+export function addPath(inputPath: string): void {}
+```
+
 ### Set outputs
 
 To set an output for the step, use `::set-output`:
@@ -50,25 +81,14 @@ 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`
 
 ### Group and Ungroup Log Lines
 
-Emitting a group with a title will instruct the logs to create a collapsible region up to the next endgroup command.
+Emitting a group with a title will instruct the logs to create a collapsable region up to the next ungroup command.
 
 ```bash
 echo "::group::my title"   
@@ -83,7 +103,6 @@ function endGroup(): void {}
 ```
 
 ### Problem Matchers
-
 Problems matchers can be used to scan a build's output to automatically surface lines to the user that matches the provided pattern. A file path to a .json Problem Matcher must be provided. See [Problem Matchers](problem-matchers.md) for more information on how to define a Problem Matcher.
 
 ```bash
@@ -93,125 +112,26 @@ echo "::remove-matcher owner=eslint-compact::"
 
 `add-matcher` takes a path to a Problem Matcher file
 `remove-matcher` removes a Problem Matcher by owner
-
 ### Save State
 
-Save a state to an environmental variable that can later be used in the main or post action.
+Save state to be used in the corresponding wrapper (finally) post job entry point.
 
 ```bash
 echo "::save-state name=FOO::foovalue"
 ```
 
-Because `save-state` prepends the string `STATE_` to the name, the environment variable `STATE_FOO` will be available to use in the post or main action. See [Sending Values to the pre and post actions](https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#sending-values-to-the-pre-and-post-actions) for more information.
-
 ### Log Level
 
-There are several commands to emit different levels of log output:
+Finally, 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)
-
-You can enable or disable this for the current step by using the `echo` command.
-
-```bash
-echo "::echo::on"
-```
-
-You can also disable echoing.
-
-```bash
-echo "::echo::off"
-```
-
-This is wrapped by the core method:
-
-```javascript
-function setCommandEcho(enabled: boolean): void {}
-```
-
-The `add-mask`, `debug`, `warning` and `error` commands do not support echoing.
-
-### Command Prompt
-
+### Command Prompt 
 CMD processes the `"` character differently from other shells when echoing. In CMD, the above snippets should have the `"` characters removed in order to correctly process. For example, the set output command would be:
-
 ```cmd
 echo ::set-output name=FOO::BAR
 ```
-
-## Environment files
-
-During the execution of a workflow, the runner generates temporary files that can be used to perform certain actions. The path to these files are exposed via environment variables. You will need to use the `utf-8` encoding when writing to these files to ensure proper processing of the commands. Multiple commands can be written to the same file, separated by newlines.
-
-### Set an environment variable
-
-To set an environment variable for future out of process steps, write to the file located at `GITHUB_ENV` or use the equivalent `actions/core` function
-
-```sh
-echo "FOO=BAR" >> $GITHUB_ENV
-```
-
-Running `$FOO` in a future step will now return `BAR`
-
-For multiline strings, you may use a heredoc style syntax with your choice of delimeter. In the below example, we use `EOF`.
-
-```
-steps:
-  - name: Set the value
-    id: step_one
-    run: |
-        echo 'JSON_RESPONSE<<EOF' >> $GITHUB_ENV
-        curl https://httpbin.org/json >> $GITHUB_ENV
-        echo 'EOF' >> $GITHUB_ENV
-```
-
-This would set the value of the `JSON_RESPONSE` env variable to the value of the curl response.
-
-The expected syntax for the heredoc style is:
-
-```
-{VARIABLE_NAME}<<{DELIMETER}
-{VARIABLE_VALUE}
-{DELIMETER}
-```
-
-This is wrapped by the core `exportVariable` method which sets for future steps but also updates the variable for this step.
-
-```javascript
-export function exportVariable(name: string, val: string): void {}
-```
-
-### PATH Manipulation
-
-To prepend a string to PATH write to the file located at `GITHUB_PATH` or use the equivalent `actions/core` function
-
-```sh
-echo "/Users/test/.nvm/versions/node/v12.18.3/bin" >> $GITHUB_PATH
-```
-
-Running `$PATH` in a future step will now return `/Users/test/.nvm/versions/node/v12.18.3/bin:{Previous Path}`;
-
-This is wrapped by the core addPath method:
-
-```javascript
-export function addPath(inputPath: string): void {}
-```
-
-### Powershell
-
-Powershell does not use UTF8 by default. You will want to make sure you write in the correct encoding. For example, to set the path:
-
-```
-steps:
-  - run: echo "mypath" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-```

docs/container-action.md

@@ -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@master
 ```
 
 # Define Metadata

docs/contribute.md

@@ -1,23 +1,4 @@
-# Contributions
-
-We welcome contributions in the form of issues and pull requests.  We view the contributions and process as the same for internal and external contributors.
-
-## Issues
-
-Log issues for both bugs and enhancement requests.  Logging issues are important for the open community.
-
-Issues in this repository should be for the toolkit packages. General feedback for GitHub Actions should be filed in the [community forums.](https://github.community/t5/GitHub-Actions/bd-p/actions) Runner specific issues can be filed [in the runner repository](https://github.com/actions/runner).
-
-## Enhancements and Feature Requests
-
-We ask that before significant effort is put into code changes, that we have agreement on taking the change before time is invested in code changes. 
-
-1. Create a feature request. 
-2. When we agree to take the enhancement, create an ADR to agree on the details of the change.
-
-An ADR is an Architectural Decision Record.  This allows consensus on the direction forward and also serves as a record of the change and motivation. [Read more here](../docs/adrs/README.md).
-
-## Development Life Cycle
+## Development
 
 This repository uses [Lerna](https://github.com/lerna/lerna#readme) to manage multiple packages. Read the documentation there to begin contributing.
 
@@ -56,4 +37,4 @@ This will ask you some questions about the new package. Start with `0.0.0` as th
 }
 ```
 
-3. Start developing 😄.
+3. Start developing 😄 and open a pull request.

docs/github-package.md

@@ -8,7 +8,7 @@ Note that a complete version of this action can be found at https://github.com/d
 
 ## Prerequisites
 
-This walkthrough assumes that you have gone through the basic [javascript action walkthrough](https://github.com/actions/javascript-action) and have a basic action set up. If not, we recommend you go through that first.
+This walkthrough assumes that you have gone through the basic [javascript action walkthrough](./javascript-action.md) and have a basic action set up. If not, we recommend you go through that first.
 
 ## Installing dependencies
 
@@ -159,7 +159,7 @@ run();
 
 ## Writing unit tests for your action
 
-Next, we're going to write a basic unit test for our action using jest. If you followed the [javascript walkthrough](https://github.com/actions/javascript-action), you should have a file `__tests__/main.test.ts` that runs tests when `npm test` is called. We're going to start by populating that with one test:
+Next, we're going to write a basic unit test for our action using jest. If you followed the [javascript walkthrough](./javascript-action.md), you should have a file `__tests__/main.test.ts` that runs tests when `npm test` is called. We're going to start by populating that with one test:
 
 ```ts
 const nock = require('nock');

docs/problem-matchers.md

@@ -1,27 +1,13 @@
 # Problem Matchers
-
 Problem Matchers are a way to scan the output of actions for a specified regex pattern and surface that information prominently in the UI. Both [GitHub Annotations](https://developer.github.com/v3/checks/runs/#annotations-object-1) and log file decorations are created when a match is detected.
 
-## Limitations
-
-Currently, GitHub Actions limit the annotation count in a workflow run.
-
-- 10 warning annotations, 10 error annotations, and 10 notice 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)
-
-If your workflow may exceed these annotation counts, consider filtering of the log messages which the Problem Matcher is exposed to (e.g. by PR touched files, lines, or other).
-
 ## Single Line Matchers
 
 Let's consider the ESLint compact output:
-
 ```
 badFile.js: line 50, col 11, Error - 'myVar' is defined but never used. (no-unused-vars)
 ```
-
 We can define a problem matcher in json that detects input in that format:
-
 ```json
 {
     "problemMatcher": [
@@ -47,34 +33,31 @@ The following fields are available for problem matchers:
 
 ```
 {
-    owner: an ID field that can be used to remove or replace the problem matcher. **required**
-    severity: indicates the default severity, either 'warning' or 'error' case-insensitive. Defaults to 'error'
+    owner: An ID field that can be used to remove or replace the problem matcher. **required**
     pattern: [
         {
-            regexp: the regex pattern that provides the groups to match against **required**
+            regexp: The regex pattern that provides the groups to match against **required**
             file: a group number containing the file name
-            fromPath: a group number containing a filepath used to root the file (e.g. a project file)
             line: a group number containing the line number
             column: a group number containing the column information
             severity: a group number containing either 'warning' or 'error' case-insensitive. Defaults to `error`
             code: a group number containing the error code
             message: a group number containing the error message. **required** at least one pattern must set the message
-            loop: whether to loop until a match is not found, only valid on the last pattern of a multipattern matcher
+            loop: loops until a match is not found, only valid on the last pattern of a multipattern matcher
         }
     ]
 }
 ```
 
+
 ## Multiline Matching
 Consider the following output:
-
 ```
 test.js
   1:0   error  Missing "use strict" statement                 strict
   5:10  error  'addOne' is defined but never used             no-unused-vars
 ✖ 2 problems (2 errors, 0 warnings)
 ```
-
 The file name is printed once, yet multiple error lines are printed. The `loop` keyword provides a way to discover multiple errors in outputs. 
 
 The eslint-stylish problem matcher defined below catches that output, and creates two annotations from it.
@@ -110,40 +93,15 @@ The eslint-stylish problem matcher defined below catches that output, and create
 The first pattern matches the `test.js` line and records the file information. This line is not decorated in the UI.
 The second pattern loops through the remaining lines with `loop: true` until it fails to find a match, and surfaces these lines prominently in the UI.
 
-Note that the pattern matches must be on consecutive lines. The following would not result in any match findings.
-
-```
-test.js
-  extraneous log line of no interest
-  1:0   error  Missing "use strict" statement                 strict
-  5:10  error  'addOne' is defined but never used             no-unused-vars
-✖ 2 problems (2 errors, 0 warnings)
-```
-
 ## Adding and Removing Problem Matchers
-
 Problem Matchers are enabled and removed via the toolkit [commands](commands.md#problem-matchers).
 
 ## Duplicate Problem Matchers
-
 Registering two problem-matchers with the same owner will result in only the problem matcher registered last running.
 
 ## Examples
-
 Some of the starter actions are already using problem matchers, for example:
-- [setup-node](https://github.com/actions/setup-node/tree/main/.github)
-- [setup-python](https://github.com/actions/setup-python/tree/main/.github)
-- [setup-go](https://github.com/actions/setup-go/tree/main/.github)
-- [setup-dotnet](https://github.com/actions/setup-dotnet/tree/main/.github)
-
-## Troubleshooting
-
-### Regular expression not matching
-
-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.
-
-This usually happens when the file does not exist or is not under the workflow repo.
+- [setup-node](https://github.com/actions/setup-node/tree/master/.github)
+- [setup-python](https://github.com/actions/setup-python/tree/master/.github)
+- [setup-go](https://github.com/actions/setup-go/tree/master/.github)
+- [setup-dotnet](https://github.com/actions/setup-dotnet/tree/master/.github)

docs/proxy-support.md

@@ -1,10 +0,0 @@
-# Proxy Server Support
-
-Self-hosted runners [can be configured](https://help.github.com/en/actions/hosting-your-own-runners/using-a-proxy-server-with-self-hosted-runners) to run behind a proxy server in enterprises.
-
-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)
-
-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).

jest.config.js

@@ -4,6 +4,7 @@ module.exports = {
   roots: ['<rootDir>/packages'],
   testEnvironment: 'node',
   testMatch: ['**/__tests__/*.test.ts'],
+  testRunner: 'jest-circus/runner',
   transform: {
     '^.+\\.ts$': 'ts-jest'
   },

package.json

@@ -2,31 +2,29 @@
   "name": "root",
   "private": true,
   "scripts": {
-    "audit-all": "lerna run audit-moderate",
     "bootstrap": "lerna bootstrap",
     "build": "lerna run tsc",
     "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"
+    "test": "jest"
   },
   "devDependencies": {
-    "@types/jest": "^27.0.2",
-    "@types/node": "^16.18.1",
-    "@types/signale": "^1.4.1",
-    "@typescript-eslint/parser": "^4.0.0",
-    "concurrently": "^6.1.0",
-    "eslint": "^7.23.0",
-    "eslint-plugin-github": "^4.1.3",
-    "eslint-plugin-jest": "^22.21.0",
-    "flow-bin": "^0.115.0",
-    "jest": "^27.2.5",
-    "lerna": "^5.4.0",
-    "prettier": "^1.19.1",
-    "ts-jest": "^27.0.5",
-    "typescript": "^3.9.9"
+    "@types/jest": "^24.0.11",
+    "@types/node": "^11.13.5",
+    "@types/signale": "^1.2.1",
+    "@typescript-eslint/parser": "^1.9.0",
+    "concurrently": "^4.1.0",
+    "eslint": "^5.16.0",
+    "eslint-plugin-github": "^2.0.0",
+    "eslint-plugin-jest": "^22.5.1",
+    "jest": "^24.9.0",
+    "jest-circus": "^24.7.1",
+    "lerna": "^3.18.4",
+    "prettier": "^1.17.0",
+    "ts-jest": "^24.0.2",
+    "typescript": "^3.6.2"
   }
 }

packages/artifact/CONTRIBUTIONS.md

@@ -1,30 +0,0 @@
-# Contributions
-
-This package is used internally by the v2+ versions of [upload-artifact](https://github.com/actions/upload-artifact) and [download-artifact](https://github.com/actions/download-artifact). This package can also be used by other actions to interact with artifacts. Any changes or updates to this package will propagate updates to these actions so it is important that major changes or updates get properly tested. 
-
-Any issues or feature requests that are related to the artifact actions should be filled in the appropriate repo.
-
-A limited range of unit tests run as part of each PR when making changes to the artifact packages. For small contributions and fixes, they should be sufficient.
-
-If making large changes, there are a few scenarios that should be tested.
-
-- Uploading very large artifacts (large artifacts get compressed using gzip so compression/decompression must be tested)
-- Uploading artifacts with lots of small files (each file is uploaded with its own HTTP call, timeouts and non-success HTTP responses can be expected so they must be properly handled)
-- Uploading artifacts using a self-hosted runner (uploads and downloads behave differently due to extra latency)
-- Downloading a single artifact (large and small, if lots of small files are part of an artifact, timeouts and non-success HTTP responses can be expected)
-- Downloading all artifacts at once
-
-Large architectural changes can impact upload/download performance so it is important to separately run extra tests. We request that any large contributions/changes have extra detailed testing so we can verify performance and possible regressions.
-
-It is not possible to run end-to-end tests for artifacts as part of a PR in this repo because certain env variables such as `ACTIONS_RUNTIME_URL` are only available from the context of an action as opposed to a shell script. These env variables are needed in order to make the necessary API calls.
-
-# Testing
-
-Any easy way to test changes is to fork the artifact actions and to use `npm link` to test your changes.
-
-1. Fork the [upload-artifact](https://github.com/actions/upload-artifact) and [download-artifact](https://github.com/actions/download-artifact) repos
-2. Clone the forks locally
-3. With your local changes to the toolkit repo, type `npm link` after ensuring there are no errors when running `tsc`
-4. In the locally cloned fork, type `npm link @actions/artifact`
-4. Create a new release for your local fork using `tsc` and `npm run release` (this will create a new `dist/index.js` file using `@vercel/ncc`)
-5. Commit and push your local changes, you will then be able to test your changes with your forked action

packages/artifact/LICENSE.md

@@ -1,9 +0,0 @@
-The MIT License (MIT)
-
-Copyright 2019 GitHub
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/artifact/README.md

@@ -1,95 +0,0 @@
-# `@actions/artifact`
-
-## Usage
-
-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)
-
-Relative paths and absolute paths are both allowed. Relative paths are rooted against the current working directory.
-
-## Upload an Artifact
-
-Method Name: `uploadArtifact`
-
-#### 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
-
-- `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
-- `size`
-    - Total size of the artifact that was uploaded in bytes
-
-## 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.

packages/artifact/RELEASES.md

@@ -1,96 +0,0 @@
-# @actions/artifact Releases
-
-### 0.1.0
-
-- Initial release
-
-### 0.2.0
-
-- Fixes to TCP connections not closing
-- GZip file compression to speed up downloads
-- Improved logging and output
-- Extra documentation
-
-### 0.3.0
-
-- Fixes to gzip decompression when downloading artifacts
-- Support handling 429 response codes
-- Improved download experience when dealing with empty files
-- Exponential backoff when retryable status codes are encountered
-- Clearer error message if storage quota has been reached
-- Improved logging and output during artifact download
-
-### 0.3.1
-
-- Fix to ensure temporary gzip files get correctly deleted during artifact upload
-- Remove spaces as a forbidden character during upload
-
-### 0.3.2
-
-- Fix to ensure readstreams get correctly reset in the event of a retry
-
-### 0.3.3
-
-- Increase chunk size during upload from 4MB to 8MB
-- Improve user-agent strings during API calls to help internally diagnose issues
-
-### 0.3.5
-
-- Retry in the event of a 413 response
-
-### 0.4.0
-
-- Add option to specify custom retentions on artifacts
-
-### 0.4.1
-
-- Update to latest @actions/core version
-
-### 0.4.2
-
-- Improved retry-ability when a partial artifact download is encountered
-
-### 0.5.0
-
-- Improved retry-ability for all http calls during artifact upload and download if an error is encountered
-
-### 0.5.1
-
-- 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)

packages/artifact/__tests__/ci-test-action/action.yml

@@ -1,5 +0,0 @@
-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'

packages/artifact/__tests__/ci-test-action/index.js

@@ -1,14 +0,0 @@
-// 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'
-})

packages/artifact/__tests__/test-artifact-file.sh

@@ -1,27 +0,0 @@
-#!/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 [ "$expectedContent" == "_EMPTY_" ] && [ ! -s "$path" ]; then
-    exit 0
-elif  [ "$actualContent" != "$expectedContent" ]; then
-    echo "File contents are not correct, expected $expectedContent, received $actualContent"
-    exit 1
-fi

packages/artifact/package.json

@@ -1,52 +0,0 @@
-{
-  "name": "@actions/artifact",
-  "version": "1.1.1",
-  "preview": true,
-  "description": "Actions artifact lib",
-  "keywords": [
-    "github",
-    "actions",
-    "artifact"
-  ],
-  "homepage": "https://github.com/actions/toolkit/tree/main/packages/artifact",
-  "license": "MIT",
-  "main": "lib/artifact.js",
-  "types": "lib/artifact.d.ts",
-  "directories": {
-    "lib": "lib",
-    "test": "__tests__"
-  },
-  "files": [
-    "lib",
-    "!.DS_Store"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/actions/toolkit.git",
-    "directory": "packages/artifact"
-  },
-  "scripts": {
-    "audit-moderate": "npm install && npm audit --json --audit-level=moderate > audit.json",
-    "test": "echo \"Error: run tests from root\" && exit 1",
-    "tsc": "tsc"
-  },
-  "bugs": {
-    "url": "https://github.com/actions/toolkit/issues"
-  },
-  "dependencies": {
-    "@actions/core": "^1.10.0",
-    "@actions/http-client": "^2.1.0",
-    "@azure/storage-blob": "^12.15.0",
-    "@types/node": "^20.4.5",
-    "archiver": "^5.3.1"
-  },
-  "devDependencies": {
-    "@protobuf-ts/plugin": "^2.2.3-alpha.1",
-    "@types/archiver": "^5.3.2",
-    "twirp-ts": "^2.5.0",
-    "typescript": "^3.9.10"
-  }
-}

packages/artifact/src/artifact.ts

@@ -1,16 +0,0 @@
-import { ArtifactClient, Client} from './internal/client'
-import { UploadOptions } from './internal/upload/upload-options'
-import { UploadResponse } from './internal/upload/upload-response'
-
-/**
- * Exported functionality that we want to expose for any users of @actions/artifact
- */
-export {
-  ArtifactClient,
-  UploadOptions,
-  UploadResponse,
-}
-
-export function create(): ArtifactClient {
-  return Client.create()
-}

packages/artifact/src/generated/google/protobuf/timestamp.ts

@@ -1,277 +0,0 @@
-// @generated by protobuf-ts 2.9.1 with parameter 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: bigint;
-    /**
-     * 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*/, L: 0 /*LongType.BIGINT*/ },
-            { 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)).toBigInt();
-        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)).toBigInt();
-        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).toBigInt();
-        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: 0n, 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().toBigInt();
-                    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 !== 0n)
-            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();

packages/artifact/src/generated/google/protobuf/wrappers.ts

@@ -1,748 +0,0 @@
-// @generated by protobuf-ts 2.9.1 with parameter 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: bigint;
-}
-/**
- * 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: bigint;
-}
-/**
- * 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*/, L: 0 /*LongType.BIGINT*/ }
-        ]);
-    }
-    /**
-     * 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.BIGINT, "value") as any;
-        return target;
-    }
-    create(value?: PartialMessage<Int64Value>): Int64Value {
-        const message = { value: 0n };
-        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().toBigInt();
-                    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 !== 0n)
-            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*/, L: 0 /*LongType.BIGINT*/ }
-        ]);
-    }
-    /**
-     * 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.BIGINT, "value") as any;
-        return target;
-    }
-    create(value?: PartialMessage<UInt64Value>): UInt64Value {
-        const message = { value: 0n };
-        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().toBigInt();
-                    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 !== 0n)
-            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();

packages/artifact/src/generated/index.ts

@@ -1,4 +0,0 @@
-export * from "../generated/google/protobuf/timestamp";
-export * from "../generated/google/protobuf/wrappers";
-export * from "../generated/results/api/v1/artifact";
-export * from "../generated/results/api/v1/artifact.twirp";

packages/artifact/src/generated/results/api/v1/artifact.ts

@@ -1,346 +0,0 @@
-// @generated by protobuf-ts 2.9.1 with parameter 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: bigint;
-    /**
-     * @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 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*/, L: 0 /*LongType.BIGINT*/ },
-            { no: 5, name: "hash", kind: "message", T: () => StringValue }
-        ]);
-    }
-    create(value?: PartialMessage<FinalizeArtifactRequest>): FinalizeArtifactRequest {
-        const message = { workflowRunBackendId: "", workflowJobRunBackendId: "", name: "", size: 0n };
-        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().toBigInt();
-                    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 !== 0n)
-            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*/ }
-        ]);
-    }
-    create(value?: PartialMessage<FinalizeArtifactResponse>): FinalizeArtifactResponse {
-        const message = { ok: false };
-        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;
-                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);
-        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 }
-]);

packages/artifact/src/generated/results/api/v1/artifact.twirp.ts

@@ -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))
-}

packages/artifact/src/internal/artifact-http-client.ts

@@ -1,140 +0,0 @@
-import { HttpCodes, HttpClient, HttpClientResponse } from '@actions/http-client'
-import { BearerCredentialHandler } from '@actions/http-client/lib/auth'
-import { info } from '@actions/core'
-import { getRuntimeToken, getResultsServiceUrl, getRetryMultiplier, getInitialRetryIntervalInMilliseconds, getRetryLimit } from './config'
-
-interface Rpc { request(
-        service: string,
-        method: string,
-        contentType: "application/json" | "application/protobuf",
-        data: object | Uint8Array
-    ): Promise<object | Uint8Array>
-}
-
-export class ArtifactHttpClient implements Rpc {
-    private httpClient: HttpClient 
-    private baseUrl: string
-
-    constructor(userAgent: string) {
-        const token = getRuntimeToken()
-        this.httpClient = new HttpClient(userAgent, [
-            new BearerCredentialHandler(token)
-        ])
-        this.baseUrl = getResultsServiceUrl()
-    }
-
-    async request(service: string, method: string, contentType: "application/json" | "application/protobuf", data: object | Uint8Array): Promise<object | Uint8Array> {
-        let url = `${this.baseUrl}/twirp/${service}/${method}`
-        let headers = {
-            "Content-Type": contentType
-        }
-
-        const resp = await this.retry(
-            `${method}`,
-            this.httpClient.post(url, JSON.stringify(data), headers),
-        )
-        const body = await resp.readBody()
-        return JSON.parse(body)
-    }
-
-    async retry(name: string, operation: Promise<HttpClientResponse>): Promise<HttpClientResponse> {
-        let response: HttpClientResponse | undefined = undefined
-        let statusCode: number | undefined = undefined
-        let isRetryable = false
-        let errorMessage = ''
-        let attempt = 1
-        const maxAttempts = getRetryLimit() 
-
-        while (attempt <= maxAttempts) {
-            try {
-                response = await operation
-                statusCode = response.message.statusCode
-
-                if (this.isSuccessStatusCode(statusCode)) {
-                    return response
-                }
-
-                isRetryable = this.isRetryableStatusCode(statusCode)
-                    errorMessage = `Artifact service responded with ${statusCode}`
-            } catch (error: any) {
-                isRetryable = true
-                errorMessage = error.message
-            }
-
-            if (!isRetryable) {
-                info(`${name} - Error is not retryable`)
-                if (response) {
-                    this.displayHttpDiagnostics(response)
-                }
-                break
-            }
-
-            info(
-                `${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`
-            )
-                
-            await this.sleep(this.getExponentialRetryTimeInMilliseconds(attempt))
-            attempt++
-        }
-
-        if (response) {
-            this.displayHttpDiagnostics(response)
-        }
-
-        throw Error(`${name} failed: ${errorMessage}`)
-    }
-
-    isSuccessStatusCode(statusCode?: number): boolean {
-        if (!statusCode) {
-            return false
-        }
-        return statusCode >= 200 && statusCode < 300
-    }
-
-    isRetryableStatusCode(statusCode: number | undefined): 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)
-    }
-
-    displayHttpDiagnostics(response: HttpClientResponse): 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 ######`
-        )
-    }
-
-    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.trunc(Math.random() * (maxTime - minTime) + minTime)
-    }
-
-    async sleep(milliseconds: number): Promise<void> {
-          return new Promise(resolve => setTimeout(resolve, milliseconds))
-    }
-}

packages/artifact/src/internal/client.ts

@@ -1,44 +0,0 @@
-import { UploadOptions } from './upload/upload-options'
-import { UploadResponse } from './upload/upload-response'
-import { uploadArtifact } from './upload/upload-artifact'
-
-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>
-
-  // TODO Download functionality
-}
-
-export class Client implements ArtifactClient {
-  /**
-   * Constructs a Client
-   */
-  static create(): Client {
-    return new Client()
-  }
-
-  /**
-   * Uploads an artifact
-   */
-  async uploadArtifact(
-    name: string,
-    files: string[],
-    rootDirectory: string,
-    options?: UploadOptions | undefined
-  ): Promise<UploadResponse> {
-    return uploadArtifact(name, files, rootDirectory, options)
-  }
-}

packages/artifact/src/internal/config.ts

@@ -1,50 +0,0 @@
-export function getRuntimeToken(): string {
-    const token = process.env['ACTIONS_RUNTIME_TOKEN']
-    if (!token) {
-      throw new Error('Unable to get the ACTIONS_RUNTIME_TOKEN environment variable which is required')
-    }
-    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 environment variable which is required')
-    }
-    return resultsUrl
-}
-  
-export function getWorkFlowRunId(): string {
-    const workFlowRunId = process.env['GITHUB_RUN_ID']
-    if (!workFlowRunId) {
-      throw new Error('Unable to get the GITHUB_RUN_ID environment variable which is required')
-    }
-    return workFlowRunId
-}
-  
-export function getWorkSpaceDirectory(): string {
-    const workspaceDirectory = process.env['GITHUB_WORKSPACE']
-    if (!workspaceDirectory) {
-      throw new Error('Unable to get the GITHUB_WORKSPACE environment variable which is required')
-    }
-    return workspaceDirectory
-}
-  
-export function getRetentionDays(): string | undefined {
-    return process.env['GITHUB_RETENTION_DAYS']
-}
-
-export function getInitialRetryIntervalInMilliseconds(): number {
-  return 3000
-}
-
-// 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 maximum number of retries that can be attempted before an upload or download fails
-export function getRetryLimit(): number {
-  return 5
-}

packages/artifact/src/internal/upload/path-and-artifact-name-validation.ts

@@ -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 /']
-])
-
-/**
- * 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 [
-    invalidCharacterKey,
-    errorMessageForCharacter
-  ] of invalidArtifactNameCharacters) {
-    if (name.includes(invalidCharacterKey)) {
-      throw new Error(
-        `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!`)
-}
-
-/**
- * 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 [
-    invalidCharacterKey,
-    errorMessageForCharacter
-  ] of invalidArtifactFilePathCharacters) {
-    if (path.includes(invalidCharacterKey)) {
-      throw new Error(
-        `Artifact path 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.
-          `
-      )
-    }
-  }
-}

packages/artifact/src/internal/upload/tmp/a.txt

@@ -1 +0,0 @@
-hello there! This is from a.txt

packages/artifact/src/internal/upload/tmp/b.txt

@@ -1 +0,0 @@
-This is from b.txt

packages/artifact/src/internal/upload/tmp/testing.ts

@@ -1,123 +0,0 @@
-import {BlobClient, BlockBlobUploadStreamOptions} from '@azure/storage-blob'
-import { TransferProgressEvent } from '@azure/core-http';
-import * as a from 'archiver'
-import * as fs from 'fs'
-import * as stream from 'stream'
-
-const bufferSize = 1024 * 1024 * 8 // 8 MB 
-
-// 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
-        })
-    }
-
-    _transform(chunk:any, enc:any, cb:any) {
-        cb(null, chunk)
-    }
-}
-
-
-// for local testing, run this using ts-node testing.ts
-export async function test(){
-    let sasURL = "paste here"
-    sasURL = sasURL.replace("http://devstoreaccount1.blob.codedev.localhost", "http://127.0.0.1:11000/devstoreaccount1")
-
-    const blobClient = new BlobClient(sasURL);
-    const zip = a.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
-    });
-
-    // append files that are going to be part of the final zip
-    zip.append('this is file 1', { name: 'file1.txt' });
-    zip.append('this is file 2', { name: 'file2.txt' });
-    zip.append('this is file 1 in a directory', { name: 'dir/file1.txt' });
-    zip.append('this is file 2 in a directory', { name: 'dir/file2.txt' });
-    zip.append('this is a live demo!!!', { name: 'dir/alive.txt' });
-    zip.append(fs.createReadStream('a.txt'), { name: 'dir2/a.txt' })
-    zip.append(fs.createReadStream('b.txt'), { name: 'dir2/b.txt' })
-
-    const zipUploadStream = new ZipUploadStream(bufferSize)
-    zip.pipe(zipUploadStream)
-    zip.finalize();
-
-    console.log("Write high watermark value " + zipUploadStream.writableHighWaterMark)
-    console.log("Read high watermark value "  + zipUploadStream.readableHighWaterMark)
-
-    // good practice to catch warnings (ie stat failures and other non-blocking errors)
-    zip.on('warning', function(err) {
-        if (err.code === 'ENOENT') {
-            console.log("zip error ENOENT")
-        } else {
-            console.log("some other warning ")
-            console.log(err)
-        }
-    });
-  
-    // good practice to catch this error explicitly
-    zip.on('error', function(err) {
-        console.log("some error with zip ")
-        console.log(err)
-    });
-
-    zip.on("progress", function(progress: a.ProgressData) {
-        console.log(progress)
-
-        /* This outputs data like this, we could potentially do something with this for even more logging to show the status of the zip creation
-            {
-            entries: { total: 7, processed: 1 },
-            fs: { totalBytes: 0, processedBytes: 0 }
-            }
-            {
-            entries: { total: 7, processed: 2 },
-            fs: { totalBytes: 0, processedBytes: 0 }
-            }
-        */
-    })
-
-
-    // We can add these to debug logging
-    zip.on('end', function() {
-        console.log("zip ending")
-    });
-    zip.on('finish', function() {
-        console.log("zip finished")
-    });
-
-    // Upload options
-    const maxBuffers = 5
-    const blockBlobClient = blobClient.getBlockBlobClient()
-
-    let uploadByteCount = 0
-    var myCallback = function(progress: TransferProgressEvent) {
-        console.log("Byte upload count " + progress.loadedBytes)
-        uploadByteCount = progress.loadedBytes
-      };
-
-    const options: BlockBlobUploadStreamOptions = {
-        blobHTTPHeaders: { "blobContentType": "zip" },
-        onProgress: myCallback
-    }
-  
-    // Upload!
-    try {
-        const aa = await blockBlobClient.uploadStream(
-            zipUploadStream,
-            bufferSize,
-            maxBuffers,
-            options
-        );
-    } catch (error){
-        console.log(error)
-    }
-    console.log("final upload size in bytes is " + uploadByteCount)
-}
-
-test()

packages/artifact/src/internal/upload/tmp/twirp_testing.ts

@@ -1,32 +0,0 @@
-import { ArtifactHttpClient } from '../../artifact-http-client'
-import { ArtifactServiceClientJSON } from '../../../generated/results/api/v1/artifact.twirp'
-
-export async function twirpTest(){
-    const artifactClient = new ArtifactHttpClient('@actions/artifact-upload')
-    const jsonClient = new ArtifactServiceClientJSON(artifactClient)
-
-    try {
-        const createResp = await jsonClient.CreateArtifact({workflowRunBackendId: "ce7f54c7-61c7-4aae-887f-30da475f5f1a", workflowJobRunBackendId: "ca395085-040a-526b-2ce8-bdc85f692774", name: Math.random().toString(), version: 4})
-
-        if (!createResp.ok) {
-            console.log("CreateArtifact failed")
-            return
-        }
-
-        console.log(createResp.signedUploadUrl)
-
-        const finalizeResp = await jsonClient.FinalizeArtifact({workflowRunBackendId: "ce7f54c7-61c7-4aae-887f-30da475f5f1a", workflowJobRunBackendId: "ca395085-040a-526b-2ce8-bdc85f692774", name: Math.random().toString(), size: BigInt(5)})
-
-        if (!finalizeResp.ok) {
-            console.log("FinalizeArtifact failed")
-            return
-        }
-    } catch (e) {
-        console.log(e)
-        return
-    }
-
-    console.log("FinalizeArtifact succeeded")
-}
-
-twirpTest()

packages/artifact/src/internal/upload/upload-artifact.ts

@@ -1,190 +0,0 @@
-import * as core from '@actions/core'
-import {checkArtifactName} from './path-and-artifact-name-validation'
-import {UploadOptions} from './upload-options'
-import {UploadResponse} from './upload-response'
-import { UploadSpecification, getUploadSpecification } from './upload-specification'
-import { ArtifactHttpClient } from '../artifact-http-client'
-import { ArtifactServiceClientJSON } from '../../generated/results/api/v1/artifact.twirp'
-
-import {BlobClient, BlockBlobUploadStreamOptions} from '@azure/storage-blob'
-import { TransferProgressEvent } from '@azure/core-http';
-import * as a from 'archiver'
-import * as fs from 'fs'
-import * as stream from 'stream'
-
-import {getBackendIds, BackendIds} from '../util' 
-
-const bufferSize = 1024 * 1024 * 8 // 8 MB
-
-// 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
-        })
-    }
-
-    _transform(chunk:any, enc:any, cb:any) {
-        cb(null, chunk)
-    }
-}
-
-export async function uploadArtifact(
-    name: string,
-    files: string[],
-    rootDirectory: string,
-    options?: UploadOptions | undefined
-  ): Promise<UploadResponse> {
-
-    let uploadByteCount = 0
-
-    // Need to keep checking the artifact name
-    checkArtifactName(name)
-
-    // Get specification for the files being uploaded
-    const uploadSpecification: UploadSpecification[] = getUploadSpecification(
-        name,
-        rootDirectory,
-        files
-    )
-
-    if (uploadSpecification.length === 0) {
-        core.warning(`No files found that can be uploaded`)
-    } else {
-        const artifactClient = new ArtifactHttpClient('@actions/artifact-upload')
-        const jsonClient = new ArtifactServiceClientJSON(artifactClient)
-
-        const backendIDs: BackendIds = getBackendIds()
-
-        console.log("workflow Run Backend ID " + backendIDs.workflowRunBackendId)
-        console.log("workflow Job Run Backend ID " + backendIDs.workflowJobRunBackendId)
-
-        console.log("hello Rob!!")
-
-        try {
-
-
-
-
-            const createResp = await jsonClient.CreateArtifact({workflowRunBackendId: backendIDs.workflowRunBackendId, workflowJobRunBackendId: backendIDs.workflowJobRunBackendId, name: name, version: 4})
-    
-            if (!createResp.ok) {
-                core.error("CreateArtifact failed")
-            }
-    
-            console.log(createResp.signedUploadUrl)
-    
-            // Blob upload start
-
-            const blobClient = new BlobClient(createResp.signedUploadUrl);
-            const zip = a.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
-            });
-
-            console.log("file specification")
-            for (const file of uploadSpecification) {
-                console.log("uploadPath:" + file.uploadFilePath + " absolute:" + file.absoluteFilePath)
-                zip.append(fs.createReadStream(file.absoluteFilePath), {name: file.uploadFilePath})
-            }
-
-            const zipUploadStream = new ZipUploadStream(bufferSize)
-            zip.pipe(zipUploadStream)
-            zip.finalize();
-
-            console.log("Write high watermark value " + zipUploadStream.writableHighWaterMark)
-            console.log("Read high watermark value "  + zipUploadStream.readableHighWaterMark)
-
-            // good practice to catch warnings (ie stat failures and other non-blocking errors)
-            zip.on('warning', function(err) {
-                if (err.code === 'ENOENT') {
-                    console.log("zip error ENOENT")
-                } else {
-                    console.log("some other warning ")
-                    console.log(err)
-                }
-            });
-        
-            // good practice to catch this error explicitly
-            zip.on('error', function(err) {
-                console.log("some error with zip ")
-                console.log(err)
-            });
-
-            zip.on("progress", function(progress: a.ProgressData) {
-                console.log(progress)
-
-                /* This outputs data like this, we could potentially do something with this for even more logging to show the status of the zip creation
-                    {
-                    entries: { total: 7, processed: 1 },
-                    fs: { totalBytes: 0, processedBytes: 0 }
-                    }
-                    {
-                    entries: { total: 7, processed: 2 },
-                    fs: { totalBytes: 0, processedBytes: 0 }
-                    }
-                */
-            })
-
-
-            // We can add these to debug logging
-            zip.on('end', function() {
-                console.log("zip ending")
-            });
-            zip.on('finish', function() {
-                console.log("zip finished")
-            });
-
-            // Upload options
-            const maxBuffers = 5
-            const blockBlobClient = blobClient.getBlockBlobClient()
-
-            var myCallback = function(progress: TransferProgressEvent) {
-                console.log("Byte upload count " + progress.loadedBytes)
-                uploadByteCount = progress.loadedBytes
-            };
-
-            const options: BlockBlobUploadStreamOptions = {
-                blobHTTPHeaders: { "blobContentType": "zip" },
-                onProgress: myCallback
-            }
-        
-            // Upload!
-            try {
-                await blockBlobClient.uploadStream(
-                    zipUploadStream,
-                    bufferSize,
-                    maxBuffers,
-                    options
-                );
-            } catch (error){
-                console.log(error)
-            }
-            console.log("final upload size in bytes is " + uploadByteCount)
-
-            console.log("we are done with the blob upload!")
-            // Blob upload end
-
-            const finalizeResp = await jsonClient.FinalizeArtifact({workflowRunBackendId: backendIDs.workflowRunBackendId, workflowJobRunBackendId: backendIDs.workflowJobRunBackendId, name: name, size: BigInt(5)})
-    
-            if (!finalizeResp.ok) {
-                core.error("FinalizeArtifact failed")
-            }
-        } catch (e) {
-            console.log(e)
-        }
-    
-        console.log("FinalizeArtifact succeeded")
-    }
-
-    const uploadResponse: UploadResponse = {
-      artifactName: name,
-      size: uploadByteCount
-    }
-
-    return uploadResponse
-}

packages/artifact/src/internal/upload/upload-options.ts

@@ -1,18 +0,0 @@
-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
-  }

packages/artifact/src/internal/upload/upload-response.ts

@@ -1,11 +0,0 @@
-export interface UploadResponse {
-    /**
-     * The name of the artifact that was uploaded
-     */
-    artifactName: string
-  
-    /**
-     * Total size of the artifact that was uploaded in bytes
-     */
-    size: number
-  }

packages/artifact/src/internal/upload/upload-specification.ts

@@ -1,94 +0,0 @@
-import * as fs from 'fs'
-import {debug} from '@actions/core'
-import {join, normalize, resolve} from 'path'
-import {checkArtifactFilePath} from './path-and-artifact-name-validation'
-
-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[] {
-  // artifact name was checked earlier on, no need to check again
-  const specifications: UploadSpecification[] = []
-
-  if (!fs.existsSync(rootDirectory)) {
-    throw new Error(`Provided rootDirectory ${rootDirectory} does not exist`)
-  }
-  if (!fs.statSync(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.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 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
-}

packages/artifact/src/internal/util.ts

@@ -1,36 +0,0 @@
-import { getRuntimeToken } from './config';
-
-export interface BackendIds {
-    workflowRunBackendId: string;
-    workflowJobRunBackendId: string;
-}
-
-export function getBackendIds(): BackendIds {
-    const token = getRuntimeToken();
-    const parsedToken = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString())
-    if (!parsedToken["scp"]) {
-        throw new Error('Unable to get scp from token')
-    }
-
-    const scp = parsedToken["scp"]
-    const scpParts = scp.split(' ')
-    if (scpParts.length == 0) {
-        throw new Error('No scp parts found')
-    }
-
-    for (const part of scpParts) {
-        const partParts = part.split(':')
-        if(partParts.length == 0) {
-            continue
-        }
-
-        if (partParts[0] == "Actions.Results") {
-            if (partParts.length == 3) {
-                return {workflowRunBackendId: partParts[1], workflowJobRunBackendId: partParts[2]}
-            }
-            throw new Error('Unable to parse Actions.Results scp part')
-        }
-    }
-
-    throw new Error('Unable to find ids')
-} 

packages/artifact/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "baseUrl": "./",
-    "outDir": "./lib",
-    "rootDir": "./src",
-    "lib": [
-      "es2020"
-    ],
-    "module": "commonjs",
-    "target": "es2020"
-  },
-  "include": [
-    "./src"
-  ]
-}

packages/cache/LICENSE.md

@@ -1,9 +0,0 @@
-The MIT License (MIT)
-
-Copyright 2019 GitHub
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/cache/README.md

@@ -1,51 +0,0 @@
-# `@actions/cache`
-
-> 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.
-
-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.
-
-## 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).
-
-#### 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.
-
-```js
-const cache = require('@actions/cache');
-const paths = [
-    'node_modules',
-    'packages/*/node_modules/'
-]
-const key = 'npm-foobar-d5ea0750'
-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.
-
-```js
-const cache = require('@actions/cache');
-const paths = [
-    'node_modules',
-    'packages/*/node_modules/'
-]
-const key = 'npm-foobar-d5ea0750'
-const restoreKeys = [
-    'npm-foobar-',
-    'npm-'
-]
-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.
-
-

packages/cache/RELEASES.md

@@ -1,162 +0,0 @@
-# @actions/cache Releases
-
-### 0.1.0
-
-- 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`

packages/cache/__tests__/__fixtures__/action.yml

@@ -1,5 +0,0 @@
-name: 'Set env variables'
-description: 'Sets certain env variables so that e2e restore and save cache can be tested in a shell'
-runs:
-  using: 'node12'
-  main: 'index.js'

packages/cache/__tests__/__fixtures__/helloWorld.txt

@@ -1 +0,0 @@
-hello world

packages/cache/__tests__/__fixtures__/index.js

@@ -1,14 +0,0 @@
-// 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 restore and save cache 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_TOKEN=${process.env.ACTIONS_RUNTIME_TOKEN}${os.EOL}`, {
-    encoding: 'utf8'
-})
-fs.appendFileSync(filePath, `ACTIONS_CACHE_URL=${process.env.ACTIONS_CACHE_URL}${os.EOL}`, {
-    encoding: 'utf8'
-})
-fs.appendFileSync(filePath, `GITHUB_RUN_ID=${process.env.GITHUB_RUN_ID}${os.EOL}`, {
-    encoding: 'utf8'
-})

packages/cache/__tests__/cache.test.ts

@@ -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)
-})

packages/cache/__tests__/cacheHttpClient.test.ts

@@ -1,152 +0,0 @@
-import {downloadCache, getCacheVersion} from '../src/internal/cacheHttpClient'
-import {CompressionMethod} from '../src/internal/constants'
-import * as downloadUtils from '../src/internal/downloadUtils'
-import {DownloadOptions, getDownloadOptions} from '../src/options'
-
-jest.mock('../src/internal/downloadUtils')
-
-test('getCacheVersion with one path returns version', async () => {
-  const paths = ['node_modules']
-  const result = getCacheVersion(paths, undefined, true)
-  expect(result).toEqual(
-    'b3e0c6cb5ecf32614eeb2997d905b9c297046d7cbf69062698f25b14b4cb0985'
-  )
-})
-
-test('getCacheVersion with multiple paths returns version', async () => {
-  const paths = ['node_modules', 'dist']
-  const result = getCacheVersion(paths, undefined, true)
-  expect(result).toEqual(
-    '165c3053bc646bf0d4fac17b1f5731caca6fe38e0e464715c0c3c6b6318bf436'
-  )
-})
-
-test('getCacheVersion with zstd compression returns version', async () => {
-  const paths = ['node_modules']
-  const result = getCacheVersion(paths, CompressionMethod.Zstd, true)
-
-  expect(result).toEqual(
-    '273877e14fd65d270b87a198edbfa2db5a43de567c9a548d2a2505b408befe24'
-  )
-})
-
-test('getCacheVersion with gzip compression returns version', async () => {
-  const paths = ['node_modules']
-  const result = getCacheVersion(paths, CompressionMethod.Gzip, true)
-
-  expect(result).toEqual(
-    '470e252814dbffc9524891b17cf4e5749b26c1b5026e63dd3f00972db2393117'
-  )
-})
-
-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,
-    'downloadCacheHttpClient'
-  )
-  const downloadCacheStorageSDKMock = jest.spyOn(
-    downloadUtils,
-    'downloadCacheStorageSDK'
-  )
-
-  const archiveLocation = 'http://www.actionscache.test/download'
-  const archivePath = '/foo/bar'
-
-  await downloadCache(archiveLocation, archivePath)
-
-  expect(downloadCacheHttpClientMock).toHaveBeenCalledTimes(1)
-  expect(downloadCacheHttpClientMock).toHaveBeenCalledWith(
-    archiveLocation,
-    archivePath
-  )
-
-  expect(downloadCacheStorageSDKMock).toHaveBeenCalledTimes(0)
-})
-
-test('downloadCache uses storage SDK for Azure storage URLs', async () => {
-  const downloadCacheHttpClientMock = jest.spyOn(
-    downloadUtils,
-    'downloadCacheHttpClient'
-  )
-  const downloadCacheStorageSDKMock = jest.spyOn(
-    downloadUtils,
-    'downloadCacheStorageSDK'
-  )
-
-  const archiveLocation = 'http://foo.blob.core.windows.net/bar/baz'
-  const archivePath = '/foo/bar'
-
-  await downloadCache(archiveLocation, archivePath)
-
-  expect(downloadCacheStorageSDKMock).toHaveBeenCalledTimes(1)
-  expect(downloadCacheStorageSDKMock).toHaveBeenCalledWith(
-    archiveLocation,
-    archivePath,
-    getDownloadOptions()
-  )
-
-  expect(downloadCacheHttpClientMock).toHaveBeenCalledTimes(0)
-})
-
-test('downloadCache passes options to download methods', async () => {
-  const downloadCacheHttpClientMock = jest.spyOn(
-    downloadUtils,
-    'downloadCacheHttpClient'
-  )
-  const downloadCacheStorageSDKMock = jest.spyOn(
-    downloadUtils,
-    'downloadCacheStorageSDK'
-  )
-
-  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(downloadCacheStorageSDKMock).toHaveBeenCalledTimes(1)
-  expect(downloadCacheStorageSDKMock).toHaveBeenCalled()
-  expect(downloadCacheStorageSDKMock).toHaveBeenCalledWith(
-    archiveLocation,
-    archivePath,
-    getDownloadOptions(options)
-  )
-
-  expect(downloadCacheHttpClientMock).toHaveBeenCalledTimes(0)
-})
-
-test('downloadCache uses http-client when overridden', async () => {
-  const downloadCacheHttpClientMock = jest.spyOn(
-    downloadUtils,
-    'downloadCacheHttpClient'
-  )
-  const downloadCacheStorageSDKMock = jest.spyOn(
-    downloadUtils,
-    'downloadCacheStorageSDK'
-  )
-
-  const archiveLocation = 'http://foo.blob.core.windows.net/bar/baz'
-  const archivePath = '/foo/bar'
-  const options: DownloadOptions = {useAzureSdk: false}
-
-  await downloadCache(archiveLocation, archivePath, options)
-
-  expect(downloadCacheHttpClientMock).toHaveBeenCalledTimes(1)
-  expect(downloadCacheHttpClientMock).toHaveBeenCalledWith(
-    archiveLocation,
-    archivePath
-  )
-
-  expect(downloadCacheStorageSDKMock).toHaveBeenCalledTimes(0)
-})

packages/cache/__tests__/cacheUtils.test.ts

@@ -1,40 +0,0 @@
-import {promises as fs} from 'fs'
-import * as path from 'path'
-import * as cacheUtils from '../src/internal/cacheUtils'
-
-test('getArchiveFileSizeInBytes returns file size', () => {
-  const filePath = path.join(__dirname, '__fixtures__', 'helloWorld.txt')
-
-  const size = cacheUtils.getArchiveFileSizeInBytes(filePath)
-
-  expect(size).toBe(11)
-})
-
-test('unlinkFile unlinks file', async () => {
-  const testDirectory = await fs.mkdtemp('unlinkFileTest')
-  const testFile = path.join(testDirectory, 'test.txt')
-  await fs.writeFile(testFile, 'hello world')
-
-  await expect(fs.stat(testFile)).resolves.not.toThrow()
-
-  await cacheUtils.unlinkFile(testFile)
-
-  // This should throw as testFile should not exist
-  await expect(fs.stat(testFile)).rejects.toThrow()
-
-  await fs.rmdir(testDirectory)
-})
-
-test('assertDefined throws if undefined', () => {
-  expect(() => cacheUtils.assertDefined('test', undefined)).toThrowError()
-})
-
-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)
-})

packages/cache/__tests__/create-cache-files.sh

@@ -1,17 +0,0 @@
-#!/bin/sh
-
-# Validate args
-prefix="$1"
-if [ -z "$prefix" ]; then
-  echo "Must supply prefix argument"
-  exit 1
-fi
-
-path="$2"
-if [ -z "$path" ]; then
-  echo "Must supply path argument"
-  exit 1
-fi
-
-mkdir -p $path
-echo "$prefix $GITHUB_RUN_ID" > $path/test-file.txt

packages/cache/__tests__/downloadUtils.test.ts

@@ -1,160 +0,0 @@
-import * as core from '@actions/core'
-import {DownloadProgress} from '../src/internal/downloadUtils'
-
-test('download progress tracked correctly', () => {
-  const progress = new DownloadProgress(1000)
-
-  expect(progress.contentLength).toBe(1000)
-  expect(progress.receivedBytes).toBe(0)
-  expect(progress.segmentIndex).toBe(0)
-  expect(progress.segmentOffset).toBe(0)
-  expect(progress.segmentSize).toBe(0)
-  expect(progress.displayedComplete).toBe(false)
-  expect(progress.timeoutHandle).toBeUndefined()
-  expect(progress.getTransferredBytes()).toBe(0)
-  expect(progress.isDone()).toBe(false)
-
-  progress.nextSegment(500)
-
-  expect(progress.contentLength).toBe(1000)
-  expect(progress.receivedBytes).toBe(0)
-  expect(progress.segmentIndex).toBe(1)
-  expect(progress.segmentOffset).toBe(0)
-  expect(progress.segmentSize).toBe(500)
-  expect(progress.displayedComplete).toBe(false)
-  expect(progress.timeoutHandle).toBeUndefined()
-  expect(progress.getTransferredBytes()).toBe(0)
-  expect(progress.isDone()).toBe(false)
-
-  progress.setReceivedBytes(250)
-
-  expect(progress.contentLength).toBe(1000)
-  expect(progress.receivedBytes).toBe(250)
-  expect(progress.segmentIndex).toBe(1)
-  expect(progress.segmentOffset).toBe(0)
-  expect(progress.segmentSize).toBe(500)
-  expect(progress.displayedComplete).toBe(false)
-  expect(progress.timeoutHandle).toBeUndefined()
-  expect(progress.getTransferredBytes()).toBe(250)
-  expect(progress.isDone()).toBe(false)
-
-  progress.setReceivedBytes(500)
-
-  expect(progress.contentLength).toBe(1000)
-  expect(progress.receivedBytes).toBe(500)
-  expect(progress.segmentIndex).toBe(1)
-  expect(progress.segmentOffset).toBe(0)
-  expect(progress.segmentSize).toBe(500)
-  expect(progress.displayedComplete).toBe(false)
-  expect(progress.timeoutHandle).toBeUndefined()
-  expect(progress.getTransferredBytes()).toBe(500)
-  expect(progress.isDone()).toBe(false)
-
-  progress.nextSegment(500)
-
-  expect(progress.contentLength).toBe(1000)
-  expect(progress.receivedBytes).toBe(0)
-  expect(progress.segmentIndex).toBe(2)
-  expect(progress.segmentOffset).toBe(500)
-  expect(progress.segmentSize).toBe(500)
-  expect(progress.displayedComplete).toBe(false)
-  expect(progress.timeoutHandle).toBeUndefined()
-  expect(progress.getTransferredBytes()).toBe(500)
-  expect(progress.isDone()).toBe(false)
-
-  progress.setReceivedBytes(250)
-
-  expect(progress.contentLength).toBe(1000)
-  expect(progress.receivedBytes).toBe(250)
-  expect(progress.segmentIndex).toBe(2)
-  expect(progress.segmentOffset).toBe(500)
-  expect(progress.segmentSize).toBe(500)
-  expect(progress.displayedComplete).toBe(false)
-  expect(progress.timeoutHandle).toBeUndefined()
-  expect(progress.getTransferredBytes()).toBe(750)
-  expect(progress.isDone()).toBe(false)
-
-  progress.setReceivedBytes(500)
-
-  expect(progress.contentLength).toBe(1000)
-  expect(progress.receivedBytes).toBe(500)
-  expect(progress.segmentIndex).toBe(2)
-  expect(progress.segmentOffset).toBe(500)
-  expect(progress.segmentSize).toBe(500)
-  expect(progress.displayedComplete).toBe(false)
-  expect(progress.timeoutHandle).toBeUndefined()
-  expect(progress.getTransferredBytes()).toBe(1000)
-  expect(progress.isDone()).toBe(true)
-})
-
-test('display timer works correctly', done => {
-  const progress = new DownloadProgress(1000)
-
-  const infoMock = jest.spyOn(core, 'info')
-  infoMock.mockImplementation(() => {})
-
-  const check = (): void => {
-    expect(infoMock).toHaveBeenLastCalledWith(
-      expect.stringContaining('Received 500 of 1000')
-    )
-  }
-
-  // Validate no further updates are displayed after stopping the timer.
-  const test2 = (): void => {
-    check()
-    expect(progress.timeoutHandle).toBeUndefined()
-    done()
-  }
-
-  // Validate the progress is displayed, stop the timer, and call test2.
-  const test1 = (): void => {
-    check()
-
-    progress.stopDisplayTimer()
-    progress.setReceivedBytes(1000)
-
-    setTimeout(() => test2(), 500)
-  }
-
-  // Start the timer, update the received bytes, and call test1.
-  const start = (): void => {
-    progress.startDisplayTimer(10)
-    expect(progress.timeoutHandle).toBeDefined()
-
-    progress.setReceivedBytes(500)
-
-    setTimeout(() => test1(), 500)
-  }
-
-  start()
-})
-
-test('display does not print completed line twice', () => {
-  const progress = new DownloadProgress(1000)
-
-  const infoMock = jest.spyOn(core, 'info')
-  infoMock.mockImplementation(() => {})
-
-  progress.display()
-
-  expect(progress.displayedComplete).toBe(false)
-  expect(infoMock).toHaveBeenCalledTimes(1)
-
-  progress.nextSegment(1000)
-  progress.setReceivedBytes(500)
-  progress.display()
-
-  expect(progress.displayedComplete).toBe(false)
-  expect(infoMock).toHaveBeenCalledTimes(2)
-
-  progress.setReceivedBytes(1000)
-  progress.display()
-
-  expect(progress.displayedComplete).toBe(true)
-  expect(infoMock).toHaveBeenCalledTimes(3)
-
-  progress.display()
-
-  expect(progress.displayedComplete).toBe(true)
-  expect(infoMock).toHaveBeenCalledTimes(3)
-})

packages/cache/__tests__/options.test.ts

@@ -1,80 +0,0 @@
-import {
-  DownloadOptions,
-  UploadOptions,
-  getDownloadOptions,
-  getUploadOptions
-} from '../src/options'
-
-const useAzureSdk = true
-const downloadConcurrency = 8
-const timeoutInMs = 30000
-const segmentTimeoutInMs = 600000
-const lookupOnly = false
-const uploadConcurrency = 4
-const uploadChunkSize = 32 * 1024 * 1024
-
-test('getDownloadOptions sets defaults', async () => {
-  const actualOptions = getDownloadOptions()
-
-  expect(actualOptions).toEqual({
-    useAzureSdk,
-    downloadConcurrency,
-    timeoutInMs,
-    segmentTimeoutInMs,
-    lookupOnly
-  })
-})
-
-test('getDownloadOptions overrides all settings', async () => {
-  const expectedOptions: DownloadOptions = {
-    useAzureSdk: false,
-    downloadConcurrency: 14,
-    timeoutInMs: 20000,
-    segmentTimeoutInMs: 3600000,
-    lookupOnly: true
-  }
-
-  const actualOptions = getDownloadOptions(expectedOptions)
-
-  expect(actualOptions).toEqual(expectedOptions)
-})
-
-test('getUploadOptions sets defaults', async () => {
-  const actualOptions = getUploadOptions()
-
-  expect(actualOptions).toEqual({
-    uploadConcurrency,
-    uploadChunkSize
-  })
-})
-
-test('getUploadOptions overrides all settings', async () => {
-  const expectedOptions: UploadOptions = {
-    uploadConcurrency: 2,
-    uploadChunkSize: 16 * 1024 * 1024
-  }
-
-  const actualOptions = getUploadOptions(expectedOptions)
-
-  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)
-})

packages/cache/__tests__/requestUtils.test.ts

@@ -1,179 +0,0 @@
-import {retry, retryTypedResponse} from '../src/internal/requestUtils'
-import {HttpClientError} from '@actions/http-client'
-import * as requestUtils from '../src/internal/requestUtils'
-
-interface ITestResponse {
-  statusCode: number
-  result: string | null
-  error: Error | null
-}
-
-function TestResponse(
-  action: number | Error,
-  result: string | null = null
-): ITestResponse {
-  if (action instanceof Error) {
-    return {
-      statusCode: -1,
-      result,
-      error: action
-    }
-  } else {
-    return {
-      statusCode: action,
-      result,
-      error: null
-    }
-  }
-}
-
-async function handleResponse(
-  response: ITestResponse | undefined
-): Promise<ITestResponse> {
-  if (!response) {
-    fail('Retry method called too many times')
-  }
-
-  if (response.error) {
-    throw response.error
-  } else {
-    return Promise.resolve(response)
-  }
-}
-
-async function testRetryExpectingResult(
-  responses: ITestResponse[],
-  expectedResult: string | null
-): Promise<void> {
-  responses = responses.reverse() // Reverse responses since we pop from end
-
-  const actualResult = await retry(
-    'test',
-    async () => handleResponse(responses.pop()),
-    (response: ITestResponse) => response.statusCode,
-    2, // maxAttempts
-    0 // delay
-  )
-
-  expect(actualResult.result).toEqual(expectedResult)
-}
-
-async function testRetryConvertingErrorToResult(
-  responses: ITestResponse[],
-  expectedStatus: number,
-  expectedResult: string | null
-): Promise<void> {
-  responses = responses.reverse() // Reverse responses since we pop from end
-
-  const actualResult = await retry(
-    'test',
-    async () => handleResponse(responses.pop()),
-    (response: ITestResponse) => response.statusCode,
-    2, // maxAttempts
-    0, // delay
-    (e: Error) => {
-      if (e instanceof HttpClientError) {
-        return {
-          statusCode: e.statusCode,
-          result: null,
-          error: null
-        }
-      }
-    }
-  )
-
-  expect(actualResult.statusCode).toEqual(expectedStatus)
-  expect(actualResult.result).toEqual(expectedResult)
-}
-
-async function testRetryExpectingError(
-  responses: ITestResponse[]
-): Promise<void> {
-  responses = responses.reverse() // Reverse responses since we pop from end
-
-  expect(
-    retry(
-      'test',
-      async () => handleResponse(responses.pop()),
-      (response: ITestResponse) => response.statusCode,
-      2, // maxAttempts,
-      0 // delay
-    )
-  ).rejects.toBeInstanceOf(Error)
-}
-
-test('retry works on successful response', async () => {
-  await testRetryExpectingResult([TestResponse(200, 'Ok')], 'Ok')
-})
-
-test('retry works after retryable status code', async () => {
-  await testRetryExpectingResult(
-    [TestResponse(503), TestResponse(200, 'Ok')],
-    'Ok'
-  )
-})
-
-test('retry fails after exhausting retries', async () => {
-  await testRetryExpectingError([
-    TestResponse(503),
-    TestResponse(503),
-    TestResponse(200, 'Ok')
-  ])
-})
-
-test('retry fails after non-retryable status code', async () => {
-  await testRetryExpectingError([TestResponse(500), TestResponse(200, 'Ok')])
-})
-
-test('retry works after error', async () => {
-  await testRetryExpectingResult(
-    [TestResponse(new Error('Test error')), TestResponse(200, 'Ok')],
-    'Ok'
-  )
-})
-
-test('retry returns after client error', async () => {
-  await testRetryExpectingResult(
-    [TestResponse(400), TestResponse(200, 'Ok')],
-    null
-  )
-})
-
-test('retry converts errors to response object', async () => {
-  await testRetryConvertingErrorToResult(
-    [TestResponse(new HttpClientError('Test error', 409))],
-    409,
-    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'
-    )
-  }
-})

packages/cache/__tests__/restoreCache.test.ts

@@ -1,314 +0,0 @@
-import * as core from '@actions/core'
-import * as path from 'path'
-import {restoreCache} from '../src/cache'
-import * as cacheHttpClient from '../src/internal/cacheHttpClient'
-import * as cacheUtils from '../src/internal/cacheUtils'
-import {CacheFilename, CompressionMethod} from '../src/internal/constants'
-import {ArtifactCacheEntry} from '../src/internal/contracts'
-import * as tar from '../src/internal/tar'
-
-jest.mock('../src/internal/cacheHttpClient')
-jest.mock('../src/internal/cacheUtils')
-jest.mock('../src/internal/tar')
-
-beforeAll(() => {
-  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(() => {})
-
-  jest.spyOn(cacheUtils, 'getCacheFileName').mockImplementation(cm => {
-    const actualUtils = jest.requireActual('../src/internal/cacheUtils')
-    return actualUtils.getCacheFileName(cm)
-  })
-})
-
-test('restore with no path should fail', async () => {
-  const paths: string[] = []
-  const key = 'node-test'
-  await expect(restoreCache(paths, key)).rejects.toThrowError(
-    `Path Validation Error: At least one directory or file path is required`
-  )
-})
-
-test('restore with too many keys should fail', async () => {
-  const paths = ['node_modules']
-  const key = 'node-test'
-  const restoreKeys = [...Array(20).keys()].map(x => x.toString())
-  await expect(restoreCache(paths, key, restoreKeys)).rejects.toThrowError(
-    `Key Validation Error: Keys are limited to a maximum of 10.`
-  )
-})
-
-test('restore with large key should fail', async () => {
-  const paths = ['node_modules']
-  const key = 'foo'.repeat(512) // Over the 512 character limit
-  await expect(restoreCache(paths, key)).rejects.toThrowError(
-    `Key Validation Error: ${key} cannot be larger than 512 characters.`
-  )
-})
-
-test('restore with invalid key should fail', async () => {
-  const paths = ['node_modules']
-  const key = 'comma,comma'
-  await expect(restoreCache(paths, key)).rejects.toThrowError(
-    `Key Validation Error: ${key} cannot contain commas.`
-  )
-})
-
-test('restore with no cache found', async () => {
-  const paths = ['node_modules']
-  const key = 'node-test'
-
-  jest.spyOn(cacheHttpClient, 'getCacheEntry').mockImplementation(async () => {
-    return Promise.resolve(null)
-  })
-
-  const cacheKey = await restoreCache(paths, key)
-
-  expect(cacheKey).toBe(undefined)
-})
-
-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'
-  )
-})
-
-test('restore with restore keys and no cache found', async () => {
-  const paths = ['node_modules']
-  const key = 'node-test'
-  const restoreKey = 'node-'
-
-  jest.spyOn(cacheHttpClient, 'getCacheEntry').mockImplementation(async () => {
-    return Promise.resolve(null)
-  })
-
-  const cacheKey = await restoreCache(paths, key, [restoreKey])
-
-  expect(cacheKey).toBe(undefined)
-})
-
-test('restore with gzip compressed cache found', async () => {
-  const paths = ['node_modules']
-  const key = 'node-test'
-
-  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 tempPath = '/foo/bar'
-
-  const createTempDirectoryMock = jest.spyOn(cacheUtils, 'createTempDirectory')
-  createTempDirectoryMock.mockImplementation(async () => {
-    return Promise.resolve(tempPath)
-  })
-
-  const archivePath = path.join(tempPath, CacheFilename.Gzip)
-  const downloadCacheMock = jest.spyOn(cacheHttpClient, 'downloadCache')
-
-  const fileSize = 142
-  const getArchiveFileSizeInBytesMock = jest
-    .spyOn(cacheUtils, 'getArchiveFileSizeInBytes')
-    .mockReturnValue(fileSize)
-
-  const extractTarMock = jest.spyOn(tar, 'extractTar')
-  const unlinkFileMock = jest.spyOn(cacheUtils, 'unlinkFile')
-
-  const compression = CompressionMethod.Gzip
-  const getCompressionMock = jest
-    .spyOn(cacheUtils, 'getCompressionMethod')
-    .mockReturnValue(Promise.resolve(compression))
-
-  const cacheKey = await restoreCache(paths, key)
-
-  expect(cacheKey).toBe(key)
-  expect(getCacheMock).toHaveBeenCalledWith([key], paths, {
-    compressionMethod: compression,
-    enableCrossOsArchive: false
-  })
-  expect(createTempDirectoryMock).toHaveBeenCalledTimes(1)
-  expect(downloadCacheMock).toHaveBeenCalledWith(
-    cacheEntry.archiveLocation,
-    archivePath,
-    undefined
-  )
-  expect(getArchiveFileSizeInBytesMock).toHaveBeenCalledWith(archivePath)
-
-  expect(extractTarMock).toHaveBeenCalledTimes(1)
-  expect(extractTarMock).toHaveBeenCalledWith(archivePath, compression)
-
-  expect(unlinkFileMock).toHaveBeenCalledTimes(1)
-  expect(unlinkFileMock).toHaveBeenCalledWith(archivePath)
-
-  expect(getCompressionMock).toHaveBeenCalledTimes(1)
-})
-
-test('restore with zstd compressed cache found', async () => {
-  const paths = ['node_modules']
-  const key = 'node-test'
-
-  const infoMock = jest.spyOn(core, 'info')
-
-  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 tempPath = '/foo/bar'
-
-  const createTempDirectoryMock = jest.spyOn(cacheUtils, 'createTempDirectory')
-  createTempDirectoryMock.mockImplementation(async () => {
-    return Promise.resolve(tempPath)
-  })
-
-  const archivePath = path.join(tempPath, CacheFilename.Zstd)
-  const downloadCacheMock = jest.spyOn(cacheHttpClient, 'downloadCache')
-
-  const fileSize = 62915000
-  const getArchiveFileSizeInBytesMock = jest
-    .spyOn(cacheUtils, 'getArchiveFileSizeInBytes')
-    .mockReturnValue(fileSize)
-
-  const extractTarMock = jest.spyOn(tar, 'extractTar')
-  const compression = CompressionMethod.Zstd
-  const getCompressionMock = jest
-    .spyOn(cacheUtils, 'getCompressionMethod')
-    .mockReturnValue(Promise.resolve(compression))
-
-  const cacheKey = await restoreCache(paths, key)
-
-  expect(cacheKey).toBe(key)
-  expect(getCacheMock).toHaveBeenCalledWith([key], paths, {
-    compressionMethod: compression,
-    enableCrossOsArchive: false
-  })
-  expect(createTempDirectoryMock).toHaveBeenCalledTimes(1)
-  expect(downloadCacheMock).toHaveBeenCalledWith(
-    cacheEntry.archiveLocation,
-    archivePath,
-    undefined
-  )
-  expect(getArchiveFileSizeInBytesMock).toHaveBeenCalledWith(archivePath)
-  expect(infoMock).toHaveBeenCalledWith(`Cache Size: ~60 MB (62915000 B)`)
-
-  expect(extractTarMock).toHaveBeenCalledTimes(1)
-  expect(extractTarMock).toHaveBeenCalledWith(archivePath, compression)
-  expect(getCompressionMock).toHaveBeenCalledTimes(1)
-})
-
-test('restore with cache found for restore key', async () => {
-  const paths = ['node_modules']
-  const key = 'node-test'
-  const restoreKey = 'node-'
-
-  const infoMock = jest.spyOn(core, 'info')
-
-  const cacheEntry: ArtifactCacheEntry = {
-    cacheKey: restoreKey,
-    scope: 'refs/heads/main',
-    archiveLocation: 'www.actionscache.test/download'
-  }
-  const getCacheMock = jest.spyOn(cacheHttpClient, 'getCacheEntry')
-  getCacheMock.mockImplementation(async () => {
-    return Promise.resolve(cacheEntry)
-  })
-  const tempPath = '/foo/bar'
-
-  const createTempDirectoryMock = jest.spyOn(cacheUtils, 'createTempDirectory')
-  createTempDirectoryMock.mockImplementation(async () => {
-    return Promise.resolve(tempPath)
-  })
-
-  const archivePath = path.join(tempPath, CacheFilename.Zstd)
-  const downloadCacheMock = jest.spyOn(cacheHttpClient, 'downloadCache')
-
-  const fileSize = 142
-  const getArchiveFileSizeInBytesMock = jest
-    .spyOn(cacheUtils, 'getArchiveFileSizeInBytes')
-    .mockReturnValue(fileSize)
-
-  const extractTarMock = jest.spyOn(tar, 'extractTar')
-  const compression = CompressionMethod.Zstd
-  const getCompressionMock = jest
-    .spyOn(cacheUtils, 'getCompressionMethod')
-    .mockReturnValue(Promise.resolve(compression))
-
-  const cacheKey = await restoreCache(paths, key, [restoreKey])
-
-  expect(cacheKey).toBe(restoreKey)
-  expect(getCacheMock).toHaveBeenCalledWith([key, restoreKey], paths, {
-    compressionMethod: compression,
-    enableCrossOsArchive: false
-  })
-  expect(createTempDirectoryMock).toHaveBeenCalledTimes(1)
-  expect(downloadCacheMock).toHaveBeenCalledWith(
-    cacheEntry.archiveLocation,
-    archivePath,
-    undefined
-  )
-  expect(getArchiveFileSizeInBytesMock).toHaveBeenCalledWith(archivePath)
-  expect(infoMock).toHaveBeenCalledWith(`Cache Size: ~0 MB (142 B)`)
-
-  expect(extractTarMock).toHaveBeenCalledTimes(1)
-  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)
-})

packages/cache/__tests__/saveCache.test.ts

@@ -1,329 +0,0 @@
-import * as core from '@actions/core'
-import * as path from 'path'
-import {saveCache} from '../src/cache'
-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')
-jest.mock('../src/internal/tar')
-
-beforeAll(() => {
-  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(() => {})
-  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')
-  })
-})
-
-test('save with missing input should fail', async () => {
-  const paths: string[] = []
-  const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
-  await expect(saveCache(paths, primaryKey)).rejects.toThrowError(
-    `Path Validation Error: At least one directory or file path is required`
-  )
-})
-
-test('save with large cache outputs should fail', 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))
-
-  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.'
-  )
-
-  const archiveFolder = '/foo/bar'
-
-  expect(createTarMock).toHaveBeenCalledTimes(1)
-  expect(createTarMock).toHaveBeenCalledWith(
-    archiveFolder,
-    cachePaths,
-    compression
-  )
-  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
-    })
-
-  const createTarMock = jest.spyOn(tar, 'createTar')
-  const saveCacheMock = jest.spyOn(cacheHttpClient, 'saveCache')
-  const compression = CompressionMethod.Zstd
-  const getCompressionMock = jest
-    .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`
-  )
-
-  expect(reserveCacheMock).toHaveBeenCalledTimes(1)
-  expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, paths, {
-    cacheSize: undefined,
-    compressionMethod: compression,
-    enableCrossOsArchive: false
-  })
-  expect(createTarMock).toHaveBeenCalledTimes(1)
-  expect(saveCacheMock).toHaveBeenCalledTimes(0)
-  expect(getCompressionMock).toHaveBeenCalledTimes(1)
-})
-
-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
-    })
-
-  const createTarMock = jest.spyOn(tar, 'createTar')
-
-  const saveCacheMock = jest
-    .spyOn(cacheHttpClient, 'saveCache')
-    .mockImplementationOnce(() => {
-      throw new Error('HTTP Error Occurred')
-    })
-  const compression = CompressionMethod.Zstd
-  const getCompressionMock = jest
-    .spyOn(cacheUtils, 'getCompressionMethod')
-    .mockReturnValueOnce(Promise.resolve(compression))
-
-  await saveCache([filePath], primaryKey)
-  expect(logWarningMock).toHaveBeenCalledTimes(1)
-  expect(logWarningMock).toHaveBeenCalledWith(
-    'Failed to save: HTTP Error Occurred'
-  )
-
-  expect(reserveCacheMock).toHaveBeenCalledTimes(1)
-  expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, [filePath], {
-    cacheSize: undefined,
-    compressionMethod: compression,
-    enableCrossOsArchive: false
-  })
-  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 valid inputs uploads a cache', async () => {
-  const filePath = 'node_modules'
-  const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
-  const cachePaths = [path.resolve(filePath)]
-
-  const cacheId = 4
-  const reserveCacheMock = jest
-    .spyOn(cacheHttpClient, 'reserveCache')
-    .mockImplementation(async () => {
-      const response: TypedResponse<ReserveCacheResponse> = {
-        statusCode: 500,
-        result: {cacheId},
-        headers: {}
-      }
-      return response
-    })
-  const createTarMock = jest.spyOn(tar, 'createTar')
-
-  const saveCacheMock = jest.spyOn(cacheHttpClient, 'saveCache')
-  const compression = CompressionMethod.Zstd
-  const getCompressionMock = jest
-    .spyOn(cacheUtils, 'getCompressionMethod')
-    .mockReturnValue(Promise.resolve(compression))
-
-  await saveCache([filePath], primaryKey)
-
-  expect(reserveCacheMock).toHaveBeenCalledTimes(1)
-  expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, [filePath], {
-    cacheSize: undefined,
-    compressionMethod: compression,
-    enableCrossOsArchive: false
-  })
-  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.`
-  )
-})

packages/cache/__tests__/tar.test.ts

@@ -1,482 +0,0 @@
-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 * as tar from '../src/internal/tar'
-import * as utils from '../src/internal/cacheUtils'
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-import fs = require('fs')
-
-jest.mock('@actions/exec')
-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'}
-
-function getTempDir(): string {
-  return path.join(__dirname, '_temp', 'tar')
-}
-
-beforeAll(async () => {
-  jest.spyOn(io, 'which').mockImplementation(async tool => {
-    return tool
-  })
-
-  process.env['GITHUB_WORKSPACE'] = process.cwd()
-  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())
-})
-
-test('zstd extract tar', async () => {
-  const mkdirMock = jest.spyOn(io, 'mkdirP')
-  const execMock = jest.spyOn(exec, 'exec')
-
-  const archivePath = IS_WINDOWS
-    ? `${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(
-    [
-      `"${tarPath}"`,
-      '-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([
-        '--use-compress-program',
-        IS_WINDOWS ? '"zstd -d --long=30"' : 'unzstd --long=30'
-      ])
-      .join(' '),
-    undefined,
-    {
-      cwd: undefined,
-      env: expect.objectContaining(defaultEnv)
-    }
-  )
-})
-
-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')
-  const archivePath = IS_WINDOWS
-    ? `${process.env['windir']}\\fakepath\\cache.tar`
-    : 'cache.tar'
-  const workspace = process.env['GITHUB_WORKSPACE']
-
-  await tar.extractTar(archivePath, CompressionMethod.Gzip)
-
-  expect(mkdirMock).toHaveBeenCalledWith(workspace)
-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
-  expect(execMock).toHaveBeenCalledTimes(1)
-  expect(execMock).toHaveBeenCalledWith(
-    [
-      `"${tarPath}"`,
-      '-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)
-    }
-  )
-})
-
-test('gzip extract GNU tar on windows with GNUtar in path', async () => {
-  if (IS_WINDOWS) {
-    // GNU tar present in path but not at default location
-    jest
-      .spyOn(utils, 'getGnuTarPathOnWindows')
-      .mockReturnValue(Promise.resolve('tar'))
-    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(execMock).toHaveBeenCalledTimes(1)
-    expect(execMock).toHaveBeenCalledWith(
-      [
-        `"tar"`,
-        '-xf',
-        archivePath.replace(/\\/g, '/'),
-        '-P',
-        '-C',
-        workspace?.replace(/\\/g, '/'),
-        '--force-local',
-        '-z'
-      ].join(' '),
-      undefined,
-      {
-        cwd: undefined,
-        env: expect.objectContaining(defaultEnv)
-      }
-    )
-  }
-})
-
-test('zstd create tar', async () => {
-  const execMock = jest.spyOn(exec, 'exec')
-
-  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 = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
-
-  expect(execMock).toHaveBeenCalledTimes(1)
-  expect(execMock).toHaveBeenCalledWith(
-    [
-      `"${tarPath}"`,
-      '--posix',
-      '-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
-    ]
-      .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
-    {
-      cwd: archiveFolder,
-      env: expect.objectContaining(defaultEnv)
-    }
-  )
-})
-
-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')
-
-  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.Gzip)
-
-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
-
-  expect(execMock).toHaveBeenCalledTimes(1)
-  expect(execMock).toHaveBeenCalledWith(
-    [
-      `"${tarPath}"`,
-      '--posix',
-      '-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
-    {
-      cwd: archiveFolder,
-      env: expect.objectContaining(defaultEnv)
-    }
-  )
-})
-
-test('zstd list tar', async () => {
-  const execMock = jest.spyOn(exec, 'exec')
-
-  const archivePath = IS_WINDOWS
-    ? `${process.env['windir']}\\fakepath\\cache.tar`
-    : 'cache.tar'
-
-  await tar.listTar(archivePath, CompressionMethod.Zstd)
-
-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
-  expect(execMock).toHaveBeenCalledTimes(1)
-  expect(execMock).toHaveBeenCalledWith(
-    [
-      `"${tarPath}"`,
-      '-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)
-    }
-  )
-})
-
-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')
-
-  const archivePath = IS_WINDOWS
-    ? `${process.env['windir']}\\fakepath\\cache.tar`
-    : 'cache.tar'
-
-  await tar.listTar(archivePath, CompressionMethod.ZstdWithoutLong)
-
-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
-  expect(execMock).toHaveBeenCalledTimes(1)
-  expect(execMock).toHaveBeenCalledWith(
-    [
-      `"${tarPath}"`,
-      '-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)
-    }
-  )
-})
-
-test('gzip list tar', async () => {
-  const execMock = jest.spyOn(exec, 'exec')
-  const archivePath = IS_WINDOWS
-    ? `${process.env['windir']}\\fakepath\\cache.tar`
-    : 'cache.tar'
-
-  await tar.listTar(archivePath, CompressionMethod.Gzip)
-
-  const tarPath = IS_WINDOWS ? GnuTarPathOnWindows : defaultTarPath
-  expect(execMock).toHaveBeenCalledTimes(1)
-  expect(execMock).toHaveBeenCalledWith(
-    [
-      `"${tarPath}"`,
-      '-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)
-    }
-  )
-})

packages/cache/__tests__/verify-cache-files.sh

@@ -1,36 +0,0 @@
-#!/bin/sh
-
-# Validate args
-prefix="$1"
-if [ -z "$prefix" ]; then
-  echo "Must supply prefix argument"
-  exit 1
-fi
-
-path="$2"
-if [ -z "$path" ]; then
-  echo "Must specify path argument"
-  exit 1
-fi
-
-# Sanity check GITHUB_RUN_ID defined
-if [ -z "$GITHUB_RUN_ID" ]; then
-  echo "GITHUB_RUN_ID not defined"
-  exit 1
-fi
-
-# Verify file exists
-file="$path/test-file.txt"
-echo "Checking for $file"
-if [ ! -e $file ]; then
-  echo "File does not exist"
-  exit 1
-fi
-
-# Verify file content
-content="$(cat $file)"
-echo "File content:\n$content"
-if [ -z "$(echo $content | grep --fixed-strings "$prefix $GITHUB_RUN_ID")" ]; then
-  echo "Unexpected file content"
-  exit 1
-fi

packages/cache/package.json

@@ -1,56 +0,0 @@
-{
-  "name": "@actions/cache",
-  "version": "3.2.1",
-  "preview": true,
-  "description": "Actions cache lib",
-  "keywords": [
-    "github",
-    "actions",
-    "cache"
-  ],
-  "homepage": "https://github.com/actions/toolkit/tree/main/packages/cache",
-  "license": "MIT",
-  "main": "lib/cache.js",
-  "types": "lib/cache.d.ts",
-  "directories": {
-    "lib": "lib",
-    "test": "__tests__"
-  },
-  "files": [
-    "lib",
-    "!.DS_Store"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/actions/toolkit.git",
-    "directory": "packages/cache"
-  },
-  "scripts": {
-    "audit-moderate": "npm install && npm audit --json --audit-level=moderate > audit.json",
-    "test": "echo \"Error: run tests from root\" && exit 1",
-    "tsc": "tsc"
-  },
-  "bugs": {
-    "url": "https://github.com/actions/toolkit/issues"
-  },
-  "dependencies": {
-    "@actions/core": "^1.10.0",
-    "@actions/exec": "^1.0.1",
-    "@actions/glob": "^0.1.0",
-    "@actions/http-client": "^2.0.1",
-    "@actions/io": "^1.0.1",
-    "@azure/abort-controller": "^1.1.0",
-    "@azure/ms-rest-js": "^2.6.0",
-    "@azure/storage-blob": "^12.13.0",
-    "semver": "^6.1.0",
-    "uuid": "^3.3.3"
-  },
-  "devDependencies": {
-    "@types/semver": "^6.0.0",
-    "@types/uuid": "^3.4.5",
-    "typescript": "^4.8.0"
-  }
-}

packages/cache/src/cache.ts

@@ -1,260 +0,0 @@
-import * as core from '@actions/core'
-import * as path from 'path'
-import * as utils from './internal/cacheUtils'
-import * as cacheHttpClient from './internal/cacheHttpClient'
-import {createTar, extractTar, listTar} from './internal/tar'
-import {DownloadOptions, UploadOptions} from './options'
-
-export class ValidationError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'ValidationError'
-    Object.setPrototypeOf(this, ValidationError.prototype)
-  }
-}
-
-export class ReserveCacheError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'ReserveCacheError'
-    Object.setPrototypeOf(this, ReserveCacheError.prototype)
-  }
-}
-
-function checkPaths(paths: string[]): void {
-  if (!paths || paths.length === 0) {
-    throw new ValidationError(
-      `Path Validation Error: At least one directory or file path is required`
-    )
-  }
-}
-
-function checkKey(key: string): void {
-  if (key.length > 512) {
-    throw new ValidationError(
-      `Key Validation Error: ${key} cannot be larger than 512 characters.`
-    )
-  }
-  const regex = /^[^,]*$/
-  if (!regex.test(key)) {
-    throw new ValidationError(
-      `Key Validation Error: ${key} cannot contain commas.`
-    )
-  }
-}
-
-/**
- * isFeatureAvailable to check the presence of Actions cache service
- *
- * @returns boolean return true if Actions cache service feature is available, otherwise false
- */
-
-export function isFeatureAvailable(): boolean {
-  return !!process.env['ACTIONS_CACHE_URL']
-}
-
-/**
- * Restores cache from keys
- *
- * @param paths a list of file paths to restore from the cache
- * @param primaryKey an explicit key for restoring the cache
- * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for key
- * @param downloadOptions cache download options
- * @param enableCrossOsArchive an optional boolean enabled to restore on windows any cache created on any platform
- * @returns string returns the key for the cache hit, otherwise returns undefined
- */
-export async function restoreCache(
-  paths: string[],
-  primaryKey: string,
-  restoreKeys?: string[],
-  options?: DownloadOptions,
-  enableCrossOsArchive = false
-): Promise<string | undefined> {
-  checkPaths(paths)
-
-  restoreKeys = restoreKeys || []
-  const keys = [primaryKey, ...restoreKeys]
-
-  core.debug('Resolved Keys:')
-  core.debug(JSON.stringify(keys))
-
-  if (keys.length > 10) {
-    throw new ValidationError(
-      `Key Validation Error: Keys are limited to a maximum of 10.`
-    )
-  }
-  for (const key of keys) {
-    checkKey(key)
-  }
-
-  const compressionMethod = await utils.getCompressionMethod()
-  let archivePath = ''
-  try {
-    // path are needed to compute version
-    const cacheEntry = await cacheHttpClient.getCacheEntry(keys, paths, {
-      compressionMethod,
-      enableCrossOsArchive
-    })
-    if (!cacheEntry?.archiveLocation) {
-      // Cache not found
-      return undefined
-    }
-
-    if (options?.lookupOnly) {
-      core.info('Lookup only - skipping download')
-      return cacheEntry.cacheKey
-    }
-
-    archivePath = path.join(
-      await utils.createTempDirectory(),
-      utils.getCacheFileName(compressionMethod)
-    )
-    core.debug(`Archive Path: ${archivePath}`)
-
-    // Download the cache from the cache entry
-    await cacheHttpClient.downloadCache(
-      cacheEntry.archiveLocation,
-      archivePath,
-      options
-    )
-
-    if (core.isDebug()) {
-      await listTar(archivePath, compressionMethod)
-    }
-
-    const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath)
-    core.info(
-      `Cache Size: ~${Math.round(
-        archiveFileSize / (1024 * 1024)
-      )} MB (${archiveFileSize} B)`
-    )
-
-    await extractTar(archivePath, compressionMethod)
-    core.info('Cache restored successfully')
-
-    return cacheEntry.cacheKey
-  } catch (error) {
-    const typedError = error as Error
-    if (typedError.name === ValidationError.name) {
-      throw error
-    } else {
-      // Supress all non-validation cache related errors because caching should be optional
-      core.warning(`Failed to restore: ${(error as Error).message}`)
-    }
-  } finally {
-    // Try to delete the archive to save space
-    try {
-      await utils.unlinkFile(archivePath)
-    } catch (error) {
-      core.debug(`Failed to delete archive: ${error}`)
-    }
-  }
-
-  return undefined
-}
-
-/**
- * Saves a list of files with the specified key
- *
- * @param paths a list of file paths to be cached
- * @param key an explicit key for restoring the cache
- * @param enableCrossOsArchive an optional boolean enabled to save cache on windows which could be restored on any platform
- * @param options cache upload options
- * @returns number returns cacheId if the cache was saved successfully and throws an error if save fails
- */
-export async function saveCache(
-  paths: string[],
-  key: string,
-  options?: UploadOptions,
-  enableCrossOsArchive = false
-): Promise<number> {
-  checkPaths(paths)
-  checkKey(key)
-
-  const compressionMethod = await utils.getCompressionMethod()
-  let cacheId = -1
-
-  const cachePaths = await utils.resolvePaths(paths)
-  core.debug('Cache Paths:')
-  core.debug(`${JSON.stringify(cachePaths)}`)
-
-  if (cachePaths.length === 0) {
-    throw new Error(
-      `Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`
-    )
-  }
-
-  const archiveFolder = await utils.createTempDirectory()
-  const archivePath = path.join(
-    archiveFolder,
-    utils.getCacheFileName(compressionMethod)
-  )
-
-  core.debug(`Archive Path: ${archivePath}`)
-
-  try {
-    await createTar(archiveFolder, cachePaths, compressionMethod)
-    if (core.isDebug()) {
-      await listTar(archivePath, compressionMethod)
-    }
-    const fileSizeLimit = 10 * 1024 * 1024 * 1024 // 10GB per repo limit
-    const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath)
-    core.debug(`File Size: ${archiveFileSize}`)
-
-    // For GHES, this check will take place in ReserveCache API with enterprise file size limit
-    if (archiveFileSize > fileSizeLimit && !utils.isGhes()) {
-      throw new Error(
-        `Cache size of ~${Math.round(
-          archiveFileSize / (1024 * 1024)
-        )} MB (${archiveFileSize} B) is over the 10GB limit, not saving cache.`
-      )
-    }
-
-    core.debug('Reserving Cache')
-    const reserveCacheResponse = await cacheHttpClient.reserveCache(
-      key,
-      paths,
-      {
-        compressionMethod,
-        enableCrossOsArchive,
-        cacheSize: archiveFileSize
-      }
-    )
-
-    if (reserveCacheResponse?.result?.cacheId) {
-      cacheId = reserveCacheResponse?.result?.cacheId
-    } else if (reserveCacheResponse?.statusCode === 400) {
-      throw new Error(
-        reserveCacheResponse?.error?.message ??
-          `Cache size of ~${Math.round(
-            archiveFileSize / (1024 * 1024)
-          )} MB (${archiveFileSize} B) is over the data cap limit, not saving cache.`
-      )
-    } else {
-      throw new ReserveCacheError(
-        `Unable to reserve cache with key ${key}, another job may be creating this cache. More details: ${reserveCacheResponse?.error?.message}`
-      )
-    }
-
-    core.debug(`Saving Cache (ID: ${cacheId})`)
-    await cacheHttpClient.saveCache(cacheId, archivePath, options)
-  } catch (error) {
-    const typedError = error as Error
-    if (typedError.name === ValidationError.name) {
-      throw error
-    } else if (typedError.name === ReserveCacheError.name) {
-      core.info(`Failed to save: ${typedError.message}`)
-    } else {
-      core.warning(`Failed to save: ${typedError.message}`)
-    }
-  } finally {
-    // Try to delete the archive to save space
-    try {
-      await utils.unlinkFile(archivePath)
-    } catch (error) {
-      core.debug(`Failed to delete archive: ${error}`)
-    }
-  }
-
-  return cacheId
-}

packages/cache/src/internal/cacheHttpClient.ts

@@ -1,364 +0,0 @@
-import * as core from '@actions/core'
-import {HttpClient} from '@actions/http-client'
-import {BearerCredentialHandler} from '@actions/http-client/lib/auth'
-import {
-  RequestOptions,
-  TypedResponse
-} from '@actions/http-client/lib/interfaces'
-import * as crypto from 'crypto'
-import * as fs from 'fs'
-import {URL} from 'url'
-
-import * as utils from './cacheUtils'
-import {CompressionMethod} from './constants'
-import {
-  ArtifactCacheEntry,
-  InternalCacheOptions,
-  CommitCacheRequest,
-  ReserveCacheRequest,
-  ReserveCacheResponse,
-  ITypedResponseWithError,
-  ArtifactCacheList
-} from './contracts'
-import {downloadCacheHttpClient, downloadCacheStorageSDK} from './downloadUtils'
-import {
-  DownloadOptions,
-  UploadOptions,
-  getDownloadOptions,
-  getUploadOptions
-} from '../options'
-import {
-  isSuccessStatusCode,
-  retryHttpClientResponse,
-  retryTypedResponse
-} from './requestUtils'
-
-const versionSalt = '1.0'
-
-function getCacheApiUrl(resource: string): string {
-  const baseUrl: string = process.env['ACTIONS_CACHE_URL'] || ''
-  if (!baseUrl) {
-    throw new Error('Cache Service Url not found, unable to restore cache.')
-  }
-
-  const url = `${baseUrl}_apis/artifactcache/${resource}`
-  core.debug(`Resource Url: ${url}`)
-  return url
-}
-
-function createAcceptHeader(type: string, apiVersion: string): string {
-  return `${type};api-version=${apiVersion}`
-}
-
-function getRequestOptions(): RequestOptions {
-  const requestOptions: RequestOptions = {
-    headers: {
-      Accept: createAcceptHeader('application/json', '6.0-preview.1')
-    }
-  }
-
-  return requestOptions
-}
-
-function createHttpClient(): HttpClient {
-  const token = process.env['ACTIONS_RUNTIME_TOKEN'] || ''
-  const bearerCredentialHandler = new BearerCredentialHandler(token)
-
-  return new HttpClient(
-    'actions/cache',
-    [bearerCredentialHandler],
-    getRequestOptions()
-  )
-}
-
-export function getCacheVersion(
-  paths: string[],
-  compressionMethod?: CompressionMethod,
-  enableCrossOsArchive = false
-): string {
-  const components = paths
-
-  // Add compression method to cache version to restore
-  // compressed cache as per compression method
-  if (compressionMethod) {
-    components.push(compressionMethod)
-  }
-
-  // Only check for windows platforms if enableCrossOsArchive is false
-  if (process.platform === 'win32' && !enableCrossOsArchive) {
-    components.push('windows-only')
-  }
-
-  // Add salt to cache version to support breaking changes in cache entry
-  components.push(versionSalt)
-
-  return crypto
-    .createHash('sha256')
-    .update(components.join('|'))
-    .digest('hex')
-}
-
-export async function getCacheEntry(
-  keys: string[],
-  paths: string[],
-  options?: InternalCacheOptions
-): Promise<ArtifactCacheEntry | null> {
-  const httpClient = createHttpClient()
-  const version = getCacheVersion(
-    paths,
-    options?.compressionMethod,
-    options?.enableCrossOsArchive
-  )
-  const resource = `cache?keys=${encodeURIComponent(
-    keys.join(',')
-  )}&version=${version}`
-
-  const response = await retryTypedResponse('getCacheEntry', async () =>
-    httpClient.getJson<ArtifactCacheEntry>(getCacheApiUrl(resource))
-  )
-  // Cache not found
-  if (response.statusCode === 204) {
-    // List cache for primary key only if cache miss occurs
-    if (core.isDebug()) {
-      await printCachesListForDiagnostics(keys[0], httpClient, version)
-    }
-    return null
-  }
-  if (!isSuccessStatusCode(response.statusCode)) {
-    throw new Error(`Cache service responded with ${response.statusCode}`)
-  }
-
-  const cacheResult = response.result
-  const cacheDownloadUrl = cacheResult?.archiveLocation
-  if (!cacheDownloadUrl) {
-    // Cache achiveLocation not found. This should never happen, and hence bail out.
-    throw new Error('Cache not found.')
-  }
-  core.setSecret(cacheDownloadUrl)
-  core.debug(`Cache Result:`)
-  core.debug(JSON.stringify(cacheResult))
-
-  return cacheResult
-}
-
-async function printCachesListForDiagnostics(
-  key: string,
-  httpClient: HttpClient,
-  version: string
-): Promise<void> {
-  const resource = `caches?key=${encodeURIComponent(key)}`
-  const response = await retryTypedResponse('listCache', async () =>
-    httpClient.getJson<ArtifactCacheList>(getCacheApiUrl(resource))
-  )
-  if (response.statusCode === 200) {
-    const cacheListResult = response.result
-    const totalCount = cacheListResult?.totalCount
-    if (totalCount && totalCount > 0) {
-      core.debug(
-        `No matching cache found for cache key '${key}', version '${version} and scope ${process.env['GITHUB_REF']}. There exist one or more cache(s) with similar key but they have different version or scope. See more info on cache matching here: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#matching-a-cache-key \nOther caches with similar key:`
-      )
-      for (const cacheEntry of cacheListResult?.artifactCaches || []) {
-        core.debug(
-          `Cache Key: ${cacheEntry?.cacheKey}, Cache Version: ${cacheEntry?.cacheVersion}, Cache Scope: ${cacheEntry?.scope}, Cache Created: ${cacheEntry?.creationTime}`
-        )
-      }
-    }
-  }
-}
-
-export async function downloadCache(
-  archiveLocation: string,
-  archivePath: string,
-  options?: DownloadOptions
-): Promise<void> {
-  const archiveUrl = new URL(archiveLocation)
-  const downloadOptions = getDownloadOptions(options)
-
-  if (
-    downloadOptions.useAzureSdk &&
-    archiveUrl.hostname.endsWith('.blob.core.windows.net')
-  ) {
-    // Use Azure storage SDK to download caches hosted on Azure to improve speed and reliability.
-    await downloadCacheStorageSDK(archiveLocation, archivePath, downloadOptions)
-  } else {
-    // Otherwise, download using the Actions http-client.
-    await downloadCacheHttpClient(archiveLocation, archivePath)
-  }
-}
-
-// Reserve Cache
-export async function reserveCache(
-  key: string,
-  paths: string[],
-  options?: InternalCacheOptions
-): Promise<ITypedResponseWithError<ReserveCacheResponse>> {
-  const httpClient = createHttpClient()
-  const version = getCacheVersion(
-    paths,
-    options?.compressionMethod,
-    options?.enableCrossOsArchive
-  )
-
-  const reserveCacheRequest: ReserveCacheRequest = {
-    key,
-    version,
-    cacheSize: options?.cacheSize
-  }
-  const response = await retryTypedResponse('reserveCache', async () =>
-    httpClient.postJson<ReserveCacheResponse>(
-      getCacheApiUrl('caches'),
-      reserveCacheRequest
-    )
-  )
-  return response
-}
-
-function getContentRange(start: number, end: number): string {
-  // Format: `bytes start-end/filesize
-  // start and end are inclusive
-  // filesize can be *
-  // For a 200 byte chunk starting at byte 0:
-  // Content-Range: bytes 0-199/*
-  return `bytes ${start}-${end}/*`
-}
-
-async function uploadChunk(
-  httpClient: HttpClient,
-  resourceUrl: string,
-  openStream: () => NodeJS.ReadableStream,
-  start: number,
-  end: number
-): Promise<void> {
-  core.debug(
-    `Uploading chunk of size ${end -
-      start +
-      1} bytes at offset ${start} with content range: ${getContentRange(
-      start,
-      end
-    )}`
-  )
-  const additionalHeaders = {
-    'Content-Type': 'application/octet-stream',
-    'Content-Range': getContentRange(start, end)
-  }
-
-  const uploadChunkResponse = await retryHttpClientResponse(
-    `uploadChunk (start: ${start}, end: ${end})`,
-    async () =>
-      httpClient.sendStream(
-        'PATCH',
-        resourceUrl,
-        openStream(),
-        additionalHeaders
-      )
-  )
-
-  if (!isSuccessStatusCode(uploadChunkResponse.message.statusCode)) {
-    throw new Error(
-      `Cache service responded with ${uploadChunkResponse.message.statusCode} during upload chunk.`
-    )
-  }
-}
-
-async function uploadFile(
-  httpClient: HttpClient,
-  cacheId: number,
-  archivePath: string,
-  options?: UploadOptions
-): Promise<void> {
-  // Upload Chunks
-  const fileSize = utils.getArchiveFileSizeInBytes(archivePath)
-  const resourceUrl = getCacheApiUrl(`caches/${cacheId.toString()}`)
-  const fd = fs.openSync(archivePath, 'r')
-  const uploadOptions = getUploadOptions(options)
-
-  const concurrency = utils.assertDefined(
-    'uploadConcurrency',
-    uploadOptions.uploadConcurrency
-  )
-  const maxChunkSize = utils.assertDefined(
-    'uploadChunkSize',
-    uploadOptions.uploadChunkSize
-  )
-
-  const parallelUploads = [...new Array(concurrency).keys()]
-  core.debug('Awaiting all uploads')
-  let offset = 0
-
-  try {
-    await Promise.all(
-      parallelUploads.map(async () => {
-        while (offset < fileSize) {
-          const chunkSize = Math.min(fileSize - offset, maxChunkSize)
-          const start = offset
-          const end = offset + chunkSize - 1
-          offset += maxChunkSize
-
-          await uploadChunk(
-            httpClient,
-            resourceUrl,
-            () =>
-              fs
-                .createReadStream(archivePath, {
-                  fd,
-                  start,
-                  end,
-                  autoClose: false
-                })
-                .on('error', error => {
-                  throw new Error(
-                    `Cache upload failed because file read failed with ${error.message}`
-                  )
-                }),
-            start,
-            end
-          )
-        }
-      })
-    )
-  } finally {
-    fs.closeSync(fd)
-  }
-  return
-}
-
-async function commitCache(
-  httpClient: HttpClient,
-  cacheId: number,
-  filesize: number
-): Promise<TypedResponse<null>> {
-  const commitCacheRequest: CommitCacheRequest = {size: filesize}
-  return await retryTypedResponse('commitCache', async () =>
-    httpClient.postJson<null>(
-      getCacheApiUrl(`caches/${cacheId.toString()}`),
-      commitCacheRequest
-    )
-  )
-}
-
-export async function saveCache(
-  cacheId: number,
-  archivePath: string,
-  options?: UploadOptions
-): Promise<void> {
-  const httpClient = createHttpClient()
-
-  core.debug('Upload cache')
-  await uploadFile(httpClient, cacheId, archivePath, options)
-
-  // Commit Cache
-  core.debug('Commiting cache')
-  const cacheSize = utils.getArchiveFileSizeInBytes(archivePath)
-  core.info(
-    `Cache Size: ~${Math.round(cacheSize / (1024 * 1024))} MB (${cacheSize} B)`
-  )
-
-  const commitCacheResponse = await commitCache(httpClient, cacheId, cacheSize)
-  if (!isSuccessStatusCode(commitCacheResponse.statusCode)) {
-    throw new Error(
-      `Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`
-    )
-  }
-
-  core.info('Cache saved successfully')
-}

packages/cache/src/internal/cacheUtils.ts

@@ -1,139 +0,0 @@
-import * as core from '@actions/core'
-import * as exec from '@actions/exec'
-import * as glob from '@actions/glob'
-import * as io from '@actions/io'
-import * as fs from 'fs'
-import * as path from 'path'
-import * as semver from 'semver'
-import * as util from 'util'
-import {v4 as uuidV4} from 'uuid'
-import {
-  CacheFilename,
-  CompressionMethod,
-  GnuTarPathOnWindows
-} from './constants'
-
-// From https://github.com/actions/toolkit/blob/main/packages/tool-cache/src/tool-cache.ts#L23
-export async function createTempDirectory(): Promise<string> {
-  const IS_WINDOWS = process.platform === 'win32'
-
-  let tempDirectory: string = process.env['RUNNER_TEMP'] || ''
-
-  if (!tempDirectory) {
-    let baseLocation: string
-    if (IS_WINDOWS) {
-      // On Windows use the USERPROFILE env variable
-      baseLocation = process.env['USERPROFILE'] || 'C:\\'
-    } else {
-      if (process.platform === 'darwin') {
-        baseLocation = '/Users'
-      } else {
-        baseLocation = '/home'
-      }
-    }
-    tempDirectory = path.join(baseLocation, 'actions', 'temp')
-  }
-
-  const dest = path.join(tempDirectory, uuidV4())
-  await io.mkdirP(dest)
-  return dest
-}
-
-export function getArchiveFileSizeInBytes(filePath: string): number {
-  return fs.statSync(filePath).size
-}
-
-export async function resolvePaths(patterns: string[]): Promise<string[]> {
-  const paths: string[] = []
-  const workspace = process.env['GITHUB_WORKSPACE'] ?? process.cwd()
-  const globber = await glob.create(patterns.join('\n'), {
-    implicitDescendants: false
-  })
-
-  for await (const file of globber.globGenerator()) {
-    const relativeFile = path
-      .relative(workspace, file)
-      .replace(new RegExp(`\\${path.sep}`, 'g'), '/')
-    core.debug(`Matched: ${relativeFile}`)
-    // Paths are made relative so the tar entries are all relative to the root of the workspace.
-    if (relativeFile === '') {
-      // path.relative returns empty string if workspace and file are equal
-      paths.push('.')
-    } else {
-      paths.push(`${relativeFile}`)
-    }
-  }
-
-  return paths
-}
-
-export async function unlinkFile(filePath: fs.PathLike): Promise<void> {
-  return util.promisify(fs.unlink)(filePath)
-}
-
-async function getVersion(
-  app: string,
-  additionalArgs: string[] = []
-): Promise<string> {
-  let versionOutput = ''
-  additionalArgs.push('--version')
-  core.debug(`Checking ${app} ${additionalArgs.join(' ')}`)
-  try {
-    await exec.exec(`${app}`, additionalArgs, {
-      ignoreReturnCode: true,
-      silent: true,
-      listeners: {
-        stdout: (data: Buffer): string => (versionOutput += data.toString()),
-        stderr: (data: Buffer): string => (versionOutput += data.toString())
-      }
-    })
-  } catch (err) {
-    core.debug(err.message)
-  }
-
-  versionOutput = versionOutput.trim()
-  core.debug(versionOutput)
-  return versionOutput
-}
-
-// Use zstandard if possible to maximize cache performance
-export async function getCompressionMethod(): Promise<CompressionMethod> {
-  const versionOutput = await getVersion('zstd', ['--quiet'])
-  const version = semver.clean(versionOutput)
-  core.debug(`zstd version: ${version}`)
-
-  if (versionOutput === '') {
-    return CompressionMethod.Gzip
-  } else {
-    return CompressionMethod.ZstdWithoutLong
-  }
-}
-
-export function getCacheFileName(compressionMethod: CompressionMethod): string {
-  return compressionMethod === CompressionMethod.Gzip
-    ? CacheFilename.Gzip
-    : CacheFilename.Zstd
-}
-
-export async function getGnuTarPathOnWindows(): Promise<string> {
-  if (fs.existsSync(GnuTarPathOnWindows)) {
-    return GnuTarPathOnWindows
-  }
-  const versionOutput = await getVersion('tar')
-  return versionOutput.toLowerCase().includes('gnu tar') ? io.which('tar') : ''
-}
-
-export function assertDefined<T>(name: string, value?: T): T {
-  if (value === undefined) {
-    throw Error(`Expected ${name} but value was undefiend`)
-  }
-
-  return value
-}
-
-export function isGhes(): boolean {
-  const ghUrl = new URL(
-    process.env['GITHUB_SERVER_URL'] || 'https://github.com'
-  )
-  return ghUrl.hostname.toUpperCase() !== 'GITHUB.COM'
-}

packages/cache/src/internal/constants.ts

@@ -1,38 +0,0 @@
-export enum CacheFilename {
-  Gzip = 'cache.tgz',
-  Zstd = 'cache.tzst'
-}
-
-export enum CompressionMethod {
-  Gzip = 'gzip',
-  // Long range mode was added to zstd in v1.3.2.
-  // This enum is for earlier version of zstd that does not have --long support
-  ZstdWithoutLong = 'zstd-without-long',
-  Zstd = 'zstd'
-}
-
-export enum ArchiveToolType {
-  GNU = 'gnu',
-  BSD = 'bsd'
-}
-
-// The default number of retry attempts.
-export const DefaultRetryAttempts = 2
-
-// The default delay in milliseconds between retry attempts.
-export const DefaultRetryDelay = 5000
-
-// Socket timeout in milliseconds during download.  If no traffic is received
-// over the socket during this period, the socket is destroyed and the download
-// is aborted.
-export const SocketTimeout = 5000
-
-// The default path of GNUtar on hosted Windows runners
-export const GnuTarPathOnWindows = `${process.env['PROGRAMFILES']}\\Git\\usr\\bin\\tar.exe`
-
-// The default path of BSDtar on hosted Windows runners
-export const SystemTarPathOnWindows = `${process.env['SYSTEMDRIVE']}\\Windows\\System32\\tar.exe`
-
-export const TarFilename = 'cache.tar'
-
-export const ManifestFilename = 'manifest.txt'

packages/cache/src/internal/contracts.d.ts

@@ -1,45 +0,0 @@
-import {CompressionMethod} from './constants'
-import {TypedResponse} from '@actions/http-client/lib/interfaces'
-import {HttpClientError} from '@actions/http-client'
-
-export interface ITypedResponseWithError<T> extends TypedResponse<T> {
-  error?: HttpClientError
-}
-
-export interface ArtifactCacheEntry {
-  cacheKey?: string
-  scope?: string
-  cacheVersion?: string
-  creationTime?: string
-  archiveLocation?: string
-}
-
-export interface ArtifactCacheList {
-  totalCount: number
-  artifactCaches?: ArtifactCacheEntry[]
-}
-
-export interface CommitCacheRequest {
-  size: number
-}
-
-export interface ReserveCacheRequest {
-  key: string
-  version?: string
-  cacheSize?: number
-}
-
-export interface ReserveCacheResponse {
-  cacheId: number
-}
-
-export interface InternalCacheOptions {
-  compressionMethod?: CompressionMethod
-  enableCrossOsArchive?: boolean
-  cacheSize?: number
-}
-
-export interface ArchiveTool {
-  path: string
-  type: string
-}

packages/cache/src/internal/downloadUtils.ts

@@ -1,303 +0,0 @@
-import * as core from '@actions/core'
-import {HttpClient, HttpClientResponse} from '@actions/http-client'
-import {BlockBlobClient} from '@azure/storage-blob'
-import {TransferProgressEvent} from '@azure/ms-rest-js'
-import * as buffer from 'buffer'
-import * as fs from 'fs'
-import * as stream from 'stream'
-import * as util from 'util'
-
-import * as utils from './cacheUtils'
-import {SocketTimeout} from './constants'
-import {DownloadOptions} from '../options'
-import {retryHttpClientResponse} from './requestUtils'
-
-import {AbortController} from '@azure/abort-controller'
-
-/**
- * Pipes the body of a HTTP response to a stream
- *
- * @param response the HTTP response
- * @param output the writable stream
- */
-async function pipeResponseToStream(
-  response: HttpClientResponse,
-  output: NodeJS.WritableStream
-): Promise<void> {
-  const pipeline = util.promisify(stream.pipeline)
-  await pipeline(response.message, output)
-}
-
-/**
- * Class for tracking the download state and displaying stats.
- */
-export class DownloadProgress {
-  contentLength: number
-  segmentIndex: number
-  segmentSize: number
-  segmentOffset: number
-  receivedBytes: number
-  startTime: number
-  displayedComplete: boolean
-  timeoutHandle?: ReturnType<typeof setTimeout>
-
-  constructor(contentLength: number) {
-    this.contentLength = contentLength
-    this.segmentIndex = 0
-    this.segmentSize = 0
-    this.segmentOffset = 0
-    this.receivedBytes = 0
-    this.displayedComplete = false
-    this.startTime = Date.now()
-  }
-
-  /**
-   * Progress to the next segment. Only call this method when the previous segment
-   * is complete.
-   *
-   * @param segmentSize the length of the next segment
-   */
-  nextSegment(segmentSize: number): void {
-    this.segmentOffset = this.segmentOffset + this.segmentSize
-    this.segmentIndex = this.segmentIndex + 1
-    this.segmentSize = segmentSize
-    this.receivedBytes = 0
-
-    core.debug(
-      `Downloading segment at offset ${this.segmentOffset} with length ${this.segmentSize}...`
-    )
-  }
-
-  /**
-   * Sets the number of bytes received for the current segment.
-   *
-   * @param receivedBytes the number of bytes received
-   */
-  setReceivedBytes(receivedBytes: number): void {
-    this.receivedBytes = receivedBytes
-  }
-
-  /**
-   * Returns the total number of bytes transferred.
-   */
-  getTransferredBytes(): number {
-    return this.segmentOffset + this.receivedBytes
-  }
-
-  /**
-   * Returns true if the download is complete.
-   */
-  isDone(): boolean {
-    return this.getTransferredBytes() === this.contentLength
-  }
-
-  /**
-   * Prints the current download stats. Once the download completes, this will print one
-   * last line and then stop.
-   */
-  display(): void {
-    if (this.displayedComplete) {
-      return
-    }
-
-    const transferredBytes = this.segmentOffset + this.receivedBytes
-    const percentage = (100 * (transferredBytes / this.contentLength)).toFixed(
-      1
-    )
-    const elapsedTime = Date.now() - this.startTime
-    const downloadSpeed = (
-      transferredBytes /
-      (1024 * 1024) /
-      (elapsedTime / 1000)
-    ).toFixed(1)
-
-    core.info(
-      `Received ${transferredBytes} of ${this.contentLength} (${percentage}%), ${downloadSpeed} MBs/sec`
-    )
-
-    if (this.isDone()) {
-      this.displayedComplete = true
-    }
-  }
-
-  /**
-   * Returns a function used to handle TransferProgressEvents.
-   */
-  onProgress(): (progress: TransferProgressEvent) => void {
-    return (progress: TransferProgressEvent) => {
-      this.setReceivedBytes(progress.loadedBytes)
-    }
-  }
-
-  /**
-   * Starts the timer that displays the stats.
-   *
-   * @param delayInMs the delay between each write
-   */
-  startDisplayTimer(delayInMs = 1000): void {
-    const displayCallback = (): void => {
-      this.display()
-
-      if (!this.isDone()) {
-        this.timeoutHandle = setTimeout(displayCallback, delayInMs)
-      }
-    }
-
-    this.timeoutHandle = setTimeout(displayCallback, delayInMs)
-  }
-
-  /**
-   * Stops the timer that displays the stats. As this typically indicates the download
-   * is complete, this will display one last line, unless the last line has already
-   * been written.
-   */
-  stopDisplayTimer(): void {
-    if (this.timeoutHandle) {
-      clearTimeout(this.timeoutHandle)
-      this.timeoutHandle = undefined
-    }
-
-    this.display()
-  }
-}
-
-/**
- * Download the cache using the Actions toolkit http-client
- *
- * @param archiveLocation the URL for the cache
- * @param archivePath the local path where the cache is saved
- */
-export async function downloadCacheHttpClient(
-  archiveLocation: string,
-  archivePath: string
-): Promise<void> {
-  const writeStream = fs.createWriteStream(archivePath)
-  const httpClient = new HttpClient('actions/cache')
-  const downloadResponse = await retryHttpClientResponse(
-    'downloadCache',
-    async () => httpClient.get(archiveLocation)
-  )
-
-  // Abort download if no traffic received over the socket.
-  downloadResponse.message.socket.setTimeout(SocketTimeout, () => {
-    downloadResponse.message.destroy()
-    core.debug(`Aborting download, socket timed out after ${SocketTimeout} ms`)
-  })
-
-  await pipeResponseToStream(downloadResponse, writeStream)
-
-  // Validate download size.
-  const contentLengthHeader = downloadResponse.message.headers['content-length']
-
-  if (contentLengthHeader) {
-    const expectedLength = parseInt(contentLengthHeader)
-    const actualLength = utils.getArchiveFileSizeInBytes(archivePath)
-
-    if (actualLength !== expectedLength) {
-      throw new Error(
-        `Incomplete download. Expected file size: ${expectedLength}, actual file size: ${actualLength}`
-      )
-    }
-  } else {
-    core.debug('Unable to validate download, no Content-Length header')
-  }
-}
-
-/**
- * Download the cache using the Azure Storage SDK.  Only call this method if the
- * URL points to an Azure Storage endpoint.
- *
- * @param archiveLocation the URL for the cache
- * @param archivePath the local path where the cache is saved
- * @param options the download options with the defaults set
- */
-export async function downloadCacheStorageSDK(
-  archiveLocation: string,
-  archivePath: string,
-  options: DownloadOptions
-): Promise<void> {
-  const client = new BlockBlobClient(archiveLocation, undefined, {
-    retryOptions: {
-      // Override the timeout used when downloading each 4 MB chunk
-      // The default is 2 min / MB, which is way too slow
-      tryTimeoutInMs: options.timeoutInMs
-    }
-  })
-
-  const properties = await client.getProperties()
-  const contentLength = properties.contentLength ?? -1
-
-  if (contentLength < 0) {
-    // We should never hit this condition, but just in case fall back to downloading the
-    // file as one large stream
-    core.debug(
-      'Unable to determine content length, downloading file with http-client...'
-    )
-
-    await downloadCacheHttpClient(archiveLocation, archivePath)
-  } else {
-    // Use downloadToBuffer for faster downloads, since internally it splits the
-    // file into 4 MB chunks which can then be parallelized and retried independently
-    //
-    // If the file exceeds the buffer maximum length (~1 GB on 32-bit systems and ~2 GB
-    // on 64-bit systems), split the download into multiple segments
-    // ~2 GB = 2147483647, beyond this, we start getting out of range error. So, capping it accordingly.
-
-    // Updated segment size to 128MB = 134217728 bytes, to complete a segment faster and fail fast
-    const maxSegmentSize = Math.min(134217728, buffer.constants.MAX_LENGTH)
-    const downloadProgress = new DownloadProgress(contentLength)
-
-    const fd = fs.openSync(archivePath, 'w')
-
-    try {
-      downloadProgress.startDisplayTimer()
-      const controller = new AbortController()
-      const abortSignal = controller.signal
-      while (!downloadProgress.isDone()) {
-        const segmentStart =
-          downloadProgress.segmentOffset + downloadProgress.segmentSize
-
-        const segmentSize = Math.min(
-          maxSegmentSize,
-          contentLength - segmentStart
-        )
-
-        downloadProgress.nextSegment(segmentSize)
-        const result = await promiseWithTimeout(
-          options.segmentTimeoutInMs || 3600000,
-          client.downloadToBuffer(segmentStart, segmentSize, {
-            abortSignal,
-            concurrency: options.downloadConcurrency,
-            onProgress: downloadProgress.onProgress()
-          })
-        )
-        if (result === 'timeout') {
-          controller.abort()
-          throw new Error(
-            'Aborting cache download as the download time exceeded the timeout.'
-          )
-        } else if (Buffer.isBuffer(result)) {
-          fs.writeFileSync(fd, result)
-        }
-      }
-    } finally {
-      downloadProgress.stopDisplayTimer()
-      fs.closeSync(fd)
-    }
-  }
-}
-
-const promiseWithTimeout = async (
-  timeoutMs: number,
-  promise: Promise<Buffer>
-): Promise<unknown> => {
-  let timeoutHandle: NodeJS.Timeout
-  const timeoutPromise = new Promise(resolve => {
-    timeoutHandle = setTimeout(() => resolve('timeout'), timeoutMs)
-  })
-
-  return Promise.race([promise, timeoutPromise]).then(result => {
-    clearTimeout(timeoutHandle)
-    return result
-  })
-}

packages/cache/src/internal/requestUtils.ts

@@ -1,138 +0,0 @@
-import * as core from '@actions/core'
-import {
-  HttpCodes,
-  HttpClientError,
-  HttpClientResponse
-} from '@actions/http-client'
-import {DefaultRetryDelay, DefaultRetryAttempts} from './constants'
-import {ITypedResponseWithError} from './contracts'
-
-export function isSuccessStatusCode(statusCode?: number): boolean {
-  if (!statusCode) {
-    return false
-  }
-  return statusCode >= 200 && statusCode < 300
-}
-
-export function isServerErrorStatusCode(statusCode?: number): boolean {
-  if (!statusCode) {
-    return true
-  }
-  return statusCode >= 500
-}
-
-export function isRetryableStatusCode(statusCode?: number): boolean {
-  if (!statusCode) {
-    return false
-  }
-  const retryableStatusCodes = [
-    HttpCodes.BadGateway,
-    HttpCodes.ServiceUnavailable,
-    HttpCodes.GatewayTimeout
-  ]
-  return retryableStatusCodes.includes(statusCode)
-}
-
-async function sleep(milliseconds: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, milliseconds))
-}
-
-export async function retry<T>(
-  name: string,
-  method: () => Promise<T>,
-  getStatusCode: (arg0: T) => number | undefined,
-  maxAttempts = DefaultRetryAttempts,
-  delay = DefaultRetryDelay,
-  onError: ((arg0: Error) => T | undefined) | undefined = undefined
-): Promise<T> {
-  let errorMessage = ''
-  let attempt = 1
-
-  while (attempt <= maxAttempts) {
-    let response: T | undefined = undefined
-    let statusCode: number | undefined = undefined
-    let isRetryable = false
-
-    try {
-      response = await method()
-    } catch (error) {
-      if (onError) {
-        response = onError(error)
-      }
-
-      isRetryable = true
-      errorMessage = error.message
-    }
-
-    if (response) {
-      statusCode = getStatusCode(response)
-
-      if (!isServerErrorStatusCode(statusCode)) {
-        return response
-      }
-    }
-
-    if (statusCode) {
-      isRetryable = isRetryableStatusCode(statusCode)
-      errorMessage = `Cache service responded with ${statusCode}`
-    }
-
-    core.debug(
-      `${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`
-    )
-
-    if (!isRetryable) {
-      core.debug(`${name} - Error is not retryable`)
-      break
-    }
-
-    await sleep(delay)
-    attempt++
-  }
-
-  throw Error(`${name} failed: ${errorMessage}`)
-}
-
-export async function retryTypedResponse<T>(
-  name: string,
-  method: () => Promise<ITypedResponseWithError<T>>,
-  maxAttempts = DefaultRetryAttempts,
-  delay = DefaultRetryDelay
-): Promise<ITypedResponseWithError<T>> {
-  return await retry(
-    name,
-    method,
-    (response: ITypedResponseWithError<T>) => response.statusCode,
-    maxAttempts,
-    delay,
-    // If the error object contains the statusCode property, extract it and return
-    // an TypedResponse<T> so it can be processed by the retry logic.
-    (error: Error) => {
-      if (error instanceof HttpClientError) {
-        return {
-          statusCode: error.statusCode,
-          result: null,
-          headers: {},
-          error
-        }
-      } else {
-        return undefined
-      }
-    }
-  )
-}
-
-export async function retryHttpClientResponse(
-  name: string,
-  method: () => Promise<HttpClientResponse>,
-  maxAttempts = DefaultRetryAttempts,
-  delay = DefaultRetryDelay
-): Promise<HttpClientResponse> {
-  return await retry(
-    name,
-    method,
-    (response: HttpClientResponse) => response.message.statusCode,
-    maxAttempts,
-    delay
-  )
-}

packages/cache/src/internal/tar.ts

@@ -1,297 +0,0 @@
-import {exec} from '@actions/exec'
-import * as io from '@actions/io'
-import {existsSync, writeFileSync} from 'fs'
-import * as path from 'path'
-import * as utils from './cacheUtils'
-import {ArchiveTool} from './contracts'
-import {
-  CompressionMethod,
-  SystemTarPathOnWindows,
-  ArchiveToolType,
-  TarFilename,
-  ManifestFilename
-} from './constants'
-
-const IS_WINDOWS = process.platform === 'win32'
-
-// Returns tar path and type: BSD or GNU
-async function getTarPath(): Promise<ArchiveTool> {
-  switch (process.platform) {
-    case 'win32': {
-      const gnuTar = await utils.getGnuTarPathOnWindows()
-      const systemTar = SystemTarPathOnWindows
-      if (gnuTar) {
-        // Use GNUtar as default on windows
-        return <ArchiveTool>{path: gnuTar, type: ArchiveToolType.GNU}
-      } else if (existsSync(systemTar)) {
-        return <ArchiveTool>{path: systemTar, type: ArchiveToolType.BSD}
-      }
-      break
-    }
-    case 'darwin': {
-      const gnuTar = await io.which('gtar', false)
-      if (gnuTar) {
-        // fix permission denied errors when extracting BSD tar archive with GNU tar - https://github.com/actions/cache/issues/527
-        return <ArchiveTool>{path: gnuTar, type: ArchiveToolType.GNU}
-      } else {
-        return <ArchiveTool>{
-          path: await io.which('tar', true),
-          type: ArchiveToolType.BSD
-        }
-      }
-    }
-    default:
-      break
-  }
-  // Default assumption is GNU tar is present in path
-  return <ArchiveTool>{
-    path: await io.which('tar', true),
-    type: ArchiveToolType.GNU
-  }
-}
-
-// Return arguments for tar as per tarPath, compressionMethod, method type and os
-async function getTarArgs(
-  tarPath: ArchiveTool,
-  compressionMethod: CompressionMethod,
-  type: string,
-  archivePath = ''
-): Promise<string[]> {
-  const args = [`"${tarPath.path}"`]
-  const cacheFileName = utils.getCacheFileName(compressionMethod)
-  const tarFile = 'cache.tar'
-  const workingDirectory = getWorkingDirectory()
-  // Speficic args for BSD tar on windows for workaround
-  const BSD_TAR_ZSTD =
-    tarPath.type === ArchiveToolType.BSD &&
-    compressionMethod !== CompressionMethod.Gzip &&
-    IS_WINDOWS
-
-  // Method specific args
-  switch (type) {
-    case 'create':
-      args.push(
-        '--posix',
-        '-cf',
-        BSD_TAR_ZSTD
-          ? tarFile
-          : cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '--exclude',
-        BSD_TAR_ZSTD
-          ? tarFile
-          : cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P',
-        '-C',
-        workingDirectory.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '--files-from',
-        ManifestFilename
-      )
-      break
-    case 'extract':
-      args.push(
-        '-xf',
-        BSD_TAR_ZSTD
-          ? tarFile
-          : archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P',
-        '-C',
-        workingDirectory.replace(new RegExp(`\\${path.sep}`, 'g'), '/')
-      )
-      break
-    case 'list':
-      args.push(
-        '-tf',
-        BSD_TAR_ZSTD
-          ? tarFile
-          : archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-        '-P'
-      )
-      break
-  }
-
-  // Platform specific args
-  if (tarPath.type === ArchiveToolType.GNU) {
-    switch (process.platform) {
-      case 'win32':
-        args.push('--force-local')
-        break
-      case 'darwin':
-        args.push('--delay-directory-restore')
-        break
-    }
-  }
-
-  return args
-}
-
-// Returns commands to run tar and compression program
-async function getCommands(
-  compressionMethod: CompressionMethod,
-  type: string,
-  archivePath = ''
-): Promise<string[]> {
-  let args
-
-  const tarPath = await getTarPath()
-  const tarArgs = await getTarArgs(
-    tarPath,
-    compressionMethod,
-    type,
-    archivePath
-  )
-  const compressionArgs =
-    type !== 'create'
-      ? await getDecompressionProgram(tarPath, compressionMethod, archivePath)
-      : await getCompressionProgram(tarPath, compressionMethod)
-  const BSD_TAR_ZSTD =
-    tarPath.type === ArchiveToolType.BSD &&
-    compressionMethod !== CompressionMethod.Gzip &&
-    IS_WINDOWS
-
-  if (BSD_TAR_ZSTD && type !== 'create') {
-    args = [[...compressionArgs].join(' '), [...tarArgs].join(' ')]
-  } else {
-    args = [[...tarArgs].join(' '), [...compressionArgs].join(' ')]
-  }
-
-  if (BSD_TAR_ZSTD) {
-    return args
-  }
-
-  return [args.join(' ')]
-}
-
-function getWorkingDirectory(): string {
-  return process.env['GITHUB_WORKSPACE'] ?? process.cwd()
-}
-
-// Common function for extractTar and listTar to get the compression method
-async function getDecompressionProgram(
-  tarPath: ArchiveTool,
-  compressionMethod: CompressionMethod,
-  archivePath: string
-): Promise<string[]> {
-  // -d: Decompress.
-  // unzstd is equivalent to 'zstd -d'
-  // --long=#: Enables long distance matching with # bits. Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
-  // Using 30 here because we also support 32-bit self-hosted runners.
-  const BSD_TAR_ZSTD =
-    tarPath.type === ArchiveToolType.BSD &&
-    compressionMethod !== CompressionMethod.Gzip &&
-    IS_WINDOWS
-  switch (compressionMethod) {
-    case CompressionMethod.Zstd:
-      return BSD_TAR_ZSTD
-        ? [
-            'zstd -d --long=30 --force -o',
-            TarFilename,
-            archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/')
-          ]
-        : [
-            '--use-compress-program',
-            IS_WINDOWS ? '"zstd -d --long=30"' : 'unzstd --long=30'
-          ]
-    case CompressionMethod.ZstdWithoutLong:
-      return BSD_TAR_ZSTD
-        ? [
-            'zstd -d --force -o',
-            TarFilename,
-            archivePath.replace(new RegExp(`\\${path.sep}`, 'g'), '/')
-          ]
-        : ['--use-compress-program', IS_WINDOWS ? '"zstd -d"' : 'unzstd']
-    default:
-      return ['-z']
-  }
-}
-
-// Used for creating the archive
-// -T#: Compress using # working thread. If # is 0, attempt to detect and use the number of physical CPU cores.
-// zstdmt is equivalent to 'zstd -T0'
-// --long=#: Enables long distance matching with # bits. Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
-// Using 30 here because we also support 32-bit self-hosted runners.
-// Long range mode is added to zstd in v1.3.2 release, so we will not use --long in older version of zstd.
-async function getCompressionProgram(
-  tarPath: ArchiveTool,
-  compressionMethod: CompressionMethod
-): Promise<string[]> {
-  const cacheFileName = utils.getCacheFileName(compressionMethod)
-  const BSD_TAR_ZSTD =
-    tarPath.type === ArchiveToolType.BSD &&
-    compressionMethod !== CompressionMethod.Gzip &&
-    IS_WINDOWS
-  switch (compressionMethod) {
-    case CompressionMethod.Zstd:
-      return BSD_TAR_ZSTD
-        ? [
-            'zstd -T0 --long=30 --force -o',
-            cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-            TarFilename
-          ]
-        : [
-            '--use-compress-program',
-            IS_WINDOWS ? '"zstd -T0 --long=30"' : 'zstdmt --long=30'
-          ]
-    case CompressionMethod.ZstdWithoutLong:
-      return BSD_TAR_ZSTD
-        ? [
-            'zstd -T0 --force -o',
-            cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
-            TarFilename
-          ]
-        : ['--use-compress-program', IS_WINDOWS ? '"zstd -T0"' : 'zstdmt']
-    default:
-      return ['-z']
-  }
-}
-
-// Executes all commands as separate processes
-async function execCommands(commands: string[], cwd?: string): Promise<void> {
-  for (const command of commands) {
-    try {
-      await exec(command, undefined, {
-        cwd,
-        env: {...(process.env as object), MSYS: 'winsymlinks:nativestrict'}
-      })
-    } catch (error) {
-      throw new Error(
-        `${command.split(' ')[0]} failed with error: ${error?.message}`
-      )
-    }
-  }
-}
-
-// List the contents of a tar
-export async function listTar(
-  archivePath: string,
-  compressionMethod: CompressionMethod
-): Promise<void> {
-  const commands = await getCommands(compressionMethod, 'list', archivePath)
-  await execCommands(commands)
-}
-
-// Extract a tar
-export async function extractTar(
-  archivePath: string,
-  compressionMethod: CompressionMethod
-): Promise<void> {
-  // Create directory to extract tar into
-  const workingDirectory = getWorkingDirectory()
-  await io.mkdirP(workingDirectory)
-  const commands = await getCommands(compressionMethod, 'extract', archivePath)
-  await execCommands(commands)
-}
-
-// Create a tar
-export async function createTar(
-  archiveFolder: string,
-  sourceDirectories: string[],
-  compressionMethod: CompressionMethod
-): Promise<void> {
-  // Write source directories to manifest.txt to avoid command length limits
-  writeFileSync(
-    path.join(archiveFolder, ManifestFilename),
-    sourceDirectories.join('\n')
-  )
-  const commands = await getCommands(compressionMethod, 'create')
-  await execCommands(commands, archiveFolder)
-}

packages/cache/src/options.ts

@@ -1,149 +0,0 @@
-import * as core from '@actions/core'
-
-/**
- * Options to control cache upload
- */
-export interface UploadOptions {
-  /**
-   * Number of parallel cache upload
-   *
-   * @default 4
-   */
-  uploadConcurrency?: number
-  /**
-   * Maximum chunk size in bytes for cache upload
-   *
-   * @default 32MB
-   */
-  uploadChunkSize?: number
-}
-
-/**
- * Options to control cache download
- */
-export interface DownloadOptions {
-  /**
-   * Indicates whether to use the Azure Blob SDK to download caches
-   * that are stored on Azure Blob Storage to improve reliability and
-   * performance
-   *
-   * @default true
-   */
-  useAzureSdk?: boolean
-
-  /**
-   * Number of parallel downloads (this option only applies when using
-   * the Azure SDK)
-   *
-   * @default 8
-   */
-  downloadConcurrency?: number
-
-  /**
-   * Maximum time for each download request, in milliseconds (this
-   * option only applies when using the Azure SDK)
-   *
-   * @default 30000
-   */
-  timeoutInMs?: number
-
-  /**
-   * Time after which a segment download should be aborted if stuck
-   *
-   * @default 3600000
-   */
-  segmentTimeoutInMs?: number
-
-  /**
-   * Weather to skip downloading the cache entry.
-   * If lookupOnly is set to true, the restore function will only check if
-   * a matching cache entry exists and return the cache key if it does.
-   *
-   * @default false
-   */
-  lookupOnly?: boolean
-}
-
-/**
- * Returns a copy of the upload options with defaults filled in.
- *
- * @param copy the original upload options
- */
-export function getUploadOptions(copy?: UploadOptions): UploadOptions {
-  const result: UploadOptions = {
-    uploadConcurrency: 4,
-    uploadChunkSize: 32 * 1024 * 1024
-  }
-
-  if (copy) {
-    if (typeof copy.uploadConcurrency === 'number') {
-      result.uploadConcurrency = copy.uploadConcurrency
-    }
-
-    if (typeof copy.uploadChunkSize === 'number') {
-      result.uploadChunkSize = copy.uploadChunkSize
-    }
-  }
-
-  core.debug(`Upload concurrency: ${result.uploadConcurrency}`)
-  core.debug(`Upload chunk size: ${result.uploadChunkSize}`)
-
-  return result
-}
-
-/**
- * Returns a copy of the download options with defaults filled in.
- *
- * @param copy the original download options
- */
-export function getDownloadOptions(copy?: DownloadOptions): DownloadOptions {
-  const result: DownloadOptions = {
-    useAzureSdk: true,
-    downloadConcurrency: 8,
-    timeoutInMs: 30000,
-    segmentTimeoutInMs: 600000,
-    lookupOnly: false
-  }
-
-  if (copy) {
-    if (typeof copy.useAzureSdk === 'boolean') {
-      result.useAzureSdk = copy.useAzureSdk
-    }
-
-    if (typeof copy.downloadConcurrency === 'number') {
-      result.downloadConcurrency = copy.downloadConcurrency
-    }
-
-    if (typeof copy.timeoutInMs === 'number') {
-      result.timeoutInMs = copy.timeoutInMs
-    }
-
-    if (typeof copy.segmentTimeoutInMs === 'number') {
-      result.segmentTimeoutInMs = copy.segmentTimeoutInMs
-    }
-
-    if (typeof copy.lookupOnly === 'boolean') {
-      result.lookupOnly = copy.lookupOnly
-    }
-  }
-  const segmentDownloadTimeoutMins =
-    process.env['SEGMENT_DOWNLOAD_TIMEOUT_MINS']
-
-  if (
-    segmentDownloadTimeoutMins &&
-    !isNaN(Number(segmentDownloadTimeoutMins)) &&
-    isFinite(Number(segmentDownloadTimeoutMins))
-  ) {
-    result.segmentTimeoutInMs = Number(segmentDownloadTimeoutMins) * 60 * 1000
-  }
-  core.debug(`Use Azure SDK: ${result.useAzureSdk}`)
-  core.debug(`Download concurrency: ${result.downloadConcurrency}`)
-  core.debug(`Request timeout (ms): ${result.timeoutInMs}`)
-  core.debug(
-    `Cache segment download timeout mins env var: ${process.env['SEGMENT_DOWNLOAD_TIMEOUT_MINS']}`
-  )
-  core.debug(`Segment download timeout (ms): ${result.segmentTimeoutInMs}`)
-  core.debug(`Lookup only: ${result.lookupOnly}`)
-
-  return result
-}

packages/cache/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "baseUrl": "./",
-    "outDir": "./lib",
-    "rootDir": "./src",
-    "lib": ["es6", "dom"],
-    "useUnknownInCatchVariables": false
-  },
-  "include": [
-    "./src"
-  ]
-}

packages/core/LICENSE.md

@@ -1,9 +0,0 @@
-The MIT License (MIT)
-
-Copyright 2019 GitHub
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/core/README.md

@@ -16,14 +16,11 @@ import * as core from '@actions/core';
 
 #### Inputs/Outputs
 
-Action inputs can be read with `getInput` which returns a `string` or `getBooleanInput` which parses a boolean based on the [yaml 1.2 specification](https://yaml.org/spec/1.2/spec.html#id2804923). If `required` set to be false, the input should have a default value in `action.yml`.
-
-Outputs can be set with `setOutput` which makes them available to be mapped into inputs of other actions to ensure they are decoupled.
+Action inputs can be read with `getInput`.  Outputs can be set with `setOutput` which makes them available to be mapped into inputs of other actions to ensure they are decoupled.
 
 ```js
 const myInput = core.getInput('inputName', { required: true });
-const myBooleanInput = core.getBooleanInput('booleanInputName', { required: true });
-const myMultilineInput = core.getMultilineInput('multilineInputName', { required: true });
+
 core.setOutput('outputKey', 'outputVal');
 ```
 
@@ -65,10 +62,11 @@ catch (err) {
   // setFailed logs the message and sets a failing exit code
   core.setFailed(`Action failed with error ${err}`);
 }
-```
 
 Note that `setNeutral` is not yet implemented in actions V2 but equivalent functionality is being planned.
 
+```
+
 #### Logging
 
 Finally, this library provides some utilities for logging. Note that debug logging is hidden from the logs by default. This behavior can be toggled by enabling the [Step Debug Logs](../../docs/action-debugging.md#step-debug-logs).
@@ -84,16 +82,7 @@ try {
     core.warning('myInput was not set');
   }
   
-  if (core.isDebug()) {
-    // curl -v https://github.com
-  } else {
-    // curl https://github.com
-  }
-
   // Do stuff
-  core.info('Output to the actions build log')
-
-  core.notice('This is a message that will also emit an annotation')
 }
 catch (err) {
   core.error(`Error ${err}, action may still succeed though`);
@@ -117,123 +106,11 @@ const result = await core.group('Do something async', async () => {
 })
 ```
 
-#### Annotations
-
-This library has 3 methods that will produce [annotations](https://docs.github.com/en/rest/reference/checks#create-a-check-run). 
-```js
-core.error('This is a bad error, action may still succeed though.')
-
-core.warning('Something went wrong, but it\'s not bad enough to fail the build.')
-
-core.notice('Something happened that you might want to know about.')
-```
-
-These will surface to the UI in the Actions page and on Pull Requests. They look something like this:
-
-![Annotations Image](../../docs/assets/annotations.png)
-
-These annotations can also be attached to particular lines and columns of your source files to show exactly where a problem is occuring. 
-
-These options are: 
-```typescript
-export interface AnnotationProperties {
-  /**
-   * A title for the annotation.
-   */
-  title?: string
-
-  /**
-   * The name of the file for which the annotation should be created.
-   */
-  file?: string
-
-  /**
-   * The start line for the annotation.
-   */
-  startLine?: number
-
-  /**
-   * The end line for the annotation. Defaults to `startLine` when `startLine` is provided.
-   */
-  endLine?: number
-
-  /**
-   * The start column for the annotation. Cannot be sent when `startLine` and `endLine` are different values.
-   */
-  startColumn?: number
-
-  /**
-   * The end column for the annotation. Cannot be sent when `startLine` and `endLine` are different values.
-   * Defaults to `startColumn` when `startColumn` is provided.
-   */
-  endColumn?: number
-}
-```
-
-#### Styling output
-
-Colored output is supported in the Action logs via standard [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code). 3/4 bit, 8 bit and 24 bit colors are all supported.
-
-Foreground colors:
-
-```js
-// 3/4 bit
-core.info('\u001b[35mThis foreground will be magenta')
-
-// 8 bit
-core.info('\u001b[38;5;6mThis foreground will be cyan')
-
-// 24 bit
-core.info('\u001b[38;2;255;0;0mThis foreground will be bright red')
-```
-
-Background colors:
-
-```js
-// 3/4 bit
-core.info('\u001b[43mThis background will be yellow');
-
-// 8 bit
-core.info('\u001b[48;5;6mThis background will be cyan')
-
-// 24 bit
-core.info('\u001b[48;2;255;0;0mThis background will be bright red')
-```
-
-Special styles:
-
-```js
-core.info('\u001b[1mBold text')
-core.info('\u001b[3mItalic text')
-core.info('\u001b[4mUnderlined text')
-```
-
-ANSI escape codes can be combined with one another:
-
-```js
-core.info('\u001b[31;46mRed foreground with a cyan background and \u001b[1mbold text at the end');
-```
-
-> Note: Escape codes reset at the start of each line
-
-```js
-core.info('\u001b[35mThis foreground will be magenta')
-core.info('This foreground will reset to the default')
-```
-
-Manually typing escape codes can be a little difficult, but you can use third party modules such as [ansi-styles](https://github.com/chalk/ansi-styles).
-
-```js
-const style = require('ansi-styles');
-core.info(style.color.ansi16m.hex('#abcdef') + 'Hello world!')
-```
-
 #### Action state
 
-You can use this library to save state and get state for sharing information between a given wrapper action:
-
-**action.yml**:
+You can use this library to save state and get state for sharing information between a given wrapper action: 
 
+**action.yml**
 ```yaml
 name: 'Wrapper action sample'
 inputs:
@@ -254,82 +131,10 @@ core.saveState("pidToKill", 12345);
 ```
 
 In action's `cleanup.js`:
-
 ```js
 const core = require('@actions/core');
 
 var pid = core.getState("pidToKill");
 
 process.kill(pid);
-```
-
-#### OIDC Token
-
-You can use these methods to interact with the GitHub OIDC provider and get a JWT ID token which would help to get access token from third party cloud providers.
-
-**Method Name**: getIDToken()
-
-**Inputs**
-
-audience : optional
-
-**Outputs**
-
-A [JWT](https://jwt.io/) ID Token
-
-In action's `main.ts`:
-```js
-const core = require('@actions/core');
-async function getIDTokenAction(): Promise<void> {
-  
-   const audience = core.getInput('audience', {required: false})
-   
-   const id_token1 = await core.getIDToken()            // ID Token with default audience
-   const id_token2 = await core.getIDToken(audience)    // ID token with custom audience
-   
-   // this id_token can be used to get access token from third party cloud providers
-}
-getIDTokenAction()
-```
-
-In action's `actions.yml`:
-
-```yaml
-name: 'GetIDToken'
-description: 'Get ID token from Github OIDC provider'
-inputs:
-  audience:  
-    description: 'Audience for which the ID token is intended for'
-    required: false
-outputs:
-  id_token1: 
-    description: 'ID token obtained from OIDC provider'
-  id_token2: 
-    description: 'ID token obtained from OIDC provider'
-runs:
-  using: 'node12'
-  main: 'dist/index.js'
-```
-
-#### Filesystem path helpers
-
-You can use these methods to manipulate file paths across operating systems.
-
-The `toPosixPath` function converts input paths to Posix-style (Linux) paths.
-The `toWin32Path` function converts input paths to Windows-style paths. These
-functions work independently of the underlying runner operating system.
-
-```js
-toPosixPath('\\foo\\bar') // => /foo/bar
-toWin32Path('/foo/bar') // => \foo\bar
-```
-
-The `toPlatformPath` function converts input paths to the expected value on the runner's operating system.
-
-```js
-// On a Windows runner.
-toPlatformPath('/foo/bar') // => \foo\bar
-
-// On a Linux runner.
-toPlatformPath('\\foo\\bar') // => /foo/bar
-```
+```

packages/core/RELEASES.md

@@ -1,69 +1,5 @@
 # @actions/core Releases
 
-### 1.10.0
-- `saveState` and `setOutput` now use environment files if available [#1178](https://github.com/actions/toolkit/pull/1178)
-- `getMultilineInput` now correctly trims whitespace by default [#1185](https://github.com/actions/toolkit/pull/1185)
-
-### 1.9.1
-- Randomize delimiter when calling `core.exportVariable`
-
-### 1.9.0
-- Added `toPosixPath`, `toWin32Path` and `toPlatformPath` utilities [#1102](https://github.com/actions/toolkit/pull/1102)
-
-### 1.8.2
-- Update to v2.0.1 of `@actions/http-client` [#1087](https://github.com/actions/toolkit/pull/1087)
-
-### 1.8.1
-- Update to v2.0.0 of `@actions/http-client`
-
-### 1.8.0
-- Deprecate `markdownSummary` extension export in favor of `summary`
-  - https://github.com/actions/toolkit/pull/1072
-  - https://github.com/actions/toolkit/pull/1073
-
-### 1.7.0
-- [Added `markdownSummary` extension](https://github.com/actions/toolkit/pull/1014)
-
-### 1.6.0
-- [Added OIDC Client function `getIDToken`](https://github.com/actions/toolkit/pull/919)
-- [Added `file` parameter to `AnnotationProperties`](https://github.com/actions/toolkit/pull/896) 
-
-### 1.5.0
-- [Added support for notice annotations and more annotation fields](https://github.com/actions/toolkit/pull/855)
-
-### 1.4.0
-- [Added the `getMultilineInput` function](https://github.com/actions/toolkit/pull/829)
-
-### 1.3.0
-- [Added the trimWhitespace option to getInput](https://github.com/actions/toolkit/pull/802)
-- [Added the getBooleanInput function](https://github.com/actions/toolkit/pull/725)
-
-### 1.2.7
-- [Prepend newline for set-output](https://github.com/actions/toolkit/pull/772)
-
-### 1.2.6
-- [Update `exportVariable` and `addPath` to use environment files](https://github.com/actions/toolkit/pull/571)
-
-### 1.2.5
-- [Correctly bundle License File with package](https://github.com/actions/toolkit/pull/548)
-
-### 1.2.4
-- [Be more lenient in accepting non-string command inputs](https://github.com/actions/toolkit/pull/405)
-- [Add Echo commands](https://github.com/actions/toolkit/pull/411)
-
-### 1.2.3
-
-- [IsDebug logging](README.md#logging)
-
-### 1.2.2
-
-- [Fix escaping for runner commands](https://github.com/actions/toolkit/pull/302)
-
-### 1.2.1
-
-- [Remove trailing comma from commands](https://github.com/actions/toolkit/pull/263)
-- [Add \"types\" to package.json](https://github.com/actions/toolkit/pull/221)
-
 ### 1.2.0
 
 - saveState and getState functions for wrapper tasks (on finally entry points that run post job)

packages/core/__tests__/command.test.ts

@@ -1,139 +0,0 @@
-import * as command from '../src/command'
-import * as os from 'os'
-
-/* eslint-disable @typescript-eslint/unbound-method */
-
-let originalWriteFunction: (str: string) => boolean
-
-describe('@actions/core/src/command', () => {
-  beforeAll(() => {
-    originalWriteFunction = process.stdout.write
-  })
-
-  beforeEach(() => {
-    process.stdout.write = jest.fn()
-  })
-
-  afterEach(() => {})
-
-  afterAll(() => {
-    process.stdout.write = (originalWriteFunction as unknown) as (
-      str: string
-    ) => boolean
-  })
-
-  it('command only', () => {
-    command.issueCommand('some-command', {}, '')
-    assertWriteCalls([`::some-command::${os.EOL}`])
-  })
-
-  it('command escapes message', () => {
-    // Verify replaces each instance, not just first instance
-    command.issueCommand(
-      'some-command',
-      {},
-      'percent % percent % cr \r cr \r lf \n lf \n'
-    )
-    assertWriteCalls([
-      `::some-command::percent %25 percent %25 cr %0D cr %0D lf %0A lf %0A${os.EOL}`
-    ])
-
-    // Verify literal escape sequences
-    process.stdout.write = jest.fn()
-    command.issueCommand('some-command', {}, '%25 %25 %0D %0D %0A %0A')
-    assertWriteCalls([
-      `::some-command::%2525 %2525 %250D %250D %250A %250A${os.EOL}`
-    ])
-  })
-
-  it('command escapes property', () => {
-    // Verify replaces each instance, not just first instance
-    command.issueCommand(
-      'some-command',
-      {
-        name:
-          'percent % percent % cr \r cr \r lf \n lf \n colon : colon : comma , comma ,'
-      },
-      ''
-    )
-    assertWriteCalls([
-      `::some-command name=percent %25 percent %25 cr %0D cr %0D lf %0A lf %0A colon %3A colon %3A comma %2C comma %2C::${os.EOL}`
-    ])
-
-    // Verify literal escape sequences
-    process.stdout.write = jest.fn()
-    command.issueCommand(
-      'some-command',
-      {},
-      '%25 %25 %0D %0D %0A %0A %3A %3A %2C %2C'
-    )
-    assertWriteCalls([
-      `::some-command::%2525 %2525 %250D %250D %250A %250A %253A %253A %252C %252C${os.EOL}`
-    ])
-  })
-
-  it('command with message', () => {
-    command.issueCommand('some-command', {}, 'some message')
-    assertWriteCalls([`::some-command::some message${os.EOL}`])
-  })
-
-  it('command with message and properties', () => {
-    command.issueCommand(
-      'some-command',
-      {prop1: 'value 1', prop2: 'value 2'},
-      'some message'
-    )
-    assertWriteCalls([
-      `::some-command prop1=value 1,prop2=value 2::some message${os.EOL}`
-    ])
-  })
-
-  it('command with one property', () => {
-    command.issueCommand('some-command', {prop1: 'value 1'}, '')
-    assertWriteCalls([`::some-command prop1=value 1::${os.EOL}`])
-  })
-
-  it('command with two properties', () => {
-    command.issueCommand(
-      'some-command',
-      {prop1: 'value 1', prop2: 'value 2'},
-      ''
-    )
-    assertWriteCalls([`::some-command prop1=value 1,prop2=value 2::${os.EOL}`])
-  })
-
-  it('command with three properties', () => {
-    command.issueCommand(
-      'some-command',
-      {prop1: 'value 1', prop2: 'value 2', prop3: 'value 3'},
-      ''
-    )
-    assertWriteCalls([
-      `::some-command prop1=value 1,prop2=value 2,prop3=value 3::${os.EOL}`
-    ])
-  })
-
-  it('should handle issuing commands for non-string objects', () => {
-    command.issueCommand(
-      'some-command',
-      {
-        prop1: ({test: 'object'} as unknown) as string,
-        prop2: (123 as unknown) as string,
-        prop3: (true as unknown) as string
-      },
-      ({test: 'object'} as unknown) as string
-    )
-    assertWriteCalls([
-      `::some-command prop1={"test"%3A"object"},prop2=123,prop3=true::{"test":"object"}${os.EOL}`
-    ])
-  })
-})
-
-// Assert that process.stdout.write calls called only with the given arguments.
-function assertWriteCalls(calls: string[]): void {
-  expect(process.stdout.write).toHaveBeenCalledTimes(calls.length)
-
-  for (let i = 0; i < calls.length; i++) {
-    expect(process.stdout.write).toHaveBeenNthCalledWith(i + 1, calls[i])
-  }
-}

packages/core/__tests__/core.test.ts

@@ -1,676 +0,0 @@
-import * as fs from 'fs'
-import * as os from 'os'
-import * as path from 'path'
-import * as core from '../src/core'
-import {HttpClient} from '@actions/http-client'
-import {toCommandProperties} from '../src/utils'
-import * as uuid from 'uuid'
-
-jest.mock('uuid')
-
-/* eslint-disable @typescript-eslint/unbound-method */
-
-const testEnvVars = {
-  'my var': '',
-  'special char var \r\n];': '',
-  'my var2': '',
-  'my secret': '',
-  'special char secret \r\n];': '',
-  'my secret2': '',
-  PATH: `path1${path.delimiter}path2`,
-
-  // Set inputs
-  INPUT_MY_INPUT: 'val',
-  INPUT_MISSING: '',
-  'INPUT_SPECIAL_CHARS_\'\t"\\': '\'\t"\\ response ',
-  INPUT_MULTIPLE_SPACES_VARIABLE: 'I have multiple spaces',
-  INPUT_BOOLEAN_INPUT: 'true',
-  INPUT_BOOLEAN_INPUT_TRUE1: 'true',
-  INPUT_BOOLEAN_INPUT_TRUE2: 'True',
-  INPUT_BOOLEAN_INPUT_TRUE3: 'TRUE',
-  INPUT_BOOLEAN_INPUT_FALSE1: 'false',
-  INPUT_BOOLEAN_INPUT_FALSE2: 'False',
-  INPUT_BOOLEAN_INPUT_FALSE3: 'FALSE',
-  INPUT_WRONG_BOOLEAN_INPUT: 'wrong',
-  INPUT_WITH_TRAILING_WHITESPACE: '  some val  ',
-  INPUT_MY_INPUT_LIST: 'val1\nval2\nval3',
-  INPUT_LIST_WITH_TRAILING_WHITESPACE: '  val1  \n  val2  \n  ',
-
-  // Save inputs
-  STATE_TEST_1: 'state_val',
-
-  // File Commands
-  GITHUB_PATH: '',
-  GITHUB_ENV: '',
-  GITHUB_OUTPUT: '',
-  GITHUB_STATE: ''
-}
-
-const UUID = '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'
-const DELIMITER = `ghadelimiter_${UUID}`
-
-describe('@actions/core', () => {
-  beforeAll(() => {
-    const filePath = path.join(__dirname, `test`)
-    if (!fs.existsSync(filePath)) {
-      fs.mkdirSync(filePath)
-    }
-  })
-
-  beforeEach(() => {
-    for (const key in testEnvVars) {
-      process.env[key] = testEnvVars[key as keyof typeof testEnvVars]
-    }
-    process.stdout.write = jest.fn()
-
-    jest.spyOn(uuid, 'v4').mockImplementation(() => {
-      return UUID
-    })
-  })
-
-  afterEach(() => {
-    jest.restoreAllMocks()
-  })
-
-  it('legacy exportVariable produces the correct command and sets the env', () => {
-    core.exportVariable('my var', 'var val')
-    assertWriteCalls([`::set-env name=my var::var val${os.EOL}`])
-  })
-
-  it('legacy exportVariable escapes variable names', () => {
-    core.exportVariable('special char var \r\n,:', 'special val')
-    expect(process.env['special char var \r\n,:']).toBe('special val')
-    assertWriteCalls([
-      `::set-env name=special char var %0D%0A%2C%3A::special val${os.EOL}`
-    ])
-  })
-
-  it('legacy exportVariable escapes variable values', () => {
-    core.exportVariable('my var2', 'var val\r\n')
-    expect(process.env['my var2']).toBe('var val\r\n')
-    assertWriteCalls([`::set-env name=my var2::var val%0D%0A${os.EOL}`])
-  })
-
-  it('legacy exportVariable handles boolean inputs', () => {
-    core.exportVariable('my var', true)
-    assertWriteCalls([`::set-env name=my var::true${os.EOL}`])
-  })
-
-  it('legacy exportVariable handles number inputs', () => {
-    core.exportVariable('my var', 5)
-    assertWriteCalls([`::set-env name=my var::5${os.EOL}`])
-  })
-
-  it('exportVariable produces the correct command and sets the env', () => {
-    const command = 'ENV'
-    createFileCommandFile(command)
-    core.exportVariable('my var', 'var val')
-    verifyFileCommand(
-      command,
-      `my var<<${DELIMITER}${os.EOL}var val${os.EOL}${DELIMITER}${os.EOL}`
-    )
-  })
-
-  it('exportVariable handles boolean inputs', () => {
-    const command = 'ENV'
-    createFileCommandFile(command)
-    core.exportVariable('my var', true)
-    verifyFileCommand(
-      command,
-      `my var<<${DELIMITER}${os.EOL}true${os.EOL}${DELIMITER}${os.EOL}`
-    )
-  })
-
-  it('exportVariable handles number inputs', () => {
-    const command = 'ENV'
-    createFileCommandFile(command)
-    core.exportVariable('my var', 5)
-    verifyFileCommand(
-      command,
-      `my var<<${DELIMITER}${os.EOL}5${os.EOL}${DELIMITER}${os.EOL}`
-    )
-  })
-
-  it('exportVariable does not allow delimiter as value', () => {
-    const command = 'ENV'
-    createFileCommandFile(command)
-
-    expect(() => {
-      core.exportVariable('my var', `good stuff ${DELIMITER} bad stuff`)
-    }).toThrow(
-      `Unexpected input: value should not contain the delimiter "${DELIMITER}"`
-    )
-
-    const filePath = path.join(__dirname, `test/${command}`)
-    fs.unlinkSync(filePath)
-  })
-
-  it('exportVariable does not allow delimiter as name', () => {
-    const command = 'ENV'
-    createFileCommandFile(command)
-
-    expect(() => {
-      core.exportVariable(`good stuff ${DELIMITER} bad stuff`, 'test')
-    }).toThrow(
-      `Unexpected input: name should not contain the delimiter "${DELIMITER}"`
-    )
-
-    const filePath = path.join(__dirname, `test/${command}`)
-    fs.unlinkSync(filePath)
-  })
-
-  it('setSecret produces the correct command', () => {
-    core.setSecret('secret val')
-    core.setSecret('multi\nline\r\nsecret')
-    assertWriteCalls([
-      `::add-mask::secret val${os.EOL}`,
-      `::add-mask::multi%0Aline%0D%0Asecret${os.EOL}`
-    ])
-  })
-
-  it('prependPath produces the correct commands and sets the env', () => {
-    const command = 'PATH'
-    createFileCommandFile(command)
-    core.addPath('myPath')
-    expect(process.env['PATH']).toBe(
-      `myPath${path.delimiter}path1${path.delimiter}path2`
-    )
-    verifyFileCommand(command, `myPath${os.EOL}`)
-  })
-
-  it('legacy prependPath produces the correct commands and sets the env', () => {
-    core.addPath('myPath')
-    expect(process.env['PATH']).toBe(
-      `myPath${path.delimiter}path1${path.delimiter}path2`
-    )
-    assertWriteCalls([`::add-path::myPath${os.EOL}`])
-  })
-
-  it('getInput gets non-required input', () => {
-    expect(core.getInput('my input')).toBe('val')
-  })
-
-  it('getInput gets required input', () => {
-    expect(core.getInput('my input', {required: true})).toBe('val')
-  })
-
-  it('getInput throws on missing required input', () => {
-    expect(() => core.getInput('missing', {required: true})).toThrow(
-      'Input required and not supplied: missing'
-    )
-  })
-
-  it('getInput does not throw on missing non-required input', () => {
-    expect(core.getInput('missing', {required: false})).toBe('')
-  })
-
-  it('getInput is case insensitive', () => {
-    expect(core.getInput('My InPuT')).toBe('val')
-  })
-
-  it('getInput handles special characters', () => {
-    expect(core.getInput('special chars_\'\t"\\')).toBe('\'\t"\\ response')
-  })
-
-  it('getInput handles multiple spaces', () => {
-    expect(core.getInput('multiple spaces variable')).toBe(
-      'I have multiple spaces'
-    )
-  })
-
-  it('getInput trims whitespace by default', () => {
-    expect(core.getInput('with trailing whitespace')).toBe('some val')
-  })
-
-  it('getInput trims whitespace when option is explicitly true', () => {
-    expect(
-      core.getInput('with trailing whitespace', {trimWhitespace: true})
-    ).toBe('some val')
-  })
-
-  it('getInput does not trim whitespace when option is false', () => {
-    expect(
-      core.getInput('with trailing whitespace', {trimWhitespace: false})
-    ).toBe('  some val  ')
-  })
-
-  it('getInput gets non-required boolean input', () => {
-    expect(core.getBooleanInput('boolean input')).toBe(true)
-  })
-
-  it('getInput gets required input', () => {
-    expect(core.getBooleanInput('boolean input', {required: true})).toBe(true)
-  })
-
-  it('getBooleanInput handles boolean input', () => {
-    expect(core.getBooleanInput('boolean input true1')).toBe(true)
-    expect(core.getBooleanInput('boolean input true2')).toBe(true)
-    expect(core.getBooleanInput('boolean input true3')).toBe(true)
-    expect(core.getBooleanInput('boolean input false1')).toBe(false)
-    expect(core.getBooleanInput('boolean input false2')).toBe(false)
-    expect(core.getBooleanInput('boolean input false3')).toBe(false)
-  })
-
-  it('getBooleanInput handles wrong boolean input', () => {
-    expect(() => core.getBooleanInput('wrong boolean input')).toThrow(
-      'Input does not meet YAML 1.2 "Core Schema" specification: wrong boolean input\n' +
-        `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``
-    )
-  })
-
-  it('getMultilineInput works', () => {
-    expect(core.getMultilineInput('my input list')).toEqual([
-      'val1',
-      'val2',
-      'val3'
-    ])
-  })
-
-  it('getMultilineInput trims whitespace by default', () => {
-    expect(core.getMultilineInput('list with trailing whitespace')).toEqual([
-      'val1',
-      'val2'
-    ])
-  })
-
-  it('getMultilineInput trims whitespace when option is explicitly true', () => {
-    expect(
-      core.getMultilineInput('list with trailing whitespace', {
-        trimWhitespace: true
-      })
-    ).toEqual(['val1', 'val2'])
-  })
-
-  it('getMultilineInput does not trim whitespace when option is false', () => {
-    expect(
-      core.getMultilineInput('list with trailing whitespace', {
-        trimWhitespace: false
-      })
-    ).toEqual(['  val1  ', '  val2  ', '  '])
-  })
-
-  it('legacy setOutput produces the correct command', () => {
-    core.setOutput('some output', 'some value')
-    assertWriteCalls([
-      os.EOL,
-      `::set-output name=some output::some value${os.EOL}`
-    ])
-  })
-
-  it('legacy setOutput handles bools', () => {
-    core.setOutput('some output', false)
-    assertWriteCalls([os.EOL, `::set-output name=some output::false${os.EOL}`])
-  })
-
-  it('legacy setOutput handles numbers', () => {
-    core.setOutput('some output', 1.01)
-    assertWriteCalls([os.EOL, `::set-output name=some output::1.01${os.EOL}`])
-  })
-
-  it('setOutput produces the correct command and sets the output', () => {
-    const command = 'OUTPUT'
-    createFileCommandFile(command)
-    core.setOutput('my out', 'out val')
-    verifyFileCommand(
-      command,
-      `my out<<${DELIMITER}${os.EOL}out val${os.EOL}${DELIMITER}${os.EOL}`
-    )
-  })
-
-  it('setOutput handles boolean inputs', () => {
-    const command = 'OUTPUT'
-    createFileCommandFile(command)
-    core.setOutput('my out', true)
-    verifyFileCommand(
-      command,
-      `my out<<${DELIMITER}${os.EOL}true${os.EOL}${DELIMITER}${os.EOL}`
-    )
-  })
-
-  it('setOutput handles number inputs', () => {
-    const command = 'OUTPUT'
-    createFileCommandFile(command)
-    core.setOutput('my out', 5)
-    verifyFileCommand(
-      command,
-      `my out<<${DELIMITER}${os.EOL}5${os.EOL}${DELIMITER}${os.EOL}`
-    )
-  })
-
-  it('setOutput does not allow delimiter as value', () => {
-    const command = 'OUTPUT'
-    createFileCommandFile(command)
-
-    expect(() => {
-      core.setOutput('my out', `good stuff ${DELIMITER} bad stuff`)
-    }).toThrow(
-      `Unexpected input: value should not contain the delimiter "${DELIMITER}"`
-    )
-
-    const filePath = path.join(__dirname, `test/${command}`)
-    fs.unlinkSync(filePath)
-  })
-
-  it('setOutput does not allow delimiter as name', () => {
-    const command = 'OUTPUT'
-    createFileCommandFile(command)
-
-    expect(() => {
-      core.setOutput(`good stuff ${DELIMITER} bad stuff`, 'test')
-    }).toThrow(
-      `Unexpected input: name should not contain the delimiter "${DELIMITER}"`
-    )
-
-    const filePath = path.join(__dirname, `test/${command}`)
-    fs.unlinkSync(filePath)
-  })
-
-  it('setFailed sets the correct exit code and failure message', () => {
-    core.setFailed('Failure message')
-    expect(process.exitCode).toBe(core.ExitCode.Failure)
-    assertWriteCalls([`::error::Failure message${os.EOL}`])
-  })
-
-  it('setFailed escapes the failure message', () => {
-    core.setFailed('Failure \r\n\nmessage\r')
-    expect(process.exitCode).toBe(core.ExitCode.Failure)
-    assertWriteCalls([`::error::Failure %0D%0A%0Amessage%0D${os.EOL}`])
-  })
-
-  it('setFailed handles Error', () => {
-    const message = 'this is my error message'
-    core.setFailed(new Error(message))
-    expect(process.exitCode).toBe(core.ExitCode.Failure)
-    assertWriteCalls([`::error::Error: ${message}${os.EOL}`])
-  })
-
-  it('error sets the correct error message', () => {
-    core.error('Error message')
-    assertWriteCalls([`::error::Error message${os.EOL}`])
-  })
-
-  it('error escapes the error message', () => {
-    core.error('Error message\r\n\n')
-    assertWriteCalls([`::error::Error message%0D%0A%0A${os.EOL}`])
-  })
-
-  it('error handles an error object', () => {
-    const message = 'this is my error message'
-    core.error(new Error(message))
-    assertWriteCalls([`::error::Error: ${message}${os.EOL}`])
-  })
-
-  it('error handles parameters correctly', () => {
-    const message = 'this is my error message'
-    core.error(new Error(message), {
-      title: 'A title',
-      file: 'root/test.txt',
-      startColumn: 1,
-      endColumn: 2,
-      startLine: 5,
-      endLine: 5
-    })
-    assertWriteCalls([
-      `::error title=A title,file=root/test.txt,line=5,endLine=5,col=1,endColumn=2::Error: ${message}${os.EOL}`
-    ])
-  })
-
-  it('warning sets the correct message', () => {
-    core.warning('Warning')
-    assertWriteCalls([`::warning::Warning${os.EOL}`])
-  })
-
-  it('warning escapes the message', () => {
-    core.warning('\r\nwarning\n')
-    assertWriteCalls([`::warning::%0D%0Awarning%0A${os.EOL}`])
-  })
-
-  it('warning handles an error object', () => {
-    const message = 'this is my error message'
-    core.warning(new Error(message))
-    assertWriteCalls([`::warning::Error: ${message}${os.EOL}`])
-  })
-
-  it('warning handles parameters correctly', () => {
-    const message = 'this is my error message'
-    core.warning(new Error(message), {
-      title: 'A title',
-      file: 'root/test.txt',
-      startColumn: 1,
-      endColumn: 2,
-      startLine: 5,
-      endLine: 5
-    })
-    assertWriteCalls([
-      `::warning title=A title,file=root/test.txt,line=5,endLine=5,col=1,endColumn=2::Error: ${message}${os.EOL}`
-    ])
-  })
-
-  it('notice sets the correct message', () => {
-    core.notice('Notice')
-    assertWriteCalls([`::notice::Notice${os.EOL}`])
-  })
-
-  it('notice escapes the message', () => {
-    core.notice('\r\nnotice\n')
-    assertWriteCalls([`::notice::%0D%0Anotice%0A${os.EOL}`])
-  })
-
-  it('notice handles an error object', () => {
-    const message = 'this is my error message'
-    core.notice(new Error(message))
-    assertWriteCalls([`::notice::Error: ${message}${os.EOL}`])
-  })
-
-  it('notice handles parameters correctly', () => {
-    const message = 'this is my error message'
-    core.notice(new Error(message), {
-      title: 'A title',
-      file: 'root/test.txt',
-      startColumn: 1,
-      endColumn: 2,
-      startLine: 5,
-      endLine: 5
-    })
-    assertWriteCalls([
-      `::notice title=A title,file=root/test.txt,line=5,endLine=5,col=1,endColumn=2::Error: ${message}${os.EOL}`
-    ])
-  })
-
-  it('annotations map field names correctly', () => {
-    const commandProperties = toCommandProperties({
-      title: 'A title',
-      file: 'root/test.txt',
-      startColumn: 1,
-      endColumn: 2,
-      startLine: 5,
-      endLine: 5
-    })
-    expect(commandProperties.title).toBe('A title')
-    expect(commandProperties.file).toBe('root/test.txt')
-    expect(commandProperties.col).toBe(1)
-    expect(commandProperties.endColumn).toBe(2)
-    expect(commandProperties.line).toBe(5)
-    expect(commandProperties.endLine).toBe(5)
-
-    expect(commandProperties.startColumn).toBeUndefined()
-    expect(commandProperties.startLine).toBeUndefined()
-  })
-
-  it('startGroup starts a new group', () => {
-    core.startGroup('my-group')
-    assertWriteCalls([`::group::my-group${os.EOL}`])
-  })
-
-  it('endGroup ends new group', () => {
-    core.endGroup()
-    assertWriteCalls([`::endgroup::${os.EOL}`])
-  })
-
-  it('group wraps an async call in a group', async () => {
-    const result = await core.group('mygroup', async () => {
-      process.stdout.write('in my group\n')
-      return true
-    })
-    expect(result).toBe(true)
-    assertWriteCalls([
-      `::group::mygroup${os.EOL}`,
-      'in my group\n',
-      `::endgroup::${os.EOL}`
-    ])
-  })
-
-  it('debug sets the correct message', () => {
-    core.debug('Debug')
-    assertWriteCalls([`::debug::Debug${os.EOL}`])
-  })
-
-  it('debug escapes the message', () => {
-    core.debug('\r\ndebug\n')
-    assertWriteCalls([`::debug::%0D%0Adebug%0A${os.EOL}`])
-  })
-
-  it('legacy saveState produces the correct command', () => {
-    core.saveState('state_1', 'some value')
-    assertWriteCalls([`::save-state name=state_1::some value${os.EOL}`])
-  })
-
-  it('legacy saveState handles numbers', () => {
-    core.saveState('state_1', 1)
-    assertWriteCalls([`::save-state name=state_1::1${os.EOL}`])
-  })
-
-  it('legacy saveState handles bools', () => {
-    core.saveState('state_1', true)
-    assertWriteCalls([`::save-state name=state_1::true${os.EOL}`])
-  })
-
-  it('saveState produces the correct command and saves the state', () => {
-    const command = 'STATE'
-    createFileCommandFile(command)
-    core.saveState('my state', 'out val')
-    verifyFileCommand(
-      command,
-      `my state<<${DELIMITER}${os.EOL}out val${os.EOL}${DELIMITER}${os.EOL}`
-    )
-  })
-
-  it('saveState handles boolean inputs', () => {
-    const command = 'STATE'
-    createFileCommandFile(command)
-    core.saveState('my state', true)
-    verifyFileCommand(
-      command,
-      `my state<<${DELIMITER}${os.EOL}true${os.EOL}${DELIMITER}${os.EOL}`
-    )
-  })
-
-  it('saveState handles number inputs', () => {
-    const command = 'STATE'
-    createFileCommandFile(command)
-    core.saveState('my state', 5)
-    verifyFileCommand(
-      command,
-      `my state<<${DELIMITER}${os.EOL}5${os.EOL}${DELIMITER}${os.EOL}`
-    )
-  })
-
-  it('saveState does not allow delimiter as value', () => {
-    const command = 'STATE'
-    createFileCommandFile(command)
-
-    expect(() => {
-      core.saveState('my state', `good stuff ${DELIMITER} bad stuff`)
-    }).toThrow(
-      `Unexpected input: value should not contain the delimiter "${DELIMITER}"`
-    )
-
-    const filePath = path.join(__dirname, `test/${command}`)
-    fs.unlinkSync(filePath)
-  })
-
-  it('saveState does not allow delimiter as name', () => {
-    const command = 'STATE'
-    createFileCommandFile(command)
-
-    expect(() => {
-      core.saveState(`good stuff ${DELIMITER} bad stuff`, 'test')
-    }).toThrow(
-      `Unexpected input: name should not contain the delimiter "${DELIMITER}"`
-    )
-
-    const filePath = path.join(__dirname, `test/${command}`)
-    fs.unlinkSync(filePath)
-  })
-
-  it('getState gets wrapper action state', () => {
-    expect(core.getState('TEST_1')).toBe('state_val')
-  })
-
-  it('isDebug check debug state', () => {
-    const current = process.env['RUNNER_DEBUG']
-    try {
-      delete process.env.RUNNER_DEBUG
-      expect(core.isDebug()).toBe(false)
-
-      process.env['RUNNER_DEBUG'] = '1'
-      expect(core.isDebug()).toBe(true)
-    } finally {
-      process.env['RUNNER_DEBUG'] = current
-    }
-  })
-
-  it('setCommandEcho can enable echoing', () => {
-    core.setCommandEcho(true)
-    assertWriteCalls([`::echo::on${os.EOL}`])
-  })
-
-  it('setCommandEcho can disable echoing', () => {
-    core.setCommandEcho(false)
-    assertWriteCalls([`::echo::off${os.EOL}`])
-  })
-})
-
-// Assert that process.stdout.write calls called only with the given arguments.
-function assertWriteCalls(calls: string[]): void {
-  expect(process.stdout.write).toHaveBeenCalledTimes(calls.length)
-
-  for (let i = 0; i < calls.length; i++) {
-    expect(process.stdout.write).toHaveBeenNthCalledWith(i + 1, calls[i])
-  }
-}
-
-function createFileCommandFile(command: string): void {
-  const filePath = path.join(__dirname, `test/${command}`)
-  process.env[`GITHUB_${command}`] = filePath
-  fs.appendFileSync(filePath, '', {
-    encoding: 'utf8'
-  })
-}
-
-function verifyFileCommand(command: string, expectedContents: string): void {
-  const filePath = path.join(__dirname, `test/${command}`)
-  const contents = fs.readFileSync(filePath, 'utf8')
-  try {
-    expect(contents).toEqual(expectedContents)
-  } finally {
-    fs.unlinkSync(filePath)
-  }
-}
-
-function getTokenEndPoint(): string {
-  return 'https://vstoken.actions.githubusercontent.com/.well-known/openid-configuration'
-}
-
-describe('oidc-client-tests', () => {
-  it('Get Http Client', async () => {
-    const http = new HttpClient('actions/oidc-client')
-    expect(http).toBeDefined()
-  })
-
-  it('HTTP get request to get token endpoint', async () => {
-    const http = new HttpClient('actions/oidc-client')
-    const res = await http.get(getTokenEndPoint())
-    expect(res.message.statusCode).toBe(200)
-  })
-})

packages/core/__tests__/lib.test.ts

@@ -0,0 +1,189 @@
+import * as os from 'os'
+import * as path from 'path'
+import * as core from '../src/core'
+
+/* eslint-disable @typescript-eslint/unbound-method */
+
+const testEnvVars = {
+  'my var': '',
+  'special char var \r\n];': '',
+  'my var2': '',
+  'my secret': '',
+  'special char secret \r\n];': '',
+  'my secret2': '',
+  PATH: `path1${path.delimiter}path2`,
+
+  // Set inputs
+  INPUT_MY_INPUT: 'val',
+  INPUT_MISSING: '',
+  'INPUT_SPECIAL_CHARS_\'\t"\\': '\'\t"\\ response ',
+  INPUT_MULTIPLE_SPACES_VARIABLE: 'I have multiple spaces',
+
+  // Save inputs
+  STATE_TEST_1: 'state_val'
+}
+
+describe('@actions/core', () => {
+  beforeEach(() => {
+    for (const key in testEnvVars)
+      process.env[key] = testEnvVars[key as keyof typeof testEnvVars]
+
+    process.stdout.write = jest.fn()
+  })
+
+  afterEach(() => {
+    for (const key in testEnvVars) Reflect.deleteProperty(testEnvVars, key)
+  })
+
+  it('exportVariable produces the correct command and sets the env', () => {
+    core.exportVariable('my var', 'var val')
+    assertWriteCalls([`::set-env name=my var,::var val${os.EOL}`])
+  })
+
+  it('exportVariable escapes variable names', () => {
+    core.exportVariable('special char var \r\n];', 'special val')
+    expect(process.env['special char var \r\n];']).toBe('special val')
+    assertWriteCalls([
+      `::set-env name=special char var %0D%0A%5D%3B,::special val${os.EOL}`
+    ])
+  })
+
+  it('exportVariable escapes variable values', () => {
+    core.exportVariable('my var2', 'var val\r\n')
+    expect(process.env['my var2']).toBe('var val\r\n')
+    assertWriteCalls([`::set-env name=my var2,::var val%0D%0A${os.EOL}`])
+  })
+
+  it('setSecret produces the correct command', () => {
+    core.setSecret('secret val')
+    assertWriteCalls([`::add-mask::secret val${os.EOL}`])
+  })
+
+  it('prependPath produces the correct commands and sets the env', () => {
+    core.addPath('myPath')
+    expect(process.env['PATH']).toBe(
+      `myPath${path.delimiter}path1${path.delimiter}path2`
+    )
+    assertWriteCalls([`::add-path::myPath${os.EOL}`])
+  })
+
+  it('getInput gets non-required input', () => {
+    expect(core.getInput('my input')).toBe('val')
+  })
+
+  it('getInput gets required input', () => {
+    expect(core.getInput('my input', {required: true})).toBe('val')
+  })
+
+  it('getInput throws on missing required input', () => {
+    expect(() => core.getInput('missing', {required: true})).toThrow(
+      'Input required and not supplied: missing'
+    )
+  })
+
+  it('getInput does not throw on missing non-required input', () => {
+    expect(core.getInput('missing', {required: false})).toBe('')
+  })
+
+  it('getInput is case insensitive', () => {
+    expect(core.getInput('My InPuT')).toBe('val')
+  })
+
+  it('getInput handles special characters', () => {
+    expect(core.getInput('special chars_\'\t"\\')).toBe('\'\t"\\ response')
+  })
+
+  it('getInput handles multiple spaces', () => {
+    expect(core.getInput('multiple spaces variable')).toBe(
+      'I have multiple spaces'
+    )
+  })
+
+  it('setOutput produces the correct command', () => {
+    core.setOutput('some output', 'some value')
+    assertWriteCalls([`::set-output name=some output,::some value${os.EOL}`])
+  })
+
+  it('setFailure sets the correct exit code and failure message', () => {
+    core.setFailed('Failure message')
+    expect(process.exitCode).toBe(core.ExitCode.Failure)
+    assertWriteCalls([`::error::Failure message${os.EOL}`])
+  })
+
+  it('setFailure escapes the failure message', () => {
+    core.setFailed('Failure \r\n\nmessage\r')
+    expect(process.exitCode).toBe(core.ExitCode.Failure)
+    assertWriteCalls([`::error::Failure %0D%0A%0Amessage%0D${os.EOL}`])
+  })
+
+  it('error sets the correct error message', () => {
+    core.error('Error message')
+    assertWriteCalls([`::error::Error message${os.EOL}`])
+  })
+
+  it('error escapes the error message', () => {
+    core.error('Error message\r\n\n')
+    assertWriteCalls([`::error::Error message%0D%0A%0A${os.EOL}`])
+  })
+
+  it('warning sets the correct message', () => {
+    core.warning('Warning')
+    assertWriteCalls([`::warning::Warning${os.EOL}`])
+  })
+
+  it('warning escapes the message', () => {
+    core.warning('\r\nwarning\n')
+    assertWriteCalls([`::warning::%0D%0Awarning%0A${os.EOL}`])
+  })
+
+  it('startGroup starts a new group', () => {
+    core.startGroup('my-group')
+    assertWriteCalls([`::group::my-group${os.EOL}`])
+  })
+
+  it('endGroup ends new group', () => {
+    core.endGroup()
+    assertWriteCalls([`::endgroup::${os.EOL}`])
+  })
+
+  it('group wraps an async call in a group', async () => {
+    const result = await core.group('mygroup', async () => {
+      process.stdout.write('in my group\n')
+      return true
+    })
+    expect(result).toBe(true)
+    assertWriteCalls([
+      `::group::mygroup${os.EOL}`,
+      'in my group\n',
+      `::endgroup::${os.EOL}`
+    ])
+  })
+
+  it('debug sets the correct message', () => {
+    core.debug('Debug')
+    assertWriteCalls([`::debug::Debug${os.EOL}`])
+  })
+
+  it('debug escapes the message', () => {
+    core.debug('\r\ndebug\n')
+    assertWriteCalls([`::debug::%0D%0Adebug%0A${os.EOL}`])
+  })
+
+  it('saveState produces the correct command', () => {
+    core.saveState('state_1', 'some value')
+    assertWriteCalls([`::save-state name=state_1,::some value${os.EOL}`])
+  })
+
+  it('getState gets wrapper action state', () => {
+    expect(core.getState('TEST_1')).toBe('state_val')
+  })
+})
+
+// Assert that process.stdout.write calls called only with the given arguments.
+function assertWriteCalls(calls: string[]): void {
+  expect(process.stdout.write).toHaveBeenCalledTimes(calls.length)
+
+  for (let i = 0; i < calls.length; i++) {
+    expect(process.stdout.write).toHaveBeenNthCalledWith(i + 1, calls[i])
+  }
+}

packages/core/__tests__/path-utils.test.ts

@@ -1,162 +0,0 @@
-import * as path from 'path'
-
-import {toPlatformPath, toPosixPath, toWin32Path} from '../src/path-utils'
-
-describe('#toPosixPath', () => {
-  const cases: {
-    only?: boolean
-    name: string
-    input: string
-    expected: string
-  }[] = [
-    {
-      name: 'empty string',
-      input: '',
-      expected: ''
-    },
-    {
-      name: 'single value',
-      input: 'foo',
-      expected: 'foo'
-    },
-    {
-      name: 'with posix relative',
-      input: 'foo/bar/baz',
-      expected: 'foo/bar/baz'
-    },
-    {
-      name: 'with posix absolute',
-      input: '/foo/bar/baz',
-      expected: '/foo/bar/baz'
-    },
-    {
-      name: 'with win32 relative',
-      input: 'foo\\bar\\baz',
-      expected: 'foo/bar/baz'
-    },
-    {
-      name: 'with win32 absolute',
-      input: '\\foo\\bar\\baz',
-      expected: '/foo/bar/baz'
-    },
-    {
-      name: 'with a mix',
-      input: '\\foo/bar/baz',
-      expected: '/foo/bar/baz'
-    }
-  ]
-
-  for (const tc of cases) {
-    const fn = tc.only ? it.only : it
-    fn(tc.name, () => {
-      const result = toPosixPath(tc.input)
-      expect(result).toEqual(tc.expected)
-    })
-  }
-})
-
-describe('#toWin32Path', () => {
-  const cases: {
-    only?: boolean
-    name: string
-    input: string
-    expected: string
-  }[] = [
-    {
-      name: 'empty string',
-      input: '',
-      expected: ''
-    },
-    {
-      name: 'single value',
-      input: 'foo',
-      expected: 'foo'
-    },
-    {
-      name: 'with posix relative',
-      input: 'foo/bar/baz',
-      expected: 'foo\\bar\\baz'
-    },
-    {
-      name: 'with posix absolute',
-      input: '/foo/bar/baz',
-      expected: '\\foo\\bar\\baz'
-    },
-    {
-      name: 'with win32 relative',
-      input: 'foo\\bar\\baz',
-      expected: 'foo\\bar\\baz'
-    },
-    {
-      name: 'with win32 absolute',
-      input: '\\foo\\bar\\baz',
-      expected: '\\foo\\bar\\baz'
-    },
-    {
-      name: 'with a mix',
-      input: '\\foo/bar\\baz',
-      expected: '\\foo\\bar\\baz'
-    }
-  ]
-
-  for (const tc of cases) {
-    const fn = tc.only ? it.only : it
-    fn(tc.name, () => {
-      const result = toWin32Path(tc.input)
-      expect(result).toEqual(tc.expected)
-    })
-  }
-})
-
-describe('#toPlatformPath', () => {
-  const cases: {
-    only?: boolean
-    name: string
-    input: string
-    expected: string
-  }[] = [
-    {
-      name: 'empty string',
-      input: '',
-      expected: ''
-    },
-    {
-      name: 'single value',
-      input: 'foo',
-      expected: 'foo'
-    },
-    {
-      name: 'with posix relative',
-      input: 'foo/bar/baz',
-      expected: path.join('foo', 'bar', 'baz')
-    },
-    {
-      name: 'with posix absolute',
-      input: '/foo/bar/baz',
-      expected: path.join(path.sep, 'foo', 'bar', 'baz')
-    },
-    {
-      name: 'with win32 relative',
-      input: 'foo\\bar\\baz',
-      expected: path.join('foo', 'bar', 'baz')
-    },
-    {
-      name: 'with win32 absolute',
-      input: '\\foo\\bar\\baz',
-      expected: path.join(path.sep, 'foo', 'bar', 'baz')
-    },
-    {
-      name: 'with a mix',
-      input: '\\foo/bar\\baz',
-      expected: path.join(path.sep, 'foo', 'bar', 'baz')
-    }
-  ]
-
-  for (const tc of cases) {
-    const fn = tc.only ? it.only : it
-    fn(tc.name, () => {
-      const result = toPlatformPath(tc.input)
-      expect(result).toEqual(tc.expected)
-    })
-  }
-})

packages/core/__tests__/summary.test.ts

@@ -1,275 +0,0 @@
-import * as fs from 'fs'
-import * as os from 'os'
-import path from 'path'
-import {summary, SUMMARY_ENV_VAR} from '../src/summary'
-
-const testDirectoryPath = path.join(__dirname, 'test')
-const testFilePath = path.join(testDirectoryPath, 'test-summary.md')
-
-async function assertSummary(expected: string): Promise<void> {
-  const file = await fs.promises.readFile(testFilePath, {encoding: 'utf8'})
-  expect(file).toEqual(expected)
-}
-
-const fixtures = {
-  text: 'hello world 🌎',
-  code: `func fork() {
-  for {
-    go fork()
-  }
-}`,
-  list: ['foo', 'bar', 'baz', '💣'],
-  table: [
-    [
-      {
-        data: 'foo',
-        header: true
-      },
-      {
-        data: 'bar',
-        header: true
-      },
-      {
-        data: 'baz',
-        header: true
-      },
-      {
-        data: 'tall',
-        rowspan: '3'
-      }
-    ],
-    ['one', 'two', 'three'],
-    [
-      {
-        data: 'wide',
-        colspan: '3'
-      }
-    ]
-  ],
-  details: {
-    label: 'open me',
-    content: '🎉 surprise'
-  },
-  img: {
-    src: 'https://github.com/actions.png',
-    alt: 'actions logo',
-    options: {
-      width: '32',
-      height: '32'
-    }
-  },
-  quote: {
-    text: 'Where the world builds software',
-    cite: 'https://github.com/about'
-  },
-  link: {
-    text: 'GitHub',
-    href: 'https://github.com/'
-  }
-}
-
-describe('@actions/core/src/summary', () => {
-  beforeEach(async () => {
-    process.env[SUMMARY_ENV_VAR] = testFilePath
-    await fs.promises.mkdir(testDirectoryPath, {recursive: true})
-    await fs.promises.writeFile(testFilePath, '', {encoding: 'utf8'})
-    summary.emptyBuffer()
-  })
-
-  afterAll(async () => {
-    await fs.promises.unlink(testFilePath)
-  })
-
-  it('throws if summary env var is undefined', async () => {
-    process.env[SUMMARY_ENV_VAR] = undefined
-    const write = summary.addRaw(fixtures.text).write()
-
-    await expect(write).rejects.toThrow()
-  })
-
-  it('throws if summary file does not exist', async () => {
-    await fs.promises.unlink(testFilePath)
-    const write = summary.addRaw(fixtures.text).write()
-
-    await expect(write).rejects.toThrow()
-  })
-
-  it('appends text to summary file', async () => {
-    await fs.promises.writeFile(testFilePath, '# ', {encoding: 'utf8'})
-    await summary.addRaw(fixtures.text).write()
-    await assertSummary(`# ${fixtures.text}`)
-  })
-
-  it('overwrites text to summary file', async () => {
-    await fs.promises.writeFile(testFilePath, 'overwrite', {encoding: 'utf8'})
-    await summary.addRaw(fixtures.text).write({overwrite: true})
-    await assertSummary(fixtures.text)
-  })
-
-  it('appends text with EOL to summary file', async () => {
-    await fs.promises.writeFile(testFilePath, '# ', {encoding: 'utf8'})
-    await summary.addRaw(fixtures.text, true).write()
-    await assertSummary(`# ${fixtures.text}${os.EOL}`)
-  })
-
-  it('chains appends text to summary file', async () => {
-    await fs.promises.writeFile(testFilePath, '', {encoding: 'utf8'})
-    await summary
-      .addRaw(fixtures.text)
-      .addRaw(fixtures.text)
-      .addRaw(fixtures.text)
-      .write()
-    await assertSummary([fixtures.text, fixtures.text, fixtures.text].join(''))
-  })
-
-  it('empties buffer after write', async () => {
-    await fs.promises.writeFile(testFilePath, '', {encoding: 'utf8'})
-    await summary.addRaw(fixtures.text).write()
-    await assertSummary(fixtures.text)
-    expect(summary.isEmptyBuffer()).toBe(true)
-  })
-
-  it('returns summary buffer as string', () => {
-    summary.addRaw(fixtures.text)
-    expect(summary.stringify()).toEqual(fixtures.text)
-  })
-
-  it('return correct values for isEmptyBuffer', () => {
-    summary.addRaw(fixtures.text)
-    expect(summary.isEmptyBuffer()).toBe(false)
-
-    summary.emptyBuffer()
-    expect(summary.isEmptyBuffer()).toBe(true)
-  })
-
-  it('clears a buffer and summary file', async () => {
-    await fs.promises.writeFile(testFilePath, 'content', {encoding: 'utf8'})
-    await summary.clear()
-    await assertSummary('')
-    expect(summary.isEmptyBuffer()).toBe(true)
-  })
-
-  it('adds EOL', async () => {
-    await summary
-      .addRaw(fixtures.text)
-      .addEOL()
-      .write()
-    await assertSummary(fixtures.text + os.EOL)
-  })
-
-  it('adds a code block without language', async () => {
-    await summary.addCodeBlock(fixtures.code).write()
-    const expected = `<pre><code>func fork() {\n  for {\n    go fork()\n  }\n}</code></pre>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds a code block with a language', async () => {
-    await summary.addCodeBlock(fixtures.code, 'go').write()
-    const expected = `<pre lang="go"><code>func fork() {\n  for {\n    go fork()\n  }\n}</code></pre>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds an unordered list', async () => {
-    await summary.addList(fixtures.list).write()
-    const expected = `<ul><li>foo</li><li>bar</li><li>baz</li><li>💣</li></ul>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds an ordered list', async () => {
-    await summary.addList(fixtures.list, true).write()
-    const expected = `<ol><li>foo</li><li>bar</li><li>baz</li><li>💣</li></ol>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds a table', async () => {
-    await summary.addTable(fixtures.table).write()
-    const expected = `<table><tr><th>foo</th><th>bar</th><th>baz</th><td rowspan="3">tall</td></tr><tr><td>one</td><td>two</td><td>three</td></tr><tr><td colspan="3">wide</td></tr></table>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds a details element', async () => {
-    await summary
-      .addDetails(fixtures.details.label, fixtures.details.content)
-      .write()
-    const expected = `<details><summary>open me</summary>🎉 surprise</details>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds an image with alt text', async () => {
-    await summary.addImage(fixtures.img.src, fixtures.img.alt).write()
-    const expected = `<img src="https://github.com/actions.png" alt="actions logo">${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds an image with custom dimensions', async () => {
-    await summary
-      .addImage(fixtures.img.src, fixtures.img.alt, fixtures.img.options)
-      .write()
-    const expected = `<img src="https://github.com/actions.png" alt="actions logo" width="32" height="32">${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds an image with custom dimensions', async () => {
-    await summary
-      .addImage(fixtures.img.src, fixtures.img.alt, fixtures.img.options)
-      .write()
-    const expected = `<img src="https://github.com/actions.png" alt="actions logo" width="32" height="32">${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds headings h1...h6', async () => {
-    for (const i of [1, 2, 3, 4, 5, 6]) {
-      summary.addHeading('heading', i)
-    }
-    await summary.write()
-    const expected = `<h1>heading</h1>${os.EOL}<h2>heading</h2>${os.EOL}<h3>heading</h3>${os.EOL}<h4>heading</h4>${os.EOL}<h5>heading</h5>${os.EOL}<h6>heading</h6>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds h1 if heading level not specified', async () => {
-    await summary.addHeading('heading').write()
-    const expected = `<h1>heading</h1>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('uses h1 if heading level is garbage or out of range', async () => {
-    await summary
-      .addHeading('heading', 'foobar')
-      .addHeading('heading', 1337)
-      .addHeading('heading', -1)
-      .addHeading('heading', Infinity)
-      .write()
-    const expected = `<h1>heading</h1>${os.EOL}<h1>heading</h1>${os.EOL}<h1>heading</h1>${os.EOL}<h1>heading</h1>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds a separator', async () => {
-    await summary.addSeparator().write()
-    const expected = `<hr>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds a break', async () => {
-    await summary.addBreak().write()
-    const expected = `<br>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds a quote', async () => {
-    await summary.addQuote(fixtures.quote.text).write()
-    const expected = `<blockquote>Where the world builds software</blockquote>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds a quote with citation', async () => {
-    await summary.addQuote(fixtures.quote.text, fixtures.quote.cite).write()
-    const expected = `<blockquote cite="https://github.com/about">Where the world builds software</blockquote>${os.EOL}`
-    await assertSummary(expected)
-  })
-
-  it('adds a link with href', async () => {
-    await summary.addLink(fixtures.link.text, fixtures.link.href).write()
-    const expected = `<a href="https://github.com/">GitHub</a>${os.EOL}`
-    await assertSummary(expected)
-  })
-})

packages/core/package-lock.json

@@ -1,89 +1,14 @@
 {
   "name": "@actions/core",
-  "version": "1.10.0",
-  "lockfileVersion": 2,
+  "version": "1.2.0",
+  "lockfileVersion": 1,
   "requires": true,
-  "packages": {
-    "": {
-      "name": "@actions/core",
-      "version": "1.10.0",
-      "license": "MIT",
-      "dependencies": {
-        "@actions/http-client": "^2.0.1",
-        "uuid": "^8.3.2"
-      },
-      "devDependencies": {
-        "@types/node": "^12.0.2",
-        "@types/uuid": "^8.3.4"
-      }
-    },
-    "node_modules/@actions/http-client": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.0.1.tgz",
-      "integrity": "sha512-PIXiMVtz6VvyaRsGY268qvj57hXQEpsYogYOu2nrQhlf+XCGmZstmuZBbAybUl1nQGnvS1k1eEsQ69ZoD7xlSw==",
-      "dependencies": {
-        "tunnel": "^0.0.6"
-      }
-    },
-    "node_modules/@types/node": {
-      "version": "12.0.2",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-12.0.2.tgz",
-      "integrity": "sha512-5tabW/i+9mhrfEOUcLDu2xBPsHJ+X5Orqy9FKpale3SjDA17j5AEpYq5vfy3oAeAHGcvANRCO3NV3d2D6q3NiA==",
-      "dev": true
-    },
-    "node_modules/@types/uuid": {
-      "version": "8.3.4",
-      "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-8.3.4.tgz",
-      "integrity": "sha512-c/I8ZRb51j+pYGAu5CrFMRxqZ2ke4y2grEBO5AUjgSkSk+qT2Ea+OdWElz/OiMf5MNpn2b17kuVBwZLQJXzihw==",
-      "dev": true
-    },
-    "node_modules/tunnel": {
-      "version": "0.0.6",
-      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz",
-      "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==",
-      "engines": {
-        "node": ">=0.6.11 <=0.7.0 || >=0.7.3"
-      }
-    },
-    "node_modules/uuid": {
-      "version": "8.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
-      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
-      "bin": {
-        "uuid": "dist/bin/uuid"
-      }
-    }
-  },
   "dependencies": {
-    "@actions/http-client": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.0.1.tgz",
-      "integrity": "sha512-PIXiMVtz6VvyaRsGY268qvj57hXQEpsYogYOu2nrQhlf+XCGmZstmuZBbAybUl1nQGnvS1k1eEsQ69ZoD7xlSw==",
-      "requires": {
-        "tunnel": "^0.0.6"
-      }
-    },
     "@types/node": {
       "version": "12.0.2",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-12.0.2.tgz",
       "integrity": "sha512-5tabW/i+9mhrfEOUcLDu2xBPsHJ+X5Orqy9FKpale3SjDA17j5AEpYq5vfy3oAeAHGcvANRCO3NV3d2D6q3NiA==",
       "dev": true
-    },
-    "@types/uuid": {
-      "version": "8.3.4",
-      "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-8.3.4.tgz",
-      "integrity": "sha512-c/I8ZRb51j+pYGAu5CrFMRxqZ2ke4y2grEBO5AUjgSkSk+qT2Ea+OdWElz/OiMf5MNpn2b17kuVBwZLQJXzihw==",
-      "dev": true
-    },
-    "tunnel": {
-      "version": "0.0.6",
-      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz",
-      "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg=="
-    },
-    "uuid": {
-      "version": "8.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
-      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="
     }
   }
 }

packages/core/package.json

@@ -1,23 +1,21 @@
 {
   "name": "@actions/core",
-  "version": "1.10.0",
+  "version": "1.2.0",
   "description": "Actions core lib",
   "keywords": [
     "github",
     "actions",
     "core"
   ],
-  "homepage": "https://github.com/actions/toolkit/tree/main/packages/core",
+  "homepage": "https://github.com/actions/toolkit/tree/master/packages/core",
   "license": "MIT",
   "main": "lib/core.js",
-  "types": "lib/core.d.ts",
   "directories": {
     "lib": "lib",
     "test": "__tests__"
   },
   "files": [
-    "lib",
-    "!.DS_Store"
+    "lib"
   ],
   "publishConfig": {
     "access": "public"
@@ -28,19 +26,13 @@
     "directory": "packages/core"
   },
   "scripts": {
-    "audit-moderate": "npm install && npm audit --json --audit-level=moderate > audit.json",
     "test": "echo \"Error: run tests from root\" && exit 1",
     "tsc": "tsc"
   },
   "bugs": {
     "url": "https://github.com/actions/toolkit/issues"
   },
-  "dependencies": {
-    "@actions/http-client": "^2.0.1",
-    "uuid": "^8.3.2"
-  },
   "devDependencies": {
-    "@types/node": "^12.0.2",
-    "@types/uuid": "^8.3.4"
+    "@types/node": "^12.0.2"
   }
 }

packages/core/src/command.ts

@@ -1,35 +1,31 @@
 import * as os from 'os'
-import {toCommandValue} from './utils'
 
 // For internal use, subject to change.
 
-// We use any as a valid input type
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-export interface CommandProperties {
-  [key: string]: any
+interface CommandProperties {
+  [key: string]: string
 }
 
 /**
  * Commands
  *
  * Command Format:
- *   ::name key=value,key=value::message
+ *   ##[name key=value;key=value]message
  *
  * Examples:
- *   ::warning::This is the message
- *   ::set-env name=MY_VAR::some value
+ *   ##[warning]This is the user warning message
+ *   ##[set-secret name=mypassword]definitelyNotAPassword!
  */
 export function issueCommand(
   command: string,
   properties: CommandProperties,
-  message: any
+  message: string
 ): void {
   const cmd = new Command(command, properties, message)
   process.stdout.write(cmd.toString() + os.EOL)
 }
 
-export function issue(name: string, message = ''): void {
+export function issue(name: string, message: string = ''): void {
   issueCommand(name, {}, message)
 }
 
@@ -55,40 +51,37 @@ class Command {
 
     if (this.properties && Object.keys(this.properties).length > 0) {
       cmdStr += ' '
-      let first = true
       for (const key in this.properties) {
         if (this.properties.hasOwnProperty(key)) {
           const val = this.properties[key]
           if (val) {
-            if (first) {
-              first = false
-            } else {
-              cmdStr += ','
-            }
-
-            cmdStr += `${key}=${escapeProperty(val)}`
+            // safely append the val - avoid blowing up when attempting to
+            // call .replace() if message is not a string for some reason
+            cmdStr += `${key}=${escape(`${val || ''}`)},`
           }
         }
       }
     }
 
-    cmdStr += `${CMD_STRING}${escapeData(this.message)}`
+    cmdStr += CMD_STRING
+
+    // safely append the message - avoid blowing up when attempting to
+    // call .replace() if message is not a string for some reason
+    const message = `${this.message || ''}`
+    cmdStr += escapeData(message)
+
     return cmdStr
   }
 }
 
-function escapeData(s: any): string {
-  return toCommandValue(s)
-    .replace(/%/g, '%25')
-    .replace(/\r/g, '%0D')
-    .replace(/\n/g, '%0A')
+function escapeData(s: string): string {
+  return s.replace(/\r/g, '%0D').replace(/\n/g, '%0A')
 }
 
-function escapeProperty(s: any): string {
-  return toCommandValue(s)
-    .replace(/%/g, '%25')
+function escape(s: string): string {
+  return s
     .replace(/\r/g, '%0D')
     .replace(/\n/g, '%0A')
-    .replace(/:/g, '%3A')
-    .replace(/,/g, '%2C')
+    .replace(/]/g, '%5D')
+    .replace(/;/g, '%3B')
 }