Merge pull request #4216 from github/backport-v3.38.3-24c54180a

Merge releases/v4 into releases/v3

.github/actions/check-codescanning-config/action.yml

@@ -54,15 +54,16 @@ runs:
       env:
         CODEQL_ACTION_TEST_MODE: 'true'
 
+    - name: Install dependencies
+      shell: bash
+      run: npm install --location=global ts-node js-yaml
+
     - name: Check config
+      working-directory: ${{ github.action_path }}
       shell: bash
       env:
         EXPECTED_CONFIG_FILE_CONTENTS: '${{ inputs.expected-config-file-contents }}'
-      run: |
-        npx tsx ../action/pr-checks/check-cs-config.ts \
-          --file "$RUNNER_TEMP/user-config.yaml" \
-          --expected-contents "$EXPECTED_CONFIG_FILE_CONTENTS"
-
+      run: ts-node ./index.ts "$RUNNER_TEMP/user-config.yaml" "$EXPECTED_CONFIG_FILE_CONTENTS"
     - name: Clean up
       shell: bash
       if: always()

.github/actions/check-codescanning-config/index.ts

@@ -0,0 +1,49 @@
+
+import * as core from '@actions/core'
+import * as yaml from 'js-yaml'
+import * as fs from 'fs'
+import * as assert from 'assert'
+
+const actualConfig = loadActualConfig()
+
+function sortConfigArrays(config) {
+  for (const key of Object.keys(config)) {
+    const value = config[key];
+    if (key === 'queries' && Array.isArray(value)) {
+      config[key] = value.sort();
+    }
+  }
+  return config;
+}
+
+const rawExpectedConfig = process.argv[3].trim()
+if (!rawExpectedConfig) {
+  core.setFailed('No expected configuration provided')
+} else {
+  core.startGroup('Expected generated user config')
+  core.info(yaml.dump(JSON.parse(rawExpectedConfig)))
+  core.endGroup()
+}
+
+const expectedConfig = rawExpectedConfig ? JSON.parse(rawExpectedConfig) : undefined;
+
+assert.deepStrictEqual(
+  sortConfigArrays(actualConfig),
+  sortConfigArrays(expectedConfig),
+  'Expected configuration does not match actual configuration'
+);
+
+
+function loadActualConfig() {
+  if (!fs.existsSync(process.argv[2])) {
+    core.info('No configuration file found')
+    return undefined
+  } else {
+    const rawActualConfig = fs.readFileSync(process.argv[2], 'utf8')
+    core.startGroup('Actual generated user config')
+    core.info(rawActualConfig)
+    core.endGroup()
+
+    return yaml.load(rawActualConfig)
+  }
+}

.github/actions/check-sarif/action.yml

@@ -16,23 +16,5 @@ inputs:
       Comma separated list of query ids that should NOT be included in this SARIF file.
 
 runs:
-  using: "composite"
-  steps:
-    - name: Run `check-sarif.ts`
-      shell: bash
-      env:
-        SARIF_FILE: ${{ inputs.sarif-file }}
-        QUERIES_RUN: ${{ inputs.queries-run }}
-        QUERIES_NOT_RUN: ${{ inputs.queries-not-run }}
-      run: |
-        if [[ -d pr-checks ]]; then
-          npx tsx ./pr-checks/check-sarif.ts \
-            --sarif-file "$SARIF_FILE" \
-            --queries-run "$QUERIES_RUN" \
-            --queries-not-run "$QUERIES_NOT_RUN"
-        else
-          npx tsx ../action/pr-checks/check-sarif.ts \
-            --sarif-file "$SARIF_FILE" \
-            --queries-run "$QUERIES_RUN" \
-            --queries-not-run "$QUERIES_NOT_RUN"
-        fi
+  using: node20
+  main: index.js

.github/actions/check-sarif/index.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const core = require('@actions/core')
+const fs = require('fs')
+
+const sarif = JSON.parse(fs.readFileSync(core.getInput('sarif-file'), 'utf8'))
+const rules = sarif.runs[0].tool.extensions.flatMap(ext => ext.rules || [])
+const ruleIds = rules.map(rule => rule.id)
+
+// Check that all the expected queries ran
+const expectedQueriesRun = getQueryIdsInput('queries-run')
+const queriesThatShouldHaveRunButDidNot = expectedQueriesRun.filter(queryId => !ruleIds.includes(queryId))
+
+if (queriesThatShouldHaveRunButDidNot.length > 0) {
+  core.setFailed(`The following queries were expected to run but did not: ${queriesThatShouldHaveRunButDidNot.join(', ')}`)
+}
+
+// Check that all the unexpected queries did not run
+const expectedQueriesNotRun = getQueryIdsInput('queries-not-run')
+
+const queriesThatShouldNotHaveRunButDid = expectedQueriesNotRun.filter(queryId => ruleIds.includes(queryId))
+
+if (queriesThatShouldNotHaveRunButDid.length > 0) {
+  core.setFailed(`The following queries were NOT expected to have run but did: ${queriesThatShouldNotHaveRunButDid.join(', ')}`)
+}
+
+
+core.startGroup('All queries run')
+rules.forEach(rule => {
+  core.info(`${rule.id}: ${(rule.properties && rule.properties.name) || rule.name}`)
+})
+core.endGroup()
+
+core.startGroup('Full SARIF')
+core.info(JSON.stringify(sarif, null, 2))
+core.endGroup()
+
+function getQueryIdsInput(name) {
+  return core.getInput(name)
+    .split(',')
+    .map(q => q.trim())
+    .filter(q => q.length > 0)
+}

.github/actions/update-bundle/action.yml

@@ -0,0 +1,14 @@
+name: Update default CodeQL bundle
+description: Updates 'src/defaults.json' to point to a new CodeQL bundle release.
+
+runs:
+  using: composite
+  steps:
+    - name: Install ts-node
+      shell: bash
+      run: npm install -g ts-node
+
+    - name: Run update script
+      working-directory: ${{ github.action_path }}
+      shell: bash
+      run: ts-node ./index.ts

.github/actions/update-bundle/index.ts

@@ -0,0 +1,67 @@
+import * as fs from 'fs';
+import * as github from '@actions/github';
+
+interface BundleInfo {
+  bundleVersion: string;
+  cliVersion: string;
+}
+
+interface Defaults {
+  bundleVersion: string;
+  cliVersion: string;
+  priorBundleVersion: string;
+  priorCliVersion: string;
+}
+
+function getCodeQLCliVersionForRelease(release): string {
+  // We do not currently tag CodeQL bundles based on the CLI version they contain.
+  // Instead, we use a marker file `cli-version-<version>.txt` to record the CLI version.
+  // This marker file is uploaded as a release asset for all new CodeQL bundles.
+  const cliVersionsFromMarkerFiles = release.assets
+    .map((asset) => asset.name.match(/cli-version-(.*)\.txt/)?.[1])
+    .filter((v) => v)
+    .map((v) => v as string);
+  if (cliVersionsFromMarkerFiles.length > 1) {
+    throw new Error(
+      `Release ${release.tag_name} has multiple CLI version marker files.`
+    );
+  } else if (cliVersionsFromMarkerFiles.length === 0) {
+    throw new Error(
+      `Failed to find the CodeQL CLI version for release ${release.tag_name}.`
+    );
+  }
+  return cliVersionsFromMarkerFiles[0];
+}
+
+async function getBundleInfoFromRelease(release): Promise<BundleInfo> {
+  return {
+    bundleVersion: release.tag_name,
+    cliVersion: getCodeQLCliVersionForRelease(release)
+  };
+}
+
+async function getNewDefaults(currentDefaults: Defaults): Promise<Defaults> {
+  const release = github.context.payload.release;
+  console.log('Updating default bundle as a result of the following release: ' +
+    `${JSON.stringify(release)}.`)
+
+  const bundleInfo = await getBundleInfoFromRelease(release);
+  return {
+    bundleVersion: bundleInfo.bundleVersion,
+    cliVersion: bundleInfo.cliVersion,
+    priorBundleVersion: currentDefaults.bundleVersion,
+    priorCliVersion: currentDefaults.cliVersion
+  };
+}
+
+async function main() {
+  const previousDefaults: Defaults = JSON.parse(fs.readFileSync('../../../src/defaults.json', 'utf8'));
+  const newDefaults = await getNewDefaults(previousDefaults);
+  // Update the source file in the repository. Calling workflows should subsequently rebuild
+  // the Action to update `lib/defaults.json`.
+  fs.writeFileSync('../../../src/defaults.json', JSON.stringify(newDefaults, null, 2) + "\n");
+}
+
+// Ideally, we'd await main() here, but that doesn't work well with `ts-node`.
+// So instead we rely on the fact that Node won't exit until the event loop is empty.
+main();

.github/actions/verify-debug-artifact-scan-completed/action.yml

@@ -1,6 +1,6 @@
 name: Verify that the best-effort debug artifact scan completed
 description: Verifies that the best-effort debug artifact scan completed successfully during tests
 runs:
-  using: node24
+  using: node20
   main: index.js
   post: post.js

.github/workflows/__go-tracing-autobuilder.yml

@@ -44,6 +44,8 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - os: ubuntu-latest
+            version: stable-v2.19.4
           - os: ubuntu-latest
             version: stable-v2.20.7
           - os: ubuntu-latest
@@ -54,8 +56,6 @@ jobs:
             version: stable-v2.23.9
           - os: ubuntu-latest
             version: stable-v2.24.3
-          - os: ubuntu-latest
-            version: stable-v2.25.6
           - os: ubuntu-latest
             version: default
           - os: ubuntu-latest

.github/workflows/__go-tracing-custom-build-steps.yml

@@ -44,6 +44,8 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - os: ubuntu-latest
+            version: stable-v2.19.4
           - os: ubuntu-latest
             version: stable-v2.20.7
           - os: ubuntu-latest
@@ -54,8 +56,6 @@ jobs:
             version: stable-v2.23.9
           - os: ubuntu-latest
             version: stable-v2.24.3
-          - os: ubuntu-latest
-            version: stable-v2.25.6
           - os: ubuntu-latest
             version: default
           - os: ubuntu-latest

.github/workflows/__go-tracing-legacy-workflow.yml

@@ -44,6 +44,8 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - os: ubuntu-latest
+            version: stable-v2.19.4
           - os: ubuntu-latest
             version: stable-v2.20.7
           - os: ubuntu-latest
@@ -54,8 +56,6 @@ jobs:
             version: stable-v2.23.9
           - os: ubuntu-latest
             version: stable-v2.24.3
-          - os: ubuntu-latest
-            version: stable-v2.25.6
           - os: ubuntu-latest
             version: default
           - os: ubuntu-latest

.github/workflows/__multi-language-autodetect.yml

@@ -54,6 +54,10 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - os: ubuntu-latest
+            version: stable-v2.19.4
+          - os: macos-15-xlarge
+            version: stable-v2.19.4
           - os: ubuntu-latest
             version: stable-v2.20.7
           - os: macos-15-xlarge
@@ -74,10 +78,6 @@ jobs:
             version: stable-v2.24.3
           - os: macos-latest-xlarge
             version: stable-v2.24.3
-          - os: ubuntu-latest
-            version: stable-v2.25.6
-          - os: macos-latest-xlarge
-            version: stable-v2.25.6
           - os: ubuntu-latest
             version: default
           - os: macos-latest-xlarge

.github/workflows/__rust.yml

@@ -35,7 +35,7 @@ jobs:
       matrix:
         include:
           - os: ubuntu-latest
-            version: stable-v2.20.7
+            version: stable-v2.19.4
           - os: ubuntu-latest
             version: stable-v2.22.1
           - os: ubuntu-latest

.github/workflows/debug-artifacts-failure-safe.yml

@@ -30,7 +30,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-        - stable-v2.20.7
+        - stable-v2.20.3
         - default
         - linked
         - nightly-latest

.github/workflows/debug-artifacts-safe.yml

@@ -29,7 +29,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-        - stable-v2.20.7
+        - stable-v2.20.3
         - default
         - linked
         - nightly-latest
@@ -85,7 +85,7 @@ jobs:
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
       - name: Check expected artifacts exist
         run: |
-          VERSIONS="stable-v2.20.7 default linked nightly-latest"
+          VERSIONS="stable-v2.20.3 default linked nightly-latest"
           LANGUAGES="cpp csharp go java javascript python"
           for version in $VERSIONS; do
             pushd "./my-debug-artifacts-${version//./}"

.github/workflows/pr-checks.yml

@@ -61,7 +61,7 @@ jobs:
           npm ci
 
       - name: Verify compiled JS up to date
-        run: npx tsx pr-checks/check-js.ts
+        run: .github/workflows/script/check-js.sh
 
       - name: Run unit tests
         if: always()

.github/workflows/script/check-js.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+set -eu
+
+# Sanity check that repo is clean to start with
+if [ ! -z "$(git status --porcelain)" ]; then
+    # If we get a fail here then this workflow needs attention...
+    >&2 echo "Failed: Repo should be clean before testing!"
+    exit 1
+fi
+# Wipe the lib directory in case there are extra unnecessary files in there
+rm -rf lib
+# Generate the JavaScript files
+npm run-script build
+# Check that repo is still clean
+if [ ! -z "$(git status --porcelain)" ]; then
+    # If we get a fail here then the PR needs attention
+    >&2 echo "Failed: JavaScript files are not up to date. Run 'rm -rf lib && npm run-script build' to update"
+    git status
+
+    echo "### Transpiled JS diff" >> $GITHUB_STEP_SUMMARY
+    echo "" >> $GITHUB_STEP_SUMMARY
+    echo '```diff' >> $GITHUB_STEP_SUMMARY
+    git diff --output="$RUNNER_TEMP/js.diff"
+    cat "$RUNNER_TEMP/js.diff" >> $GITHUB_STEP_SUMMARY
+    echo '```' >> $GITHUB_STEP_SUMMARY
+
+    # Reset bundled files to allow other checks to test for changes
+    git checkout lib
+
+    # Fail this check
+    exit 1
+fi
+echo "Success: JavaScript files are up to date"

.github/workflows/update-bundle.yml

@@ -50,7 +50,7 @@ jobs:
         run: npm ci
 
       - name: Update bundle
-        run: npx tsx pr-checks/update-bundle.ts
+        uses: ./.github/actions/update-bundle
 
       - name: Set up CodeQL CLI from new bundle
         id: setup-codeql

CHANGELOG.md

@@ -2,106 +2,102 @@
 
 See the [releases page](https://github.com/github/codeql-action/releases) for the relevant changes to the CodeQL CLI and language packs.
 
-## [UNRELEASED]
-
-- _Breaking change_: Bump the minimum required CodeQL bundle version to 2.20.7. [#4205](https://github.com/github/codeql-action/pull/4205)
-
-## 4.38.3 - 08 Oct 2026
+## 3.38.3 - 08 Oct 2026
 
 - _Upcoming breaking change_: CodeQL version 2.21.2 and earlier were discontinued on 24 September 2026 alongside GitHub Enterprise Server 3.17, and will be unsupported by the next minor release of the CodeQL Action. Added a deprecation warning for customers using these versions of CodeQL. [#4188](https://github.com/github/codeql-action/pull/4188)
 - Update default CodeQL bundle version to [2.27.2](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.27.2). [#4203](https://github.com/github/codeql-action/pull/4203)
 - Fixed a bug where the decision of whether to use a per-language bundle did not account for custom configurations that reference queries outside of compiled CodeQL packs. This issue was caught during internal testing and did not affect any customer repositories. We will resume the roll out of per-language bundles in the coming weeks. [#4184](https://github.com/github/codeql-action/pull/4184)
 
-## 4.38.2 - 24 Sept 2026
+## 3.38.2 - 24 Sept 2026
 
 - Update default CodeQL bundle version to [2.27.1](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.27.1). [#4160](https://github.com/github/codeql-action/pull/4160)
 
-## 4.38.1 - 18 Sept 2026
+## 3.38.1 - 18 Sept 2026
 
 - The CodeQL Action now has experimental support for CodeQL releases for which per-language bundles are available. Per-language bundles support analysis for a single language and are therefore smaller than the combined bundles that allow analysis for all supported languages. As a result, per-language bundles take up less space on disk and are faster to download. We expect to roll this change out to everyone in the coming weeks. [#4146](https://github.com/github/codeql-action/pull/4146)
 
-## 4.38.0 - 09 Sept 2026
+## 3.38.0 - 09 Sept 2026
 
 - On GitHub-hosted runners, the CodeQL Action now deletes unused CodeQL bundles from the toolcache before downloading a different bundle, which frees up disk space for the analysis. We expect to roll this change out to everyone in September. [#4124](https://github.com/github/codeql-action/pull/4124)
 - The CodeQL Action now supports CodeQL releases that are compatible with Linux Arm64 and downloads the native `linux-arm64` CodeQL bundle when available. [#4072](https://github.com/github/codeql-action/pull/4072)
 - Update default CodeQL bundle version to [2.27.0](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.27.0). [#4129](https://github.com/github/codeql-action/pull/4129)
 
-## 4.37.9 - 26 Aug 2026
+## 3.37.9 - 26 Aug 2026
 
 - Update default CodeQL bundle version to [2.26.4](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.26.4). [#4106](https://github.com/github/codeql-action/pull/4106)
 
-## 4.37.8 - 21 Aug 2026
+## 3.37.8 - 21 Aug 2026
 
 No user facing changes.
 
-## 4.37.7 - 13 Aug 2026
+## 3.37.7 - 13 Aug 2026
 
 - Update default CodeQL bundle version to [2.26.3](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.26.3). [#4085](https://github.com/github/codeql-action/pull/4085)
 
-## 4.37.6 - 04 Aug 2026
+## 3.37.6 - 04 Aug 2026
 
 - Changed the default filepath for the new remote file address format that was introduced in CodeQL Action 4.37.0 / 3.37.0 to `.github/codeql-config.yml` to align it with the suggested path that is used elsewhere. [#4070](https://github.com/github/codeql-action/pull/4070)
 
-## 4.37.5 - 03 Aug 2026
+## 3.37.5 - 03 Aug 2026
 
 - Fixed a bug where a network error while streaming the download of the CodeQL bundle could terminate the `init` Action instead of falling back to downloading the bundle before extracting it. [#4061](https://github.com/github/codeql-action/pull/4061)
 
-## 4.37.4 - 29 Jul 2026
+## 3.37.4 - 29 Jul 2026
 
 - This version of the CodeQL Action adds support for the `tools` input for the `codeql-action/init` step to be specified using a `github-codeql-tools` [repository property](https://docs.github.com/en/organizations/managing-organization-settings/managing-custom-properties-for-repositories-in-your-organization). This feature will gradually be rolled out following the release of this version. Once rolled out, this allows for the CodeQL CLI version that is used in GitHub-managed workflows, such as Default Setup, to be set to a custom value. For example, customers who run into issues with rate limits when a new CodeQL CLI version is released can set the value to `toolcache` to always use the CodeQL CLI version that is available in the runner toolcache. For Advanced Setup workflows, the value provided for `tools` in the workflow definition always takes precedence unless the value of the repository property starts with `!`. [#4037](https://github.com/github/codeql-action/pull/4037)
 - Update default CodeQL bundle version to [2.26.2](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.26.2). [#4051](https://github.com/github/codeql-action/pull/4051)
 
-## 4.37.3 - 22 Jul 2026
+## 3.37.3 - 22 Jul 2026
 
 No user facing changes.
 
-## 4.37.2 - 21 Jul 2026
+## 3.37.2 - 21 Jul 2026
 
 - The new address format for the `config-file` input that was introduced in CodeQL Action 4.37.0 is now enabled by default. In addition to the format described there, the `remote=` prefix can now be used to explicitly indicate that the input refers to a remote file. All previous input formats continue to be accepted as well. [#4023](https://github.com/github/codeql-action/pull/4023)
 - The CodeQL Action can now make use of [configured private registries](https://docs.github.com/en/code-security/how-tos/secure-at-scale/configure-organization-security/manage-usage-and-access/giving-org-access-private-registries) in Default Setup to retrieve CodeQL configuration files from remote repositories that require authentication. This will allow customers to store their CodeQL configuration in a single repository that can then be referenced by Default Setup workflows in other repositories. We expect to roll this and other, related changes out to everyone in July. [#4007](https://github.com/github/codeql-action/pull/4007)
 
-## 4.37.1 - 16 Jul 2026
+## 3.37.1 - 16 Jul 2026
 
 - _Upcoming breaking change_: Add a deprecation warning for customers using CodeQL version 2.20.6 and earlier. These versions of CodeQL were discontinued on 1 July 2026 alongside GitHub Enterprise Server 3.16, and will be unsupported by the next minor release of the CodeQL Action. [#3956](https://github.com/github/codeql-action/pull/3956)
 - Update default CodeQL bundle version to [2.26.1](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.26.1). [#4019](https://github.com/github/codeql-action/pull/4019)
 
-## 4.37.0 - 08 Jul 2026
+## 3.37.0 - 08 Jul 2026
 
 - Update default CodeQL bundle version to [2.26.0](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.26.0). [#3995](https://github.com/github/codeql-action/pull/3995)
 - In addition to the existing input format, the `config-file` input for the `codeql-action/init` step will soon support a new `[owner/]repo[@ref][:path]` format. All components except the repository name are optional. If omitted, `owner` defaults to the same owner as the repository the analysis is running for, `ref` to `main`, and `path` to `.github/codeql-action.yaml`. Support for this format ships in this version of the CodeQL Action, but will only be enabled over the coming weeks. [#3973](https://github.com/github/codeql-action/pull/3973)
 
-## 4.36.3 - 01 Jul 2026
+## 3.36.3 - 01 Jul 2026
 
 No user facing changes.
 
-## 4.36.2 - 04 Jun 2026
+## 3.36.2 - 04 Jun 2026
 
 - Cache CodeQL CLI version information across Actions steps. [#3943](https://github.com/github/codeql-action/pull/3943)
 - Reduce requests while waiting for analysis processing by using exponential backoff when polling SARIF processing status. [#3937](https://github.com/github/codeql-action/pull/3937)
 - Update default CodeQL bundle version to [2.25.6](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.25.6). [#3948](https://github.com/github/codeql-action/pull/3948)
 
-## 4.36.1 - 02 Jun 2026
+## 3.36.1 - 02 Jun 2026
 
 No user facing changes.
 
-## 4.36.0 - 22 May 2026
+## 3.36.0 - 22 May 2026
 
 - _Breaking change_: Bump the minimum required CodeQL bundle version to 2.19.4. [#3894](https://github.com/github/codeql-action/pull/3894)
 - Add support for SHA-256 Git object IDs. [#3893](https://github.com/github/codeql-action/pull/3893)
 - Update default CodeQL bundle version to [2.25.5](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.25.5). [#3926](https://github.com/github/codeql-action/pull/3926)
 
-## 4.35.5 - 15 May 2026
+## 3.35.5 - 15 May 2026
 
 - We have improved how the JavaScript bundles for the CodeQL Action are generated to avoid duplication across bundles and reduce the size of the repository by around 70%. This should have no effect on the runtime behaviour of the CodeQL Action. [#3899](https://github.com/github/codeql-action/pull/3899)
 - For performance and accuracy reasons, [improved incremental analysis](https://github.com/github/roadmap/issues/1158) will now only be enabled on a pull request when diff-informed analysis is also enabled for that run. If diff-informed analysis is unavailable (for example, because the PR diff ranges could not be computed), the action will fall back to a full analysis. [#3791](https://github.com/github/codeql-action/pull/3791)
 - If multiple inputs are provided for the GitHub-internal `analysis-kinds` input, only `code-scanning` will be enabled. The `analysis-kinds` input is experimental, for GitHub-internal use only, and may change without notice at any time. [#3892](https://github.com/github/codeql-action/pull/3892)
 - Added an experimental change which, when running a Code Scanning analysis for a PR with [improved incremental analysis](https://github.com/github/roadmap/issues/1158) enabled, prefers CodeQL CLI versions that have a cached overlay-base database for the configured languages. This speeds up analysis for a repository when there is not yet a cached overlay-base database for the latest CLI version. We expect to roll this change out to everyone in May. [#3880](https://github.com/github/codeql-action/pull/3880)
 
-## 4.35.4 - 07 May 2026
+## 3.35.4 - 07 May 2026
 
 - Update default CodeQL bundle version to [2.25.4](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.25.4). [#3881](https://github.com/github/codeql-action/pull/3881)
 
-## 4.35.3 - 01 May 2026
+## 3.35.3 - 01 May 2026
 
 - _Upcoming breaking change_: Add a deprecation warning for customers using CodeQL version 2.19.3 and earlier. These versions of CodeQL were discontinued on 9 April 2026 alongside GitHub Enterprise Server 3.15, and will be unsupported by the next minor release of the CodeQL Action. [#3837](https://github.com/github/codeql-action/pull/3837)
 - Configurations for private registries that use Cloudsmith or GCP OIDC are now accepted. [#3850](https://github.com/github/codeql-action/pull/3850)
@@ -109,7 +105,7 @@ No user facing changes.
 - Fixed a bug where two diagnostics produced within the same millisecond could overwrite each other on disk, causing one of them to be lost. [#3852](https://github.com/github/codeql-action/pull/3852)
 - Update default CodeQL bundle version to [2.25.3](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.25.3). [#3865](https://github.com/github/codeql-action/pull/3865)
 
-## 4.35.2 - 15 Apr 2026
+## 3.35.2 - 15 Apr 2026
 
 - The undocumented TRAP cache cleanup feature that could be enabled using the `CODEQL_ACTION_CLEANUP_TRAP_CACHES` environment variable is deprecated and will be removed in May 2026. If you are affected by this, we recommend disabling TRAP caching by passing the `trap-caching: false` input to the `init` Action. [#3795](https://github.com/github/codeql-action/pull/3795)
 - The Git version 2.36.0 requirement for improved incremental analysis now only applies to repositories that contain submodules. [#3789](https://github.com/github/codeql-action/pull/3789)
@@ -117,26 +113,26 @@ No user facing changes.
 - Fixed a bug in the validation of OIDC configurations for private registries that was added in CodeQL Action 4.33.0 / 3.33.0. [#3807](https://github.com/github/codeql-action/pull/3807)
 - Update default CodeQL bundle version to [2.25.2](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.25.2). [#3823](https://github.com/github/codeql-action/pull/3823)
 
-## 4.35.1 - 27 Mar 2026
+## 3.35.1 - 27 Mar 2026
 
 - Fix incorrect minimum required Git version for [improved incremental analysis](https://github.com/github/roadmap/issues/1158): it should have been 2.36.0, not 2.11.0. [#3781](https://github.com/github/codeql-action/pull/3781)
 
-## 4.35.0 - 27 Mar 2026
+## 3.35.0 - 27 Mar 2026
 
 - Reduced the minimum Git version required for [improved incremental analysis](https://github.com/github/roadmap/issues/1158) from 2.38.0 to 2.11.0. [#3767](https://github.com/github/codeql-action/pull/3767)
 - Update default CodeQL bundle version to [2.25.1](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.25.1). [#3773](https://github.com/github/codeql-action/pull/3773)
 
-## 4.34.1 - 20 Mar 2026
+## 3.34.1 - 20 Mar 2026
 
 - Downgrade default CodeQL bundle version to [2.24.3](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.24.3) due to issues with a small percentage of Actions and JavaScript analyses. [#3762](https://github.com/github/codeql-action/pull/3762)
 
-## 4.34.0 - 20 Mar 2026
+## 3.34.0 - 20 Mar 2026
 
 - Added an experimental change which disables TRAP caching when [improved incremental analysis](https://github.com/github/roadmap/issues/1158) is enabled, since improved incremental analysis supersedes TRAP caching. This will improve performance and reduce Actions cache usage. We expect to roll this change out to everyone in March. [#3569](https://github.com/github/codeql-action/pull/3569)
 - We are rolling out improved incremental analysis to C/C++ analyses that use build mode `none`. We expect this rollout to be complete by the end of April 2026. [#3584](https://github.com/github/codeql-action/pull/3584)
 - Update default CodeQL bundle version to [2.25.0](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.25.0). [#3585](https://github.com/github/codeql-action/pull/3585)
 
-## 4.33.0 - 16 Mar 2026
+## 3.33.0 - 16 Mar 2026
 
 - Upcoming change: Starting April 2026, the CodeQL Action will skip collecting file coverage information on pull requests to improve analysis performance. File coverage information will still be computed on non-PR analyses. Pull request analyses will log a warning about this upcoming change. [#3562](https://github.com/github/codeql-action/pull/3562)
 
@@ -150,11 +146,11 @@ No user facing changes.
 - Fixed the retry mechanism for database uploads. Previously this would fail with the error "Response body object should not be disturbed or locked". [#3564](https://github.com/github/codeql-action/pull/3564)
 - A warning is now emitted if the CodeQL Action detects a repository property whose name suggests that it relates to the CodeQL Action, but which is not one of the properties recognised by the current version of the CodeQL Action. [#3570](https://github.com/github/codeql-action/pull/3570)
 
-## 4.32.6 - 05 Mar 2026
+## 3.32.6 - 05 Mar 2026
 
 - Update default CodeQL bundle version to [2.24.3](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.24.3). [#3548](https://github.com/github/codeql-action/pull/3548)
 
-## 4.32.5 - 02 Mar 2026
+## 3.32.5 - 02 Mar 2026
 
 - Repositories owned by an organization can now set up the `github-codeql-disable-overlay` custom repository property to disable [improved incremental analysis for CodeQL](https://github.com/github/roadmap/issues/1158). First, create a custom repository property with the name `github-codeql-disable-overlay` and the type "True/false" in the organization's settings. Then in the repository's settings, set this property to `true` to disable improved incremental analysis. For more information, see [Managing custom properties for repositories in your organization](https://docs.github.com/en/organizations/managing-organization-settings/managing-custom-properties-for-repositories-in-your-organization). This feature is not yet available on GitHub Enterprise Server. [#3507](https://github.com/github/codeql-action/pull/3507)
 - Added an experimental change so that when [improved incremental analysis](https://github.com/github/roadmap/issues/1158) fails on a runner — potentially due to insufficient disk space — the failure is recorded in the Actions cache so that subsequent runs will automatically skip improved incremental analysis until something changes (e.g. a larger runner is provisioned or a new CodeQL version is released). We expect to roll this change out to everyone in March. [#3487](https://github.com/github/codeql-action/pull/3487)
@@ -164,7 +160,7 @@ No user facing changes.
 - Added an experimental change which allows the `start-proxy` action to resolve the CodeQL CLI version from feature flags instead of using the linked CLI bundle version. We expect to roll this change out to everyone in March. [#3512](https://github.com/github/codeql-action/pull/3512)
 - The previously experimental changes from versions 4.32.3, 4.32.4, 3.32.3 and 3.32.4 are now enabled by default. [#3503](https://github.com/github/codeql-action/pull/3503), [#3504](https://github.com/github/codeql-action/pull/3504)
 
-## 4.32.4 - 20 Feb 2026
+## 3.32.4 - 20 Feb 2026
 
 - Update default CodeQL bundle version to [2.24.2](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.24.2). [#3493](https://github.com/github/codeql-action/pull/3493)
 - Added an experimental change which improves how certificates are generated for the authentication proxy that is used by the CodeQL Action in Default Setup when [private package registries are configured](https://docs.github.com/en/code-security/how-tos/secure-at-scale/configure-organization-security/manage-usage-and-access/giving-org-access-private-registries). This is expected to generate more widely compatible certificates and should have no impact on analyses which are working correctly already. We expect to roll this change out to everyone in February. [#3473](https://github.com/github/codeql-action/pull/3473)
@@ -172,89 +168,89 @@ No user facing changes.
 - Added a setting which allows the CodeQL Action to enable network debugging for Java programs. This will help GitHub staff support customers with troubleshooting issues in GitHub-managed CodeQL workflows, such as Default Setup. This setting can only be enabled by GitHub staff. [#3485](https://github.com/github/codeql-action/pull/3485)
 - Added a setting which enables GitHub-managed workflows, such as Default Setup, to use a [nightly CodeQL CLI release](https://github.com/dsp-testing/codeql-cli-nightlies) instead of the latest, stable release that is used by default. This will help GitHub staff support customers whose analyses for a given repository or organization require early access to a change in an upcoming CodeQL CLI release. This setting can only be enabled by GitHub staff. [#3484](https://github.com/github/codeql-action/pull/3484)
 
-## 4.32.3 - 13 Feb 2026
+## 3.32.3 - 13 Feb 2026
 
 - Added experimental support for testing connections to [private package registries](https://docs.github.com/en/code-security/how-tos/secure-at-scale/configure-organization-security/manage-usage-and-access/giving-org-access-private-registries). This feature is not currently enabled for any analysis. In the future, it may be enabled by default for Default Setup. [#3466](https://github.com/github/codeql-action/pull/3466)
 
-## 4.32.2 - 05 Feb 2026
+## 3.32.2 - 05 Feb 2026
 
 - Update default CodeQL bundle version to [2.24.1](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.24.1). [#3460](https://github.com/github/codeql-action/pull/3460)
 
-## 4.32.1 - 02 Feb 2026
+## 3.32.1 - 02 Feb 2026
 
 - A warning is now shown in Default Setup workflow logs if a [private package registry is configured](https://docs.github.com/en/code-security/how-tos/secure-at-scale/configure-organization-security/manage-usage-and-access/giving-org-access-private-registries) using a GitHub Personal Access Token (PAT), but no username is configured. [#3422](https://github.com/github/codeql-action/pull/3422)
 - Fixed a bug which caused the CodeQL Action to fail when repository properties cannot successfully be retrieved. [#3421](https://github.com/github/codeql-action/pull/3421)
 
-## 4.32.0 - 26 Jan 2026
+## 3.32.0 - 26 Jan 2026
 
 - Update default CodeQL bundle version to [2.24.0](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.24.0). [#3425](https://github.com/github/codeql-action/pull/3425)
 
-## 4.31.11 - 23 Jan 2026
+## 3.31.11 - 23 Jan 2026
 
 - When running a Default Setup workflow with [Actions debugging enabled](https://docs.github.com/en/actions/how-tos/monitor-workflows/enable-debug-logging), the CodeQL Action will now use more unique names when uploading logs from the Dependabot authentication proxy as workflow artifacts. This ensures that the artifact names do not clash between multiple jobs in a build matrix. [#3409](https://github.com/github/codeql-action/pull/3409)
 - Improved error handling throughout the CodeQL Action. [#3415](https://github.com/github/codeql-action/pull/3415)
 - Added experimental support for automatically excluding [generated files](https://docs.github.com/en/repositories/working-with-files/managing-files/customizing-how-changed-files-appear-on-github) from the analysis. This feature is not currently enabled for any analysis. In the future, it may be enabled by default for some GitHub-managed analyses. [#3318](https://github.com/github/codeql-action/pull/3318)
 - The changelog extracts that are included with releases of the CodeQL Action are now shorter to avoid duplicated information from appearing in Dependabot PRs. [#3403](https://github.com/github/codeql-action/pull/3403)
 
-## 4.31.10 - 12 Jan 2026
+## 3.31.10 - 12 Jan 2026
 
 - Update default CodeQL bundle version to 2.23.9. [#3393](https://github.com/github/codeql-action/pull/3393)
 
-## 4.31.9 - 16 Dec 2025
+## 3.31.9 - 16 Dec 2025
 
 No user facing changes.
 
-## 4.31.8 - 11 Dec 2025
+## 3.31.8 - 11 Dec 2025
 
 - Update default CodeQL bundle version to 2.23.8. [#3354](https://github.com/github/codeql-action/pull/3354)
 
-## 4.31.7 - 05 Dec 2025
+## 3.31.7 - 05 Dec 2025
 
 - Update default CodeQL bundle version to 2.23.7. [#3343](https://github.com/github/codeql-action/pull/3343)
 
-## 4.31.6 - 01 Dec 2025
+## 3.31.6 - 01 Dec 2025
 
 No user facing changes.
 
-## 4.31.5 - 24 Nov 2025
+## 3.31.5 - 24 Nov 2025
 
 - Update default CodeQL bundle version to 2.23.6. [#3321](https://github.com/github/codeql-action/pull/3321)
 
-## 4.31.4 - 18 Nov 2025
+## 3.31.4 - 18 Nov 2025
 
 No user facing changes.
 
-## 4.31.3 - 13 Nov 2025
+## 3.31.3 - 13 Nov 2025
 
 - CodeQL Action v3 will be deprecated in December 2026.  The Action now logs a warning for customers who are running v3 but could be running v4. For more information, see [Upcoming deprecation of CodeQL Action v3](https://github.blog/changelog/2025-10-28-upcoming-deprecation-of-codeql-action-v3/).
 - Update default CodeQL bundle version to 2.23.5. [#3288](https://github.com/github/codeql-action/pull/3288)
 
-## 4.31.2 - 30 Oct 2025
+## 3.31.2 - 30 Oct 2025
 
 No user facing changes.
 
-## 4.31.1 - 30 Oct 2025
+## 3.31.1 - 30 Oct 2025
 
 - The `add-snippets` input has been removed from the `analyze` action. This input has been deprecated since CodeQL Action 3.26.4 in August 2024 when this removal was announced.
 
-## 4.31.0 - 24 Oct 2025
+## 3.31.0 - 24 Oct 2025
 
 - Bump minimum CodeQL bundle version to 2.17.6. [#3223](https://github.com/github/codeql-action/pull/3223)
 - When SARIF files are uploaded by the `analyze` or `upload-sarif` actions, the CodeQL Action automatically performs post-processing steps to prepare the data for the upload. Previously, these post-processing steps were only performed before an upload took place. We are now changing this so that the post-processing steps will always be performed, even when the SARIF files are not uploaded. This does not change anything for the `upload-sarif` action. For `analyze`, this may affect Advanced Setup for CodeQL users who specify a value other than `always` for the `upload` input. [#3222](https://github.com/github/codeql-action/pull/3222)
 
-## 4.30.9 - 17 Oct 2025
+## 3.30.9 - 17 Oct 2025
 
 - Update default CodeQL bundle version to 2.23.3. [#3205](https://github.com/github/codeql-action/pull/3205)
 - Experimental: A new `setup-codeql` action has been added which is similar to `init`, except it only installs the CodeQL CLI and does not initialize a database. Do not use this in production as it is part of an internal experiment and subject to change at any time. [#3204](https://github.com/github/codeql-action/pull/3204)
 
-## 4.30.8 - 10 Oct 2025
+## 3.30.8 - 10 Oct 2025
 
 No user facing changes.
 
-## 4.30.7 - 06 Oct 2025
+## 3.30.7 - 06 Oct 2025
 
-- [v4+ only] The CodeQL Action now runs on Node.js v24. [#3169](https://github.com/github/codeql-action/pull/3169)
 
+No user facing changes.
 ## 3.30.6 - 02 Oct 2025
 
 - Update default CodeQL bundle version to 2.23.2. [#3168](https://github.com/github/codeql-action/pull/3168)

CONTRIBUTING.md

@@ -53,7 +53,6 @@ Here are a few things you can do that will increase the likelihood of your pull
 - Write tests.
 - Keep your change as focused as possible. If there are multiple changes you would like to make that are not dependent upon each other, consider submitting them as separate pull requests.
 - Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
-- For user-facing changes, add a change-note file. See [unreleased-change-notes/README.md](unreleased-change-notes/README.md).
 
 ## Releasing (write access required)
 

analyze/action.yml

@@ -94,6 +94,6 @@ outputs:
   sarif-id:
     description: The ID of the uploaded SARIF file.
 runs:
-  using: node24
+  using: node20
   main: "../lib/analyze-entry.js"
   post: "../lib/analyze-post-entry.js"

autobuild/action.yml

@@ -15,5 +15,5 @@ inputs:
       $GITHUB_WORKSPACE as its working directory.
     required: false
 runs:
-  using: node24
+  using: node20
   main: '../lib/autobuild-entry.js'

ava.setup.mjs

@@ -1,4 +1,3 @@
 import pkg from "./package.json" with { type: "json" };
 
 globalThis.__CODEQL_ACTION_VERSION__ = pkg.version;
-globalThis.__CODEQL_ACTION_TEST_ENV__ = "unit-test";

build.mjs

@@ -78,7 +78,7 @@ const UPLOAD_LIB_SRC = "./src/upload-lib";
  *
  * The virtual module additionally re-exports `upload-lib` under the `uploadLib` namespace so that
  * external consumers can access it via the small `lib/upload-lib.js` stub emitted below.
- *
+ * 
  * A tiny stub file is emitted for each Action entrypoint, and one for `upload-lib`. Each stub
  * imports the shared bundle and calls/re-exports from the respective entry point.
  *
@@ -212,7 +212,6 @@ const context = await esbuild.context({
   target: ["node20"],
   define: {
     __CODEQL_ACTION_VERSION__: JSON.stringify(pkg.version),
-    __CODEQL_ACTION_TEST_ENV__: JSON.stringify(""),
   },
   metafile: true,
 });

eslint.config.mjs

@@ -140,17 +140,6 @@ export default [
       "no-async-foreach/no-async-foreach": "error",
       "no-sequences": "error",
       "no-shadow": "off",
-
-      // A basic check that we don't use `exportVariable` from `@actions/core`.
-      "no-restricted-syntax": [
-        "error",
-        {
-          selector: "MemberExpression[property.name='exportVariable']",
-          message:
-            "Use the `export` method of an `Env` instance or `exportEnvVar` from `environment.ts` instead.",
-        },
-      ],
-
       // This is overly restrictive with unsetting `EnvVar`s
       "@typescript-eslint/no-dynamic-delete": "off",
       "@typescript-eslint/no-shadow": "error",
@@ -168,15 +157,6 @@ export default [
       ],
     },
   },
-  {
-    files: ["src/environment.ts"],
-
-    // We allow `exportVariable` from `@actions/core` to be used in this file
-    // since it defines the wrapper around it that other modules use.
-    rules: {
-      "no-restricted-syntax": "off",
-    },
-  },
   {
     files: ["**/*.ts", "**/*.js"],
 

init/action.yml

@@ -177,6 +177,6 @@ outputs:
   codeql-version:
     description: The version of the CodeQL binary used for analysis
 runs:
-  using: node24
+  using: node20
   main: '../lib/init-entry.js'
   post: '../lib/init-post-entry.js'

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "codeql",
-  "version": "4.39.0",
+  "version": "4.38.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "codeql",
-      "version": "4.39.0",
+      "version": "4.38.3",
       "license": "MIT",
       "workspaces": [
         "pr-checks"
@@ -58,7 +58,7 @@
         "eslint-import-resolver-typescript": "^4.4.5",
         "eslint-plugin-github": "^6.1.2",
         "eslint-plugin-import-x": "^4.17.1",
-        "eslint-plugin-jsdoc": "^65.0.1",
+        "eslint-plugin-jsdoc": "^64.5.4",
         "eslint-plugin-no-async-foreach": "^0.1.1",
         "glob": "^13.0.6",
         "globals": "^17.12.0",
@@ -5381,15 +5381,15 @@
       }
     },
     "node_modules/eslint-plugin-jsdoc": {
-      "version": "65.0.1",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-65.0.1.tgz",
-      "integrity": "sha512-7IvB+ZS71WCw5tGKh6f6D5k55qtXKdrGTnIpQTBKWdpyZ5IfhGHfh0i6ArWlCJ4JEtz22YRk5Bqu1MvbOlpMKQ==",
+      "version": "64.5.4",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-64.5.4.tgz",
+      "integrity": "sha512-xfRhXPSSWT612muJ6XTvxuVJ8zYHv99qNgBqPVqF28aSqoy4s4XbSkrWXnYA2hl5ejC02yEpk6fqkj3BmJ6Xbg==",
       "dev": true,
       "license": "BSD-3-Clause",
       "dependencies": {
         "@es-joy/jsdoccomment": "~0.98.0",
         "@es-joy/resolve.exports": "1.2.0",
-        "@typescript-eslint/utils": "^8.70.1",
+        "@typescript-eslint/utils": "^8.70.0",
         "are-docs-informative": "^0.1.1",
         "comment-parser": "1.4.9",
         "debug": "^4.4.3",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeql",
-  "version": "4.39.0",
+  "version": "3.38.3",
   "private": true,
   "description": "CodeQL action",
   "scripts": {
@@ -66,7 +66,7 @@
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-github": "^6.1.2",
     "eslint-plugin-import-x": "^4.17.1",
-    "eslint-plugin-jsdoc": "^65.0.1",
+    "eslint-plugin-jsdoc": "^64.5.4",
     "eslint-plugin-no-async-foreach": "^0.1.1",
     "glob": "^13.0.6",
     "globals": "^17.12.0",

pr-checks/changelog/validate.test.ts

@@ -154,6 +154,26 @@ await describe("isValidChangenoteFile", async () => {
     assert.equal(isValidChangenoteFile("non-existent-file.md"), false);
   });
 
+  await it("rejects invalid filename", async () => {
+    await withTmpFile(
+      "fix-bug.md",
+      "---\ncategory: fix\n---\n- Fixed a bug\n",
+      (filePath) => {
+        assert.equal(isValidChangenoteFile(filePath), false);
+      },
+    );
+  });
+
+  await it("rejects missing frontmatter", async () => {
+    await withTmpFile(
+      "2026-01-01-fix-bug.md",
+      "- Fixed a bug\n",
+      (filePath) => {
+        assert.equal(isValidChangenoteFile(filePath), false);
+      },
+    );
+  });
+
   await it("rejects invalid Markdown", async () => {
     await withTmpFile(
       "2026-01-01-fix-bug.md",

pr-checks/changelog/validate.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as path from "node:path";
 
 import { matter } from "lite-matter";
 import type { List, ListItem } from "mdast";
@@ -94,7 +95,21 @@ export function isValidChangenoteFile(filename: string): boolean {
     return false;
   }
 
-  const { content } = matter(fileData);
+  const { data: frontmatter, content } = matter(fileData);
+
+  if (!isValidChangenoteFilename(path.basename(filename))) {
+    isValid = false;
+    console.error(
+      `${filename}: invalid filename; must match pattern YYYY-MM-DD-id.md`,
+    );
+  }
+  if (!hasValidChangenoteCategory(frontmatter)) {
+    isValid = false;
+    const categories = Object.keys(VALID_CHANGE_NOTE_CATEGORIES).join(", ");
+    console.error(
+      `${filename}: invalid category; must be one of: ${categories}`,
+    );
+  }
   if (!isValidChangenoteContent(content)) {
     isValid = false;
     console.error(

pr-checks/changenotes.ts

@@ -28,12 +28,12 @@ interface ChangenoteFile {
 
 /**
  * Returns the absolute file paths of all files in
- * {@link CHANGENOTES_DIR} (except ".gitkeep" and "README.md").
+ * {@link CHANGENOTES_DIR} (except ".gitkeep").
  * */
 function listUnreleasedChangenoteDir(): string[] {
   return fs
     .readdirSync(CHANGENOTES_DIR)
-    .filter((name) => ![".gitkeep", "README.md"].includes(name))
+    .filter((name) => name !== ".gitkeep")
     .map((name) => path.join(CHANGENOTES_DIR, name));
 }
 

pr-checks/check-cs-config.test.ts

@@ -1,68 +0,0 @@
-/**
- * Tests for `check-cs-config.ts`.
- */
-
-import * as assert from "node:assert/strict";
-import { describe, it } from "node:test";
-
-import type { UserConfig } from "../src/config/db-config";
-
-import { checkConfiguration } from "./check-cs-config";
-
-describe("checkConfiguration", async () => {
-  await it("passes when actual and expected configs match", () => {
-    const actual: UserConfig = { name: "test-config", paths: ["src"] };
-    const expected = JSON.stringify(actual);
-    assert.doesNotThrow(() => checkConfiguration(actual, expected));
-  });
-
-  await it("passes when queries arrays match after sorting", () => {
-    const actual: UserConfig = { paths: ["b", "a", "c"] };
-    const expected = JSON.stringify(actual);
-    assert.doesNotThrow(() => checkConfiguration(actual, expected));
-  });
-
-  await it("throws when actual config does not match expected", () => {
-    const actual: UserConfig = { name: "actual-name" };
-    const expected = JSON.stringify({
-      name: "expected-name",
-    } satisfies UserConfig);
-    assert.throws(() => checkConfiguration(actual, expected), {
-      message: /Expected configuration does not match actual configuration/,
-    });
-  });
-
-  await it("throws when expected contents are empty", () => {
-    assert.throws(() => checkConfiguration({}, ""), {
-      message: /No expected configuration provided/,
-    });
-  });
-
-  await it("throws when expected contents are only whitespace", () => {
-    assert.throws(() => checkConfiguration({}, "   "), {
-      message: /No expected configuration provided/,
-    });
-  });
-
-  await it("passes with complex config", () => {
-    const actual: UserConfig = {
-      name: "complex",
-      "disable-default-queries": true,
-      paths: ["src", "lib"],
-      "paths-ignore": ["test"],
-      "threat-models": ["remote"],
-    };
-    const expected = JSON.stringify(actual);
-    assert.doesNotThrow(() => checkConfiguration(actual, expected));
-  });
-
-  await it("trims whitespace from expected contents before parsing", () => {
-    const actual: UserConfig = { name: "trimmed" };
-    const expected = `  ${JSON.stringify(actual)}  `;
-    assert.doesNotThrow(() => checkConfiguration(actual, expected));
-  });
-
-  await it("passes when both configs are empty objects", () => {
-    assert.doesNotThrow(() => checkConfiguration({}, "{}"));
-  });
-});

pr-checks/check-cs-config.ts

@@ -1,100 +0,0 @@
-#!/usr/bin/env npx tsx
-
-/**
- * Checks the code scanning configuration file generated by the
- * action to ensure it contains the expected contents
- */
-
-import * as assert from "node:assert";
-import * as fs from "node:fs";
-import { parseArgs } from "node:util";
-
-import * as core from "@actions/core";
-import * as yaml from "yaml";
-
-import type { UserConfig } from "../src/config/db-config";
-
-import { getErrorMessage } from "./util";
-
-function sortConfigArrays(config: UserConfig) {
-  for (const key of Object.keys(config)) {
-    const value = config[key];
-    if (key === "queries" && Array.isArray(value)) {
-      config[key] = value.sort();
-    }
-  }
-  return config;
-}
-
-function loadActualConfig(configPath: string) {
-  if (!fs.existsSync(configPath)) {
-    throw new Error("No configuration file found");
-  } else {
-    const rawActualConfig = fs.readFileSync(configPath, "utf8");
-    core.startGroup("Actual generated user config");
-    core.info(rawActualConfig);
-    core.endGroup();
-
-    return yaml.parse(rawActualConfig) as UserConfig;
-  }
-}
-
-export function checkConfiguration(
-  actualConfig: UserConfig,
-  expectedContents: string,
-) {
-  const rawExpectedConfig = expectedContents.trim();
-  if (!rawExpectedConfig) {
-    throw new Error("No expected configuration provided");
-  }
-
-  const expectedConfig = JSON.parse(rawExpectedConfig) as UserConfig;
-
-  core.startGroup("Expected generated user config");
-  core.info(yaml.stringify(expectedConfig));
-  core.endGroup();
-
-  assert.deepStrictEqual(
-    sortConfigArrays(actualConfig),
-    sortConfigArrays(expectedConfig),
-    "Expected configuration does not match actual configuration",
-  );
-}
-
-function main() {
-  const { values } = parseArgs({
-    options: {
-      // The path of the configuration file to check.
-      file: {
-        type: "string",
-      },
-      // The expected contents of the file.
-      "expected-contents": {
-        type: "string",
-      },
-    },
-    strict: true,
-  });
-
-  if (values.file === undefined) {
-    throw new Error("The '--file' input is required.");
-  }
-  if (values["expected-contents"] === undefined) {
-    throw new Error("The '--expected-contents' input is required.");
-  }
-
-  const actualConfig = loadActualConfig(values.file);
-
-  try {
-    checkConfiguration(actualConfig, values["expected-contents"]);
-  } catch (err) {
-    core.error(getErrorMessage(err));
-    return -1;
-  }
-
-  return 0;
-}
-
-if (import.meta.main) {
-  process.exit(main());
-}

pr-checks/check-js.ts

@@ -1,67 +0,0 @@
-#!/usr/bin/env npx tsx
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-import * as core from "@actions/core";
-
-import { runCommand, runGit } from "./command";
-import { LIB_ROOT, PR_CHECKS_DIR, REPO_ROOT } from "./config";
-import { getErrorMessage } from "./util";
-
-function main() {
-  // Sanity check that repo is clean to start with
-  try {
-    runGit(["diff", "--exit-code"], { allowNonZeroExitCode: false });
-    console.info("Repository is clean.");
-  } catch (err) {
-    // If we get a fail here then this workflow needs attention...
-    console.error(getErrorMessage(err));
-    console.error("Failed: Repo should be clean before testing!");
-    return -1;
-  }
-
-  // Wipe the lib directory in case there are extra unnecessary files in there
-  console.info(`Removing ${LIB_ROOT}...`);
-  fs.rmSync(LIB_ROOT, { recursive: true, force: true });
-
-  // Generate the JavaScript files
-  runCommand("npm", ["run", "build"], { execOptions: { shell: true } });
-
-  // Check that repo is still clean
-  try {
-    runGit(["diff", "--exit-code"], { allowNonZeroExitCode: false });
-    console.info("Repository is clean.");
-  } catch (err) {
-    // If we get a fail here then the PR needs attention
-    console.error(getErrorMessage(err));
-    console.error("Failed: JavaScript files are not up to date.");
-    console.error("Run 'rm -rf lib && npm run build' to update.");
-
-    const diffFile = path.join(
-      process.env["RUNNER_TEMP"] ?? PR_CHECKS_DIR,
-      "js.diff",
-    );
-    runCommand("git", ["status"]);
-    runCommand("git", ["diff", `--output=${diffFile}`], {
-      execOptions: { cwd: REPO_ROOT },
-    });
-
-    core.summary.addHeading("Transpiled JS diff", 3);
-    core.summary.addCodeBlock(fs.readFileSync(diffFile, "utf-8"), "diff");
-
-    fs.rmSync(diffFile);
-
-    // Reset bundled files to allow other checks to test for changes
-    runCommand("git", ["checkout", "lib"]);
-
-    return 1;
-  }
-
-  console.info("Success: JavaScript files are up to date");
-  return 0;
-}
-
-if (import.meta.main) {
-  process.exit(main());
-}

pr-checks/check-sarif.test.ts

@@ -1,159 +0,0 @@
-/**
- * Tests for `check-sarif.ts`.
- */
-
-import * as assert from "node:assert/strict";
-import { describe, it } from "node:test";
-
-import type { Log } from "sarif";
-
-import { checkSarif } from "./check-sarif";
-
-/** Builds a minimal SARIF Log with the given rule IDs spread across extensions. */
-function buildSarifLog(ruleIds: string[]): Log {
-  return {
-    version: "2.1.0",
-    $schema:
-      "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json",
-    runs: [
-      {
-        tool: {
-          driver: { name: "CodeQL" },
-          extensions: [
-            {
-              name: "test-pack",
-              rules: ruleIds.map((id) => ({ id })),
-            },
-          ],
-        },
-        results: [],
-      },
-    ],
-  };
-}
-
-describe("checkSarif", async () => {
-  await it("returns 0 when all expected queries ran and no unexpected queries ran", () => {
-    const sarif = buildSarifLog(["js/sql-injection", "js/xss"]);
-    const exitCode = checkSarif(sarif, {
-      sarifFile: "test.sarif",
-      queriesRun: "js/sql-injection, js/xss",
-      queriesNotRun: "js/hardcoded-credentials",
-    });
-    assert.equal(exitCode, 0);
-  });
-
-  await it("returns -2 when an expected query did not run", () => {
-    const sarif = buildSarifLog(["js/sql-injection"]);
-    const exitCode = checkSarif(sarif, {
-      sarifFile: "test.sarif",
-      queriesRun: "js/sql-injection, js/xss",
-      queriesNotRun: "",
-    });
-    assert.equal(exitCode, -2);
-  });
-
-  await it("returns -2 when an unexpected query ran", () => {
-    const sarif = buildSarifLog(["js/sql-injection", "js/xss"]);
-    const exitCode = checkSarif(sarif, {
-      sarifFile: "test.sarif",
-      queriesRun: "js/sql-injection",
-      queriesNotRun: "js/xss",
-    });
-    assert.equal(exitCode, -2);
-  });
-
-  await it("handles empty queries-run and queries-not-run inputs", () => {
-    const sarif = buildSarifLog(["js/sql-injection"]);
-    const exitCode = checkSarif(sarif, {
-      sarifFile: "test.sarif",
-      queriesRun: "",
-      queriesNotRun: "",
-    });
-    assert.equal(exitCode, 0);
-  });
-
-  await it("handles multiple extensions with rules", () => {
-    const sarif: Log = {
-      version: "2.1.0",
-      $schema:
-        "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json",
-      runs: [
-        {
-          tool: {
-            driver: { name: "CodeQL" },
-            extensions: [
-              {
-                name: "pack-a",
-                rules: [{ id: "js/sql-injection" }],
-              },
-              {
-                name: "pack-b",
-                rules: [{ id: "js/xss" }],
-              },
-            ],
-          },
-          results: [],
-        },
-      ],
-    };
-    const exitCode = checkSarif(sarif, {
-      sarifFile: "test.sarif",
-      queriesRun: "js/sql-injection, js/xss",
-      queriesNotRun: "",
-    });
-    assert.equal(exitCode, 0);
-  });
-
-  await it("handles extensions with no rules", () => {
-    const sarif: Log = {
-      version: "2.1.0",
-      $schema:
-        "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json",
-      runs: [
-        {
-          tool: {
-            driver: { name: "CodeQL" },
-            extensions: [
-              { name: "empty-pack" },
-              {
-                name: "pack-with-rules",
-                rules: [{ id: "js/xss" }],
-              },
-            ],
-          },
-          results: [],
-        },
-      ],
-    };
-    const exitCode = checkSarif(sarif, {
-      sarifFile: "test.sarif",
-      queriesRun: "js/xss",
-      queriesNotRun: "js/sql-injection",
-    });
-    assert.equal(exitCode, 0);
-  });
-
-  await it("throws when tool extensions are undefined", () => {
-    const sarif: Log = {
-      version: "2.1.0",
-      $schema:
-        "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json",
-      runs: [
-        {
-          tool: { driver: { name: "CodeQL" } },
-          results: [],
-        },
-      ],
-    };
-    assert.throws(
-      () =>
-        checkSarif(sarif, {
-          sarifFile: "test.sarif",
-          queriesRun: "js/xss",
-          queriesNotRun: "",
-        }),
-      { message: /Couldn't find tool extensions/ },
-    );
-  });
-});

pr-checks/check-sarif.ts

@@ -1,125 +0,0 @@
-#!/usr/bin/env npx tsx
-
-/** Checks a SARIF file to see if certain queries were run and others were not run. */
-
-import * as fs from "node:fs";
-import { parseArgs } from "node:util";
-
-import * as core from "@actions/core";
-import type { ReportingDescriptor, Log } from "sarif";
-
-import { getErrorMessage } from "./util";
-
-type Options = { sarifFile: string; queriesRun: string; queriesNotRun: string };
-
-function getOptions(): Options {
-  const { values } = parseArgs({
-    options: {
-      // The path of the SARIF file to check.
-      "sarif-file": {
-        type: "string",
-      },
-      // The query ids to check are present.
-      "queries-run": {
-        type: "string",
-      },
-      // The query ids to check are absent.
-      "queries-not-run": {
-        type: "string",
-      },
-    },
-    strict: true,
-  });
-
-  if (values["sarif-file"] === undefined) {
-    throw new Error("The '--sarif-file' input is required.");
-  }
-  if (values["queries-run"] === undefined) {
-    throw new Error("The '--queries-run' input is required.");
-  }
-  if (values["queries-not-run"] === undefined) {
-    throw new Error("The '--queries-not-run' input is required.");
-  }
-
-  return {
-    sarifFile: values["sarif-file"],
-    queriesRun: values["queries-run"],
-    queriesNotRun: values["queries-not-run"],
-  };
-}
-
-function parseQueryIdsInput(queriesRun: string): string[] {
-  return queriesRun
-    .split(",")
-    .map((q) => q.trim())
-    .filter((q) => q.length > 0);
-}
-
-export function checkSarif(sarif: Log, options: Options) {
-  if (sarif.runs[0].tool.extensions === undefined) {
-    throw new Error(`Couldn't find tool extensions in the SARIF file.`);
-  }
-
-  let exitCode = 0;
-
-  // Extract the rule ids from the SARIF file.
-  const rules: ReportingDescriptor[] = sarif.runs[0].tool.extensions.flatMap(
-    (ext) => ext.rules || [],
-  );
-  const ruleIds: string[] = rules.map((rule) => rule.id);
-
-  // Check that all the expected queries ran
-  const expectedQueriesRun = parseQueryIdsInput(options.queriesRun);
-  const queriesThatShouldHaveRunButDidNot = expectedQueriesRun.filter(
-    (queryId) => !ruleIds.includes(queryId),
-  );
-
-  if (queriesThatShouldHaveRunButDidNot.length > 0) {
-    core.error(
-      `The following queries were expected to run but did not: ${queriesThatShouldHaveRunButDidNot.join(", ")}`,
-    );
-    exitCode = -2;
-  }
-
-  // Check that all the unexpected queries did not run
-  const expectedQueriesNotRun = parseQueryIdsInput(options.queriesNotRun);
-
-  const queriesThatShouldNotHaveRunButDid = expectedQueriesNotRun.filter(
-    (queryId) => ruleIds.includes(queryId),
-  );
-
-  if (queriesThatShouldNotHaveRunButDid.length > 0) {
-    core.error(
-      `The following queries were NOT expected to have run but did: ${queriesThatShouldNotHaveRunButDid.join(", ")}`,
-    );
-    exitCode = -2;
-  }
-
-  core.startGroup("All queries that ran");
-  for (const rule of rules) {
-    core.info(`${rule.id}: ${rule.properties?.name || rule.name}`);
-  }
-  core.endGroup();
-
-  core.startGroup("Full SARIF");
-  core.info(JSON.stringify(sarif, null, 2));
-  core.endGroup();
-
-  return exitCode;
-}
-
-function main() {
-  try {
-    const options = getOptions();
-    const sarif: Log = JSON.parse(fs.readFileSync(options.sarifFile, "utf8"));
-
-    return checkSarif(sarif, options);
-  } catch (err) {
-    core.error(`Failed to check SARIF file: ${getErrorMessage(err)}`);
-    return -1;
-  }
-}
-
-if (import.meta.main) {
-  process.exit(main());
-}

pr-checks/checks/multi-language-autodetect.yml

@@ -10,6 +10,7 @@ operatingSystems:
   - os: macos
     runner-image: macos-15-xlarge
     codeql-versions:
+      - stable-v2.19.4
       - stable-v2.20.7
       - stable-v2.21.4
       - stable-v2.22.4

pr-checks/checks/rust.yml

@@ -1,8 +1,8 @@
 name: "Rust analysis"
 description: "Tests creation of a Rust database"
 versions:
-  # oldest CodeQL version supported by the Action, where Rust support is experimental and requires the Action to set `CODEQL_ENABLE_EXPERIMENTAL_FEATURES`
-  - stable-v2.20.7
+  # experimental rust support introduced, requires action to set `CODEQL_ENABLE_EXPERIMENTAL_FEATURES`
+  - stable-v2.19.4
   # first public preview version
   - stable-v2.22.1
   - linked

pr-checks/command.ts

@@ -1,81 +0,0 @@
-import { execFileSync, ExecFileSyncOptions } from "node:child_process";
-
-import { DryRunOption, REPO_ROOT } from "./config";
-
-/** Options for {@link runCommand}. */
-export interface RunCommandOptions extends DryRunOption {
-  /** Options for `execFileSync`. */
-  execOptions?: ExecFileSyncOptions;
-}
-
-/**
- * Runs a command, streaming output to the console by default.
- *
- * @param command The name of the command to run.
- * @param args The arguments for the command.
- * @throws When the process exits with a non-zero exit code.
- * @param options How to run the command.
- */
-export function runCommand(
-  command: string,
-  args: string[],
-  options?: RunCommandOptions,
-) {
-  if (!options?.dryRun) {
-    console.log(`Running \`${command} ${args.join(" ")}\`.`);
-    return execFileSync(command, args, {
-      stdio: "inherit",
-      cwd: REPO_ROOT,
-      ...options?.execOptions,
-    });
-  } else {
-    console.info(
-      `[DRY RUN] Would have executed '${command} ${args.join(" ")}'`,
-    );
-    return "";
-  }
-}
-
-/** Options for {@link runGit}. */
-export interface RunGitOptions extends DryRunOption {
-  /** When true, non-zero exit codes will not throw. */
-  allowNonZeroExitCode?: boolean;
-}
-
-/**
- * Runs `git` with the given `args` and returns the stdout.
- *
- * @param args - Arguments to pass to `git`.
- * @param options - Optional settings.
- * @throws If `git` does not exit successfully, unless
- *         `options.allowNonZeroExitCode` is `true`.
- * @returns The trimmed stdout output.
- */
-export function runGit(args: string[], options?: RunGitOptions): string {
-  const execOptions: ExecFileSyncOptions = {
-    encoding: "utf8",
-    stdio: ["pipe", "pipe", "pipe"],
-  };
-
-  try {
-    const result = runCommand("git", args, {
-      dryRun: options?.dryRun,
-      execOptions,
-    }) as string;
-    return result.trimEnd();
-  } catch (error: unknown) {
-    if (options?.allowNonZeroExitCode) {
-      // execFileSync throws an object with `stdout` when the process exits
-      // with a non-zero code.
-      const execError = error as { stdout?: Buffer | string };
-      if (typeof execError.stdout === "string") {
-        return execError.stdout.trimEnd();
-      }
-      if (Buffer.isBuffer(execError.stdout)) {
-        return execError.stdout.toString("utf8").trimEnd();
-      }
-      return "";
-    }
-    throw error;
-  }
-}

pr-checks/config.ts

@@ -30,13 +30,7 @@ export const CHANGENOTES_DIR = path.join(REPO_ROOT, "unreleased-change-notes");
 export const BUNDLE_METADATA_FILE = path.join(REPO_ROOT, "meta.json");
 
 /** The `src` directory. */
-export const SOURCE_ROOT = path.join(REPO_ROOT, "src");
-
-/** The `src` directory. */
-export const LIB_ROOT = path.join(REPO_ROOT, "lib");
-
-/** The path to `defaults.json`. */
-export const DEFAULTS_FILE = path.join(SOURCE_ROOT, "defaults.json");
+const SOURCE_ROOT = path.join(REPO_ROOT, "src");
 
 /** The path to the built-in languages file. */
 export const BUILTIN_LANGUAGES_FILE = path.join(

pr-checks/sync.ts

@@ -136,6 +136,8 @@ type LanguageSetups = Partial<Record<BuiltInLanguage, LanguageSetup>>;
 // The default set of CodeQL Bundle versions to use for the PR checks.
 const defaultTestVersions = [
   // The oldest supported CodeQL version. If bumping, update `CODEQL_MINIMUM_VERSION` in `codeql.ts`
+  "stable-v2.19.4",
+  // The last CodeQL release in the 2.20 series.
   "stable-v2.20.7",
   // The last CodeQL release in the 2.21 series.
   "stable-v2.21.4",
@@ -145,8 +147,6 @@ const defaultTestVersions = [
   "stable-v2.23.9",
   // The last CodeQL release in the 2.24 series.
   "stable-v2.24.3",
-  // The last CodeQL release in the 2.25 series.
-  "stable-v2.25.6",
   // The default version of CodeQL for Dotcom, as determined by feature flags.
   "default",
   // The version of CodeQL shipped with the Action in `defaults.json`. During the release process

pr-checks/update-bundle.test.ts

@@ -1,58 +0,0 @@
-/*
- * Tests for the update-bundle.ts script.
- */
-
-import * as assert from "node:assert/strict";
-import { describe, it } from "node:test";
-
-import { Defaults, getNewDefaults } from "./update-bundle";
-
-const testDefaults: Defaults = {
-  bundleVersion: "codeql-bundle-v2.26.2",
-  cliVersion: "2.26.2",
-  priorBundleVersion: "codeql-bundle-v2.26.1",
-  priorCliVersion: "2.26.1",
-};
-
-describe("getNewDefaults", async () => {
-  await it("throws if there is no cli-version-*.txt asset", async () => {
-    assert.throws(
-      () => getNewDefaults({ tag_name: "foo", assets: [] }, testDefaults),
-      { message: "Failed to find the CodeQL CLI version for release foo." },
-    );
-  });
-
-  await it("throws if there are multiple cli-version-*.txt assets", async () => {
-    assert.throws(
-      () =>
-        getNewDefaults(
-          {
-            tag_name: "foo",
-            assets: [
-              { name: "cli-version-foo.txt" },
-              { name: "cli-version-bar.txt" },
-            ],
-          },
-          testDefaults,
-        ),
-      { message: "Release foo has multiple CLI version marker files." },
-    );
-  });
-
-  await it("finds the new bundle info", async () => {
-    const newDefaults = getNewDefaults(
-      {
-        tag_name: "foo",
-        assets: [{ name: "cli-version-1.2.3.txt" }],
-      },
-      testDefaults,
-    );
-
-    assert.deepEqual(newDefaults, {
-      bundleVersion: "foo",
-      cliVersion: "1.2.3",
-      priorBundleVersion: testDefaults.bundleVersion,
-      priorCliVersion: testDefaults.cliVersion,
-    } satisfies Defaults);
-  });
-});

pr-checks/update-bundle.ts

@@ -1,93 +0,0 @@
-#!/usr/bin/env npx tsx
-
-/** Updates 'src/defaults.json' to point to a new CodeQL bundle release. */
-
-import * as fs from "fs";
-
-import * as github from "@actions/github";
-
-import * as defaults from "../src/defaults.json";
-
-import { DEFAULTS_FILE } from "./config";
-
-interface BundleInfo {
-  bundleVersion: string;
-  cliVersion: string;
-}
-
-export type Defaults = typeof defaults;
-
-interface Release {
-  tag_name: string;
-  assets: Array<{
-    name: string;
-  }>;
-}
-
-function getCodeQLCliVersionForRelease(release: Release): string {
-  // We do not currently tag CodeQL bundles based on the CLI version they contain.
-  // Instead, we use a marker file `cli-version-<version>.txt` to record the CLI version.
-  // This marker file is uploaded as a release asset for all new CodeQL bundles.
-  const cliVersionsFromMarkerFiles = release.assets
-    .map((asset) => asset.name.match(/cli-version-(.*)\.txt/)?.[1])
-    .filter((v) => v)
-    .map((v) => v as string);
-  if (cliVersionsFromMarkerFiles.length > 1) {
-    throw new Error(
-      `Release ${release.tag_name} has multiple CLI version marker files.`,
-    );
-  } else if (cliVersionsFromMarkerFiles.length === 0) {
-    throw new Error(
-      `Failed to find the CodeQL CLI version for release ${release.tag_name}.`,
-    );
-  }
-  return cliVersionsFromMarkerFiles[0];
-}
-
-function getBundleInfoFromRelease(release: Release): BundleInfo {
-  return {
-    bundleVersion: release.tag_name,
-    cliVersion: getCodeQLCliVersionForRelease(release),
-  };
-}
-
-export function getNewDefaults(
-  release: Release,
-  currentDefaults: Defaults,
-): Defaults {
-  console.log(
-    "Updating default bundle as a result of the following release: " +
-      `${JSON.stringify(release)}.`,
-  );
-
-  const bundleInfo = getBundleInfoFromRelease(release);
-
-  return {
-    bundleVersion: bundleInfo.bundleVersion,
-    cliVersion: bundleInfo.cliVersion,
-    priorBundleVersion: currentDefaults.bundleVersion,
-    priorCliVersion: currentDefaults.cliVersion,
-  };
-}
-
-function main() {
-  const release: Release = github.context.payload.release;
-
-  if (release === undefined) {
-    console.error(`Release payload is undefined.`);
-    return -1;
-  }
-
-  const previousDefaults = defaults;
-  const newDefaults = getNewDefaults(release, previousDefaults);
-
-  // Update the source file in the repository. Calling workflows should subsequently rebuild
-  // the Action to update `lib/defaults.json`.
-  fs.writeFileSync(DEFAULTS_FILE, `${JSON.stringify(newDefaults, null, 2)}\n`);
-
-  return 0;
-}
-
-if (import.meta.main) {
-  process.exit(main());
-}

pr-checks/update-release-branch.ts

@@ -18,12 +18,12 @@
  *     [--dry-run]
  */
 
-import { execFileSync } from "node:child_process";
+import { execFileSync, type ExecFileSyncOptions } from "node:child_process";
 import { parseArgs } from "node:util";
 
 import { type ApiClient, getApiClient } from "./api-client";
 import * as changelog from "./changelog";
-import { runCommand, runGit } from "./command";
+import { DryRunOption, REPO_ROOT } from "./config";
 import {
   getCurrentVersion,
   replaceVersionInPackageJson,
@@ -65,6 +65,84 @@ export function getGitHubToken(): string {
   throw new Error("Missing GitHub token. Set GITHUB_TOKEN or GH_TOKEN.");
 }
 
+/** Options for {@link runCommand}. */
+export interface RunCommandOptions extends DryRunOption {
+  /** Options for `execFileSync`. */
+  execOptions?: ExecFileSyncOptions;
+}
+
+/**
+ * Runs a command, streaming output to the console by default.
+ *
+ * @param command The name of the command to run.
+ * @param args The arguments for the command.
+ * @throws When the process exits with a non-zero exit code.
+ * @param options How to run the command.
+ */
+export function runCommand(
+  command: string,
+  args: string[],
+  options?: RunCommandOptions,
+) {
+  if (!options?.dryRun) {
+    console.log(`Running \`${command} ${args.join(" ")}\`.`);
+    return execFileSync(command, args, {
+      stdio: "inherit",
+      cwd: REPO_ROOT,
+      ...options?.execOptions,
+    });
+  } else {
+    console.info(
+      `[DRY RUN] Would have executed '${command} ${args.join(" ")}'`,
+    );
+    return "";
+  }
+}
+
+/** Options for {@link runGit}. */
+export interface RunGitOptions extends DryRunOption {
+  /** When true, non-zero exit codes will not throw. */
+  allowNonZeroExitCode?: boolean;
+}
+
+/**
+ * Runs `git` with the given `args` and returns the stdout.
+ *
+ * @param args - Arguments to pass to `git`.
+ * @param options - Optional settings.
+ * @throws If `git` does not exit successfully, unless
+ *         `options.allowNonZeroExitCode` is `true`.
+ * @returns The trimmed stdout output.
+ */
+export function runGit(args: string[], options?: RunGitOptions): string {
+  const execOptions: ExecFileSyncOptions = {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+  };
+
+  try {
+    const result = runCommand("git", args, {
+      dryRun: options?.dryRun,
+      execOptions,
+    }) as string;
+    return result.trimEnd();
+  } catch (error: unknown) {
+    if (options?.allowNonZeroExitCode) {
+      // execFileSync throws an object with `stdout` when the process exits
+      // with a non-zero code.
+      const execError = error as { stdout?: Buffer | string };
+      if (typeof execError.stdout === "string") {
+        return execError.stdout.trimEnd();
+      }
+      if (Buffer.isBuffer(execError.stdout)) {
+        return execError.stdout.toString("utf8").trimEnd();
+      }
+      return "";
+    }
+    throw error;
+  }
+}
+
 /** Returns true if the given branch exists on the origin remote. */
 export function branchExistsOnRemote(branchName: string): boolean {
   const result = runGit(["ls-remote", "--heads", ORIGIN, branchName]);

queries/default-setup-environment-variables.ql

@@ -23,8 +23,7 @@ predicate isSafeForDefaultSetup(string envVar) {
       "GITHUB_BASE_REF", "GITHUB_EVENT_NAME", "GITHUB_JOB", "GITHUB_RUN_ATTEMPT", "GITHUB_RUN_ID",
       "GITHUB_SHA", "GITHUB_REPOSITORY", "GITHUB_SERVER_URL", "GITHUB_TOKEN", "GITHUB_WORKFLOW",
       "GITHUB_WORKSPACE", "GOFLAGS", "ImageVersion", "JAVA_TOOL_OPTIONS", "RUNNER_ARCH",
-      "RUNNER_ENVIRONMENT", "RUNNER_NAME", "RUNNER_OS", "RUNNER_TEMP", "RUNNER_TOOL_CACHE",
-      "NODE_ENV"
+      "RUNNER_ENVIRONMENT", "RUNNER_NAME", "RUNNER_OS", "RUNNER_TEMP", "RUNNER_TOOL_CACHE"
     ]
 }
 

resolve-environment/action.yml

@@ -21,5 +21,5 @@ outputs:
   environment:
     description: The inferred build environment configuration.
 runs:
-  using: node24
+  using: node20
   main: '../lib/resolve-environment-entry.js'

setup-codeql/action.yml

@@ -51,5 +51,5 @@ outputs:
   codeql-version:
     description: The version of the CodeQL binary that was installed.
 runs:
-  using: node24
+  using: node20
   main: '../lib/setup-codeql-entry.js'

src/action-common.test.ts

@@ -19,24 +19,6 @@ import { getErrorMessage } from "./util";
 
 setupTests(test);
 
-for (const [key, displayName] of Object.entries(
-  statusReport.ACTION_DISPLAY_NAMES,
-)) {
-  test(`getDisplayActionName - '${displayName}' instead of '${key}'`, (t) => {
-    t.is(statusReport.getDisplayActionName(key as ActionName), displayName);
-  });
-}
-
-test("getDisplayActionName - returns action name", (t) => {
-  for (const actionName of Object.values(ActionName)) {
-    if (statusReport.ACTION_DISPLAY_NAMES[actionName]) {
-      continue;
-    }
-
-    t.is(statusReport.getDisplayActionName(actionName), actionName);
-  }
-});
-
 interface RunInActionsTestOpts {
   runFn?: () => Promise<any>;
   expectedErrorMessage?: string;

src/action-common.ts

@@ -56,29 +56,6 @@ export interface FeatureState {
 /** Identifies a type of state an Action may have. */
 export type StateFeature = keyof FeatureState;
 
-/**
- * The `Env` feature implies the availability of the `ReadOnlyEnv` feature.
- *
- * If `T` is `Env`, this returns `Env | ReadOnlyEnv`.
- * Otherwise, it is the identity and returns T.
- */
-type ImpliedFeatures<T extends StateFeature> = T extends "Env"
-  ? "Env" | "ReadOnlyEnv"
-  : T;
-
-/**
- * Given an object type `Obj`, this tries to lookup a corresponding `StateFeature`
- * to which the object type belongs in `FeatureState`. Resolves to `never` if there
- * is no match.
- */
-type FeatureNameFor<Obj extends object> = {
-  [K in StateFeature]: [Obj] extends [FeatureState[K]]
-    ? [FeatureState[K]] extends [Obj]
-      ? K
-      : never
-    : never;
-}[StateFeature];
-
 /** Constructs the intersection of all state types identifies by `Fs`. */
 export type FieldsOf<Fs extends readonly StateFeature[]> = Fs extends []
   ? Record<never, never>
@@ -89,54 +66,8 @@ export type FieldsOf<Fs extends readonly StateFeature[]> = Fs extends []
     ? FeatureState[Head] & FieldsOf<Tail>
     : never;
 
-/**
- * Symbol used for a field in `ActionState` that carries the type array of state features.
- * This is a Symbol so that it doesn't clash with any property names we might want to have.
- */
-const stateFeatures = Symbol();
-
 /** Describes the state of an Action that has access to the state corresponding to `Fs`. */
-export type ActionState<Fs extends readonly StateFeature[]> = FieldsOf<Fs> & {
-  /**
-   * When given a chance, TypeScript will simplify an `ActionState<Fs>` type as much as possible,
-   * which results in a concrete object type that doesn't mention `Fs`.
-   *
-   * That causes problems for functions which accept `ActionState<Fs>` values, but need to know the
-   * feature keys `Fs`. This property here explicitly captures `Fs` in the concrete object type
-   * that results from simplifying `ActionState<Fs>`.
-   *
-   * This is a function rather than a field, because we want to be able to provide values of type
-   * `ActionState<Fs>` to functions expecting `ActionState<As>` where `As` is a subset of `Fs`.
-   *
-   * Since function types are contravariant in the types of their parameters, using a function
-   * type here allows that to happen.
-   *
-   * Because the field is optional, we don't have to explicitly provide a value
-   * for it anywhere while the type is still inferred.
-   *
-   * `Fs[number]` returns the union of all features in `Fs`. We wrap it in `ImpliedFeatures`
-   * so that `Env` is expanded into `Env | ReadOnlyEnv`, allowing functions that expect the
-   * `ReadOnlyEnv` feature to be provided with an `ActionState` that has the `Env` feature
-   * without requiring this to be made explicit.
-   */
-  readonly [stateFeatures]?: (ts: ImpliedFeatures<Fs[number]>) => void;
-};
-
-/** Extends `state` with an `extra` feature. */
-export function extendActionState<
-  // In first position, so that it can be explicitly provided if `FeatureNameFor`
-  // should not work on `extra`.
-  F extends StateFeature,
-  Fs extends readonly StateFeature[],
-  E extends FeatureState[F],
->(
-  state: ActionState<Fs>,
-  extra: E,
-): ActionState<[...Fs, FeatureNameFor<E> & F]> {
-  return { ...state, ...extra } as unknown as ActionState<
-    [...Fs, FeatureNameFor<E> & F]
-  >;
-}
+export type ActionState<Fs extends readonly StateFeature[]> = FieldsOf<Fs>;
 
 /** The type of an Action's main entry point. This is a function that is provided
  * with a basic `ActionState` object with features that are always available.

src/actions-util.test.ts

@@ -7,13 +7,12 @@ import {
   isAnalyzingPullRequest,
   isDefaultSetup,
   isDynamicWorkflow,
-  printDebugLogs,
 } from "./actions-util";
 import { computeAutomationID } from "./api-client";
 import { EnvVar } from "./environment";
 import { getRunnerLogger } from "./logging";
-import { RecordingLogger, setupTests } from "./testing-utils";
-import { initializeEnvironment, withTmpDir } from "./util";
+import { setupTests } from "./testing-utils";
+import { initializeEnvironment } from "./util";
 
 setupTests(test);
 
@@ -101,21 +100,6 @@ test("computeAutomationID()", async (t) => {
   );
 });
 
-test("printDebugLogs - doesn't throw when config doesn't have needed properties", async (t) => {
-  const logger = new RecordingLogger();
-  await t.notThrowsAsync(printDebugLogs(logger, {}));
-  await t.notThrowsAsync(printDebugLogs(logger, { languages: [] }));
-  await t.notThrowsAsync(printDebugLogs(logger, { dbLocation: "nowhere" }));
-});
-
-test("printDebugLogs - doesn't throw when language db doesn't exist", async (t) =>
-  withTmpDir(async (tmpDir) => {
-    const logger = new RecordingLogger();
-    await t.notThrowsAsync(
-      printDebugLogs(logger, { dbLocation: tmpDir, languages: ["javascript"] }),
-    );
-  }));
-
 test.serial("getPullRequestBranches() with pull request context", (t) => {
   withMockedContext(
     {

src/actions-util.ts

@@ -6,7 +6,7 @@ import * as toolrunner from "@actions/exec/lib/toolrunner";
 import * as github from "@actions/github";
 import * as io from "@actions/io";
 
-import { hasConfigKey, type Config } from "./config/action-config";
+import type { Config } from "./config-utils";
 import { Env, EnvVar, ActionsEnvVars, ReadOnlyEnv } from "./environment";
 import { Logger } from "./logging";
 import {
@@ -30,6 +30,7 @@ declare const __CODEQL_ACTION_VERSION__: string;
 export interface ActionsEnv {
   getRequiredInput: (name: string) => string;
   getOptionalInput: (name: string) => string | undefined;
+  exportVariable: (name: string, value: string) => void;
 }
 
 /**
@@ -39,6 +40,7 @@ export function getActionsEnv(): ActionsEnv {
   return {
     getRequiredInput,
     getOptionalInput,
+    exportVariable: core.exportVariable,
   };
 }
 
@@ -131,38 +133,28 @@ export function getWorkflowEvent(env: Env = getEnv()): any {
   }
 }
 
-export async function printDebugLogs(logger: Logger, config: Partial<Config>) {
-  if (
-    !hasConfigKey(config, "languages") ||
-    !hasConfigKey(config, "dbLocation")
-  ) {
-    logger.debug(
-      `Not printing debug logs, because the configuration does not include the 'languages' or 'dbLocation' fields.`,
-    );
-    return;
-  }
-
+export async function printDebugLogs(config: Config) {
   for (const language of config.languages) {
     const databaseDirectory = getCodeQLDatabasePath(config, language);
     const logsDirectory = path.join(databaseDirectory, "log");
     if (!doesDirectoryExist(logsDirectory)) {
-      logger.info(`Directory ${logsDirectory} does not exist.`);
+      core.info(`Directory ${logsDirectory} does not exist.`);
       continue; // Skip this language database.
     }
 
     const walkLogFiles = (dir: string) => {
       const entries = fs.readdirSync(dir, { withFileTypes: true });
       if (entries.length === 0) {
-        logger.info(`No debug logs found at directory ${logsDirectory}.`);
+        core.info(`No debug logs found at directory ${logsDirectory}.`);
       }
       for (const entry of entries) {
         if (entry.isFile()) {
           const absolutePath = path.resolve(dir, entry.name);
-          logger.startGroup(
+          core.startGroup(
             `CodeQL Debug Logs - ${language} - ${entry.name} from file at path ${absolutePath}`,
           );
-          logger.info(fs.readFileSync(absolutePath, "utf-8"));
-          logger.endGroup();
+          process.stdout.write(fs.readFileSync(absolutePath));
+          core.endGroup();
         } else if (entry.isDirectory()) {
           walkLogFiles(path.resolve(dir, entry.name));
         }

src/analyze-action-post.ts

@@ -9,6 +9,7 @@ import * as core from "@actions/core";
 
 import * as actionsUtil from "./actions-util";
 import { getGitHubVersion } from "./api-client";
+import { getCodeQL } from "./codeql";
 import { getConfig } from "./config-utils";
 import * as debugArtifacts from "./debug-artifacts";
 import {
@@ -37,9 +38,12 @@ export async function runWrapper() {
         logger,
       );
       if (config !== undefined) {
+        const codeql = await getCodeQL(logger, config.codeQLCmd);
+        const version = await codeql.getVersion();
         await debugArtifacts.uploadCombinedSarifArtifacts(
           logger,
           config.gitHubVersion.type,
+          version.version,
         );
       }
     }

src/analyze-action.ts

@@ -214,10 +214,9 @@ async function runAutobuildIfLegacyGoWorkflow(config: Config, logger: Logger) {
 
 async function run({
   startedAt,
-  env,
   logger,
   actions,
-}: ActionState<["Base", "Env", "Logger", "Actions"]>) {
+}: ActionState<["Base", "Logger", "Actions"]>) {
   // To capture errors appropriately, keep as much code within the try-catch as
   // possible, and only use safe functions outside.
 
@@ -268,6 +267,17 @@ async function run({
       );
     }
 
+    // Unset the CODEQL_PROXY_* environment variables when using older CodeQL
+    // CLIs, as they are not needed and can cause issues.
+    if (
+      process.env.CODEQL_PROXY_HOST === "" &&
+      !(await util.codeQlVersionAtLeast(codeql, "2.20.7"))
+    ) {
+      delete process.env.CODEQL_PROXY_HOST;
+      delete process.env.CODEQL_PROXY_PORT;
+      delete process.env.CODEQL_PROXY_CA_CERTIFICATE;
+    }
+
     if (actionsUtil.getOptionalInput("cleanup-level")) {
       logger.info(
         "The 'cleanup-level' input is ignored since the CodeQL Action now automatically " +
@@ -277,7 +287,7 @@ async function run({
 
     const apiDetails = getApiDetails();
     const outputDir = actionsUtil.getRequiredInput("output");
-    env.export(EnvVar.SARIF_RESULTS_OUTPUT_DIR, outputDir);
+    core.exportVariable(EnvVar.SARIF_RESULTS_OUTPUT_DIR, outputDir);
     const threads = util.getThreadsFlag(
       actionsUtil.getOptionalInput("threads") || process.env["CODEQL_THREADS"],
       logger,
@@ -446,7 +456,7 @@ async function run({
         `expect-error input was set to true but no error was thrown.`,
       );
     }
-    env.export(EnvVar.ANALYZE_DID_COMPLETE_SUCCESSFULLY, "true");
+    core.exportVariable(EnvVar.ANALYZE_DID_COMPLETE_SUCCESSFULLY, "true");
   } catch (unwrappedError) {
     const error = util.wrapError(unwrappedError);
     if (

src/analyze.ts

@@ -9,7 +9,6 @@ import { getTemporaryDirectory } from "./actions-util";
 import * as analyses from "./analyses";
 import { setupCppAutobuild } from "./autobuild";
 import { type CodeQL } from "./codeql";
-import type { ActionConfig } from "./config/action-config";
 import { defaultSuites } from "./config/db-config";
 import * as configUtils from "./config-utils";
 import {
@@ -125,7 +124,7 @@ export async function runExtraction(
           language === BuiltInLanguage.cpp &&
           config.buildMode === BuildMode.Autobuild
         ) {
-          await setupCppAutobuild(logger);
+          await setupCppAutobuild(codeql, logger);
         }
 
         // The Java and C# `build-mode: none` extractors place dependencies in the
@@ -172,7 +171,7 @@ async function shouldExtractLanguage(
 }
 
 export function dbIsFinalized(
-  config: ActionConfig<"dbLocation">,
+  config: configUtils.Config,
   language: Language,
   logger: Logger,
 ) {

src/api-client.ts

@@ -17,7 +17,6 @@ import {
   ReadOnlyEnv,
   RegistryProxyVars,
   getEnv,
-  exportEnvVar,
 } from "./environment";
 import { Logger } from "./logging";
 import { getRepositoryNwo, RepositoryNwo } from "./repository";
@@ -317,7 +316,7 @@ export async function getAnalysisKey(): Promise<string> {
   const jobName = getRequiredEnvParam("GITHUB_JOB");
 
   analysisKey = `${workflowPath}:${jobName}`;
-  exportEnvVar(EnvVar.ANALYSIS_KEY, analysisKey);
+  core.exportVariable(EnvVar.ANALYSIS_KEY, analysisKey);
   return analysisKey;
 }
 

src/autobuild-action.ts

@@ -68,11 +68,7 @@ async function sendCompletedStatusReport(
   }
 }
 
-async function run({
-  startedAt,
-  env,
-  logger,
-}: ActionState<["Base", "Env", "Logger"]>) {
+async function run({ startedAt, logger }: ActionState<["Base", "Logger"]>) {
   // To capture errors appropriately, keep as much code within the try-catch as
   // possible, and only use safe functions outside.
 
@@ -139,7 +135,7 @@ async function run({
     return;
   }
 
-  env.export(EnvVar.AUTOBUILD_DID_COMPLETE_SUCCESSFULLY, "true");
+  core.exportVariable(EnvVar.AUTOBUILD_DID_COMPLETE_SUCCESSFULLY, "true");
 
   await sendCompletedStatusReport(config, logger, startedAt, languages ?? []);
 }

src/autobuild.ts

@@ -1,9 +1,11 @@
+import * as core from "@actions/core";
+
 import { getTemporaryDirectory, getWorkflowEventName } from "./actions-util";
 import { getGitHubVersion } from "./api-client";
 import { CodeQL, getCodeQL } from "./codeql";
 import * as configUtils from "./config-utils";
 import { DocUrl } from "./doc-url";
-import { ActionsEnvVars, EnvVar, exportEnvVar } from "./environment";
+import { ActionsEnvVars, EnvVar } from "./environment";
 import { Feature, featureConfig, initFeatures } from "./feature-flags";
 import { BuiltInLanguage, Language } from "./languages";
 import { Logger } from "./logging";
@@ -110,7 +112,7 @@ export async function determineAutobuildLanguages(
   return languages;
 }
 
-export async function setupCppAutobuild(logger: Logger) {
+export async function setupCppAutobuild(codeql: CodeQL, logger: Logger) {
   const envVar = featureConfig[Feature.CppDependencyInstallation].envVar;
   const featureName = "C++ automatic installation of dependencies";
   const gitHubVersion = await getGitHubVersion();
@@ -121,7 +123,7 @@ export async function setupCppAutobuild(logger: Logger) {
     getTemporaryDirectory(),
     logger,
   );
-  if (await features.getValue(Feature.CppDependencyInstallation)) {
+  if (await features.getValue(Feature.CppDependencyInstallation, codeql)) {
     // disable autoinstall on self-hosted runners unless explicitly requested
     if (
       process.env[ActionsEnvVars.RUNNER_ENVIRONMENT] === "self-hosted" &&
@@ -134,16 +136,16 @@ export async function setupCppAutobuild(logger: Logger) {
             : ""
         }`,
       );
-      exportEnvVar(envVar, "false");
+      core.exportVariable(envVar, "false");
     } else {
       logger.info(
         `Enabling ${featureName}. This can be disabled by setting the ${envVar} environment variable to 'false'. See ${DocUrl.DEFINE_ENV_VARIABLES} for more information.`,
       );
-      exportEnvVar(envVar, "true");
+      core.exportVariable(envVar, "true");
     }
   } else {
     logger.info(`Disabling ${featureName}.`);
-    exportEnvVar(envVar, "false");
+    core.exportVariable(envVar, "false");
   }
 }
 
@@ -155,7 +157,7 @@ export async function runAutobuild(
   logger.startGroup(`Attempting to automatically build ${language} code`);
   const codeQL = await getCodeQL(logger, config.codeQLCmd);
   if (language === BuiltInLanguage.cpp) {
-    await setupCppAutobuild(logger);
+    await setupCppAutobuild(codeQL, logger);
   }
   if (config.buildMode) {
     await codeQL.extractUsingBuildMode(config, language);
@@ -163,7 +165,7 @@ export async function runAutobuild(
     await codeQL.runAutobuild(config, language);
   }
   if (language === BuiltInLanguage.go) {
-    exportEnvVar(EnvVar.DID_AUTOBUILD_GOLANG, "true");
+    core.exportVariable(EnvVar.DID_AUTOBUILD_GOLANG, "true");
   }
   logger.endGroup();
 }

src/codeql.ts

@@ -15,10 +15,9 @@ import * as api from "./api-client";
 import * as outputCache from "./cli/output-cache";
 import type { VersionInfo } from "./cli/types";
 import { CliError, wrapCliConfigurationError } from "./cli-errors";
-import type { ActionConfig } from "./config/action-config";
 import { appendExtraQueryExclusions, type Config } from "./config-utils";
 import { DocUrl } from "./doc-url";
-import { EnvVar, getEnv, exportEnvVar } from "./environment";
+import { EnvVar, getEnv } from "./environment";
 import {
   CodeQLDefaultVersionInfo,
   Feature,
@@ -198,7 +197,7 @@ export interface CodeQL {
   diagnosticsExport(
     sarifFile: string,
     automationDetailsId: string | undefined,
-    config: ActionConfig<"tempDir">,
+    config: Config,
   ): Promise<void>;
   /** Get the location of an extractor for the specified language. */
   resolveExtractor(language: Language): Promise<string>;
@@ -254,7 +253,7 @@ let cachedCodeQL: CodeQL | undefined = undefined;
  * The version flags below can be used to conditionally enable certain features
  * on versions newer than this.
  */
-const CODEQL_MINIMUM_VERSION = "2.20.7";
+const CODEQL_MINIMUM_VERSION = "2.19.4";
 
 /**
  * This version will shortly become the oldest version of CodeQL that the Action will run with.
@@ -914,7 +913,7 @@ async function getCodeQLForCmd(
     async diagnosticsExport(
       sarifFile: string,
       automationDetailsId: string | undefined,
-      config: ActionConfig<"tempDir">,
+      config: Config,
     ): Promise<void> {
       const args = [
         "diagnostics",
@@ -1055,7 +1054,7 @@ async function getCodeQLForCmd(
         }' by 'github/codeql-action/*@v${getActionVersion()}' in your code scanning workflow to ` +
         "continue using this version of the CodeQL Action.",
     );
-    exportEnvVar(EnvVar.SUPPRESS_DEPRECATED_SOON_WARNING, "true");
+    core.exportVariable(EnvVar.SUPPRESS_DEPRECATED_SOON_WARNING, "true");
   }
   return codeql;
 }
@@ -1238,9 +1237,7 @@ export async function getTrapCachingExtractorConfigArgsForLang(
  *
  * This will not exist if the configuration is being parsed in the Action.
  */
-function getGeneratedCodeScanningConfigPath(
-  config: ActionConfig<"tempDir">,
-): string {
+function getGeneratedCodeScanningConfigPath(config: Config): string {
   return path.resolve(config.tempDir, "user-config.yaml");
 }
 

src/config-utils.ts

@@ -2,6 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { performance } from "perf_hooks";
 
+import * as core from "@actions/core";
 import * as yaml from "js-yaml";
 
 import { ActionState } from "./action-common";
@@ -21,11 +22,7 @@ import {
 import * as api from "./api-client";
 import { getCachingKind } from "./caching-utils";
 import { type CodeQL } from "./codeql";
-import {
-  type AbortedInitConfig,
-  type ActionConfig,
-  type Config,
-} from "./config/action-config";
+import { type Config } from "./config/action-config";
 import {
   calculateAugmentation,
   ExcludeQueryFilter,
@@ -49,7 +46,7 @@ import {
   makeTelemetryDiagnostic,
 } from "./diagnostics";
 import { prepareDiffInformedAnalysis } from "./diff-informed-analysis-utils";
-import { EnvVar, exportEnvVar } from "./environment";
+import { EnvVar } from "./environment";
 import * as errorMessages from "./error-messages";
 import { Feature, FeatureEnablement, FeatureWithoutCLI } from "./feature-flags";
 import {
@@ -75,7 +72,6 @@ import {
 import { OverlayDatabaseMode } from "./overlay/overlay-database-mode";
 import { shouldSkipOverlayAnalysis } from "./overlay/status";
 import { RepositoryNwo } from "./repository";
-import { ActionName } from "./status-report";
 import { ToolsFeature } from "./tools-features";
 import { downloadTrapCaches } from "./trap-caching";
 import {
@@ -969,10 +965,10 @@ async function setCppTrapCachingEnvironmentVariables(
       );
     } else if (config.trapCaches[BuiltInLanguage.cpp]) {
       logger.info("Enabling TRAP caching for C/C++.");
-      exportEnvVar(envVar, "true");
+      core.exportVariable(envVar, "true");
     } else {
       logger.debug(`Disabling TRAP caching for C/C++.`);
-      exportEnvVar(envVar, "false");
+      core.exportVariable(envVar, "false");
     }
   }
 }
@@ -1384,86 +1380,31 @@ export function getPathToParsedConfigFile(tempDir: string): string {
   return path.join(tempDir, "config");
 }
 
-function getPathToFailedConfigFile(tempDir: string): string {
-  return path.join(tempDir, "failed-config");
-}
-
 /**
- * Writes {@link config} to {@link configFilePath}.
- *
- * This function is not intended to be called, other than by
- * {@link saveConfig} and {@link saveAbortedInitConfig} below.
+ * Store the given config to the path returned from getPathToParsedConfigFile.
  */
-function saveConfigFile(
-  logger: Logger,
-  configFilePath: string,
-  config: Partial<Config>,
-) {
+export async function saveConfig(config: Config, logger: Logger) {
   const configString = JSON.stringify(config);
-  fs.mkdirSync(path.dirname(configFilePath), { recursive: true });
-  fs.writeFileSync(configFilePath, configString, "utf8");
+  const configFile = getPathToParsedConfigFile(config.tempDir);
+  fs.mkdirSync(path.dirname(configFile), { recursive: true });
+  fs.writeFileSync(configFile, configString, "utf8");
   logger.debug("Saved config:");
   logger.debug(configString);
 }
 
 /**
- * Store the given config to the path returned from getPathToParsedConfigFile.
+ * Get the config that has been saved to the given temp dir.
+ * If the config could not be found then returns undefined.
  */
-export async function saveConfig(config: Config, logger: Logger) {
-  const configFile = getPathToParsedConfigFile(config.tempDir);
-  saveConfigFile(logger, configFile, config);
-}
-
-/**
- * Store parts of {@link config} as a failed configuration file.
- *
- * The file will only contain parts of {@link config} that are relevant to
- * the `init-post` step in the workflow.
- */
-export function saveAbortedInitConfig(
-  action: ActionState<["Base", "Logger"]>,
-  config: Config,
-) {
-  // Should only be called by init.
-  if (action.name !== ActionName.Init) {
-    throw new Error(
-      `Internal error: 'saveAbortedInitConfig' should only be called by '${ActionName.Init}', but was called by '${action.name}'.`,
-    );
-  }
-
-  // Create a copy of the input `Config` that only contains the keys we want.
-  const failedConfig: AbortedInitConfig = {
-    version: config.version,
-    tempDir: config.tempDir,
-    codeQLCmd: config.codeQLCmd,
-    debugMode: config.debugMode,
-    gitHubVersion: config.gitHubVersion,
-    languages: config.languages,
-    analysisKinds: config.analysisKinds,
-  };
-
-  action.logger.debug(`Saving config for failed init step.`);
-  saveConfigFile(
-    action.logger,
-    getPathToFailedConfigFile(config.tempDir),
-    failedConfig,
-  );
-}
-
-/**
- * Attempts to read a {@link Config} from {@link configFilePath}.
- *
- * This function is not intended to be called, other than by
- * {@link getConfig} and {@link getAbortedInitConfig} below.
- */
-function readConfigFile(
+export async function getConfig(
+  tempDir: string,
   logger: Logger,
-  configFilePath: string,
-): Config | undefined {
-  if (!fs.existsSync(configFilePath)) {
+): Promise<Config | undefined> {
+  const configFile = getPathToParsedConfigFile(tempDir);
+  if (!fs.existsSync(configFile)) {
     return undefined;
   }
-  const configString = fs.readFileSync(configFilePath, "utf8");
+  const configString = fs.readFileSync(configFile, "utf8");
   logger.debug("Loaded config:");
   logger.debug(configString);
 
@@ -1488,38 +1429,6 @@ function readConfigFile(
   return config as Config;
 }
 
-/**
- * Get the config that has been saved to the given temp dir.
- * If the config could not be found then returns undefined.
- */
-export async function getConfig(
-  tempDir: string,
-  logger: Logger,
-): Promise<Config | undefined> {
-  const configFile = getPathToParsedConfigFile(tempDir);
-  return readConfigFile(logger, configFile);
-}
-
-/**
- * Loads a {@link AbortedInitConfig} from a failed `init` step if it exists.
- *
- * The result will only contain parts of a {@link Config} that are relevant to
- * the `init-post` step in the workflow.
- */
-export function getAbortedInitConfig(
-  action: ActionState<["Base", "Logger"]>,
-  tempDir: string,
-): AbortedInitConfig | undefined {
-  // Only intended to be called by the `init-post` action.
-  if (action.name !== ActionName.InitPost) {
-    throw new Error(
-      `Internal error: 'getAbortedInitConfig' should only be called by '${ActionName.InitPost}', but was called by '${action.name}'.`,
-    );
-  }
-
-  return readConfigFile(action.logger, getPathToFailedConfigFile(tempDir));
-}
-
 /**
  * Generate a `qlconfig.yml` file from the `registries` input.
  * This file is used by the CodeQL CLI to list the registries to use for each
@@ -1710,27 +1619,21 @@ export function appendExtraQueryExclusions(
 /**
  * Returns `true` if Code Scanning analysis is enabled, or `false` if not.
  */
-export function isCodeScanningEnabled(
-  config: ActionConfig<"analysisKinds">,
-): boolean {
+export function isCodeScanningEnabled(config: Config): boolean {
   return config.analysisKinds.includes(AnalysisKind.CodeScanning);
 }
 
 /**
  * Returns `true` if Code Quality analysis is enabled, or `false` if not.
  */
-export function isCodeQualityEnabled(
-  config: ActionConfig<"analysisKinds">,
-): boolean {
+export function isCodeQualityEnabled(config: Config): boolean {
   return config.analysisKinds.includes(AnalysisKind.CodeQuality);
 }
 
 /**
  * Returns `true` if Code Scanning Risk Assessment analysis is enabled, or `false` if not.
  */
-export function isRiskAssessmentEnabled(
-  config: ActionConfig<"analysisKinds">,
-): boolean {
+export function isRiskAssessmentEnabled(config: Config): boolean {
   return config.analysisKinds.includes(AnalysisKind.RiskAssessment);
 }
 

src/config/action-config.ts

@@ -126,38 +126,3 @@ export interface Config {
    */
   enableFileCoverageInformation: boolean;
 }
-
-/** Properties available in `Config`. */
-export type ActionConfigProperties = keyof Config;
-
-/**
- * The CodeQL Action configuration state that is persisted
- * between steps of the CodeQL Action in a CodeQL workflow.
- *
- * By default, this is equivalent to `Config`. By explicitly
- * providing required property names for `T` this can be restricted
- * to requiring only those. For example, in `ActionConfig<"codeQLCmd">`
- * all properties except `codeqlCmd` are optional.
- */
-export type ActionConfig<
-  T extends ActionConfigProperties = ActionConfigProperties,
-> = Partial<Config> & Pick<Config, T>;
-
-/** Helper function to check whether `config` has `key` to narrow the type of `config`. */
-export function hasConfigKey<Key extends ActionConfigProperties>(
-  config: Partial<Config>,
-  key: Key,
-): config is ActionConfig<Key> {
-  return config[key] !== undefined;
-}
-
-/** A minimal configuration that we can make available even when `init` aborts. */
-export type AbortedInitConfig = ActionConfig<
-  | "version"
-  | "tempDir"
-  | "gitHubVersion"
-  | "debugMode"
-  | "languages"
-  | "analysisKinds"
-  | "codeQLCmd"
->;

src/debug-artifacts.test.ts

@@ -55,20 +55,25 @@ test("getArtifactSuffix", (t) => {
   }
 });
 
-// These next tests check whether `uploadArtifacts` attempts to upload an artifact. Since it's not
-// easy to mock the actual call to upload an artifact, we check that we get an "upload-failed"
-// result, instead of actually uploading the artifact.
+// These next tests check the correctness of the logic to determine whether or not
+// artifacts are uploaded in debug mode. Since it's not easy to mock the actual
+// call to upload an artifact, we just check that we get an "upload-failed" result,
+// instead of actually uploading the artifact.
+//
+// For tests where we expect artifact upload to be blocked, we check for a different
+// response from the function.
 
-test("uploadArtifacts returns 'no-artifacts-to-upload' when there are no files to upload", async (t) => {
+test("uploadDebugArtifacts when artifacts empty should emit 'no-artifacts-to-upload'", async (t) => {
   // Test that no error is thrown if artifacts list is empty.
   const logger = getActionsLogger();
   await t.notThrowsAsync(async () => {
-    const uploaded = await debugArtifacts.uploadArtifacts(
+    const uploaded = await debugArtifacts.uploadDebugArtifacts(
       logger,
       [],
       "i-dont-exist",
       "artifactName",
       GitHubVariant.DOTCOM,
+      undefined,
     );
     t.is(
       uploaded,
@@ -78,15 +83,17 @@ test("uploadArtifacts returns 'no-artifacts-to-upload' when there are no files t
   });
 });
 
-test("uploadArtifacts attempts an upload when there are files to upload", async (t) => {
+test("uploadDebugArtifacts when no codeql version is used should invoke artifact upload", async (t) => {
+  // Test that the artifact is uploaded.
   const logger = getActionsLogger();
   await t.notThrowsAsync(async () => {
-    const uploaded = await debugArtifacts.uploadArtifacts(
+    const uploaded = await debugArtifacts.uploadDebugArtifacts(
       logger,
       ["hucairz"],
       "i-dont-exist",
       "artifactName",
       GitHubVariant.DOTCOM,
+      undefined,
     );
     t.is(
       uploaded,
@@ -96,3 +103,44 @@ test("uploadArtifacts attempts an upload when there are files to upload", async
     );
   });
 });
+
+test("uploadDebugArtifacts when new codeql version is used should invoke artifact upload", async (t) => {
+  // Test that the artifact is uploaded.
+  const logger = getActionsLogger();
+  await t.notThrowsAsync(async () => {
+    const uploaded = await debugArtifacts.uploadDebugArtifacts(
+      logger,
+      ["hucairz"],
+      "i-dont-exist",
+      "artifactName",
+      GitHubVariant.DOTCOM,
+      "2.20.3",
+    );
+    t.is(
+      uploaded,
+      // The failure is expected since we don't want to actually upload any artifacts in unit tests.
+      "upload-failed",
+      "Expect failure to upload artifacts since root dir does not exist",
+    );
+  });
+});
+
+test("uploadDebugArtifacts when old codeql is used should avoid trying to upload artifacts", async (t) => {
+  // Test that the artifact is not uploaded.
+  const logger = getActionsLogger();
+  await t.notThrowsAsync(async () => {
+    const uploaded = await debugArtifacts.uploadDebugArtifacts(
+      logger,
+      ["hucairz"],
+      "i-dont-exist",
+      "artifactName",
+      GitHubVariant.DOTCOM,
+      "2.20.2",
+    );
+    t.is(
+      uploaded,
+      "upload-not-supported",
+      "Expected artifact upload to be blocked because of old CodeQL version",
+    );
+  });
+});

src/debug-artifacts.ts

@@ -10,11 +10,15 @@ import { getOptionalInput, getTemporaryDirectory } from "./actions-util";
 import { dbIsFinalized } from "./analyze";
 import { scanArtifactsForTokens } from "./artifact-scanner";
 import { type CodeQL } from "./codeql";
-import type { ActionConfig } from "./config/action-config";
-import { EnvVar, exportEnvVar } from "./environment";
+import { Config } from "./config-utils";
+import { EnvVar } from "./environment";
 import * as json from "./json";
 import { Language } from "./languages";
 import { Logger, withGroup } from "./logging";
+import {
+  isSafeArtifactUpload,
+  SafeArtifactUploadVersion,
+} from "./tools-features";
 import {
   bundleDb,
   doesDirectoryExist,
@@ -36,6 +40,7 @@ export function sanitizeArtifactName(name: string): string {
 export async function uploadCombinedSarifArtifacts(
   logger: Logger,
   gitHubVariant: GitHubVariant,
+  codeQlVersion: string | undefined,
 ) {
   const tempDir = getTemporaryDirectory();
 
@@ -65,12 +70,13 @@ export async function uploadCombinedSarifArtifacts(
       }
 
       try {
-        await uploadArtifacts(
+        await uploadDebugArtifacts(
           logger,
           toUpload,
           baseTempDir,
           "combined-sarif-artifacts",
           gitHubVariant,
+          codeQlVersion,
         );
       } catch (e) {
         logger.warning(
@@ -89,7 +95,7 @@ export async function uploadCombinedSarifArtifacts(
  * @return The path to that debug artifact, or undefined if an error occurs.
  */
 function tryPrepareSarifDebugArtifact(
-  config: ActionConfig<"dbLocation">,
+  config: Config,
   language: Language,
   logger: Logger,
 ): string | undefined {
@@ -131,7 +137,7 @@ function tryPrepareSarifDebugArtifact(
  */
 async function tryBundleDatabase(
   codeql: CodeQL,
-  config: ActionConfig<"dbLocation">,
+  config: Config,
   language: Language,
   logger: Logger,
 ): Promise<string | undefined> {
@@ -157,11 +163,6 @@ async function tryBundleDatabase(
   }
 }
 
-/** The minimal configuration needed for `tryUploadAllAvailableDebugArtifacts`. */
-export type UploadDebugArtifactsConfig = ActionConfig<
-  "languages" | "gitHubVersion" | "dbLocation" | "debugArtifactName"
->;
-
 /**
  * Attempt to upload all available debug artifacts.
  *
@@ -169,8 +170,9 @@ export type UploadDebugArtifactsConfig = ActionConfig<
  */
 export async function tryUploadAllAvailableDebugArtifacts(
   codeql: CodeQL,
-  config: UploadDebugArtifactsConfig,
+  config: Config,
   logger: Logger,
+  codeQlVersion: string | undefined,
 ) {
   const filesToUpload: string[] = [];
   try {
@@ -229,12 +231,13 @@ export async function tryUploadAllAvailableDebugArtifacts(
 
   try {
     await withGroup("Uploading debug artifacts", async () =>
-      uploadArtifacts(
+      uploadDebugArtifacts(
         logger,
         filesToUpload,
         config.dbLocation,
         config.debugArtifactName,
         config.gitHubVersion.type,
+        codeQlVersion,
       ),
     );
   } catch (e) {
@@ -280,6 +283,26 @@ export type UploadArtifactsResult =
   | "upload-successful"
   | "upload-failed";
 
+export async function uploadDebugArtifacts(
+  logger: Logger,
+  toUpload: string[],
+  rootDir: string,
+  artifactName: string,
+  ghVariant: GitHubVariant,
+  codeQlVersion: string | undefined,
+): Promise<UploadArtifactsResult | "upload-not-supported"> {
+  const uploadSupported = isSafeArtifactUpload(codeQlVersion);
+
+  if (!uploadSupported) {
+    core.info(
+      `Skipping debug artifact upload because the current CLI does not support safe upload. Please upgrade to CLI v${SafeArtifactUploadVersion} or later.`,
+    );
+    return "upload-not-supported";
+  }
+
+  return uploadArtifacts(logger, toUpload, rootDir, artifactName, ghVariant);
+}
+
 /**
  * Uploads the specified files as a single workflow artifact.
  *
@@ -307,7 +330,7 @@ export async function uploadArtifacts(
   // some issues early.
   if (isInTestMode()) {
     await scanArtifactsForTokens(toUpload, logger);
-    exportEnvVar("CODEQL_ACTION_ARTIFACT_SCAN_FINISHED", "true");
+    core.exportVariable("CODEQL_ACTION_ARTIFACT_SCAN_FINISHED", "true");
   }
 
   const suffix = getArtifactSuffix(getOptionalInput("matrix"));
@@ -358,7 +381,7 @@ export async function getArtifactUploaderClient(
  * all files in the database folder and return the path.
  */
 async function createPartialDatabaseBundle(
-  config: ActionConfig<"dbLocation">,
+  config: Config,
   language: Language,
 ): Promise<string> {
   const databasePath = getCodeQLDatabasePath(config, language);
@@ -399,7 +422,7 @@ async function createPartialDatabaseBundle(
  */
 async function createDatabaseBundleCli(
   codeql: CodeQL,
-  config: ActionConfig<"dbLocation">,
+  config: Config,
   language: Language,
 ): Promise<string> {
   const databaseBundlePath = await bundleDb(

src/environment.test.ts

@@ -1,12 +0,0 @@
-import test from "ava";
-
-import { Env, ReadOnlyEnv } from "./environment";
-import { getTestEnv, setupTests } from "./testing-utils";
-
-setupTests(test);
-
-test("isTestingEnv() is true", (t) => {
-  t.true(new ReadOnlyEnv(process.env).isTestingEnv());
-  t.true(new Env(process.env).isTestingEnv());
-  t.true(getTestEnv().isTestingEnv());
-});

src/environment.ts

@@ -1,10 +1,3 @@
-import * as core from "@actions/core";
-
-/**
- * This constant is set in `ava.setup.mjs` for tests.
- */
-declare const __CODEQL_ACTION_TEST_ENV__: string | undefined;
-
 /**
  * Environment variables used by Default Setup to communicate the private registry proxy configuration.
  */
@@ -218,20 +211,8 @@ export enum ActionsEnvVars {
   RUNNER_TOOL_CACHE = "RUNNER_TOOL_CACHE",
 }
 
-/** Environment variables which are not specific to CodeQL. */
-export enum SystemEnvVar {
-  /**
-   * Used by Node and related tools to indicate what kind of environment we are running in.
-   */
-  NODE_ENV = "NODE_ENV",
-}
-
 /** A type representing all known environment variables. */
-export type KnownEnvVar =
-  | EnvVar
-  | ActionsEnvVars
-  | RegistryProxyVars
-  | SystemEnvVar;
+export type KnownEnvVar = EnvVar | ActionsEnvVars | RegistryProxyVars;
 
 /**
  * Gets an environment variable, but throws an error if it is not set.
@@ -308,26 +289,6 @@ export class ReadOnlyEnv<T extends string | undefined = string | undefined> {
   public entries(): Array<[string, T]> {
     return Object.entries(this.vars);
   }
-
-  /**
-   * Gets a value indicating whether we should skip uploads of
-   * all kinds (SARIF results, status reports, DBs, ...).
-   *
-   * This is not guaranteed to be set in all test environments.
-   */
-  public isSkippingUploadsInTests(): boolean {
-    return this.getOptional(EnvVar.TEST_MODE) === "true";
-  }
-
-  /**
-   * Gets a value indicative of whether we are in a testing environment
-   * by testing whether the value of the `NODE_ENV` variable is "test".
-   * This is expected to be the case if e.g. `ava` is running the tests
-   * or if this instance was constructed by `getTestEnv`.
-   */
-  public isTestingEnv(): boolean {
-    return __CODEQL_ACTION_TEST_ENV__ === "unit-test";
-  }
 }
 
 /**
@@ -346,26 +307,6 @@ export class Env<
     this.changed = true;
   }
 
-  /**
-   * Wrapper around `core.exportVariable` which does not call `core.exportVariable`
-   * when running unit tests. This is important, because otherwise `core.exportVariable`
-   * sets environment variables for other steps in a workflow when we run unit tests in CI.
-   *
-   * @param name The name of the environment variable to set and export.
-   * @param val The value to set and export for the environment variable.
-   */
-  public export(name: string, val: T): void {
-    // Setting the environment variable for this instance is always OK, including
-    // in tests, since we use fresh `Env` instances whenever needed. This allows
-    // tests to pass that rely on that part of the `core.exportVariable` behaviour.
-    this.set(name, val);
-
-    // Call `core.exportVariable` whenever we are not in a test environment.
-    if (!this.isTestingEnv()) {
-      core.exportVariable(name, val);
-    }
-  }
-
   /** Gets a value indicating whether `set` was called at least once. */
   public hasChanged(): boolean {
     return this.changed;
@@ -376,34 +317,3 @@ export class Env<
 export function getEnv(env: NodeJS.ProcessEnv = process.env): Env {
   return new Env(env);
 }
-
-/**
- * Returns whether we are in test mode. This is used by CodeQL Action PR checks.
- *
- * In test mode, we skip several uploads (SARIF results, status reports, DBs, ...).
- *
- * @deprecated
- *  The purpose of this function is ambiguous. Use `isSkippingUploadsInTests` on
- *  a `ReadOnlyEnv` instance instead for equivalent behaviour. Use `isTestingEnv`
- *  to determine if we are running in a unit test.
- */
-export function isInTestMode(): boolean {
-  return getEnv().isSkippingUploadsInTests();
-}
-
-/**
- * Wrapper around `core.exportVariable` which does not call `core.exportVariable`
- * when running unit tests. This is important, because otherwise `core.exportVariable`
- * sets environment variables for other steps in a workflow when we run unit tests in CI.
- *
- * @deprecated Use `export` on an `Env` instance instead.
- */
-export function exportEnvVar(name: string, val: any): void {
-  const env = getEnv();
-
-  if (typeof val === "string") {
-    env.export(name, val);
-  } else {
-    env.export(name, JSON.stringify(val));
-  }
-}

src/feature-flags.ts

@@ -240,7 +240,7 @@ export const featureConfig = {
     defaultValue: false,
     envVar: "CODEQL_EXTRACTOR_CPP_AUTOINSTALL_DEPENDENCIES",
     legacyApi: true,
-    minimumVersion: undefined,
+    minimumVersion: "2.15.0",
   },
   [Feature.CsharpCacheBuildModeNone]: {
     defaultValue: false,

src/init-action-post-helper.ts

@@ -7,11 +7,6 @@ import * as actionsUtil from "./actions-util";
 import { CodeScanning, RiskAssessment } from "./analyses";
 import { getApiClient, getGitHubVersion } from "./api-client";
 import { CodeQL, getCodeQL } from "./codeql";
-import {
-  hasConfigKey,
-  type AbortedInitConfig,
-  type ActionConfig,
-} from "./config/action-config";
 import {
   Config,
   isCodeScanningEnabled,
@@ -21,7 +16,6 @@ import {
   getArtifactSuffix,
   getArtifactUploaderClient,
   sanitizeArtifactName,
-  type UploadDebugArtifactsConfig,
 } from "./debug-artifacts";
 import * as dependencyCaching from "./dependency-caching";
 import { EnvVar, ReadOnlyEnv } from "./environment";
@@ -92,11 +86,6 @@ interface FailedSarifInfo {
   checkoutPath: string;
 }
 
-/** The minimal Action configuration required to prepare and upload a failed SARIF. */
-export type FailedSarifConfig = ActionConfig<
-  "codeQLCmd" | "tempDir" | "analysisKinds" | "languages"
->;
-
 /**
  * Tries to prepare a SARIF file that contains information about a failed analysis.
  *
@@ -105,7 +94,7 @@ export type FailedSarifConfig = ActionConfig<
 async function prepareFailedSarif(
   logger: Logger,
   features: FeatureEnablement,
-  config: FailedSarifConfig,
+  config: Config,
 ): Promise<Result<FailedSarifInfo, UploadFailedSarifResult>> {
   if (!config.codeQLCmd) {
     return new Failure({
@@ -171,7 +160,7 @@ async function prepareFailedSarif(
 async function generateFailedSarif(
   logger: Logger,
   features: FeatureEnablement,
-  config: ActionConfig<"codeQLCmd" | "tempDir">,
+  config: Config,
   category: string | undefined,
   checkoutPath: string,
   sarifFile?: string,
@@ -203,7 +192,7 @@ async function generateFailedSarif(
  * category for the workflow.
  */
 async function maybeUploadFailedSarif(
-  config: FailedSarifConfig,
+  config: Config,
   repositoryNwo: RepositoryNwo,
   features: FeatureEnablement,
   logger: Logger,
@@ -238,7 +227,7 @@ async function maybeUploadFailedSarif(
 
 /** Uploads a failed SARIF file as workflow artifact, if it can be generated. */
 async function maybeUploadFailedSarifArtifact(
-  config: FailedSarifConfig,
+  config: Config,
   features: FeatureEnablement,
   logger: Logger,
 ): Promise<UploadFailedSarifResult> {
@@ -278,7 +267,7 @@ async function maybeUploadFailedSarifArtifact(
  * @returns The results of uploading the SARIF file for the failure.
  */
 export async function tryUploadSarifIfRunFailed(
-  config: FailedSarifConfig,
+  config: Config,
   repositoryNwo: RepositoryNwo,
   features: FeatureEnablement,
   logger: Logger,
@@ -335,12 +324,13 @@ export async function tryUploadSarifIfRunFailed(
 export async function uploadFailureInfo(
   uploadAllAvailableDebugArtifacts: (
     codeql: CodeQL,
-    config: UploadDebugArtifactsConfig,
+    config: Config,
     logger: Logger,
+    codeQlVersion: string,
   ) => Promise<void>,
-  printDebugLogs: (logger: Logger, config: Partial<Config>) => Promise<void>,
+  printDebugLogs: (config: Config) => Promise<void>,
   codeql: CodeQL,
-  config: Config | AbortedInitConfig,
+  config: Config,
   repositoryNwo: RepositoryNwo,
   features: FeatureEnablement,
   jobStatus: string | undefined,
@@ -387,15 +377,21 @@ export async function uploadFailureInfo(
   }
 
   // Upload appropriate Actions artifacts for debugging
-  if (config.debugMode && hasConfigKey(config, "dbLocation")) {
+  if (config.debugMode) {
     logger.info(
       "Debug mode is on. Uploading available database bundles and logs as Actions debugging artifacts...",
     );
-    await uploadAllAvailableDebugArtifacts(codeql, config, logger);
-    await printDebugLogs(logger, config);
+    const version = await codeql.getVersion();
+    await uploadAllAvailableDebugArtifacts(
+      codeql,
+      config,
+      logger,
+      version.version,
+    );
+    await printDebugLogs(config);
   }
 
-  if (actionsUtil.isSelfHostedRunner() && config.dbLocation) {
+  if (actionsUtil.isSelfHostedRunner()) {
     try {
       fs.rmSync(config.dbLocation, {
         recursive: true,
@@ -410,10 +406,6 @@ export async function uploadFailureInfo(
         `Failed to clean up database cluster directory ${config.dbLocation}. Details: ${e}`,
       );
     }
-  } else if (config.dbLocation === undefined) {
-    logger.debug(
-      "Skipping cleanup of database cluster directory since the configuration does not include a database path.",
-    );
   } else {
     logger.debug(
       "Skipping cleanup of database cluster directory since we are running on a GitHub-hosted " +
@@ -462,7 +454,7 @@ function isConclusiveJobStatus(jobStatus: string | undefined): boolean {
  */
 async function recordOverlayStatus(
   codeql: CodeQL,
-  config: Partial<Config>,
+  config: Config,
   features: FeatureEnablement,
   jobStatus: string | undefined,
   env: ReadOnlyEnv,
@@ -474,11 +466,6 @@ async function recordOverlayStatus(
     !(await features.getValue(Feature.OverlayAnalysisStatusSave))
   ) {
     return;
-  } else if (config.languages === undefined) {
-    logger.debug(
-      "Not recording overlay status, because the configuration contains no 'languages'.",
-    );
-    return;
   }
 
   // Only record a failure when the job outcome tells us something about the analysis. A cancelled

src/init-action-post.ts

@@ -6,7 +6,6 @@
 
 import * as core from "@actions/core";
 
-import { runInActions, type Action, type ActionState } from "./action-common";
 import {
   restoreInputs,
   getOptionalInput,
@@ -16,25 +15,22 @@ import {
 import { getGitHubVersion, wrapApiConfigurationError } from "./api-client";
 import { CachingKind } from "./caching-utils";
 import { getCodeQL } from "./codeql";
-import {
-  hasConfigKey,
-  type AbortedInitConfig,
-  type Config,
-} from "./config/action-config";
-import { getAbortedInitConfig, getConfig } from "./config-utils";
+import { type Config, getConfig } from "./config-utils";
 import * as debugArtifacts from "./debug-artifacts";
 import {
   DependencyCachingUsageReport,
   getDependencyCacheUsage,
 } from "./dependency-caching";
-import { EnvVar, type ReadOnlyEnv } from "./environment";
+import { EnvVar, getEnv } from "./environment";
 import { initFeatures } from "./feature-flags";
 import * as gitUtils from "./git-utils";
 import * as initActionPostHelper from "./init-action-post-helper";
+import { getActionsLogger } from "./logging";
 import { getRepositoryNwo } from "./repository";
 import {
   StatusReportBase,
   sendStatusReport,
+  sendUnhandledErrorStatusReport,
   createStatusReportBase,
   getActionsStatus,
   ActionName,
@@ -49,17 +45,16 @@ interface InitPostStatusReport
     initActionPostHelper.JobStatusReport,
     initActionPostHelper.DependencyCachingUsageReport {}
 
-async function run(action: ActionState<["Base", "Logger", "Env"]>) {
+async function run(startedAt: Date) {
   // To capture errors appropriately, keep as much code within the try-catch as
   // possible, and only use safe functions outside.
-  const logger = action.logger;
 
-  let config: Config | AbortedInitConfig | undefined;
+  const logger = getActionsLogger();
+  let config: Config | undefined;
   let uploadFailedSarifResult:
     | initActionPostHelper.UploadFailedSarifResult
     | undefined;
   let dependencyCachingUsage: DependencyCachingUsageReport | undefined;
-
   try {
     // Read the job status before restoring inputs, since it is provided by the Actions runtime
     // environment for this step and would otherwise be overwritten by the value that the `init`
@@ -69,15 +64,7 @@ async function run(action: ActionState<["Base", "Logger", "Env"]>) {
     // Restore inputs from `init` Action.
     restoreInputs(logger);
 
-    const tmpDir = getTemporaryDirectory();
-    config = await getConfig(tmpDir, logger);
-
-    // If we weren't able to read the normal configuration file, the `init` step failed before it could write it.
-    // Try to load the "failed" configuration file instead which may have been written by the `init` step
-    // with a minimal configuration for this post-action.
-    if (config === undefined) {
-      config = getAbortedInitConfig(action, tmpDir);
-    }
+    config = await getConfig(getTemporaryDirectory(), logger);
 
     const gitHubVersion = config?.gitHubVersion ?? (await getGitHubVersion());
     checkGitHubVersionInRange(gitHubVersion, logger);
@@ -105,7 +92,7 @@ async function run(action: ActionState<["Base", "Logger", "Env"]>) {
         repositoryNwo,
         features,
         jobStatus,
-        action.env,
+        getEnv(),
         logger,
       );
 
@@ -115,7 +102,6 @@ async function run(action: ActionState<["Base", "Logger", "Env"]>) {
       // and where caching may not be enabled.
       if (
         (await gitUtils.isAnalyzingDefaultBranch()) &&
-        hasConfigKey(config, "dependencyCachingEnabled") &&
         config.dependencyCachingEnabled !== CachingKind.None
       ) {
         dependencyCachingUsage = await getDependencyCacheUsage(logger);
@@ -126,9 +112,9 @@ async function run(action: ActionState<["Base", "Logger", "Env"]>) {
     core.setFailed(error.message);
 
     const statusReportBase = await createStatusReportBase(
-      action.name,
+      ActionName.InitPost,
       getActionsStatus(error),
-      action.startedAt,
+      startedAt,
       config,
       await checkDiskUsage(logger),
       logger,
@@ -140,13 +126,13 @@ async function run(action: ActionState<["Base", "Logger", "Env"]>) {
     }
     return;
   }
-  const jobStatus = getFinalJobStatus(action, config);
+  const jobStatus = getFinalJobStatus(config);
   logger.info(`CodeQL job status was ${getJobStatusDisplayName(jobStatus)}.`);
 
   const statusReportBase = await createStatusReportBase(
-    action.name,
+    ActionName.InitPost,
     "success",
-    action.startedAt,
+    startedAt,
     config,
     await checkDiskUsage(logger),
     logger,
@@ -171,21 +157,16 @@ async function run(action: ActionState<["Base", "Logger", "Env"]>) {
  * Otherwise, we determine the job status based on whether the analyze step
  * completed successfully and whether we have a valid CodeQL config.
  */
-function getFinalJobStatus(
-  action: ActionState<["Env"]>,
-  config: Partial<Config> | undefined,
-): JobStatus {
-  const existingJobStatus = getJobStatusFromEnvironment(action.env);
+function getFinalJobStatus(config: Config | undefined): JobStatus {
+  const existingJobStatus = getJobStatusFromEnvironment();
   if (existingJobStatus !== undefined) {
     return existingJobStatus;
   }
 
   let jobStatus: JobStatus;
 
-  if (
-    action.env.getOptional(EnvVar.ANALYZE_DID_COMPLETE_SUCCESSFULLY) === "true"
-  ) {
-    action.env.export(EnvVar.JOB_STATUS, JobStatus.SuccessStatus);
+  if (process.env[EnvVar.ANALYZE_DID_COMPLETE_SUCCESSFULLY] === "true") {
+    core.exportVariable(EnvVar.JOB_STATUS, JobStatus.SuccessStatus);
     jobStatus = JobStatus.SuccessStatus;
   } else if (config !== undefined) {
     // - We have computed a CodeQL config
@@ -210,7 +191,7 @@ function getFinalJobStatus(
 
   // This shouldn't be necessary, but in the odd case that we run more than one
   // `init` post step, ensure the job status is consistent between them.
-  action.env.export(EnvVar.JOB_STATUS, jobStatus);
+  core.exportVariable(EnvVar.JOB_STATUS, jobStatus);
   return jobStatus;
 }
 
@@ -219,8 +200,8 @@ function getFinalJobStatus(
  *
  * If the job status is invalid, return `UnknownStatus`.
  */
-function getJobStatusFromEnvironment(env: ReadOnlyEnv): JobStatus | undefined {
-  const jobStatusFromEnvironment = env.getOptional(EnvVar.JOB_STATUS);
+function getJobStatusFromEnvironment(): JobStatus | undefined {
+  const jobStatusFromEnvironment = process.env[EnvVar.JOB_STATUS];
 
   if (jobStatusFromEnvironment !== undefined) {
     // Validate the job status from the environment. If it is invalid, return unknown.
@@ -235,11 +216,18 @@ function getJobStatusFromEnvironment(env: ReadOnlyEnv): JobStatus | undefined {
   return undefined;
 }
 
-const initPost: Action = {
-  name: ActionName.InitPost,
-  run,
-};
-
 export async function runWrapper() {
-  return await runInActions(initPost);
+  const startedAt = new Date();
+  const logger = getActionsLogger();
+  try {
+    await run(startedAt);
+  } catch (error) {
+    core.setFailed(`init post action failed: ${wrapError(error).message}`);
+    await sendUnhandledErrorStatusReport(
+      ActionName.InitPost,
+      startedAt,
+      error,
+      logger,
+    );
+  }
 }

src/init-action.ts

@@ -5,12 +5,7 @@ import * as core from "@actions/core";
 import * as io from "@actions/io";
 import * as semver from "semver";
 
-import {
-  Action,
-  ActionState,
-  extendActionState,
-  runInActions,
-} from "./action-common";
+import { Action, ActionState, runInActions } from "./action-common";
 import {
   FileCmdNotFoundError,
   getActionVersion,
@@ -98,6 +93,7 @@ import {
   checkActionVersion,
   getErrorMessage,
   BuildMode,
+  getOptionalEnvVar,
 } from "./util";
 import { checkWorkflow } from "./workflow";
 
@@ -257,7 +253,7 @@ async function run(
     );
     const repositoryProperties = repositoryPropertiesResult.orElse({});
 
-    actionState.env.export(EnvVar.INIT_ACTION_HAS_RUN, "true");
+    core.exportVariable(EnvVar.INIT_ACTION_HAS_RUN, "true");
 
     // path.resolve() respects the intended semantics of source-root. If
     // source-root is relative, it is relative to the GITHUB_WORKSPACE. If
@@ -282,9 +278,7 @@ async function run(
     }
 
     // Compute the value of the `config-file` input.
-    const actionStateWithFeatures = extendActionState(actionState, {
-      features,
-    });
+    const actionStateWithFeatures = { ...actionState, features };
     configFile = await getConfigFileInput(
       actionStateWithFeatures,
       repositoryProperties,
@@ -355,7 +349,7 @@ async function run(
     // to the workflow log. No exceptions are thrown.
     await checkWorkflow(logger, codeql);
 
-    // Set CODEQL_ENABLE_EXPERIMENTAL_FEATURES for Rust if the CLI is older than 2.22.1.
+    // Set CODEQL_ENABLE_EXPERIMENTAL_FEATURES for Rust if between 2.19.3 (included) and 2.22.1 (excluded)
     // We need to set this environment variable before initializing the config, otherwise Rust
     // analysis will not be enabled (experimental language packs are only active with that environment
     // variable set to `true`).
@@ -366,10 +360,16 @@ async function run(
         .getRawLanguagesNoAutodetect(getOptionalInput("languages"))
         .includes(BuiltInLanguage.rust)
     ) {
+      const experimental = "2.19.3";
       const publicPreview = "2.22.1";
       const actualVer = (await codeql.getVersion()).version;
+      if (semver.lt(actualVer, experimental)) {
+        throw new ConfigurationError(
+          `Rust analysis is supported by CodeQL CLI version ${experimental} or higher, but found version ${actualVer}`,
+        );
+      }
       if (semver.lt(actualVer, publicPreview)) {
-        actionState.env.export(EnvVar.EXPERIMENTAL_FEATURES, "true");
+        core.exportVariable(EnvVar.EXPERIMENTAL_FEATURES, "true");
         logger.info("Experimental Rust analysis enabled");
       }
     }
@@ -457,18 +457,6 @@ async function run(
 
     await checkInstallPython311(config.languages, codeql);
   } catch (unwrappedError) {
-    // If we have initialised the Action state, then try to save a subset of it for use by the `init-post` action
-    // so that it can try to create and upload additional diagnostic information.
-    if (config !== undefined) {
-      try {
-        configUtils.saveAbortedInitConfig(actionState, config);
-      } catch (configSaveError) {
-        logger.warning(
-          `Unable to save configuration for '${ActionName.InitPost}' step: ${getErrorMessage(configSaveError)}`,
-        );
-      }
-    }
-
     const error = wrapError(unwrappedError);
     core.setFailed(error.message);
     const statusReportBase = await createStatusReportBase(
@@ -529,9 +517,9 @@ async function run(
     }
 
     // Forward Go flags
-    const goFlags = actionState.env.getOptional("GOFLAGS");
+    const goFlags = process.env["GOFLAGS"];
     if (goFlags) {
-      actionState.env.export("GOFLAGS", goFlags);
+      core.exportVariable("GOFLAGS", goFlags);
       core.warning(
         "Passing the GOFLAGS env parameter to the init action is deprecated. Please move this to the analyze action.",
       );
@@ -577,7 +565,7 @@ async function run(
 
             // Store the original location of our wrapper script somewhere where we can
             // later retrieve it from and cross-check that it hasn't been changed.
-            actionState.env.export(EnvVar.GO_BINARY_LOCATION, goWrapperPath);
+            core.exportVariable(EnvVar.GO_BINARY_LOCATION, goWrapperPath);
           } catch (e) {
             logger.warning(
               `Analyzing Go on Linux, but failed to install wrapper script. Tracing custom builds may fail: ${e}`,
@@ -586,7 +574,7 @@ async function run(
         } else {
           // Store the location of the original Go binary, so we can check that no setup tasks were performed after the
           // `init` Action ran.
-          actionState.env.export(EnvVar.GO_BINARY_LOCATION, goBinaryPath);
+          core.exportVariable(EnvVar.GO_BINARY_LOCATION, goBinaryPath);
         }
       } catch (e) {
         logger.warning(
@@ -621,12 +609,12 @@ async function run(
     // threads it would ask extractors to use. See help text for the "--ram" and "--threads"
     // options at https://codeql.github.com/docs/codeql-cli/manual/database-trace-command/
     // for details.
-    actionState.env.export(
+    core.exportVariable(
       "CODEQL_RAM",
       process.env["CODEQL_RAM"] ||
         getCodeQLMemoryLimit(getOptionalInput("ram"), logger).toString(),
     );
-    actionState.env.export(
+    core.exportVariable(
       "CODEQL_THREADS",
       process.env["CODEQL_THREADS"] ||
         getThreadsFlagValue(getOptionalInput("threads"), logger).toString(),
@@ -634,15 +622,21 @@ async function run(
 
     // Disable Kotlin extractor if feature flag set
     if (await features.getValue(Feature.DisableKotlinAnalysisEnabled)) {
-      actionState.env.export(
-        "CODEQL_EXTRACTOR_JAVA_AGENT_DISABLE_KOTLIN",
-        "true",
-      );
+      core.exportVariable("CODEQL_EXTRACTOR_JAVA_AGENT_DISABLE_KOTLIN", "true");
     }
 
     // Emergency override to force the CodeQL CLI back to the JGit-based Git backend.
     if (await features.getValue(Feature.ForceJGit)) {
-      actionState.env.export("CODEQL_GIT_BACKEND", "jgit");
+      core.exportVariable("CODEQL_GIT_BACKEND", "jgit");
+    }
+
+    const kotlinLimitVar =
+      "CODEQL_EXTRACTOR_KOTLIN_OVERRIDE_MAXIMUM_VERSION_LIMIT";
+    if (
+      (await codeQlVersionAtLeast(codeql, "2.20.3")) &&
+      !(await codeQlVersionAtLeast(codeql, "2.20.4"))
+    ) {
+      core.exportVariable(kotlinLimitVar, "2.1.20");
     }
 
     // Restore dependency cache(s), if they exist.
@@ -691,7 +685,7 @@ async function run(
       config.buildMode === BuildMode.None &&
       config.languages.includes(BuiltInLanguage.java)
     ) {
-      actionState.env.export(
+      core.exportVariable(
         EnvVar.JAVA_EXTRACTOR_MINIMIZE_DEPENDENCY_JARS,
         "true",
       );
@@ -749,7 +743,7 @@ async function run(
     const tracerConfig = await getCombinedTracerConfig(logger, codeql, config);
     if (tracerConfig !== undefined) {
       for (const [key, value] of Object.entries(tracerConfig.env)) {
-        actionState.env.export(key, value);
+        core.exportVariable(key, value);
       }
     }
 
@@ -757,10 +751,10 @@ async function run(
     if (await features.getValue(Feature.JavaNetworkDebugging)) {
       // Get the existing value of `JAVA_TOOL_OPTIONS`, if any.
       const existingJavaToolOptions =
-        actionState.env.getOptional(JavaEnvVars.JAVA_TOOL_OPTIONS) ?? "";
+        getOptionalEnvVar(JavaEnvVars.JAVA_TOOL_OPTIONS) || "";
 
       // Add the network debugging options.
-      actionState.env.export(
+      core.exportVariable(
         JavaEnvVars.JAVA_TOOL_OPTIONS,
         `${existingJavaToolOptions} -Djavax.net.debug=all`,
       );

src/init.test.ts

@@ -1,13 +1,14 @@
 import * as fs from "fs";
 import path from "path";
 
+import * as core from "@actions/core";
 import * as github from "@actions/github";
 import test, { ExecutionContext } from "ava";
 import * as sinon from "sinon";
 
 import * as actionsUtil from "./actions-util";
 import { createStubCodeQL } from "./codeql";
-import * as environment from "./environment";
+import { ActionsEnvVars } from "./environment";
 import { Feature } from "./feature-flags";
 import {
   checkPacksForOverlayCompatibility,
@@ -84,7 +85,7 @@ for (const { runnerEnv, ErrorConstructor, message } of [
     `cleanupDatabaseClusterDirectory throws a ${ErrorConstructor.name} when cleanup fails on ${runnerEnv} runner`,
     async (t) => {
       await withTmpDir(async (tmpDir: string) => {
-        process.env[environment.ActionsEnvVars.RUNNER_ENVIRONMENT] = runnerEnv;
+        process.env[ActionsEnvVars.RUNNER_ENVIRONMENT] = runnerEnv;
 
         const dbLocation = path.resolve(tmpDir, "dbs");
         fs.mkdirSync(dbLocation, { recursive: true });
@@ -545,7 +546,7 @@ test.serial(
 test.serial(
   "file coverage deprecation warning for org-owned repo with default setup recommends repo property",
   (t) => {
-    const exportEnvVarStub = sinon.stub(environment, "exportEnvVar");
+    const exportVariableStub = sinon.stub(core, "exportVariable");
     sinon.stub(actionsUtil, "isDefaultSetup").returns(true);
     github.context.payload = {
       repository: {
@@ -565,14 +566,14 @@ test.serial(
         'with the name `github-codeql-file-coverage-on-prs` and the type "True/false", then set this property to ' +
         "`true` in the repository's settings.",
     );
-    t.true(exportEnvVarStub.calledOnce);
+    t.true(exportVariableStub.calledOnce);
   },
 );
 
 test.serial(
   "file coverage deprecation warning for org-owned repo with advanced setup recommends env var and repo property",
   (t) => {
-    const exportEnvVarStub = sinon.stub(environment, "exportEnvVar");
+    const exportVariableStub = sinon.stub(core, "exportVariable");
     sinon.stub(actionsUtil, "isDefaultSetup").returns(false);
     github.context.payload = {
       repository: {
@@ -593,14 +594,14 @@ test.serial(
         'with the name `github-codeql-file-coverage-on-prs` and the type "True/false", then set this property to ' +
         "`true` in the repository's settings.",
     );
-    t.true(exportEnvVarStub.calledOnce);
+    t.true(exportVariableStub.calledOnce);
   },
 );
 
 test.serial(
   "file coverage deprecation warning for user-owned repo with default setup recommends advanced setup",
   (t) => {
-    const exportEnvVarStub = sinon.stub(environment, "exportEnvVar");
+    const exportVariableStub = sinon.stub(core, "exportVariable");
     sinon.stub(actionsUtil, "isDefaultSetup").returns(true);
     github.context.payload = {
       repository: {
@@ -619,14 +620,14 @@ test.serial(
         "To opt out of this change, switch to an advanced setup workflow and " +
         "set the `CODEQL_ACTION_FILE_COVERAGE_ON_PRS` environment variable to `true`.",
     );
-    t.true(exportEnvVarStub.calledOnce);
+    t.true(exportVariableStub.calledOnce);
   },
 );
 
 test.serial(
   "file coverage deprecation warning for user-owned repo with advanced setup recommends env var",
   (t) => {
-    const exportEnvVarStub = sinon.stub(environment, "exportEnvVar");
+    const exportVariableStub = sinon.stub(core, "exportVariable");
     sinon.stub(actionsUtil, "isDefaultSetup").returns(false);
     github.context.payload = {
       repository: {
@@ -644,14 +645,14 @@ test.serial(
         "to improve analysis performance. File coverage information will still be computed on non-PR analyses.\n\n" +
         "To opt out of this change, set the `CODEQL_ACTION_FILE_COVERAGE_ON_PRS` environment variable to `true`.",
     );
-    t.true(exportEnvVarStub.calledOnce);
+    t.true(exportVariableStub.calledOnce);
   },
 );
 
 test.serial(
   "file coverage deprecation warning for unknown owner type with default setup recommends advanced setup",
   (t) => {
-    const exportEnvVarStub = sinon.stub(environment, "exportEnvVar");
+    const exportVariableStub = sinon.stub(core, "exportVariable");
     sinon.stub(actionsUtil, "isDefaultSetup").returns(true);
     github.context.payload = { repository: undefined };
     const messages: LoggedMessage[] = [];
@@ -665,14 +666,14 @@ test.serial(
         "To opt out of this change, switch to an advanced setup workflow and " +
         "set the `CODEQL_ACTION_FILE_COVERAGE_ON_PRS` environment variable to `true`.",
     );
-    t.true(exportEnvVarStub.calledOnce);
+    t.true(exportVariableStub.calledOnce);
   },
 );
 
 test.serial(
   "file coverage deprecation warning for unknown owner type with advanced setup recommends env var",
   (t) => {
-    const exportEnvVarStub = sinon.stub(environment, "exportEnvVar");
+    const exportVariableStub = sinon.stub(core, "exportVariable");
     sinon.stub(actionsUtil, "isDefaultSetup").returns(false);
     github.context.payload = { repository: undefined };
     const messages: LoggedMessage[] = [];
@@ -685,7 +686,7 @@ test.serial(
         "to improve analysis performance. File coverage information will still be computed on non-PR analyses.\n\n" +
         "To opt out of this change, set the `CODEQL_ACTION_FILE_COVERAGE_ON_PRS` environment variable to `true`.",
     );
-    t.true(exportEnvVarStub.calledOnce);
+    t.true(exportVariableStub.calledOnce);
   },
 );
 
@@ -694,10 +695,10 @@ test.serial(
   (t) => {
     process.env["CODEQL_ACTION_DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION"] =
       "true";
-    const exportEnvVarStub = sinon.stub(environment, "exportEnvVar");
+    const exportVariableStub = sinon.stub(core, "exportVariable");
     const messages: LoggedMessage[] = [];
     logFileCoverageOnPrsDeprecationWarning(getRecordingLogger(messages));
     t.is(messages.length, 0);
-    t.true(exportEnvVarStub.notCalled);
+    t.true(exportVariableStub.notCalled);
   },
 );

src/init.ts

@@ -1,6 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 
+import * as core from "@actions/core";
 import * as toolrunner from "@actions/exec/lib/toolrunner";
 import * as github from "@actions/github";
 import * as io from "@actions/io";
@@ -16,7 +17,7 @@ import {
 import { GitHubApiDetails } from "./api-client";
 import { CodeQL, setupCodeQL } from "./codeql";
 import * as configUtils from "./config-utils";
-import { EnvVar, exportEnvVar } from "./environment";
+import { EnvVar } from "./environment";
 import {
   CodeQLDefaultVersionInfo,
   Feature,
@@ -410,5 +411,5 @@ export function logFileCoverageOnPrsDeprecationWarning(logger: Logger): void {
   }
 
   logger.warning(message);
-  exportEnvVar(EnvVar.DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION, "true");
+  core.exportVariable(EnvVar.DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION, "true");
 }

src/overlay/caching.test.ts

@@ -8,7 +8,6 @@ import * as sinon from "sinon";
 import * as actionsUtil from "../actions-util";
 import * as apiClient from "../api-client";
 import type { ResolveDatabaseOutput } from "../codeql";
-import * as environment from "../environment";
 import * as gitUtils from "../git-utils";
 import { BuiltInLanguage } from "../languages";
 import { getRunnerLogger } from "../logging";
@@ -83,7 +82,7 @@ const testDownloadOverlayBaseDatabaseFromCache = makeMacro({
 
       sinon.stub(apiClient, "getAutomationID").resolves("test-automation-id/");
 
-      sinon.stub(environment, "isInTestMode").returns(testCase.isInTestMode);
+      sinon.stub(utils, "isInTestMode").returns(testCase.isInTestMode);
 
       if (testCase.restoreCacheResult instanceof Error) {
         sinon

src/setup-codeql-action.ts

@@ -1,11 +1,6 @@
 import * as core from "@actions/core";
 
-import {
-  Action,
-  ActionState,
-  extendActionState,
-  runInActions,
-} from "./action-common";
+import { Action, ActionState, runInActions } from "./action-common";
 import {
   getActionVersion,
   getOptionalInput,
@@ -136,9 +131,7 @@ async function run(
     );
     const repositoryProperties = repositoryPropertiesResult.orElse({});
 
-    const actionStateWithFeatures = extendActionState(actionState, {
-      features,
-    });
+    const actionStateWithFeatures = { ...actionState, features };
 
     const statusReportBase = await createStatusReportBase(
       ActionName.SetupCodeQL,
@@ -191,7 +184,7 @@ async function run(
     core.setOutput("codeql-path", codeql.getPath());
     core.setOutput("codeql-version", (await codeql.getVersion()).version);
 
-    actionState.env.export(EnvVar.SETUP_CODEQL_ACTION_HAS_RUN, "true");
+    core.exportVariable(EnvVar.SETUP_CODEQL_ACTION_HAS_RUN, "true");
   } catch (unwrappedError) {
     const error = wrapError(unwrappedError);
     core.setFailed(error.message);

src/setup-codeql.ts

@@ -3,6 +3,7 @@ import { OutgoingHttpHeaders } from "http";
 import * as path from "path";
 import { performance } from "perf_hooks";
 
+import * as core from "@actions/core";
 import * as toolcache from "@actions/tool-cache";
 import { default as deepEqual } from "fast-deep-equal";
 import * as semver from "semver";
@@ -28,7 +29,7 @@ import {
   makeDiagnostic,
   makeTelemetryDiagnostic,
 } from "./diagnostics";
-import { EnvVar, exportEnvVar, getEnv } from "./environment";
+import { EnvVar, getEnv } from "./environment";
 import {
   CODEQL_VERSION_ZSTD_BUNDLE,
   CodeQLDefaultVersionInfo,
@@ -1070,7 +1071,7 @@ export async function setupCodeQLBundle(
 
   // Record that this job now has a copy of the CodeQL tools, so that a later step doesn't delete
   // the toolcache out from under the path we are about to return.
-  exportEnvVar(EnvVar.HAS_SET_UP_CODEQL, "true");
+  core.exportVariable(EnvVar.HAS_SET_UP_CODEQL, "true");
 
   return {
     codeqlFolder,

src/start-proxy-action.ts

@@ -3,12 +3,7 @@ import * as path from "path";
 
 import * as core from "@actions/core";
 
-import {
-  Action,
-  ActionState,
-  extendActionState,
-  runInActions,
-} from "./action-common";
+import { Action, ActionState, runInActions } from "./action-common";
 import * as actionsUtil from "./actions-util";
 import { getGitHubVersion } from "./api-client";
 import { FeatureEnablement, initFeatures } from "./feature-flags";
@@ -103,8 +98,7 @@ async function run(action: ActionState<["Base", "Logger", "Env", "Actions"]>) {
     };
 
     // Start the Proxy
-    const actionWithFeatures = extendActionState(action, { features });
-    const proxyBin = await getProxyBinaryPath(actionWithFeatures);
+    const proxyBin = await getProxyBinaryPath({ ...action, features });
     const proxyInfo = await startProxy(
       proxyBin,
       proxyConfig,

src/status-report.ts

@@ -23,13 +23,7 @@ import type { ComputedInput, InputName } from "./config/inputs";
 import { parseRegistriesWithoutCredentials } from "./config/pack-registries";
 import type { DependencyCacheRestoreStatusReport } from "./dependency-caching";
 import { DocUrl } from "./doc-url";
-import {
-  EnvVar,
-  getEnv,
-  ReadOnlyEnv,
-  RegistryProxyVars,
-  exportEnvVar,
-} from "./environment";
+import { EnvVar, getEnv, ReadOnlyEnv, RegistryProxyVars } from "./environment";
 import { getRef } from "./git-utils";
 import * as json from "./json";
 import type { Logger } from "./logging";
@@ -61,21 +55,13 @@ export enum ActionName {
   UploadSarif = "upload-sarif",
 }
 
-/** A partial mapping from `ActionName` to names for actions whose display name is not the `ActionName` value. */
-export const ACTION_DISPLAY_NAMES: Partial<Record<ActionName, string>> = {
-  [ActionName.Analyze]: "analyze",
-  [ActionName.InitPost]: "init post",
-};
-
 /**
- * Maps an {@link ActionName} to its display name. Usually that is the same, except
- * for actions which have a different display name in {@link ACTION_DISPLAY_NAMES}.
+ * Maps an `ActionName` to its display name. Usually that is the same, except
+ * for `ActionName.Analyze` where it is `"analyze"` instead of `"finish"`.
  */
 export function getDisplayActionName(actionName: ActionName): string {
-  const displayName = ACTION_DISPLAY_NAMES[actionName];
-
-  if (displayName !== undefined) {
-    return displayName;
+  if (actionName === ActionName.Analyze) {
+    return "analyze";
   }
   return actionName;
 }
@@ -85,7 +71,9 @@ export function getDisplayActionName(actionName: ActionName): string {
  * environment and returns it.
  * If a new UUID is generated, it is also exported as an environment variable.
  */
-export function getJobUUID(action: ActionState<["Logger", "Env", "Actions"]>) {
+export function getJobUUID(
+  action: ActionState<["Logger", "ReadOnlyEnv", "Actions"]>,
+) {
   // Check if we already have a UUID for the analysis and return it if so.
   const existingJobRunUuid = action.env.getOptional(EnvVar.JOB_RUN_UUID);
 
@@ -98,7 +86,7 @@ export function getJobUUID(action: ActionState<["Logger", "Env", "Actions"]>) {
   const jobRunUuid = uuid.v4();
   action.logger.info(`Job run UUID is ${jobRunUuid}.`);
 
-  action.env.export(EnvVar.JOB_RUN_UUID, jobRunUuid);
+  action.actions.exportVariable(EnvVar.JOB_RUN_UUID, jobRunUuid);
   return jobRunUuid;
 }
 
@@ -280,12 +268,12 @@ export function getJobStatusDisplayName(status: JobStatus): string {
  */
 function setJobStatusIfUnsuccessful(actionStatus: ActionStatus) {
   if (actionStatus === "user-error") {
-    exportEnvVar(
+    core.exportVariable(
       EnvVar.JOB_STATUS,
       process.env[EnvVar.JOB_STATUS] ?? JobStatus.ConfigErrorStatus,
     );
   } else if (actionStatus === "failure" || actionStatus === "aborted") {
-    exportEnvVar(
+    core.exportVariable(
       EnvVar.JOB_STATUS,
       process.env[EnvVar.JOB_STATUS] ?? JobStatus.FailureStatus,
     );
@@ -388,7 +376,7 @@ export async function createStatusReportBase(
     let workflowStartedAt = process.env[EnvVar.WORKFLOW_STARTED_AT];
     if (workflowStartedAt === undefined) {
       workflowStartedAt = actionStartedAt.toISOString();
-      exportEnvVar(EnvVar.WORKFLOW_STARTED_AT, workflowStartedAt);
+      core.exportVariable(EnvVar.WORKFLOW_STARTED_AT, workflowStartedAt);
     }
     const runnerOs = getRequiredEnvParam("RUNNER_OS");
     const codeQlCliVersion = getCachedCodeQlVersion(
@@ -400,7 +388,7 @@ export async function createStatusReportBase(
     // re-export the testing environment variable so that it is available to subsequent steps,
     // even if it was only set for this step
     if (testingEnvironment) {
-      exportEnvVar(EnvVar.TESTING_ENVIRONMENT, testingEnvironment);
+      core.exportVariable(EnvVar.TESTING_ENVIRONMENT, testingEnvironment);
     }
     const isSteadyStateDefaultSetupRun =
       process.env["CODE_SCANNING_IS_STEADY_STATE_DEFAULT_SETUP"] === "true";

src/testing-utils.ts

@@ -202,6 +202,10 @@ class TestActionsEnv implements ActionsEnv {
   public getOptionalInput(_name: string): string | undefined {
     return undefined;
   }
+
+  public exportVariable(name: string, value: string): void {
+    this.env.set(name, value);
+  }
 }
 
 /**

src/tools-features.ts

@@ -1,3 +1,5 @@
+import * as semver from "semver";
+
 import type { VersionInfo } from "./cli/types";
 
 export enum ToolsFeature {
@@ -21,3 +23,21 @@ export function isSupportedToolsFeature(
 ): boolean {
   return !!versionInfo.features && versionInfo.features[feature];
 }
+
+export const SafeArtifactUploadVersion = "2.20.3";
+
+/**
+ * The first version of the CodeQL CLI where artifact upload is safe to use
+ * for failed runs. This is not really a feature flag, but it is easiest to
+ * model the behavior as a feature flag.
+ *
+ * This was not captured in a tools feature, so we need to use semver.
+ *
+ * @param codeQlVersion The version of the CodeQL CLI to check. If not provided, it is assumed to be safe.
+ * @returns True if artifact upload is safe to use for failed runs or false otherwise.
+ */
+export function isSafeArtifactUpload(codeQlVersion?: string): boolean {
+  return !codeQlVersion
+    ? true
+    : semver.gte(codeQlVersion, SafeArtifactUploadVersion);
+}

src/upload-lib.ts

@@ -14,7 +14,7 @@ import { getGitHubVersion, wrapApiConfigurationError } from "./api-client";
 import { CodeQL, getCodeQL } from "./codeql";
 import { getConfig } from "./config-utils";
 import { readDiffRangesJsonFile } from "./diff-informed-analysis-utils";
-import { EnvVar, exportEnvVar } from "./environment";
+import { EnvVar } from "./environment";
 import { FeatureEnablement } from "./feature-flags";
 import * as fingerprints from "./fingerprints";
 import * as gitUtils from "./git-utils";
@@ -126,7 +126,7 @@ async function combineSarifFilesUsingCLI(
       logger.warning(
         `Uploading multiple SARIF runs with the same category is deprecated ${deprecationWarningMessage}. Please update your workflow to upload a single run per category. ${deprecationMoreInformationMessage}`,
       );
-      exportEnvVar("CODEQL_MERGE_SARIF_DEPRECATION_WARNING", "true");
+      core.exportVariable("CODEQL_MERGE_SARIF_DEPRECATION_WARNING", "true");
     }
 
     // If not, use the naive method of combining the files.
@@ -1032,7 +1032,7 @@ export function validateUniqueCategory(
           `Category: (${id ? id : "none"}) Tool: (${tool ? tool : "none"})`,
       );
     }
-    exportEnvVar(sentinelEnvVar, sentinelEnvVar);
+    core.exportVariable(sentinelEnvVar, sentinelEnvVar);
   }
 }
 

src/upload-sarif-action-post.ts

@@ -34,7 +34,13 @@ export async function runWrapper() {
         return;
       }
       await withGroup("Uploading combined SARIF debug artifact", () =>
-        debugArtifacts.uploadCombinedSarifArtifacts(logger, gitHubVersion.type),
+        debugArtifacts.uploadCombinedSarifArtifacts(
+          logger,
+          gitHubVersion.type,
+          // The codeqlVersion is not applicable for uploading non-codeql sarif.
+          // We can assume all versions are safe to upload.
+          undefined,
+        ),
       );
     }
   } catch (error) {

src/util.ts

@@ -12,26 +12,15 @@ import * as semver from "semver";
 
 import * as apiCompatibility from "./api-compatibility.json";
 import type { CodeQL } from "./codeql";
-import type { ActionConfig } from "./config/action-config";
 import type { Pack } from "./config/db-config";
 import type { Config } from "./config-utils";
-import {
-  EnvVar,
-  getRequiredEnvParam,
-  isInTestMode,
-  exportEnvVar,
-} from "./environment";
+import { EnvVar, getRequiredEnvParam } from "./environment";
 import * as json from "./json";
 import { Language } from "./languages";
 import { Logger } from "./logging";
 
 // Re-export for backwards compatibility to avoid updating a lot of imports elsewhere.
-export {
-  getRequiredEnvParam,
-  getOptionalEnvVar,
-  getEnv,
-  isInTestMode,
-} from "./environment";
+export { getRequiredEnvParam, getOptionalEnvVar, getEnv } from "./environment";
 
 /**
  * The name of the file containing the base database OIDs, as stored in the
@@ -446,10 +435,7 @@ export function getThreadsFlag(
 /**
  * Get the path where the CodeQL database for the given language lives.
  */
-export function getCodeQLDatabasePath(
-  config: ActionConfig<"dbLocation">,
-  language: Language,
-) {
+export function getCodeQLDatabasePath(config: Config, language: Language) {
   return path.resolve(config.dbLocation, language);
 }
 
@@ -556,7 +542,7 @@ export function checkGitHubVersionInRange(
     );
   }
   hasBeenWarnedAboutVersion = true;
-  exportEnvVar(CODEQL_ACTION_WARNED_ABOUT_VERSION_ENV_VAR, true);
+  core.exportVariable(CODEQL_ACTION_WARNED_ABOUT_VERSION_ENV_VAR, true);
 }
 
 export enum DisallowedAPIVersionReason {
@@ -600,11 +586,11 @@ export function assertNever(value: never): never {
  * knowing what version of CodeQL we're running.
  */
 export function initializeEnvironment(version: string) {
-  exportEnvVar(EnvVar.FEATURE_MULTI_LANGUAGE, "false");
-  exportEnvVar(EnvVar.FEATURE_SANDWICH, "false");
-  exportEnvVar(EnvVar.FEATURE_SARIF_COMBINE, "true");
-  exportEnvVar(EnvVar.FEATURE_WILL_UPLOAD, "true");
-  exportEnvVar(EnvVar.VERSION, version);
+  core.exportVariable(EnvVar.FEATURE_MULTI_LANGUAGE, "false");
+  core.exportVariable(EnvVar.FEATURE_SANDWICH, "false");
+  core.exportVariable(EnvVar.FEATURE_SARIF_COMBINE, "true");
+  core.exportVariable(EnvVar.FEATURE_WILL_UPLOAD, "true");
+  core.exportVariable(EnvVar.VERSION, version);
 }
 
 export class HTTPError extends Error {
@@ -643,9 +629,7 @@ export async function codeQlVersionAtLeast(
   return semver.gte((await codeql.getVersion()).version, requiredVersion);
 }
 
-export function getBaseDatabaseOidsFilePath(
-  config: ActionConfig<"dbLocation">,
-): string {
+export function getBaseDatabaseOidsFilePath(config: Config): string {
   return path.join(config.dbLocation, BASE_DATABASE_OIDS_FILE_NAME);
 }
 
@@ -657,7 +641,7 @@ export function getBaseDatabaseOidsFilePath(
  * given `includeDiagnostics` value.
  */
 export async function bundleDb(
-  config: ActionConfig<"dbLocation">,
+  config: Config,
   language: Language,
   codeql: CodeQL,
   dbName: string,
@@ -727,6 +711,15 @@ export function isGoodVersion(versionSpec: string) {
   return !BROKEN_VERSIONS.includes(versionSpec);
 }
 
+/**
+ * Returns whether we are in test mode. This is used by CodeQL Action PR checks.
+ *
+ * In test mode, we skip several uploads (SARIF results, status reports, DBs, ...).
+ */
+export function isInTestMode(): boolean {
+  return process.env[EnvVar.TEST_MODE] === "true";
+}
+
 /**
  * Returns whether we specifically want to skip uploading SARIF files.
  */
@@ -955,7 +948,7 @@ export async function checkDiskUsage(
       } else {
         logger.debug(message);
       }
-      exportEnvVar(EnvVar.HAS_WARNED_ABOUT_DISK_SPACE, "true");
+      core.exportVariable(EnvVar.HAS_WARNED_ABOUT_DISK_SPACE, "true");
     }
     return {
       numAvailableBytes: diskUsage.bavail * blockSizeInBytes,
@@ -1004,7 +997,7 @@ export function checkActionVersion(
           "https://github.blog/changelog/2025-10-28-upcoming-deprecation-of-codeql-action-v3/",
       );
       // set LOG_VERSION_DEPRECATION env var to prevent the warning from being logged multiple times
-      exportEnvVar(EnvVar.LOG_VERSION_DEPRECATION, "true");
+      core.exportVariable(EnvVar.LOG_VERSION_DEPRECATION, "true");
     }
   }
 }

start-proxy/action.yml

@@ -29,6 +29,6 @@ outputs:
   proxy_urls:
     description: A stringified JSON array of objects containing the types and URLs of the configured registries.
 runs:
-  using: node24
+  using: node20
   main: "../lib/start-proxy-entry.js"
   post: "../lib/start-proxy-post-entry.js"

unreleased-change-notes/README.md

@@ -1,24 +0,0 @@
-## Change notes
-
-Change-notes are Markdown files used to document user-facing changes. When making a change that affects users, create a Markdown file here that describes the change. During the next release, the change-note files in `unreleased-change-notes/` will automatically be added to `CHANGELOG.md`.
-
-### Change-note file format
-
-Change-note files must follow a certain format so that they can be automatically validated and processed. Failure to follow the format will result in a failed PR check.
-
-You may validate your change-note file locally by running `npx tsx pr-checks/changenotes.ts validate`. This command will scan all change-note files in `unreleased-change-notes/` and report any errors.
-
-
-#### Body
-
-The body of the change-note file must:
-
-- Be written in valid [GitHub-Flavored Markdown](https://github.github.com/gfm/).
-- Be structured as a single unordered Markdown list with hyphen (`-`) bullets. Each list item should describe a single change. If there are multiple changes, use multiple list items.
-
-### Example change-note file
-
-```
-- Fixed a bug where a network error while streaming the download of the CodeQL bundle could terminate the `init` Action instead of falling back to downloading the bundle before extracting it. [#4061](https://github.com/github/codeql-action/pull/4061)
-- Fix incorrect minimum required Git version for [improved incremental analysis](https://github.com/github/roadmap/issues/1158): it should have been 2.36.0, not 2.11.0. [#3781](https://github.com/github/codeql-action/pull/3781)
-```

upload-sarif/action.yml

@@ -41,6 +41,6 @@ outputs:
 
       { "code-scanning": "some-id", "code-quality": "some-other-id" }
 runs:
-  using: node24
+  using: node20
   main: '../lib/upload-sarif-entry.js'
   post: '../lib/upload-sarif-post-entry.js'