From 35f51abf321b0ee1397355ea6957602a76600aba Mon Sep 17 00:00:00 2001 From: Ludovic Henry Date: Thu, 19 Nov 2026 00:19:01 +0100 Subject: [PATCH 1/2] upstreaming: hash-pinned native artifact compatibility fix for v1.2.2 Use the existing protected native-target frame around artifact uploads. Preserve immutable repository selectors, original Claim/run binding, Completion, closed channels and independent artifact verification. Add native-handler regressions and fail-closed installer tests. Read replay JSON from its actual CLI stream and require the native artifact name. --- upstreaming/gh-aw-compat/LICENSE | 21 + upstreaming/gh-aw-compat/README.md | 79 +++ upstreaming/gh-aw-compat/check.sh | 20 + .../gh-aw-compat/native-artifact.patch | 55 ++ .../tests/upload_artifact.v1.2.2.cjs.b64 | 641 ++++++++++++++++++ .../tests/upload_artifact_work_queue.test.cjs | 340 ++++++++++ upstreaming/gh_aw_compat.py | 52 ++ upstreaming/queue_result.py | 17 +- upstreaming/tests/test_gh_aw_compat.py | 38 ++ upstreaming/tests/test_pipeline.py | 2 +- upstreaming/tests/test_queue_result.py | 15 +- upstreaming/work.py | 2 +- 12 files changed, 1276 insertions(+), 6 deletions(-) create mode 100644 upstreaming/gh-aw-compat/LICENSE create mode 100644 upstreaming/gh-aw-compat/README.md create mode 100644 upstreaming/gh-aw-compat/check.sh create mode 100644 upstreaming/gh-aw-compat/native-artifact.patch create mode 100644 upstreaming/gh-aw-compat/tests/upload_artifact.v1.2.2.cjs.b64 create mode 100644 upstreaming/gh-aw-compat/tests/upload_artifact_work_queue.test.cjs create mode 100644 upstreaming/gh_aw_compat.py create mode 100644 upstreaming/tests/test_gh_aw_compat.py diff --git a/upstreaming/gh-aw-compat/LICENSE b/upstreaming/gh-aw-compat/LICENSE new file mode 100644 index 00000000000..28a50fa2263 --- /dev/null +++ b/upstreaming/gh-aw-compat/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright GitHub, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/upstreaming/gh-aw-compat/README.md b/upstreaming/gh-aw-compat/README.md new file mode 100644 index 00000000000..9ace4849fad --- /dev/null +++ b/upstreaming/gh-aw-compat/README.md @@ -0,0 +1,79 @@ +# Native artifact compatibility patch for gh-aw v1.2.2 + +Approved by the operator after investigator run 44415024119 failed native +artifact delivery. Base source: github/gh-aw tag v1.2.2, commit +`399a445fe2d8926c616b54b1b82a16b5b2be4445`. + +## Why + +`upload_artifact.cjs` constructs a target containing the native repository +ID and worker run ID, then authorizes it as an ordinary resource effect. +Ordinary targets require matching run IDs in immutable Work selectors. +The dispatcher cannot know a future worker run ID when admitting Work. + +The handler already resolves the native repository via the GitHub API. +The patch wraps the native upload in `withClaimResourceEffects`, gh-aw's +existing protected native-target frame. That frame authenticates the Claim, +checks immutable repository selectors and the exact original dispatch/run +binding, and authorizes the concrete target before calling the artifact client. +It does not change general resource-scope validation. + +Unchanged: durable Completion requirement, original Claim and factory fences, +repository-ID checks, immutable Work scope, original native run binding, +closed effect channels, private in-process delivery receipt, independent +artifact ID/name/run/digest/size readback, and verified Result publication. +No credentials, scheduler changes, generic artifact fallback, or direct pushes. + +## Installation + +The worker and investigator use `jobs.safe_outputs.pre-steps`, a supported +compiler hook, immediately after runtime setup and before artifact downloads +or handler loading. They check out trusted code at `github.sha` with no persisted +credentials and run `upstreaming/gh_aw_compat.py` against the flat runtime modules. +The installer checks the original handler SHA-256, applies only +`native-artifact.patch`, and checks the exact resulting SHA-256. Unknown source, +symlink, failed application or unexpected output aborts the job. Reapplication +of the exact patched file is idempotent. + +Compiler-generated lock files are never edited by hand. The gh-aw release, +setup action and CLI stay pinned to v1.2.2. + +## Tests + +```sh +python3 -m unittest upstreaming.tests.test_gh_aw_compat +sh upstreaming/gh-aw-compat/check.sh +``` + +The second command fetches the pinned source and locked test dependencies, +applies the exact runtime patch, and runs upstream's native upload and +resource-scope tests. All native upload tests now use an immutable repository +selector without a future run ID. Additional tests reject a mismatched +repository ID, explicit foreign run selector and changed runtime run ID before +upload. Existing tests reject foreign Claims, cancelled Claims, reused factories, +closed channels and every altered artifact metadata field. All APIs and uploads +are mocked. No remote state is changed. + +Local result: 109 tests pass (30 artifact tests, 79 resource-scope tests). +Live end-to-end validation is still required; this result alone does not prove +that the pipeline publishes or that numpy CI runs. + +Two companion integration corrections use the actual v1.2.2 behavior: + +- The validating CLI replay emits JSON on stderr. The reader accepts one complete + projection from stdout or stderr only after a successful exit. +- The native safe-output tool takes `path`, not a name override. The verified + artifact suffix is `upstreaming-out`, matching the uploaded directory. The + exact artifact ID, Claim/run binding and digest checks are unchanged. + +The old failed Work has Completion but no Result and a pending delivery barrier. +This patch does not rewrite that history or authorize replay of its effects. +Recovery must use supported queue operations and independently verified state, +not fabricated receipts or a reset queue. + +## Licensing + +The patch, upstream handler fixture, and adapted upstream regression test are +based on GitHub's MIT-licensed source. Its copyright and license are retained +in `LICENSE`. No upstream issue or PR has been opened; that is a separate remote +action requiring authorization. diff --git a/upstreaming/gh-aw-compat/check.sh b/upstreaming/gh-aw-compat/check.sh new file mode 100644 index 00000000000..9f547b34464 --- /dev/null +++ b/upstreaming/gh-aw-compat/check.sh @@ -0,0 +1,20 @@ +#!/bin/sh +# SPDX-FileCopyrightText: 2026 The RISE Project +# SPDX-License-Identifier: MIT +# Reproduce the native handler tests against the exact v1.2.2 source. +# No GitHub writes, artifact uploads, credentials or live API calls. +set -eu +root=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd) +tmp=$(mktemp -d) +trap 'rm -rf "$tmp"' EXIT +git clone --quiet --depth 1 --branch v1.2.2 --filter=blob:none --sparse \ + https://github.com/github/gh-aw.git "$tmp/source" +[ "$(git -C "$tmp/source" rev-parse HEAD)" = 399a445fe2d8926c616b54b1b82a16b5b2be4445 ] +git -C "$tmp/source" sparse-checkout set actions/setup/js specs/work-queue +python3 "$root/upstreaming/gh_aw_compat.py" "$tmp/source/actions/setup/js" +cp "$root/upstreaming/gh-aw-compat/tests/upload_artifact_work_queue.test.cjs" \ + "$tmp/source/actions/setup/js/upload_artifact_work_queue.test.cjs" +cd "$tmp/source/actions/setup/js" +npm ci --ignore-scripts --no-audit --no-fund +npx --no-install vitest run --no-file-parallelism \ + upload_artifact_work_queue.test.cjs work_queue_resource_scope.test.cjs diff --git a/upstreaming/gh-aw-compat/native-artifact.patch b/upstreaming/gh-aw-compat/native-artifact.patch new file mode 100644 index 00000000000..2af67a05070 --- /dev/null +++ b/upstreaming/gh-aw-compat/native-artifact.patch @@ -0,0 +1,55 @@ +Upstream-Status: To upstream [Local reproduction validated; upstream submission requires separate authorization] + +diff --git a/actions/setup/js/upload_artifact.cjs b/actions/setup/js/upload_artifact.cjs +index b9553d6..fefed59 100644 +--- a/actions/setup/js/upload_artifact.cjs ++++ b/actions/setup/js/upload_artifact.cjs +@@ -55,6 +55,7 @@ const { + claimIdentity, + assertClaimIdentity, + receiptMatchesClaim, ++ withClaimResourceEffects, + } = require("./work_queue_claim_scope.cjs"); + const { expectedGitHubHost } = require("./work_queue_host.cjs"); + const privateDeliveryReceipts = new WeakMap(); +@@ -712,19 +713,33 @@ async function main(config = {}) { + uploadOpts.skipArchive = true; + } + const repository = process.env.GITHUB_REPOSITORY || ""; ++ const uploadNativeArtifact = async () => { ++ const effect = recordClaimEffect({ kind: "artifact", repository, outcome: "unknown" }); ++ const result = await client.uploadArtifact(artifactName, absoluteFiles, stagingDirectory(), uploadOpts); ++ if (effect) { ++ effect.outcome = "succeeded"; ++ effect.id = String(result.id || ""); ++ } ++ return result; ++ }; ++ let uploadResult; + if (factoryClaim) { + if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository)) throw new Error(`${ERR_VALIDATION}: Artifact upload requires the original native repository in owner/repo format`); + const [owner, repo] = repository.split("/"); + const { data: nativeRepository } = await github.rest.repos.get({ owner, repo }); + if (nativeRepository.full_name !== repository || !/^[1-9][0-9]*$/.test(String(nativeRepository.id))) + throw new Error(`${ERR_VALIDATION}: Artifact upload repository identity differs from its native target; scoped effects remain blocked`); +- await assertClaimAuthorized({ ...message, repo: repository }, { effect: true, resource: { repository, host: expectedGitHubHost(), repository_id: String(nativeRepository.id), run_id: process.env.GITHUB_RUN_ID } }); +- } +- const effect = recordClaimEffect({ kind: "artifact", repository, outcome: "unknown" }); +- const uploadResult = await client.uploadArtifact(artifactName, absoluteFiles, stagingDirectory(), uploadOpts); +- if (effect) { +- effect.outcome = "succeeded"; +- effect.id = String(uploadResult.id || ""); ++ // The trusted native target is the original bound worker run. Work ++ // cannot predict its future run ID at admission. Use the existing ++ // protected adapter frame, retaining immutable repository selectors ++ // and the independent exact Claim/run binding checks. ++ const target = { repository, host: expectedGitHubHost(), repository_id: String(nativeRepository.id), run_id: process.env.GITHUB_RUN_ID }; ++ uploadResult = await withClaimResourceEffects([target], ["upload_artifact"], async () => { ++ await assertClaimAuthorized({ ...message, repo: repository }, { effect: true, resource: target }); ++ return uploadNativeArtifact(); ++ }); ++ } else { ++ uploadResult = await uploadNativeArtifact(); + } + artifactId = uploadResult.id; + trustedDigest = uploadResult.digest; diff --git a/upstreaming/gh-aw-compat/tests/upload_artifact.v1.2.2.cjs.b64 b/upstreaming/gh-aw-compat/tests/upload_artifact.v1.2.2.cjs.b64 new file mode 100644 index 00000000000..90e44590904 --- /dev/null +++ b/upstreaming/gh-aw-compat/tests/upload_artifact.v1.2.2.cjs.b64 @@ -0,0 +1,641 @@ +Ly8gQHRzLWNoZWNrCi8vLyA8cmVmZXJlbmNlIHR5cGVzPSJAYWN0aW9ucy9naXRodWItc2NyaXB0 +IiAvPgoKY29uc3QgeyBpc1N0YWdlZE1vZGUgfSA9IHJlcXVpcmUoIi4vc2FmZV9vdXRwdXRfaGVs +cGVycy5janMiKTsKCi8qKgogKiB1cGxvYWRfYXJ0aWZhY3QgaGFuZGxlcgogKgogKiBWYWxpZGF0 +ZXMgYXJ0aWZhY3QgdXBsb2FkIHJlcXVlc3RzIGVtaXR0ZWQgYnkgdGhlIG1vZGVsIHZpYSB0aGUg +dXBsb2FkX2FydGlmYWN0IHNhZmUgb3V0cHV0CiAqIHRvb2wsIHRoZW4gdXBsb2FkcyB0aGUgYXBw +cm92ZWQgZmlsZXMgZGlyZWN0bHkgdmlhIHRoZSBpbnRlcm5hbCBhcnRpZmFjdCBjbGllbnQuCiAq +CiAqIEZpbGVzIGNhbiBiZSBwcmUtc3RhZ2VkIGluIC90bXAvZ2gtYXcvc2FmZW91dHB1dHMvdXBs +b2FkLWFydGlmYWN0cy8gb3IgcmVmZXJlbmNlZCBieSB0aGVpcgogKiBvcmlnaW5hbCBwYXRoLiAg +V2hlbiBhIHJlcXVlc3RlZCBwYXRoIGlzIG5vdCBmb3VuZCBpbiB0aGUgc3RhZ2luZyBkaXJlY3Rv +cnkgdGhlIGhhbmRsZXIKICogYXV0b21hdGljYWxseSBjb3BpZXMgdGhlIGZpbGUgKG9yIGRpcmVj +dG9yeSkgZnJvbSBpdHMgb3JpZ2luYWwgbG9jYXRpb24g4oCUIHN1cHBvcnRpbmcKICogYWJzb2x1 +dGUgcGF0aHMsIHdvcmtzcGFjZS1yZWxhdGl2ZSBwYXRocywgYW5kIGN3ZC1yZWxhdGl2ZSBwYXRo +cy4KICoKICogVGhpcyBoYW5kbGVyIGZvbGxvd3MgdGhlIHBlci1tZXNzYWdlIGhhbmRsZXIgcGF0 +dGVybiB1c2VkIGJ5IHRoZSBzYWZlX291dHB1dHMgaGFuZGxlciBsb29wLgogKiBtYWluKGNvbmZp +ZykgcmV0dXJucyBhIHBlci1tZXNzYWdlIGhhbmRsZXIgZnVuY3Rpb24gdGhhdDoKICogMS4gVmFs +aWRhdGVzIHRoZSByZXF1ZXN0IGFnYWluc3QgdGhlIHdvcmtmbG93J3MgcG9saWN5IGNvbmZpZ3Vy +YXRpb24uCiAqIDIuIFJlc29sdmVzIHRoZSByZXF1ZXN0ZWQgZmlsZXMgKHBhdGggb3IgZmlsdGVy +LWJhc2VkKSBmcm9tIHRoZSBzdGFnaW5nIGRpcmVjdG9yeS4KICogMy4gVXBsb2FkcyB0aGUgYXBw +cm92ZWQgZmlsZXMgZGlyZWN0bHkgdmlhIERlZmF1bHRBcnRpZmFjdENsaWVudC51cGxvYWRBcnRp +ZmFjdCgpLgogKiA0LiBTZXRzIHN0ZXAgb3V0cHV0cyAoc2xvdF9OX3RtcF9pZCwgdXBsb2FkX2Fy +dGlmYWN0X2NvdW50KSBmb3IgZG93bnN0cmVhbSBjb25zdW1lcnMuCiAqIDUuIEdlbmVyYXRlcyBh +IHRlbXBvcmFyeSBhcnRpZmFjdCBJRCBmb3IgZWFjaCB1cGxvYWQgYW5kIHdyaXRlcyBhIHJlc29s +dmVyIGZpbGUuCiAqCiAqIENvbmZpZ3VyYXRpb24ga2V5cyAocGFzc2VkIHZpYSBjb25maWcgcGFy +YW1ldGVyIGZyb20gaGFuZGxlciBtYW5hZ2VyKToKICogICBtYXgtdXBsb2FkcyAgICAgICAtIE1h +eCBudW1iZXIgb2YgdXBsb2FkX2FydGlmYWN0IGNhbGxzIGFsbG93ZWQgKGRlZmF1bHQ6IDEpCiAq +ICAgcmV0ZW50aW9uLWRheXMgICAgLSBGaXhlZCByZXRlbnRpb24gcGVyaW9kIGluIGRheXMgKGRl +ZmF1bHQ6IDMwKTsgYWdlbnQgY2Fubm90IG92ZXJyaWRlCiAqICAgc2tpcC1hcmNoaXZlICAgICAg +LSBGaXhlZCBza2lwLWFyY2hpdmUgZmxhZyAoZGVmYXVsdDogZmFsc2UpOyBhZ2VudCBjYW5ub3Qg +b3ZlcnJpZGUKICogICBtYXgtc2l6ZS1ieXRlcyAgICAtIE1heGltdW0gdG90YWwgYnl0ZXMgcGVy +IHVwbG9hZCAoZGVmYXVsdDogMTAwIE1CKQogKiAgIGFsbG93ZWQtcGF0aHMgICAgIC0gQXJyYXkg +b2YgYWxsb3dlZCBwYXRoIGdsb2IgcGF0dGVybnMKICogICBkZWZhdWx0LWlmLW5vLWZpbGVzIC0g +ImVycm9yIiBvciAiaWdub3JlIiAoZGVmYXVsdDogImVycm9yIikKICogICBmaWx0ZXJzLWluY2x1 +ZGUgICAtIEFycmF5IG9mIGRlZmF1bHQgaW5jbHVkZSBnbG9iIHBhdHRlcm5zCiAqICAgZmlsdGVy +cy1leGNsdWRlICAgLSBBcnJheSBvZiBkZWZhdWx0IGV4Y2x1ZGUgZ2xvYiBwYXR0ZXJucwogKiAg +IHN0YWdlZCAgICAgICAgICAgIC0gdHJ1ZSBmb3Igc3RhZ2VkL2RyeS1ydW4gbW9kZSAoc2tpcHMg +YWN0dWFsIHVwbG9hZCkKICovCgpjb25zdCBmcyA9IHJlcXVpcmUoImZzIik7CmNvbnN0IG9zID0g +cmVxdWlyZSgib3MiKTsKY29uc3QgcGF0aCA9IHJlcXVpcmUoInBhdGgiKTsKY29uc3QgeyBEZWZh +dWx0QXJ0aWZhY3RDbGllbnQgfSA9IHJlcXVpcmUoIi4vYXJ0aWZhY3RfY2xpZW50LmNqcyIpOwpj +b25zdCB7IGdldEVycm9yTWVzc2FnZSB9ID0gcmVxdWlyZSgiLi9lcnJvcl9oZWxwZXJzLmNqcyIp +Owpjb25zdCB7IGdsb2JQYXR0ZXJuVG9SZWdleCB9ID0gcmVxdWlyZSgiLi9nbG9iX3BhdHRlcm5f +aGVscGVycy5janMiKTsKY29uc3QgeyBFUlJfVkFMSURBVElPTiwgRVJSX1NZU1RFTSB9ID0gcmVx +dWlyZSgiLi9lcnJvcl9jb2Rlcy5janMiKTsKY29uc3QgeyBpc1RlbXBvcmFyeUlkLCBub3JtYWxp +emVUZW1wb3JhcnlJZCB9ID0gcmVxdWlyZSgiLi90ZW1wb3JhcnlfaWQuY2pzIik7CmNvbnN0IHsg +bHN0YXRHdWFyZCB9ID0gcmVxdWlyZSgiLi9zeW1saW5rX2d1YXJkLmNqcyIpOwpjb25zdCB7CiAg +YXNzZXJ0Q2xhaW1BdXRob3JpemVkLAogIGN1cnJlbnRDbGFpbUhhbmRsZSwKICByZWFkQ2xhaW1T +Y29wZUNvbnRleHQsCiAgY2xhaW1BcnRpZmFjdFBhdGgsCiAgYXNzZXJ0Q2xhaW1BcnRpZmFjdERp +cmVjdG9yeSwKICBhc3NlcnRDbGFpbUFydGlmYWN0RmlsZSwKICBzY29wZWRBcnRpZmFjdEZpbGVu +YW1lLAogIHJlY29yZENsYWltRWZmZWN0LAogIGNsYWltSWRlbnRpdHksCiAgYXNzZXJ0Q2xhaW1J +ZGVudGl0eSwKICByZWNlaXB0TWF0Y2hlc0NsYWltLAp9ID0gcmVxdWlyZSgiLi93b3JrX3F1ZXVl +X2NsYWltX3Njb3BlLmNqcyIpOwpjb25zdCB7IGV4cGVjdGVkR2l0SHViSG9zdCB9ID0gcmVxdWly +ZSgiLi93b3JrX3F1ZXVlX2hvc3QuY2pzIik7CmNvbnN0IHByaXZhdGVEZWxpdmVyeVJlY2VpcHRz +ID0gbmV3IFdlYWtNYXAoKTsKCi8qKgogKiBTdGFnaW5nIGRpcmVjdG9yeSB3aGVyZSB0aGUgbW9k +ZWwgcGxhY2VzIGZpbGVzIHRvIGJlIHVwbG9hZGVkLgogKiBVc2VzIFJVTk5FUl9URU1QIHRvIG1h +dGNoIHRoZSBwYXRoIHVzZWQgYnkgdGhlIGNvbXBpbGVkIHdvcmtmbG93IHdoZW4KICogZG93bmxv +YWRpbmcgdGhlIHN0YWdpbmcgYXJ0aWZhY3QgaW4gdGhlIHNhZmVfb3V0cHV0cyBqb2IuCiAqIFF1 +ZXVlIENsYWltIG5hbWVzcGFjZXMgYXJlIHJlc29sdmVkIGluIHRoZWlyIGltbXV0YWJsZSBleGVj +dXRpb24gY29udGV4dC4KICovCmNvbnN0IFNUQUdJTkdfQkFTRSA9IHBhdGguam9pbihwcm9jZXNz +LmVudi5SVU5ORVJfVEVNUCB8fCAiL3RtcCIsICJnaC1hdyIsICJzYWZlb3V0cHV0cyIsICJ1cGxv +YWQtYXJ0aWZhY3RzIik7CmZ1bmN0aW9uIHN0YWdpbmdEaXJlY3RvcnkoKSB7CiAgY29uc3QgaGFu +ZGxlID0gY3VycmVudENsYWltSGFuZGxlKCk7CiAgY29uc3QgZGlyZWN0b3J5ID0gaGFuZGxlID8g +Y2xhaW1BcnRpZmFjdFBhdGgoU1RBR0lOR19CQVNFLCBoYW5kbGUpIDogU1RBR0lOR19CQVNFOwog +IGlmIChoYW5kbGUgJiYgZnMuZXhpc3RzU3luYyhkaXJlY3RvcnkpKSBhc3NlcnRDbGFpbUFydGlm +YWN0RGlyZWN0b3J5KGRpcmVjdG9yeSk7CiAgcmV0dXJuIGRpcmVjdG9yeSArIHBhdGguc2VwOwp9 +CgovKiogUGF0aCB3aGVyZSB0aGUgcmVzb2x2ZXIgbWFwcGluZyAodG1wSWQg4oaSIGFydGlmYWN0 +IG5hbWUpIGlzIHdyaXR0ZW4uICovCmNvbnN0IFJFU09MVkVSX0ZJTEUgPSBwcm9jZXNzLmVudi5H +SF9BV19BUlRJRkFDVF9SRVNPTFZFUl9GSUxFIHx8ICIvdG1wL2doLWF3L2FydGlmYWN0LXJlc29s +dmVyLmpzb24iOwoKLyoqCiAqIEdlbmVyYXRlIGEgdGVtcG9yYXJ5IGFydGlmYWN0IElEIHVzaW5n +IHRoZSBzYW1lIGF3XyBwcmVmaXggZm9ybWF0IGFzIG90aGVyIHNhZmUgb3V0cHV0cy4KICogRm9y +bWF0OiBhd188OCBhbHBoYW51bWVyaWMgY2hhcmFjdGVycyAoQS1aYS16MC05KT4KICogQHJldHVy +bnMge3N0cmluZ30KICovCmZ1bmN0aW9uIGdlbmVyYXRlVGVtcG9yYXJ5QXJ0aWZhY3RJZCgpIHsK +ICBjb25zdCBjaGFycyA9ICJBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1u +b3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OSI7CiAgbGV0IGlkID0gImF3XyI7CiAgZm9yIChsZXQgaSA9 +IDA7IGkgPCA4OyBpKyspIHsKICAgIGlkICs9IGNoYXJzW01hdGguZmxvb3IoTWF0aC5yYW5kb20o +KSAqIGNoYXJzLmxlbmd0aCldOwogIH0KICByZXR1cm4gaWQ7Cn0KCi8qKgogKiBSZXNvbHZlIHRo +ZSB0ZW1wb3JhcnkgYXJ0aWZhY3QgSUQgZnJvbSBhbiB1cGxvYWRfYXJ0aWZhY3QgbWVzc2FnZS4K +ICogSWYgdGhlIG1lc3NhZ2UgZGVjbGFyZXMgYSB2YWxpZCBgdGVtcG9yYXJ5X2lkYCwgdGhhdCB2 +YWx1ZSBpcyB1c2VkIChub3JtYWxpc2VkIHRvIGxvd2VyY2FzZSkuCiAqIE90aGVyd2lzZSBhIHJh +bmRvbSBJRCBpcyBnZW5lcmF0ZWQuCiAqCiAqIEhvbm91cmluZyBgbWVzc2FnZS50ZW1wb3Jhcnlf +aWRgIGlzIGVzc2VudGlhbCBmb3IgdG9wb2xvZ2ljYWwgb3JkZXJpbmc6IHdoZW4gYW4gYWdlbnQK +ICogZGVjbGFyZXMgYSBgdGVtcG9yYXJ5X2lkYCBvbiB0aGUgYHVwbG9hZF9hcnRpZmFjdGAgbWVz +c2FnZSBhbmQgdGhlbiBlbWJlZHMgYCNhd19JRGAgaW4gYQogKiBzdWJzZXF1ZW50IG1lc3NhZ2Ug +Ym9keSwgdGhlIGRlcGVuZGVuY3kgZ3JhcGggYnVpbHQgYnkgdGhlIHRvcG9sb2dpY2FsIHNvcnQg +Y2FuIG9yZGVyCiAqIHRoZSB1cGxvYWQgYmVmb3JlIHRoZSByZWZlcmVuY2luZyBtZXNzYWdlLCBh +bmQgdGhlIGhhbmRsZXIgbWFuYWdlciBjYW4gcmVwbGFjZSB0aGUKICogcmVmZXJlbmNlIHdpdGgg +dGhlIHJlc29sdmVkIGFydGlmYWN0IFVSTC4KICoKICogQHBhcmFtIHtSZWNvcmQ8c3RyaW5nLCBh +bnk+fSBtZXNzYWdlIC0gVGhlIHVwbG9hZF9hcnRpZmFjdCBtZXNzYWdlIGZyb20gdGhlIG1vZGVs +CiAqIEByZXR1cm5zIHtzdHJpbmd9IFRoZSB0ZW1wb3JhcnkgYXJ0aWZhY3QgSUQgdG8gdXNlIGZv +ciB0aGlzIHVwbG9hZAogKi8KZnVuY3Rpb24gcmVzb2x2ZVRlbXBvcmFyeUFydGlmYWN0SWQobWVz +c2FnZSkgewogIGNvbnN0IGRlY2xhcmVkID0gbWVzc2FnZS50ZW1wb3JhcnlfaWQ7CiAgaWYgKGRl +Y2xhcmVkICYmIHR5cGVvZiBkZWNsYXJlZCA9PT0gInN0cmluZyIpIHsKICAgIGNvbnN0IHRyaW1t +ZWQgPSBkZWNsYXJlZC50cmltKCk7CiAgICBpZiAoaXNUZW1wb3JhcnlJZCh0cmltbWVkKSkgewog +ICAgICByZXR1cm4gbm9ybWFsaXplVGVtcG9yYXJ5SWQodHJpbW1lZCk7CiAgICB9CiAgICBpZiAo +dHlwZW9mIGNvcmUgIT09ICJ1bmRlZmluZWQiKSB7CiAgICAgIGNvcmUud2FybmluZyhgdXBsb2Fk +X2FydGlmYWN0OiBpbnZhbGlkIHRlbXBvcmFyeV9pZCBmb3JtYXQgJyR7ZGVjbGFyZWR9Jy4gYCAr +IGBUZW1wb3JhcnkgSURzIG11c3QgYmUgJ2F3XycgZm9sbG93ZWQgYnkgM+KAkzEyIGFscGhhbnVt +ZXJpYyBvciB1bmRlcnNjb3JlIGNoYXJhY3RlcnMuIGAgKyBgQSByYW5kb20gSUQgd2lsbCBiZSBn +ZW5lcmF0ZWQgaW5zdGVhZC5gKTsKICAgIH0KICB9CiAgcmV0dXJuIGdlbmVyYXRlVGVtcG9yYXJ5 +QXJ0aWZhY3RJZCgpOwp9CgovKioKICogQ2hlY2sgd2hldGhlciBhIHJlbGF0aXZlIHBhdGggbWF0 +Y2hlcyBhbnkgb2YgdGhlIHByb3ZpZGVkIGdsb2IgcGF0dGVybnMuCiAqIEBwYXJhbSB7c3RyaW5n +fSByZWxQYXRoIC0gUGF0aCByZWxhdGl2ZSB0byB0aGUgc3RhZ2luZyByb290CiAqIEBwYXJhbSB7 +c3RyaW5nW119IHBhdHRlcm5zCiAqIEByZXR1cm5zIHtib29sZWFufQogKi8KZnVuY3Rpb24gbWF0 +Y2hlc0FueVBhdHRlcm4ocmVsUGF0aCwgcGF0dGVybnMpIHsKICBpZiAocGF0dGVybnMubGVuZ3Ro +ID09PSAwKSByZXR1cm4gZmFsc2U7CiAgcmV0dXJuIHBhdHRlcm5zLnNvbWUocGF0dGVybiA9PiB7 +CiAgICBjb25zdCByZWdleCA9IGdsb2JQYXR0ZXJuVG9SZWdleChwYXR0ZXJuKTsKICAgIHJldHVy +biByZWdleC50ZXN0KHJlbFBhdGgpOwogIH0pOwp9CgovKioKICogVmFsaWRhdGUgdGhhdCBhIHBh +dGggZG9lcyBub3QgZXNjYXBlIHRoZSBzdGFnaW5nIHJvb3QgdXNpbmcgdHJhdmVyc2FsIHNlcXVl +bmNlcy4KICogQHBhcmFtIHtzdHJpbmd9IGZpbGVQYXRoIC0gQWJzb2x1dGUgcGF0aAogKiBAcGFy +YW0ge3N0cmluZ30gcm9vdCAtIEFic29sdXRlIHJvb3QgZGlyZWN0b3J5IChtdXN0IGVuZCB3aXRo +IC8pCiAqIEByZXR1cm5zIHtib29sZWFufQogKi8KZnVuY3Rpb24gaXNXaXRoaW5Sb290KGZpbGVQ +YXRoLCByb290KSB7CiAgY29uc3QgcmVzb2x2ZWQgPSBwYXRoLnJlc29sdmUoZmlsZVBhdGgpOwog +IGNvbnN0IG5vcm1hbFJvb3QgPSBwYXRoLnJlc29sdmUocm9vdCk7CiAgcmV0dXJuIHJlc29sdmVk +LnN0YXJ0c1dpdGgobm9ybWFsUm9vdCArIHBhdGguc2VwKSB8fCByZXNvbHZlZCA9PT0gbm9ybWFs +Um9vdDsKfQoKLyoqCiAqIFZhbGlkYXRlIHRoYXQgYSBjYW5vbmljYWwgYWJzb2x1dGUgcGF0aCBk +b2VzIG5vdCByZWZlciB0byBzZW5zaXRpdmUgc3lzdGVtIG9yIGNyZWRlbnRpYWwKICogbG9jYXRp +b25zLiBNaXJyb3JzIHRoZSBjaGVjayBpbiBzYWZlX291dHB1dHNfaGFuZGxlcnMuY2pzIGZvciBk +ZWZlbnNlLWluLWRlcHRoLgogKgogKiBAcGFyYW0ge3N0cmluZ30gY2Fub25pY2FsUGF0aCAtIFJl +c29sdmVkIGFic29sdXRlIHBhdGgKICogQHJldHVybnMge3N0cmluZ3xudWxsfSBFcnJvciBtZXNz +YWdlIG9yIG51bGwgaWYgc2FmZQogKi8KZnVuY3Rpb24gdmFsaWRhdGVTb3VyY2VQYXRoKGNhbm9u +aWNhbFBhdGgpIHsKICBjb25zdCBwYXJ0cyA9IGNhbm9uaWNhbFBhdGguc3BsaXQocGF0aC5zZXAp +OwogIGlmIChwYXJ0cy5zb21lKHAgPT4gcCA9PT0gIi5naXQiKSkgewogICAgcmV0dXJuIGBwYXRo +IGNvbnRhaW5zIHNlbnNpdGl2ZSByZXBvc2l0b3J5IG1ldGFkYXRhICguZ2l0KTogJHtjYW5vbmlj +YWxQYXRofWA7CiAgfQoKICBjb25zdCBzeXN0ZW1EZW5pZWQgPSBbIi9ldGMiLCAiL3Byb2MiLCAi +L3N5cyIsICIvZGV2IiwgIi9ydW4iLCAiL2Jvb3QiLCAiL2xpYiIsICIvbGliNjQiLCAiL3Vzci9s +aWIiLCAiL3Vzci9sb2NhbC9saWIiXTsKICBmb3IgKGNvbnN0IGRlbmllZCBvZiBzeXN0ZW1EZW5p +ZWQpIHsKICAgIGNvbnN0IG5vcm1hbERlbmllZCA9IHBhdGgucmVzb2x2ZShkZW5pZWQpOwogICAg +aWYgKGNhbm9uaWNhbFBhdGggPT09IG5vcm1hbERlbmllZCB8fCBjYW5vbmljYWxQYXRoLnN0YXJ0 +c1dpdGgobm9ybWFsRGVuaWVkICsgcGF0aC5zZXApKSB7CiAgICAgIHJldHVybiBgcGF0aCByZWZl +cnMgdG8gYSBzeXN0ZW0gZGlyZWN0b3J5OiAke2Nhbm9uaWNhbFBhdGh9YDsKICAgIH0KICB9Cgog +IGNvbnN0IGhvbWVEaXIgPSBvcy5ob21lZGlyKCk7CiAgaWYgKGhvbWVEaXIpIHsKICAgIGNvbnN0 +IHNlbnNpdGl2ZU5hbWVzID0gWyIuc3NoIiwgIi5hd3MiLCAiLmdudXBnIiwgIi5kb2NrZXIiLCAi +Lmt1YmUiLCAiLmF6dXJlIiwgIi5nY3AiLCAiLmNvbmZpZyIsICIubmV0cmMiLCAiLm5wbXJjIiwg +Ii5naXRjb25maWciLCAiLmdpdGNyZWRlbnRpYWxzIiwgIi5naXQtY3JlZGVudGlhbHMiXTsKICAg +IGZvciAoY29uc3QgbmFtZSBvZiBzZW5zaXRpdmVOYW1lcykgewogICAgICBjb25zdCBzZW5zaXRp +dmUgPSBwYXRoLmpvaW4ocGF0aC5yZXNvbHZlKGhvbWVEaXIpLCBuYW1lKTsKICAgICAgaWYgKGNh +bm9uaWNhbFBhdGggPT09IHNlbnNpdGl2ZSB8fCBjYW5vbmljYWxQYXRoLnN0YXJ0c1dpdGgoc2Vu +c2l0aXZlICsgcGF0aC5zZXApKSB7CiAgICAgICAgcmV0dXJuIGBwYXRoIHJlZmVycyB0byBhIHNl +bnNpdGl2ZSBIT01FIGxvY2F0aW9uOiAke2Nhbm9uaWNhbFBhdGh9YDsKICAgICAgfQogICAgfQog +IH0KCiAgcmV0dXJuIG51bGw7Cn0KCi8qKgogKiBSZXNvbHZlIGEgcm9vdCBwYXRoIHRvIGl0cyBj +YW5vbmljYWwgZm9ybSwgZmFsbGluZyBiYWNrIHRvIHBhdGgucmVzb2x2ZSB3aGVuIHRoZQogKiBk +aXJlY3RvcnkgZG9lcyBub3QgeWV0IGV4aXN0IChlLmcuIEdJVEhVQl9XT1JLU1BBQ0UgYmVmb3Jl +IGNoZWNrb3V0KS4KICogQHBhcmFtIHtzdHJpbmd9IHJvb3QKICogQHJldHVybnMge3N0cmluZ30K +ICovCmZ1bmN0aW9uIGNhbm9uaWNhbGl6ZVJvb3Qocm9vdCkgewogIHRyeSB7CiAgICByZXR1cm4g +ZnMucmVhbHBhdGhTeW5jKHJvb3QpOwogIH0gY2F0Y2ggewogICAgcmV0dXJuIHBhdGgucmVzb2x2 +ZShyb290KTsKICB9Cn0KCi8qKgogKiBWYWxpZGF0ZSB0aGF0IGEgY2Fub25pY2FsIGFic29sdXRl +IHBhdGggaXMgd2l0aGluIG9uZSBvZiB0aGUgYWxsb3dlZCBzb3VyY2Ugcm9vdHMuCiAqIEFsbG93 +ZWQgcm9vdHM6IHN0YWdpbmcgZGlyZWN0b3J5LCBHSVRIVUJfV09SS1NQQUNFLgogKiBSVU5ORVJf +VEVNUCBpcyBpbnRlbnRpb25hbGx5IGV4Y2x1ZGVkIOKAlCBvbmx5IHRoZSBzcGVjaWZpYyBzdGFn +aW5nIHN1YmRpcmVjdG9yeSBpcyBhbGxvd2VkLgogKgogKiBAcGFyYW0ge3N0cmluZ30gY2Fub25p +Y2FsUGF0aCAtIFJlc29sdmVkIGFic29sdXRlIHBhdGgKICogQHJldHVybnMge3N0cmluZ3xudWxs +fSBFcnJvciBtZXNzYWdlIG9yIG51bGwgaWYgd2l0aGluIGFuIGFsbG93ZWQgcm9vdAogKi8KZnVu +Y3Rpb24gdmFsaWRhdGVBbGxvd2VkUm9vdChjYW5vbmljYWxQYXRoKSB7CiAgY29uc3QgYWxsb3dl +ZFJvb3RzID0gW2Nhbm9uaWNhbGl6ZVJvb3Qoc3RhZ2luZ0RpcmVjdG9yeSgpKV07CiAgaWYgKHBy +b2Nlc3MuZW52LkdJVEhVQl9XT1JLU1BBQ0UpIHsKICAgIGFsbG93ZWRSb290cy5wdXNoKGNhbm9u +aWNhbGl6ZVJvb3QocHJvY2Vzcy5lbnYuR0lUSFVCX1dPUktTUEFDRSkpOwogIH0KICBjb25zdCB3 +aXRoaW5BbGxvd2VkUm9vdCA9IGFsbG93ZWRSb290cy5zb21lKHJvb3QgPT4gY2Fub25pY2FsUGF0 +aCA9PT0gcm9vdCB8fCBjYW5vbmljYWxQYXRoLnN0YXJ0c1dpdGgocm9vdCArIHBhdGguc2VwKSk7 +CiAgaWYgKCF3aXRoaW5BbGxvd2VkUm9vdCkgewogICAgcmV0dXJuIGBwYXRoIGlzIG91dHNpZGUg +YWxsb3dlZCBzb3VyY2Ugcm9vdHMgKEdJVEhVQl9XT1JLU1BBQ0UsIHN0YWdpbmcgZGlyZWN0b3J5 +KTogJHtjYW5vbmljYWxQYXRofWA7CiAgfQogIHJldHVybiBudWxsOwp9CgovKioKICogUmVjdXJz +aXZlbHkgbGlzdCBhbGwgcmVndWxhciBmaWxlcyB1bmRlciBhIGRpcmVjdG9yeS4KICogQHBhcmFt +IHtzdHJpbmd9IGRpciAtIEFic29sdXRlIGRpcmVjdG9yeSBwYXRoCiAqIEBwYXJhbSB7c3RyaW5n +fSBiYXNlRGlyIC0gUm9vdCB1c2VkIHRvIGNvbXB1dGUgcmVsYXRpdmUgcGF0aHMKICogQHJldHVy +bnMge3N0cmluZ1tdfSBSZWxhdGl2ZSBwYXRocyBmcm9tIGJhc2VEaXIKICovCmZ1bmN0aW9uIGxp +c3RGaWxlc1JlY3Vyc2l2ZShkaXIsIGJhc2VEaXIpIHsKICAvKiogQHR5cGUge3N0cmluZ1tdfSAq +LwogIGNvbnN0IGZpbGVzID0gW107CiAgaWYgKCFmcy5leGlzdHNTeW5jKGRpcikpIHJldHVybiBm +aWxlczsKCiAgY29uc3QgZW50cmllcyA9IGZzLnJlYWRkaXJTeW5jKGRpciwgeyB3aXRoRmlsZVR5 +cGVzOiB0cnVlIH0pOwogIGZvciAoY29uc3QgZW50cnkgb2YgZW50cmllcykgewogICAgY29uc3Qg +ZnVsbFBhdGggPSBwYXRoLmpvaW4oZGlyLCBlbnRyeS5uYW1lKTsKICAgIGlmIChlbnRyeS5pc0Rp +cmVjdG9yeSgpKSB7CiAgICAgIGZpbGVzLnB1c2goLi4ubGlzdEZpbGVzUmVjdXJzaXZlKGZ1bGxQ +YXRoLCBiYXNlRGlyKSk7CiAgICB9IGVsc2UgaWYgKGVudHJ5LmlzRmlsZSgpKSB7CiAgICAgIC8v +IFJlamVjdCBzeW1saW5rcyDigJMgZW50cnkuaXNGaWxlKCkgcmV0dXJucyBmYWxzZSBmb3Igc3lt +bGlua3MgdW5sZXNzIGRlcmVmZXJlbmNlZC4KICAgICAgLy8gV2UgY2hlY2sgZXhwbGljaXRseSB0 +byBhdm9pZCBmb2xsb3dpbmcgc3ltbGlua3MuCiAgICAgIGlmIChsc3RhdEd1YXJkKGZ1bGxQYXRo +KSAhPT0gbnVsbCkgewogICAgICAgIGZpbGVzLnB1c2gocGF0aC5yZWxhdGl2ZShiYXNlRGlyLCBm +dWxsUGF0aCkpOwogICAgICB9IGVsc2UgewogICAgICAgIGNvcmUud2FybmluZyhgU2tpcHBpbmcg +c3ltbGluazogJHtmdWxsUGF0aH1gKTsKICAgICAgfQogICAgfQogIH0KICByZXR1cm4gZmlsZXM7 +Cn0KCi8qKgogKiBDb3B5IGEgc2luZ2xlIGZpbGUgdG8gdGhlIHN0YWdpbmcgZGlyZWN0b3J5LCBw +cmVzZXJ2aW5nIHRoZSByZWxhdGl2ZSBwYXRoIHN0cnVjdHVyZS4KICogUmVqZWN0cyBzeW1saW5r +cyBhbmQgY3JlYXRlcyBpbnRlcm1lZGlhdGUgZGlyZWN0b3JpZXMgYXMgbmVlZGVkLgogKgogKiBA +cGFyYW0ge3N0cmluZ30gc291cmNlUGF0aCAtIEFic29sdXRlIHBhdGggdG8gdGhlIHNvdXJjZSBm +aWxlCiAqIEBwYXJhbSB7c3RyaW5nfSBkZXN0UmVsUGF0aCAtIFJlbGF0aXZlIHBhdGggd2l0aGlu +IHRoZSBzdGFnaW5nIGRpcmVjdG9yeQogKiBAcmV0dXJucyB7eyBlcnJvcjogc3RyaW5nfG51bGwg +fX0KICovCmZ1bmN0aW9uIGNvcHlTaW5nbGVGaWxlVG9TdGFnaW5nKHNvdXJjZVBhdGgsIGRlc3RS +ZWxQYXRoKSB7CiAgY29uc3QgZGVzdFBhdGggPSBwYXRoLmpvaW4oc3RhZ2luZ0RpcmVjdG9yeSgp +LCBkZXN0UmVsUGF0aCk7CiAgLy8gTmV2ZXIgb3ZlcndyaXRlIGEgZmlsZSB0aGF0IGlzIGFscmVh +ZHkgc3RhZ2VkIOKAlCB0aGUgcHJlLXN0YWdlZCB2ZXJzaW9uIHRha2VzIHByZWNlZGVuY2UuCiAg +aWYgKGZzLmV4aXN0c1N5bmMoZGVzdFBhdGgpKSB7CiAgICBjb3JlLmluZm8oYFNraXBwaW5nIGF1 +dG8tY29weSBmb3IgJHtkZXN0UmVsUGF0aH06IGFscmVhZHkgZXhpc3RzIGluIHN0YWdpbmcgZGly +ZWN0b3J5YCk7CiAgICByZXR1cm4geyBlcnJvcjogbnVsbCB9OwogIH0KICBjb25zdCBzdGF0ID0g +bHN0YXRHdWFyZChzb3VyY2VQYXRoKTsKICBpZiAoc3RhdCA9PT0gbnVsbCkgewogICAgcmV0dXJu +IHsgZXJyb3I6IGBzeW1saW5rcyBhcmUgbm90IGFsbG93ZWQ6ICR7c291cmNlUGF0aH1gIH07CiAg +fQogIGlmICghc3RhdC5pc0ZpbGUoKSkgewogICAgcmV0dXJuIHsgZXJyb3I6IGBub3QgYSByZWd1 +bGFyIGZpbGU6ICR7c291cmNlUGF0aH1gIH07CiAgfQogIHRyeSB7CiAgICBmcy5ta2RpclN5bmMo +cGF0aC5kaXJuYW1lKGRlc3RQYXRoKSwgeyByZWN1cnNpdmU6IHRydWUgfSk7CiAgICBpZiAoY3Vy +cmVudENsYWltSGFuZGxlKCkpIGFzc2VydENsYWltQXJ0aWZhY3REaXJlY3Rvcnkoc3RhZ2luZ0Rp +cmVjdG9yeSgpKTsKICB9IGNhdGNoIChlcnIpIHsKICAgIHRocm93IG5ldyBFcnJvcihgJHtFUlJf +U1lTVEVNfTogRmFpbGVkIHRvIGNyZWF0ZSBkaXJlY3RvcnkgJHtwYXRoLmRpcm5hbWUoZGVzdFBh +dGgpfTogJHtnZXRFcnJvck1lc3NhZ2UoZXJyKX1gLCB7IGNhdXNlOiBlcnIgfSk7CiAgfQogIHRy +eSB7CiAgICBmcy5jb3B5RmlsZVN5bmMoc291cmNlUGF0aCwgZGVzdFBhdGgpOwogICAgZnMuY2ht +b2RTeW5jKGRlc3RQYXRoLCAwbzYwMCk7CiAgfSBjYXRjaCAoZXJyKSB7CiAgICB0aHJvdyBuZXcg +RXJyb3IoYCR7RVJSX1NZU1RFTX06IEZhaWxlZCB0byBjb3B5IGZpbGUgJHtzb3VyY2VQYXRofSB0 +byAke2Rlc3RQYXRofTogJHtnZXRFcnJvck1lc3NhZ2UoZXJyKX1gLCB7IGNhdXNlOiBlcnIgfSk7 +CiAgfQogIHJldHVybiB7IGVycm9yOiBudWxsIH07Cn0KCi8qKgogKiBSZWN1cnNpdmVseSBjb3B5 +IGEgZGlyZWN0b3J5IGludG8gdGhlIHN0YWdpbmcgZGlyZWN0b3J5LgogKiBTa2lwcyBzeW1saW5r +cyBhbmQgbG9ncyB3YXJuaW5ncyBmb3IgdGhlbS4KICoKICogQHBhcmFtIHtzdHJpbmd9IHNvdXJj +ZURpciAtIEFic29sdXRlIHBhdGggdG8gdGhlIHNvdXJjZSBkaXJlY3RvcnkKICogQHBhcmFtIHtz +dHJpbmd9IGRlc3RSZWxEaXIgLSBSZWxhdGl2ZSBkaXJlY3RvcnkgcGF0aCB3aXRoaW4gdGhlIHN0 +YWdpbmcgZGlyZWN0b3J5CiAqIEByZXR1cm5zIHt7IGNvcGllZENvdW50OiBudW1iZXIsIGVycm9y +OiBzdHJpbmd8bnVsbCB9fQogKi8KZnVuY3Rpb24gY29weURpcmVjdG9yeVRvU3RhZ2luZyhzb3Vy +Y2VEaXIsIGRlc3RSZWxEaXIpIHsKICBsZXQgY29waWVkQ291bnQgPSAwOwogIGNvbnN0IGVudHJp +ZXMgPSBmcy5yZWFkZGlyU3luYyhzb3VyY2VEaXIsIHsgd2l0aEZpbGVUeXBlczogdHJ1ZSB9KTsK +ICBmb3IgKGNvbnN0IGVudHJ5IG9mIGVudHJpZXMpIHsKICAgIGNvbnN0IHNyY0Z1bGwgPSBwYXRo +LmpvaW4oc291cmNlRGlyLCBlbnRyeS5uYW1lKTsKICAgIGNvbnN0IGRlc3RSZWwgPSBwYXRoLmpv +aW4oZGVzdFJlbERpciwgZW50cnkubmFtZSk7CiAgICBjb25zdCBzdGF0ID0gbHN0YXRHdWFyZChz +cmNGdWxsKTsKICAgIGlmIChzdGF0ID09PSBudWxsKSB7CiAgICAgIGNvcmUud2FybmluZyhgU2tp +cHBpbmcgc3ltbGluayBkdXJpbmcgYXV0by1jb3B5OiAke3NyY0Z1bGx9YCk7CiAgICAgIGNvbnRp +bnVlOwogICAgfQogICAgaWYgKHN0YXQuaXNEaXJlY3RvcnkoKSkgewogICAgICAvLyBSZWplY3Qg +c2Vuc2l0aXZlIGRpcmVjdG9yeSBuYW1lcyBhdCBldmVyeSBsZXZlbCAoZS5nLiBmb28vLmdpdC9j +b25maWcpLgogICAgICBsZXQgY2Fub25pY2FsRGlyOwogICAgICB0cnkgewogICAgICAgIGNhbm9u +aWNhbERpciA9IGZzLnJlYWxwYXRoU3luYyhzcmNGdWxsKTsKICAgICAgfSBjYXRjaCAoZXJyKSB7 +CiAgICAgICAgcmV0dXJuIHsgY29waWVkQ291bnQsIGVycm9yOiBgZmFpbGVkIHRvIHJlc29sdmUg +Y2Fub25pY2FsIHBhdGggZm9yICR7c3JjRnVsbH06ICR7Z2V0RXJyb3JNZXNzYWdlKGVycil9YCB9 +OwogICAgICB9CiAgICAgIGNvbnN0IHNlbnNpdGl2ZUVyciA9IHZhbGlkYXRlU291cmNlUGF0aChj +YW5vbmljYWxEaXIpOwogICAgICBpZiAoc2Vuc2l0aXZlRXJyKSB7CiAgICAgICAgcmV0dXJuIHsg +Y29waWVkQ291bnQsIGVycm9yOiBzZW5zaXRpdmVFcnIgfTsKICAgICAgfQogICAgICBjb25zdCBz +dWIgPSBjb3B5RGlyZWN0b3J5VG9TdGFnaW5nKHNyY0Z1bGwsIGRlc3RSZWwpOwogICAgICBpZiAo +c3ViLmVycm9yKSByZXR1cm4gc3ViOwogICAgICBjb3BpZWRDb3VudCArPSBzdWIuY29waWVkQ291 +bnQ7CiAgICB9IGVsc2UgaWYgKHN0YXQuaXNGaWxlKCkpIHsKICAgICAgLy8gUmV2YWxpZGF0ZSBl +YWNoIGZpbGUncyBjYW5vbmljYWwgcGF0aCBiZWZvcmUgY29weWluZy4KICAgICAgbGV0IGNhbm9u +aWNhbEZpbGU7CiAgICAgIHRyeSB7CiAgICAgICAgY2Fub25pY2FsRmlsZSA9IGZzLnJlYWxwYXRo +U3luYyhzcmNGdWxsKTsKICAgICAgfSBjYXRjaCAoZXJyKSB7CiAgICAgICAgcmV0dXJuIHsgY29w +aWVkQ291bnQsIGVycm9yOiBgZmFpbGVkIHRvIHJlc29sdmUgY2Fub25pY2FsIHBhdGggZm9yICR7 +c3JjRnVsbH06ICR7Z2V0RXJyb3JNZXNzYWdlKGVycil9YCB9OwogICAgICB9CiAgICAgIGNvbnN0 +IHNlbnNpdGl2ZUVyciA9IHZhbGlkYXRlU291cmNlUGF0aChjYW5vbmljYWxGaWxlKTsKICAgICAg +aWYgKHNlbnNpdGl2ZUVycikgewogICAgICAgIHJldHVybiB7IGNvcGllZENvdW50LCBlcnJvcjog +c2Vuc2l0aXZlRXJyIH07CiAgICAgIH0KICAgICAgY29uc3QgcmVzdWx0ID0gY29weVNpbmdsZUZp +bGVUb1N0YWdpbmcoc3JjRnVsbCwgZGVzdFJlbCk7CiAgICAgIGlmIChyZXN1bHQuZXJyb3IpIHJl +dHVybiB7IGNvcGllZENvdW50LCBlcnJvcjogcmVzdWx0LmVycm9yIH07CiAgICAgIGNvcGllZENv +dW50Kys7CiAgICB9CiAgfQogIHJldHVybiB7IGNvcGllZENvdW50LCBlcnJvcjogbnVsbCB9Owp9 +CgovKioKICogQXR0ZW1wdCB0byBsb2NhdGUgdGhlIHJlcXVlc3RlZCBwYXRoIG91dHNpZGUgdGhl +IHN0YWdpbmcgZGlyZWN0b3J5IGFuZCBjb3B5IGl0IGluLgogKgogKiBTZWFyY2ggb3JkZXIgZm9y +IGFic29sdXRlIHBhdGhzOgogKiAgIDEuIFVzZSB0aGUgYWJzb2x1dGUgcGF0aCBkaXJlY3RseS4K +ICoKICogU2VhcmNoIG9yZGVyIGZvciByZWxhdGl2ZSBwYXRoczoKICogICAxLiBHSVRIVUJfV09S +S1NQQUNFIGVudmlyb25tZW50IHZhcmlhYmxlIChHaXRIdWIgQWN0aW9ucyB3b3Jrc3BhY2UpLgog +KiAgIDIuIEN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkgKHByb2Nlc3MuY3dkKCkpLgogKgogKiBA +cGFyYW0ge3N0cmluZ30gcmVxUGF0aCAtIFRoZSBwYXRoIGZyb20gdGhlIHJlcXVlc3QgKGFic29s +dXRlIG9yIHJlbGF0aXZlKQogKiBAcmV0dXJucyB7eyBjb3BpZWQ6IGJvb2xlYW4sIHJlbFBhdGg6 +IHN0cmluZywgZXJyb3I6IHN0cmluZ3xudWxsIH19CiAqLwpmdW5jdGlvbiBhdXRvQ29weVRvU3Rh +Z2luZyhyZXFQYXRoKSB7CiAgaWYgKHBhdGguaXNBYnNvbHV0ZShyZXFQYXRoKSkgewogICAgaWYg +KCFmcy5leGlzdHNTeW5jKHJlcVBhdGgpKSB7CiAgICAgIHJldHVybiB7IGNvcGllZDogZmFsc2Us +IHJlbFBhdGg6ICIiLCBlcnJvcjogYGFic29sdXRlIHBhdGggZG9lcyBub3QgZXhpc3Q6ICR7cmVx +UGF0aH1gIH07CiAgICB9CiAgICBjb25zdCBzdGF0ID0gbHN0YXRHdWFyZChyZXFQYXRoKTsKICAg +IGlmIChzdGF0ID09PSBudWxsKSB7CiAgICAgIHJldHVybiB7IGNvcGllZDogZmFsc2UsIHJlbFBh +dGg6ICIiLCBlcnJvcjogYHN5bWxpbmtzIGFyZSBub3QgYWxsb3dlZDogJHtyZXFQYXRofWAgfTsK +ICAgIH0KCiAgICAvLyBDYW5vbmljYWxpemUgYW5kIHZhbGlkYXRlIGJlZm9yZSBjb3B5aW5nLgog +ICAgbGV0IGNhbm9uaWNhbDsKICAgIHRyeSB7CiAgICAgIGNhbm9uaWNhbCA9IGZzLnJlYWxwYXRo +U3luYyhyZXFQYXRoKTsKICAgIH0gY2F0Y2ggKGVycikgewogICAgICByZXR1cm4geyBjb3BpZWQ6 +IGZhbHNlLCByZWxQYXRoOiAiIiwgZXJyb3I6IGBmYWlsZWQgdG8gcmVzb2x2ZSBjYW5vbmljYWwg +cGF0aCBmb3IgJHtyZXFQYXRofTogJHtnZXRFcnJvck1lc3NhZ2UoZXJyKX1gIH07CiAgICB9CiAg +ICBjb25zdCBzZW5zaXRpdmVFcnIgPSB2YWxpZGF0ZVNvdXJjZVBhdGgoY2Fub25pY2FsKTsKICAg +IGlmIChzZW5zaXRpdmVFcnIpIHsKICAgICAgcmV0dXJuIHsgY29waWVkOiBmYWxzZSwgcmVsUGF0 +aDogIiIsIGVycm9yOiBzZW5zaXRpdmVFcnIgfTsKICAgIH0KICAgIGNvbnN0IHJvb3RFcnIgPSB2 +YWxpZGF0ZUFsbG93ZWRSb290KGNhbm9uaWNhbCk7CiAgICBpZiAocm9vdEVycikgewogICAgICBy +ZXR1cm4geyBjb3BpZWQ6IGZhbHNlLCByZWxQYXRoOiAiIiwgZXJyb3I6IHJvb3RFcnIgfTsKICAg +IH0KCiAgICAvLyBEZXJpdmUgYSByZWxhdGl2ZSBkZXN0aW5hdGlvbiBwYXRoIGZyb20gdGhlIGJh +c2VuYW1lIChvciByZWxhdGl2ZSB0byBmaWxlc3lzdGVtIHJvb3QgZm9yIG5lc3RlZCBwYXRocyku +CiAgICBjb25zdCByZWxQYXRoID0gcGF0aC5iYXNlbmFtZShyZXFQYXRoKTsKICAgIGlmIChzdGF0 +LmlzRGlyZWN0b3J5KCkpIHsKICAgICAgY29uc3QgcmVzdWx0ID0gY29weURpcmVjdG9yeVRvU3Rh +Z2luZyhyZXFQYXRoLCByZWxQYXRoKTsKICAgICAgaWYgKHJlc3VsdC5lcnJvcikgcmV0dXJuIHsg +Y29waWVkOiBmYWxzZSwgcmVsUGF0aDogIiIsIGVycm9yOiByZXN1bHQuZXJyb3IgfTsKICAgICAg +Y29yZS5pbmZvKGBBdXRvLWNvcGllZCBkaXJlY3RvcnkgJHtyZXFQYXRofSB0byBzdGFnaW5nICgk +e3Jlc3VsdC5jb3BpZWRDb3VudH0gZmlsZShzKSlgKTsKICAgIH0gZWxzZSB7CiAgICAgIGNvbnN0 +IHJlc3VsdCA9IGNvcHlTaW5nbGVGaWxlVG9TdGFnaW5nKHJlcVBhdGgsIHJlbFBhdGgpOwogICAg +ICBpZiAocmVzdWx0LmVycm9yKSByZXR1cm4geyBjb3BpZWQ6IGZhbHNlLCByZWxQYXRoOiAiIiwg +ZXJyb3I6IHJlc3VsdC5lcnJvciB9OwogICAgICBjb3JlLmluZm8oYEF1dG8tY29waWVkIGZpbGUg +JHtyZXFQYXRofSB0byBzdGFnaW5nIGFzICR7cmVsUGF0aH1gKTsKICAgIH0KICAgIHJldHVybiB7 +IGNvcGllZDogdHJ1ZSwgcmVsUGF0aCwgZXJyb3I6IG51bGwgfTsKICB9CgogIC8vIFJlbGF0aXZl +IHBhdGg6IHNlYXJjaCBpbiBHSVRIVUJfV09SS1NQQUNFLCB0aGVuIGN3ZC4KICBjb25zdCBzZWFy +Y2hSb290cyA9IFtdOwogIGlmIChwcm9jZXNzLmVudi5HSVRIVUJfV09SS1NQQUNFKSB7CiAgICBz +ZWFyY2hSb290cy5wdXNoKHByb2Nlc3MuZW52LkdJVEhVQl9XT1JLU1BBQ0UpOwogIH0KICBjb25z +dCBjd2QgPSBwcm9jZXNzLmN3ZCgpOwogIGlmICghc2VhcmNoUm9vdHMuaW5jbHVkZXMoY3dkKSkg +ewogICAgc2VhcmNoUm9vdHMucHVzaChjd2QpOwogIH0KCiAgZm9yIChjb25zdCByb290IG9mIHNl +YXJjaFJvb3RzKSB7CiAgICBjb25zdCBjYW5kaWRhdGUgPSBwYXRoLnJlc29sdmUocm9vdCwgcmVx +UGF0aCk7CiAgICBpZiAoIWZzLmV4aXN0c1N5bmMoY2FuZGlkYXRlKSkgY29udGludWU7CiAgICBj +b25zdCBzdGF0ID0gbHN0YXRHdWFyZChjYW5kaWRhdGUpOwogICAgaWYgKHN0YXQgPT09IG51bGwp +IHsKICAgICAgcmV0dXJuIHsgY29waWVkOiBmYWxzZSwgcmVsUGF0aDogIiIsIGVycm9yOiBgc3lt +bGlua3MgYXJlIG5vdCBhbGxvd2VkOiAke2NhbmRpZGF0ZX1gIH07CiAgICB9CgogICAgLy8gQ2Fu +b25pY2FsaXplIGFuZCB2YWxpZGF0ZSBiZWZvcmUgY29weWluZy4KICAgIGxldCBjYW5vbmljYWw7 +CiAgICB0cnkgewogICAgICBjYW5vbmljYWwgPSBmcy5yZWFscGF0aFN5bmMoY2FuZGlkYXRlKTsK +ICAgIH0gY2F0Y2ggKGVycikgewogICAgICByZXR1cm4geyBjb3BpZWQ6IGZhbHNlLCByZWxQYXRo +OiAiIiwgZXJyb3I6IGBmYWlsZWQgdG8gcmVzb2x2ZSBjYW5vbmljYWwgcGF0aCBmb3IgJHtjYW5k +aWRhdGV9OiAke2dldEVycm9yTWVzc2FnZShlcnIpfWAgfTsKICAgIH0KICAgIGNvbnN0IHNlbnNp +dGl2ZUVyciA9IHZhbGlkYXRlU291cmNlUGF0aChjYW5vbmljYWwpOwogICAgaWYgKHNlbnNpdGl2 +ZUVycikgewogICAgICByZXR1cm4geyBjb3BpZWQ6IGZhbHNlLCByZWxQYXRoOiAiIiwgZXJyb3I6 +IHNlbnNpdGl2ZUVyciB9OwogICAgfQogICAgY29uc3Qgcm9vdEVyciA9IHZhbGlkYXRlQWxsb3dl +ZFJvb3QoY2Fub25pY2FsKTsKICAgIGlmIChyb290RXJyKSB7CiAgICAgIHJldHVybiB7IGNvcGll +ZDogZmFsc2UsIHJlbFBhdGg6ICIiLCBlcnJvcjogcm9vdEVyciB9OwogICAgfQoKICAgIGlmIChz +dGF0LmlzRGlyZWN0b3J5KCkpIHsKICAgICAgY29uc3QgcmVzdWx0ID0gY29weURpcmVjdG9yeVRv +U3RhZ2luZyhjYW5kaWRhdGUsIHJlcVBhdGgpOwogICAgICBpZiAocmVzdWx0LmVycm9yKSByZXR1 +cm4geyBjb3BpZWQ6IGZhbHNlLCByZWxQYXRoOiAiIiwgZXJyb3I6IHJlc3VsdC5lcnJvciB9Owog +ICAgICBjb3JlLmluZm8oYEF1dG8tY29waWVkIGRpcmVjdG9yeSAke2NhbmRpZGF0ZX0gdG8gc3Rh +Z2luZyBhcyAke3JlcVBhdGh9ICgke3Jlc3VsdC5jb3BpZWRDb3VudH0gZmlsZShzKSlgKTsKICAg +IH0gZWxzZSB7CiAgICAgIGNvbnN0IHJlc3VsdCA9IGNvcHlTaW5nbGVGaWxlVG9TdGFnaW5nKGNh +bmRpZGF0ZSwgcmVxUGF0aCk7CiAgICAgIGlmIChyZXN1bHQuZXJyb3IpIHJldHVybiB7IGNvcGll +ZDogZmFsc2UsIHJlbFBhdGg6ICIiLCBlcnJvcjogcmVzdWx0LmVycm9yIH07CiAgICAgIGNvcmUu +aW5mbyhgQXV0by1jb3BpZWQgZmlsZSAke2NhbmRpZGF0ZX0gdG8gc3RhZ2luZyBhcyAke3JlcVBh +dGh9YCk7CiAgICB9CiAgICByZXR1cm4geyBjb3BpZWQ6IHRydWUsIHJlbFBhdGg6IHJlcVBhdGgs +IGVycm9yOiBudWxsIH07CiAgfQoKICByZXR1cm4geyBjb3BpZWQ6IGZhbHNlLCByZWxQYXRoOiAi +IiwgZXJyb3I6IG51bGwgfTsKfQoKLyoqCiAqIFJlc29sdmUgdGhlIGxpc3Qgb2YgZmlsZXMgdG8g +dXBsb2FkIGZvciBhIHNpbmdsZSByZXF1ZXN0LgogKiBBcHBsaWVzOiBzdGFnaW5nIHJvb3Qg4oaS +IGF1dG8tY29weSDihpIgYWxsb3dlZC1wYXRocyDihpIgcmVxdWVzdCBpbmNsdWRlL2V4Y2x1ZGUg +4oaSIGRlZHVwICsgc29ydC4KICoKICogSWYgYSBwYXRoLWJhc2VkIHJlcXVlc3QgcmVmZXJzIHRv +IGEgZmlsZSB0aGF0IGlzIG5vdCBpbiB0aGUgc3RhZ2luZyBkaXJlY3RvcnkgYnV0IGV4aXN0cwog +KiBlbHNld2hlcmUgKGFic29sdXRlIHBhdGgsIHdvcmtzcGFjZSwgb3IgY3dkKSwgdGhlIGZpbGUg +aXMgYXV0b21hdGljYWxseSBjb3BpZWQgaW50byB0aGUKICogc3RhZ2luZyBkaXJlY3RvcnkgYmVm +b3JlIHJlc29sdXRpb24gY29udGludWVzLgogKgogKiBAcGFyYW0ge1JlY29yZDxzdHJpbmcsIGFu +eT59IHJlcXVlc3QgLSBQYXJzZWQgdXBsb2FkX2FydGlmYWN0IHJlY29yZAogKiBAcGFyYW0ge3N0 +cmluZ1tdfSBhbGxvd2VkUGF0aHMgLSBQb2xpY3kgYWxsb3dlZC1wYXRocyBwYXR0ZXJucwogKiBA +cGFyYW0ge3N0cmluZ1tdfSBkZWZhdWx0SW5jbHVkZSAtIFBvbGljeSBkZWZhdWx0IGluY2x1ZGUg +cGF0dGVybnMKICogQHBhcmFtIHtzdHJpbmdbXX0gZGVmYXVsdEV4Y2x1ZGUgLSBQb2xpY3kgZGVm +YXVsdCBleGNsdWRlIHBhdHRlcm5zCiAqIEByZXR1cm5zIHt7IGZpbGVzOiBzdHJpbmdbXSwgZXJy +b3I6IHN0cmluZ3xudWxsIH19CiAqLwpmdW5jdGlvbiByZXNvbHZlRmlsZXMocmVxdWVzdCwgYWxs +b3dlZFBhdGhzLCBkZWZhdWx0SW5jbHVkZSwgZGVmYXVsdEV4Y2x1ZGUpIHsKICBjb25zdCBoYXNQ +YXRoID0gInBhdGgiIGluIHJlcXVlc3Q7CiAgY29uc3QgaGFzRmlsdGVycyA9ICJmaWx0ZXJzIiBp +biByZXF1ZXN0OwogIGlmIChoYXNQYXRoID09PSBoYXNGaWx0ZXJzKSB7CiAgICByZXR1cm4geyBm +aWxlczogW10sIGVycm9yOiAiZXhhY3RseSBvbmUgb2YgJ3BhdGgnIG9yICdmaWx0ZXJzJyBtdXN0 +IGJlIHByZXNlbnQiIH07CiAgfQoKICAvKiogQHR5cGUge3N0cmluZ1tdfSAqLwogIGxldCBjYW5k +aWRhdGVSZWxQYXRoczsKCiAgaWYgKCJwYXRoIiBpbiByZXF1ZXN0KSB7CiAgICBsZXQgcmVxUGF0 +aCA9IFN0cmluZyhyZXF1ZXN0LnBhdGgpOwoKICAgIC8vIEZvciBhYnNvbHV0ZSBwYXRocywgYXR0 +ZW1wdCBhdXRvLWNvcHkgdG8gc3RhZ2luZy4KICAgIGlmIChwYXRoLmlzQWJzb2x1dGUocmVxUGF0 +aCkpIHsKICAgICAgY29uc3QgY29weVJlc3VsdCA9IGF1dG9Db3B5VG9TdGFnaW5nKHJlcVBhdGgp +OwogICAgICBpZiAoY29weVJlc3VsdC5lcnJvcikgewogICAgICAgIHJldHVybiB7IGZpbGVzOiBb +XSwgZXJyb3I6IGNvcHlSZXN1bHQuZXJyb3IgfTsKICAgICAgfQogICAgICBpZiAoIWNvcHlSZXN1 +bHQuY29waWVkKSB7CiAgICAgICAgcmV0dXJuIHsgZmlsZXM6IFtdLCBlcnJvcjogYHBhdGggbXVz +dCBiZSByZWxhdGl2ZSAoc3RhZ2luZy1kaXItcmVsYXRpdmUpLCBnb3QgYWJzb2x1dGUgcGF0aDog +JHtyZXFQYXRofWAgfTsKICAgICAgfQogICAgICAvLyBTd2l0Y2ggdG8gdGhlIHJlbGF0aXZlIHBh +dGggaW5zaWRlIHRoZSBzdGFnaW5nIGRpcmVjdG9yeS4KICAgICAgcmVxUGF0aCA9IGNvcHlSZXN1 +bHQucmVsUGF0aDsKICAgIH0KCiAgICAvLyBSZWplY3QgdHJhdmVyc2FsCiAgICBjb25zdCByZXNv +bHZlZCA9IHBhdGgucmVzb2x2ZShzdGFnaW5nRGlyZWN0b3J5KCksIHJlcVBhdGgpOwogICAgaWYg +KCFpc1dpdGhpblJvb3QocmVzb2x2ZWQsIHN0YWdpbmdEaXJlY3RvcnkoKSkpIHsKICAgICAgcmV0 +dXJuIHsgZmlsZXM6IFtdLCBlcnJvcjogYHBhdGggbXVzdCBub3QgdHJhdmVyc2Ugb3V0c2lkZSBz +dGFnaW5nIGRpcmVjdG9yeTogJHtyZXFQYXRofWAgfTsKICAgIH0KCiAgICAvLyBJZiB0aGUgcGF0 +aCBkb2VzIG5vdCBleGlzdCBpbiBzdGFnaW5nLCB0cnkgYXV0by1jb3B5IGZyb20gd29ya3NwYWNl +L2N3ZC4KICAgIGlmICghZnMuZXhpc3RzU3luYyhyZXNvbHZlZCkpIHsKICAgICAgY29uc3QgY29w +eVJlc3VsdCA9IGF1dG9Db3B5VG9TdGFnaW5nKHJlcVBhdGgpOwogICAgICBpZiAoY29weVJlc3Vs +dC5lcnJvcikgewogICAgICAgIHJldHVybiB7IGZpbGVzOiBbXSwgZXJyb3I6IGNvcHlSZXN1bHQu +ZXJyb3IgfTsKICAgICAgfQogICAgICBpZiAoIWNvcHlSZXN1bHQuY29waWVkKSB7CiAgICAgICAg +Y29uc3QgYXZhaWxhYmxlID0gbGlzdEZpbGVzUmVjdXJzaXZlKHN0YWdpbmdEaXJlY3RvcnkoKSwg +c3RhZ2luZ0RpcmVjdG9yeSgpKTsKICAgICAgICBjb25zdCBoaW50ID0KICAgICAgICAgIGF2YWls +YWJsZS5sZW5ndGggPiAwCiAgICAgICAgICAgID8gYCBBdmFpbGFibGUgZmlsZXM6IFske2F2YWls +YWJsZS5zbGljZSgwLCAyMCkuam9pbigiLCAiKX1dJHthdmFpbGFibGUubGVuZ3RoID4gMjAgPyBg +IOKApiBhbmQgJHthdmFpbGFibGUubGVuZ3RoIC0gMjB9IG1vcmVgIDogIiJ9YAogICAgICAgICAg +ICA6ICIgVGhlIHN0YWdpbmcgZGlyZWN0b3J5IGlzIGVtcHR5IOKAlCBkaWQgeW91IGZvcmdldCB0 +byBjb3B5IGZpbGVzIHRvICIgKyBzdGFnaW5nRGlyZWN0b3J5KCkgKyAiPyI7CiAgICAgICAgcmV0 +dXJuIHsgZmlsZXM6IFtdLCBlcnJvcjogYHBhdGggZG9lcyBub3QgZXhpc3QgaW4gc3RhZ2luZyBk +aXJlY3Rvcnk6ICR7cmVxUGF0aH0uJHtoaW50fWAgfTsKICAgICAgfQogICAgICByZXFQYXRoID0g +Y29weVJlc3VsdC5yZWxQYXRoOwogICAgfQoKICAgIGNvbnN0IHN0YXQgPSBsc3RhdEd1YXJkKHBh +dGgucmVzb2x2ZShzdGFnaW5nRGlyZWN0b3J5KCksIHJlcVBhdGgpKTsKICAgIGlmIChzdGF0ID09 +PSBudWxsKSB7CiAgICAgIHJldHVybiB7IGZpbGVzOiBbXSwgZXJyb3I6IGBzeW1saW5rcyBhcmUg +bm90IGFsbG93ZWQ6ICR7cmVxUGF0aH1gIH07CiAgICB9CiAgICBpZiAoc3RhdC5pc0RpcmVjdG9y +eSgpKSB7CiAgICAgIGNhbmRpZGF0ZVJlbFBhdGhzID0gbGlzdEZpbGVzUmVjdXJzaXZlKHBhdGgu +cmVzb2x2ZShzdGFnaW5nRGlyZWN0b3J5KCksIHJlcVBhdGgpLCBzdGFnaW5nRGlyZWN0b3J5KCkp +OwogICAgfSBlbHNlIHsKICAgICAgY2FuZGlkYXRlUmVsUGF0aHMgPSBbcmVxUGF0aF07CiAgICB9 +CiAgfSBlbHNlIHsKICAgIC8vIEZpbHRlci1iYXNlZCBzZWxlY3Rpb246IHN0YXJ0IGZyb20gYWxs +IGZpbGVzIGluIHRoZSBzdGFnaW5nIGRpcmVjdG9yeS4KICAgIGNvbnN0IGFsbEZpbGVzID0gbGlz +dEZpbGVzUmVjdXJzaXZlKHN0YWdpbmdEaXJlY3RvcnkoKSwgc3RhZ2luZ0RpcmVjdG9yeSgpKTsK +ICAgIGNvbnN0IHJlcXVlc3RGaWx0ZXJzID0gcmVxdWVzdC5maWx0ZXJzIHx8IHt9OwogICAgY29u +c3QgaW5jbHVkZSA9IC8qKiBAdHlwZSB7c3RyaW5nW119ICovIHJlcXVlc3RGaWx0ZXJzLmluY2x1 +ZGUgfHwgZGVmYXVsdEluY2x1ZGU7CiAgICBjb25zdCBleGNsdWRlID0gLyoqIEB0eXBlIHtzdHJp +bmdbXX0gKi8gcmVxdWVzdEZpbHRlcnMuZXhjbHVkZSB8fCBkZWZhdWx0RXhjbHVkZTsKCiAgICBj +YW5kaWRhdGVSZWxQYXRocyA9IGFsbEZpbGVzLmZpbHRlcihmID0+IChpbmNsdWRlLmxlbmd0aCA9 +PT0gMCB8fCBtYXRjaGVzQW55UGF0dGVybihmLCBpbmNsdWRlKSkgJiYgKGV4Y2x1ZGUubGVuZ3Ro +ID09PSAwIHx8ICFtYXRjaGVzQW55UGF0dGVybihmLCBleGNsdWRlKSkpOwogIH0KCiAgLy8gQXBw +bHkgYWxsb3dlZC1wYXRocyBwb2xpY3kgZmlsdGVyLgogIGlmIChhbGxvd2VkUGF0aHMubGVuZ3Ro +ID4gMCkgewogICAgY2FuZGlkYXRlUmVsUGF0aHMgPSBjYW5kaWRhdGVSZWxQYXRocy5maWx0ZXIo +ZiA9PiBtYXRjaGVzQW55UGF0dGVybihmLCBhbGxvd2VkUGF0aHMpKTsKICB9CgogIC8vIERlZHVw +bGljYXRlIGFuZCBzb3J0IGRldGVybWluaXN0aWNhbGx5LgogIGNvbnN0IHVuaXF1ZSA9IEFycmF5 +LmZyb20obmV3IFNldChjYW5kaWRhdGVSZWxQYXRocykpLnNvcnQoKTsKICBpZiAoY3VycmVudENs +YWltSGFuZGxlKCkpIGZvciAoY29uc3QgZmlsZW5hbWUgb2YgdW5pcXVlKSBhc3NlcnRDbGFpbUFy +dGlmYWN0RmlsZShwYXRoLmpvaW4oc3RhZ2luZ0RpcmVjdG9yeSgpLCBmaWxlbmFtZSksIHN0YWdp +bmdEaXJlY3RvcnkoKSk7CiAgcmV0dXJuIHsgZmlsZXM6IHVuaXF1ZSwgZXJyb3I6IG51bGwgfTsK +fQoKLyoqCiAqIFZhbGlkYXRlIHNraXBfYXJjaGl2ZSBjb25zdHJhaW50czoKICogLSBza2lwX2Fy +Y2hpdmUgbWF5IG9ubHkgYmUgdXNlZCBmb3IgYSBzaW5nbGUgZmlsZS4KICogLSBkaXJlY3Rvcmll +cyBhcmUgcmVqZWN0ZWQgKGFscmVhZHkgZXhwYW5kZWQgdG8gZmlsZSBsaXN0KS4KICoKICogQHBh +cmFtIHtib29sZWFufSBza2lwQXJjaGl2ZQogKiBAcGFyYW0ge3N0cmluZ1tdfSBmaWxlcwogKiBA +cmV0dXJucyB7c3RyaW5nfG51bGx9IEVycm9yIG1lc3NhZ2Ugb3IgbnVsbAogKi8KZnVuY3Rpb24g +dmFsaWRhdGVTa2lwQXJjaGl2ZShza2lwQXJjaGl2ZSwgZmlsZXMpIHsKICBpZiAoIXNraXBBcmNo +aXZlKSByZXR1cm4gbnVsbDsKICBpZiAoZmlsZXMubGVuZ3RoICE9PSAxKSB7CiAgICByZXR1cm4g +YHNraXAtYXJjaGl2ZSByZXF1aXJlcyBleGFjdGx5IG9uZSBzZWxlY3RlZCBmaWxlLCBidXQgJHtm +aWxlcy5sZW5ndGh9IGZpbGVzIG1hdGNoZWRgOwogIH0KICByZXR1cm4gbnVsbDsKfQoKLyoqCiAq +IENvbXB1dGUgdG90YWwgc2l6ZSBvZiB0aGUgZ2l2ZW4gZmlsZSBsaXN0IChyZWxhdGl2ZSBwYXRo +cyBmcm9tIFNUQUdJTkdfRElSKS4KICogQHBhcmFtIHtzdHJpbmdbXX0gZmlsZXMKICogQHJldHVy +bnMge251bWJlcn0gVG90YWwgc2l6ZSBpbiBieXRlcwogKi8KZnVuY3Rpb24gY29tcHV0ZVRvdGFs +U2l6ZShmaWxlcykgewogIGxldCB0b3RhbCA9IDA7CiAgZm9yIChjb25zdCBmIG9mIGZpbGVzKSB7 +CiAgICBjb25zdCBhYnMgPSBwYXRoLmpvaW4oc3RhZ2luZ0RpcmVjdG9yeSgpLCBmKTsKICAgIHRy +eSB7CiAgICAgIHRvdGFsICs9IGZzLnN0YXRTeW5jKGFicykuc2l6ZTsKICAgIH0gY2F0Y2ggewog +ICAgICAvLyBJZ25vcmUgbWlzc2luZyBmaWxlcyAoYWxyZWFkeSB2YWxpZGF0ZWQgdXBzdHJlYW0p +LgogICAgfQogIH0KICByZXR1cm4gdG90YWw7Cn0KCi8qKgogKiBEZXJpdmUgYSBzYW5pdGlzZWQg +YXJ0aWZhY3QgbmFtZSBmcm9tIGEgcGF0aCBvciBhIHNsb3QgaW5kZXguCiAqIEBwYXJhbSB7UmVj +b3JkPHN0cmluZywgYW55Pn0gcmVxdWVzdAogKiBAcGFyYW0ge251bWJlcn0gc2xvdEluZGV4CiAq +IEByZXR1cm5zIHtzdHJpbmd9CiAqLwpmdW5jdGlvbiBkZXJpdmVBcnRpZmFjdE5hbWUocmVxdWVz +dCwgc2xvdEluZGV4KSB7CiAgaWYgKHR5cGVvZiByZXF1ZXN0Lm5hbWUgPT09ICJzdHJpbmciICYm +IHJlcXVlc3QubmFtZS50cmltKCkpIHsKICAgIHJldHVybiByZXF1ZXN0Lm5hbWUudHJpbSgpLnJl +cGxhY2UoL1teYS16QS1aMC05Ll9cLV0vZywgIi0iKTsKICB9CiAgaWYgKCJwYXRoIiBpbiByZXF1 +ZXN0ICYmIHR5cGVvZiByZXF1ZXN0LnBhdGggPT09ICJzdHJpbmciKSB7CiAgICBjb25zdCBiYXNl +ID0gcGF0aC5iYXNlbmFtZShTdHJpbmcocmVxdWVzdC5wYXRoKSkucmVwbGFjZSgvW15hLXpBLVow +LTkuX1wtXS9nLCAiLSIpOwogICAgaWYgKGJhc2UpIHJldHVybiBiYXNlOwogIH0KICByZXR1cm4g +YGFydGlmYWN0LXNsb3QtJHtzbG90SW5kZXh9YDsKfQoKLyoqCiAqIENyZWF0ZSBvciByZXR1cm4g +dGhlIGludGVybmFsIERlZmF1bHRBcnRpZmFjdENsaWVudC4KICogZ2xvYmFsLl9fY3JlYXRlQXJ0 +aWZhY3RDbGllbnQgY2FuIGJlIHNldCBpbiB0ZXN0cyB0byBpbmplY3QgYSBtb2NrIGNsaWVudCBm +YWN0b3J5LgogKiBAcmV0dXJucyB7UHJvbWlzZTx7IHVwbG9hZEFydGlmYWN0OiAobmFtZTogc3Ry +aW5nLCBmaWxlczogc3RyaW5nW10sIHJvb3REaXI6IHN0cmluZywgb3B0czogb2JqZWN0KSA9PiBQ +cm9taXNlPHtpZD86IG51bWJlciwgc2l6ZT86IG51bWJlciwgZGlnZXN0Pzogc3RyaW5nfT4gfT59 +CiAqLwphc3luYyBmdW5jdGlvbiBnZXRBcnRpZmFjdENsaWVudCgpIHsKICBpZiAodHlwZW9mIGds +b2JhbC5fX2NyZWF0ZUFydGlmYWN0Q2xpZW50ID09PSAiZnVuY3Rpb24iKSB7CiAgICByZXR1cm4g +Z2xvYmFsLl9fY3JlYXRlQXJ0aWZhY3RDbGllbnQoKTsKICB9CiAgcmV0dXJuIG5ldyBEZWZhdWx0 +QXJ0aWZhY3RDbGllbnQoKTsKfQoKLyoqCiAqIFJldHVybnMgYSBwZXItbWVzc2FnZSBoYW5kbGVy +IGZ1bmN0aW9uIHRoYXQgcHJvY2Vzc2VzIGEgc2luZ2xlIHVwbG9hZF9hcnRpZmFjdCByZXF1ZXN0 +LgogKgogKiBAcGFyYW0ge09iamVjdH0gY29uZmlnIC0gSGFuZGxlciBjb25maWd1cmF0aW9uIGZy +b20gdGhlIHNhZmUgb3V0cHV0cyBjb25maWcKICogQHJldHVybnMge1Byb21pc2U8RnVuY3Rpb24+ +fSBQZXItbWVzc2FnZSBoYW5kbGVyIGZ1bmN0aW9uCiAqLwphc3luYyBmdW5jdGlvbiBtYWluKGNv +bmZpZyA9IHt9KSB7CiAgY29uc3QgZmFjdG9yeUNsYWltID0gY3VycmVudENsYWltSGFuZGxlKCk7 +CiAgaWYgKCFmYWN0b3J5Q2xhaW0gJiYgcmVhZENsYWltU2NvcGVDb250ZXh0KCk/LmFzc2lnbm1l +bnQpIHRocm93IG5ldyBFcnJvcihgJHtFUlJfVkFMSURBVElPTn06IHVwbG9hZF9hcnRpZmFjdCBy +ZXF1aXJlcyBpdHMgb3JpZ2luYWwgcGVyLUNsYWltIGV4ZWN1dGlvbiBjb250ZXh0OyB1c2UgdGhl +IHNjb3BlZCBzYWZlLW91dHB1dCBoYW5kbGVyYCk7CiAgY29uc3QgZmFjdG9yeUlkZW50aXR5ID0g +ZmFjdG9yeUNsYWltID8gY2xhaW1JZGVudGl0eShmYWN0b3J5Q2xhaW0pIDogbnVsbDsKICBjb25z +dCBtYXhVcGxvYWRzID0gdHlwZW9mIGNvbmZpZ1sibWF4LXVwbG9hZHMiXSA9PT0gIm51bWJlciIg +PyBjb25maWdbIm1heC11cGxvYWRzIl0gOiAxOwogIC8vIHJldGVudGlvbi1kYXlzIGFuZCBza2lw +LWFyY2hpdmUgYXJlIGZpeGVkIHdvcmtmbG93IGNvbmZpZ3VyYXRpb247IHRoZSBhZ2VudCBjYW5u +b3Qgb3ZlcnJpZGUgdGhlbS4KICBjb25zdCBjb25maWd1cmVkUmV0ZW50aW9uID0gY29uZmlnWyJy +ZXRlbnRpb24tZGF5cyJdID8/IDMwOwogIGNvbnN0IHJldGVudGlvbkRheXMgPSB0eXBlb2YgY29u +ZmlndXJlZFJldGVudGlvbiA9PT0gIm51bWJlciIgfHwgdHlwZW9mIGNvbmZpZ3VyZWRSZXRlbnRp +b24gPT09ICJzdHJpbmciID8gTnVtYmVyKGNvbmZpZ3VyZWRSZXRlbnRpb24pIDogTmFOOwogIGlm +ICghTnVtYmVyLmlzSW50ZWdlcihyZXRlbnRpb25EYXlzKSB8fCByZXRlbnRpb25EYXlzIDwgMSB8 +fCByZXRlbnRpb25EYXlzID4gNDAwKSB7CiAgICB0aHJvdyBuZXcgRXJyb3IoYCR7RVJSX1ZBTElE +QVRJT059OiB1cGxvYWRfYXJ0aWZhY3QgcmV0ZW50aW9uLWRheXMgbXVzdCByZXNvbHZlIHRvIGFu +IGludGVnZXIgYmV0d2VlbiAxIGFuZCA0MDAsIGdvdCAke0pTT04uc3RyaW5naWZ5KGNvbmZpZ3Vy +ZWRSZXRlbnRpb24pfWApOwogIH0KICBjb25zdCBza2lwQXJjaGl2ZSA9IGNvbmZpZ1sic2tpcC1h +cmNoaXZlIl0gPT09IHRydWU7CiAgY29uc3QgbWF4U2l6ZUJ5dGVzID0gdHlwZW9mIGNvbmZpZ1si +bWF4LXNpemUtYnl0ZXMiXSA9PT0gIm51bWJlciIgPyBjb25maWdbIm1heC1zaXplLWJ5dGVzIl0g +OiAxMDQ4NTc2MDA7CiAgY29uc3QgZGVmYXVsdElmTm9GaWxlcyA9IHR5cGVvZiBjb25maWdbImRl +ZmF1bHQtaWYtbm8tZmlsZXMiXSA9PT0gInN0cmluZyIgPyBjb25maWdbImRlZmF1bHQtaWYtbm8t +ZmlsZXMiXSA6ICJlcnJvciI7CiAgY29uc3QgYWxsb3dlZFBhdGhzID0gQXJyYXkuaXNBcnJheShj +b25maWdbImFsbG93ZWQtcGF0aHMiXSkgPyBjb25maWdbImFsbG93ZWQtcGF0aHMiXSA6IFtdOwog +IGNvbnN0IGZpbHRlcnNJbmNsdWRlID0gQXJyYXkuaXNBcnJheShjb25maWdbImZpbHRlcnMtaW5j +bHVkZSJdKSA/IGNvbmZpZ1siZmlsdGVycy1pbmNsdWRlIl0gOiBbXTsKICBjb25zdCBmaWx0ZXJz +RXhjbHVkZSA9IEFycmF5LmlzQXJyYXkoY29uZmlnWyJmaWx0ZXJzLWV4Y2x1ZGUiXSkgPyBjb25m +aWdbImZpbHRlcnMtZXhjbHVkZSJdIDogW107CiAgY29uc3QgaXNTdGFnZWQgPSBpc1N0YWdlZE1v +ZGUoY29uZmlnKTsKCiAgY29yZS5pbmZvKGB1cGxvYWRfYXJ0aWZhY3QgaGFuZGxlcjogbWF4X3Vw +bG9hZHM9JHttYXhVcGxvYWRzfSwgcmV0ZW50aW9uX2RheXM9JHtyZXRlbnRpb25EYXlzfSwgc2tp +cF9hcmNoaXZlPSR7c2tpcEFyY2hpdmV9YCk7CiAgY29yZS5pbmZvKGBBbGxvd2VkIHBhdGhzOiAk +e2FsbG93ZWRQYXRocy5sZW5ndGggPiAwID8gYWxsb3dlZFBhdGhzLmpvaW4oIiwgIikgOiAiKG5v +bmUg4oCTIGFsbCBzdGFnaW5nIGZpbGVzIGFsbG93ZWQpIn1gKTsKCiAgLy8gU2xvdCBpbmRleCB0 +cmFja3Mgd2hpY2ggc2xvdCBlYWNoIHN1Y2Nlc3NmdWwgcmVxdWVzdCBtYXBzIHRvLgogIGxldCBz +bG90SW5kZXggPSAwOwoKICAvKiogQHR5cGUge1JlY29yZDxzdHJpbmcsIHN0cmluZz59IHJlc29s +dmVyOiB0bXBJZCDihpIgYXJ0aWZhY3QgbmFtZSAqLwogIGNvbnN0IHJlc29sdmVyID0ge307Cgog +IC8qKgogICAqIFBlci1tZXNzYWdlIGhhbmRsZXI6IHByb2Nlc3NlcyBvbmUgdXBsb2FkX2FydGlm +YWN0IHJlcXVlc3QuCiAgICoKICAgKiBDYWxsZWQgYnkgdGhlIHNhZmVfb3V0cHV0cyBoYW5kbGVy +IG1hbmFnZXIgZm9yIGVhY2ggYHVwbG9hZF9hcnRpZmFjdGAgbWVzc2FnZSBlbWl0dGVkCiAgICog +YnkgdGhlIG1vZGVsLiBTdGF0ZSAoc2xvdEluZGV4LCByZXNvbHZlcikgaXMgc2hhcmVkIGFjcm9z +cyBjYWxscyB2aWEgY2xvc3VyZSBzbyB0aGF0CiAgICogc3VjY2Vzc2l2ZSByZXF1ZXN0cyBhcmUg +YXNzaWduZWQgdG8gc2VxdWVudGlhbCBzbG90IGRpcmVjdG9yaWVzLgogICAqCiAgICogQHBhcmFt +IHtPYmplY3R9IG1lc3NhZ2UgLSBUaGUgdXBsb2FkX2FydGlmYWN0IG1lc3NhZ2UgZnJvbSB0aGUg +bW9kZWwKICAgKiBAcGFyYW0ge09iamVjdH0gcmVzb2x2ZWRUZW1wb3JhcnlJZHMgLSBNYXAgb2Yg +YWxyZWFkeS1yZXNvbHZlZCB0ZW1wb3JhcnkgSURzICh1bnVzZWQgaGVyZSkKICAgKiBAcGFyYW0g +e01hcDxzdHJpbmcsIGFueT59IHRlbXBvcmFyeUlkTWFwIC0gU2hhcmVkIHRlbXAtSUQgbWFwOyB0 +aGUgaGFuZGxlciBkb2VzIG5vdCBtb2RpZnkgaXQKICAgKiBAcmV0dXJucyB7UHJvbWlzZTx7c3Vj +Y2VzczogYm9vbGVhbiwgZXJyb3I/OiBzdHJpbmcsIHNraXBwZWQ/OiBib29sZWFuLCB0bXBJZD86 +IHN0cmluZywgdGVtcG9yYXJ5SWQ/OiBzdHJpbmcsIGFydGlmYWN0TmFtZT86IHN0cmluZywgYXJ0 +aWZhY3RJZD86IG51bWJlciwgYXJ0aWZhY3RVcmw/OiBzdHJpbmcsIHNsb3RJbmRleD86IG51bWJl +cn0+fQogICAqLwogIHJldHVybiBhc3luYyBmdW5jdGlvbiBoYW5kbGVVcGxvYWRBcnRpZmFjdCht +ZXNzYWdlLCByZXNvbHZlZFRlbXBvcmFyeUlkcywgdGVtcG9yYXJ5SWRNYXApIHsKICAgIGlmIChj +dXJyZW50Q2xhaW1IYW5kbGUoKSAhPT0gZmFjdG9yeUNsYWltKSB0aHJvdyBuZXcgRXJyb3IoYCR7 +RVJSX1ZBTElEQVRJT059OiB1cGxvYWRfYXJ0aWZhY3QgZmFjdG9yeSBjYW5ub3QgZXNjYXBlIGl0 +cyBvcmlnaW5hbCBDbGFpbTsgY3JlYXRlIGEgaGFuZGxlciBmb3IgdGhlIGN1cnJlbnQgQ2xhaW1g +KTsKICAgIGlmIChmYWN0b3J5SWRlbnRpdHkpIGFzc2VydENsYWltSWRlbnRpdHkoZmFjdG9yeUlk +ZW50aXR5KTsKICAgIG1lc3NhZ2UgPSBhd2FpdCBhc3NlcnRDbGFpbUF1dGhvcml6ZWQobWVzc2Fn +ZSk7CiAgICBpZiAoc2xvdEluZGV4ID49IG1heFVwbG9hZHMpIHsKICAgICAgcmV0dXJuIHsKICAg +ICAgICBzdWNjZXNzOiBmYWxzZSwKICAgICAgICBlcnJvcjogYCR7RVJSX1ZBTElEQVRJT059OiB1 +cGxvYWRfYXJ0aWZhY3Q6IGV4Y2VlZGVkIG1heC11cGxvYWRzIHBvbGljeSAoJHttYXhVcGxvYWRz +fSkuIFJlZHVjZSB0aGUgbnVtYmVyIG9mIHVwbG9hZF9hcnRpZmFjdCBjYWxscyBvciByYWlzZSBt +YXgtdXBsb2FkcyBpbiB3b3JrZmxvdyBjb25maWd1cmF0aW9uLmAsCiAgICAgIH07CiAgICB9Cgog +ICAgY29uc3QgaSA9IHNsb3RJbmRleDsKCiAgICAvLyBSZXNvbHZlIGZpbGVzLgogICAgY29uc3Qg +eyBmaWxlcywgZXJyb3I6IHJlc29sdmVFcnJvciB9ID0gcmVzb2x2ZUZpbGVzKG1lc3NhZ2UsIGFs +bG93ZWRQYXRocywgZmlsdGVyc0luY2x1ZGUsIGZpbHRlcnNFeGNsdWRlKTsKICAgIGlmIChyZXNv +bHZlRXJyb3IpIHsKICAgICAgcmV0dXJuIHsgc3VjY2VzczogZmFsc2UsIGVycm9yOiBgJHtFUlJf +VkFMSURBVElPTn06IHVwbG9hZF9hcnRpZmFjdDogJHtyZXNvbHZlRXJyb3J9YCB9OwogICAgfQoK +ICAgIGlmIChmaWxlcy5sZW5ndGggPT09IDApIHsKICAgICAgaWYgKGRlZmF1bHRJZk5vRmlsZXMg +PT09ICJpZ25vcmUiKSB7CiAgICAgICAgY29yZS53YXJuaW5nKGB1cGxvYWRfYXJ0aWZhY3Q6IG5v +IGZpbGVzIG1hdGNoZWQsIHNraXBwaW5nIChpZi1uby1maWxlcz1pZ25vcmUpYCk7CiAgICAgICAg +cmV0dXJuIHsgc3VjY2VzczogZmFsc2UsIHNraXBwZWQ6IHRydWUsIGVycm9yOiAiTm8gZmlsZXMg +bWF0Y2hlZCB0aGUgc2VsZWN0aW9uIGNyaXRlcmlhIiB9OwogICAgICB9CiAgICAgIHJldHVybiB7 +CiAgICAgICAgc3VjY2VzczogZmFsc2UsCiAgICAgICAgZXJyb3I6IGAke0VSUl9WQUxJREFUSU9O +fTogdXBsb2FkX2FydGlmYWN0OiBubyBmaWxlcyBtYXRjaGVkIHRoZSBzZWxlY3Rpb24gY3JpdGVy +aWEuIENoZWNrIGFsbG93ZWQtcGF0aHMsIGZpbHRlcnMsIG9yIHVzZSBkZWZhdWx0cy5pZi1uby1m +aWxlczogaWdub3JlIHRvIHNraXAgZW1wdHkgdXBsb2Fkcy5gLAogICAgICB9OwogICAgfQoKICAg +IC8vIFZhbGlkYXRlIHNraXAtYXJjaGl2ZSBmaWxlLWNvdW50IGNvbnN0cmFpbnQuCiAgICBjb25z +dCBza2lwQXJjaGl2ZUVycm9yID0gdmFsaWRhdGVTa2lwQXJjaGl2ZShza2lwQXJjaGl2ZSwgZmls +ZXMpOwogICAgaWYgKHNraXBBcmNoaXZlRXJyb3IpIHsKICAgICAgcmV0dXJuIHsgc3VjY2Vzczog +ZmFsc2UsIGVycm9yOiBgJHtFUlJfVkFMSURBVElPTn06IHVwbG9hZF9hcnRpZmFjdDogJHtza2lw +QXJjaGl2ZUVycm9yfWAgfTsKICAgIH0KCiAgICAvLyBWYWxpZGF0ZSB0b3RhbCBzaXplLgogICAg +Y29uc3QgdG90YWxTaXplID0gY29tcHV0ZVRvdGFsU2l6ZShmaWxlcyk7CiAgICBpZiAodG90YWxT +aXplID4gbWF4U2l6ZUJ5dGVzKSB7CiAgICAgIHJldHVybiB7CiAgICAgICAgc3VjY2VzczogZmFs +c2UsCiAgICAgICAgZXJyb3I6IGAke0VSUl9WQUxJREFUSU9OfTogdXBsb2FkX2FydGlmYWN0OiB0 +b3RhbCBmaWxlIHNpemUgJHt0b3RhbFNpemV9IGJ5dGVzIGV4Y2VlZHMgbWF4LXNpemUtYnl0ZXMg +bGltaXQgb2YgJHttYXhTaXplQnl0ZXN9IGJ5dGVzLmAsCiAgICAgIH07CiAgICB9CgogICAgLy8g +RGVyaXZlIGFydGlmYWN0IG5hbWUgYW5kIGdlbmVyYXRlIHRlbXBvcmFyeSBJRC4KICAgIGNvbnN0 +IGJhc2VOYW1lID0gZGVyaXZlQXJ0aWZhY3ROYW1lKG1lc3NhZ2UsIGkpOwogICAgY29uc3QgYXJ0 +aWZhY3ROYW1lID0gZmFjdG9yeUNsYWltID8gYGNsYWltLSR7cGF0aC5iYXNlbmFtZShjbGFpbUFy +dGlmYWN0UGF0aCgiIiwgZmFjdG9yeUNsYWltKSl9LSR7YmFzZU5hbWV9YCA6IGJhc2VOYW1lOwog +ICAgY29uc3QgdG1wSWQgPSByZXNvbHZlVGVtcG9yYXJ5QXJ0aWZhY3RJZChtZXNzYWdlKTsKICAg +IGlmIChPYmplY3QucHJvdG90eXBlLmhhc093blByb3BlcnR5LmNhbGwocmVzb2x2ZXIsIHRtcElk +KSkgewogICAgICBjb3JlLndhcm5pbmcoYHVwbG9hZF9hcnRpZmFjdDogZHVwbGljYXRlIHRlbXBv +cmFyeV9pZCAiJHt0bXBJZH0iIGRldGVjdGVkIGZvciBhcnRpZmFjdCAiJHthcnRpZmFjdE5hbWV9 +Ii4gVXNpbmcgdGhlIGZpcnN0IG9jY3VycmVuY2UuIEVuc3VyZSBlYWNoIGFydGlmYWN0IGhhcyBh +IHVuaXF1ZSB0ZW1wb3JhcnlfaWQuYCk7CiAgICB9IGVsc2UgaWYgKCFmYWN0b3J5Q2xhaW0pIHsK +ICAgICAgcmVzb2x2ZXJbdG1wSWRdID0gYXJ0aWZhY3ROYW1lOwogICAgfQoKICAgIGNvcmUuaW5m +byhgU2xvdCAke2l9OiBhcnRpZmFjdD0iJHthcnRpZmFjdE5hbWV9IiwgZmlsZXM9JHtmaWxlcy5s +ZW5ndGh9LCBzaXplPSR7dG90YWxTaXplfUIsIHJldGVudGlvbj0ke3JldGVudGlvbkRheXN9ZCwg +c2tpcF9hcmNoaXZlPSR7c2tpcEFyY2hpdmV9LCB0bXBfaWQ9JHt0bXBJZH1gKTsKCiAgICAvKiog +QHR5cGUge251bWJlcnx1bmRlZmluZWR9ICovCiAgICBsZXQgYXJ0aWZhY3RJZDsKICAgIC8qKiBA +dHlwZSB7c3RyaW5nfSAqLwogICAgbGV0IGFydGlmYWN0VXJsID0gIiI7CiAgICBsZXQgdHJ1c3Rl +ZERpZ2VzdDsKICAgIGxldCB0cnVzdGVkU2l6ZTsKCiAgICBpZiAoIWlzU3RhZ2VkKSB7CiAgICAg +IC8vIFVwbG9hZCBmaWxlcyBkaXJlY3RseSB2aWEgdGhlIGludGVybmFsIGFydGlmYWN0IGNsaWVu +dC4KICAgICAgY29uc3QgYWJzb2x1dGVGaWxlcyA9IGZpbGVzLm1hcChmID0+IHBhdGguam9pbihz +dGFnaW5nRGlyZWN0b3J5KCksIGYpKTsKICAgICAgY29uc3QgY2xpZW50ID0gYXdhaXQgZ2V0QXJ0 +aWZhY3RDbGllbnQoKTsKICAgICAgdHJ5IHsKICAgICAgICBjb25zdCB1cGxvYWRPcHRzID0geyBy +ZXRlbnRpb25EYXlzIH07CiAgICAgICAgaWYgKHNraXBBcmNoaXZlKSB7CiAgICAgICAgICB1cGxv +YWRPcHRzLnNraXBBcmNoaXZlID0gdHJ1ZTsKICAgICAgICB9CiAgICAgICAgY29uc3QgcmVwb3Np +dG9yeSA9IHByb2Nlc3MuZW52LkdJVEhVQl9SRVBPU0lUT1JZIHx8ICIiOwogICAgICAgIGlmIChm +YWN0b3J5Q2xhaW0pIHsKICAgICAgICAgIGlmICghL15bQS1aYS16MC05Xy4tXStcL1tBLVphLXow +LTlfLi1dKyQvLnRlc3QocmVwb3NpdG9yeSkpIHRocm93IG5ldyBFcnJvcihgJHtFUlJfVkFMSURB +VElPTn06IEFydGlmYWN0IHVwbG9hZCByZXF1aXJlcyB0aGUgb3JpZ2luYWwgbmF0aXZlIHJlcG9z +aXRvcnkgaW4gb3duZXIvcmVwbyBmb3JtYXRgKTsKICAgICAgICAgIGNvbnN0IFtvd25lciwgcmVw +b10gPSByZXBvc2l0b3J5LnNwbGl0KCIvIik7CiAgICAgICAgICBjb25zdCB7IGRhdGE6IG5hdGl2 +ZVJlcG9zaXRvcnkgfSA9IGF3YWl0IGdpdGh1Yi5yZXN0LnJlcG9zLmdldCh7IG93bmVyLCByZXBv +IH0pOwogICAgICAgICAgaWYgKG5hdGl2ZVJlcG9zaXRvcnkuZnVsbF9uYW1lICE9PSByZXBvc2l0 +b3J5IHx8ICEvXlsxLTldWzAtOV0qJC8udGVzdChTdHJpbmcobmF0aXZlUmVwb3NpdG9yeS5pZCkp +KQogICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYCR7RVJSX1ZBTElEQVRJT059OiBBcnRpZmFj +dCB1cGxvYWQgcmVwb3NpdG9yeSBpZGVudGl0eSBkaWZmZXJzIGZyb20gaXRzIG5hdGl2ZSB0YXJn +ZXQ7IHNjb3BlZCBlZmZlY3RzIHJlbWFpbiBibG9ja2VkYCk7CiAgICAgICAgICBhd2FpdCBhc3Nl +cnRDbGFpbUF1dGhvcml6ZWQoeyAuLi5tZXNzYWdlLCByZXBvOiByZXBvc2l0b3J5IH0sIHsgZWZm +ZWN0OiB0cnVlLCByZXNvdXJjZTogeyByZXBvc2l0b3J5LCBob3N0OiBleHBlY3RlZEdpdEh1Ykhv +c3QoKSwgcmVwb3NpdG9yeV9pZDogU3RyaW5nKG5hdGl2ZVJlcG9zaXRvcnkuaWQpLCBydW5faWQ6 +IHByb2Nlc3MuZW52LkdJVEhVQl9SVU5fSUQgfSB9KTsKICAgICAgICB9CiAgICAgICAgY29uc3Qg +ZWZmZWN0ID0gcmVjb3JkQ2xhaW1FZmZlY3QoeyBraW5kOiAiYXJ0aWZhY3QiLCByZXBvc2l0b3J5 +LCBvdXRjb21lOiAidW5rbm93biIgfSk7CiAgICAgICAgY29uc3QgdXBsb2FkUmVzdWx0ID0gYXdh +aXQgY2xpZW50LnVwbG9hZEFydGlmYWN0KGFydGlmYWN0TmFtZSwgYWJzb2x1dGVGaWxlcywgc3Rh +Z2luZ0RpcmVjdG9yeSgpLCB1cGxvYWRPcHRzKTsKICAgICAgICBpZiAoZWZmZWN0KSB7CiAgICAg +ICAgICBlZmZlY3Qub3V0Y29tZSA9ICJzdWNjZWVkZWQiOwogICAgICAgICAgZWZmZWN0LmlkID0g +U3RyaW5nKHVwbG9hZFJlc3VsdC5pZCB8fCAiIik7CiAgICAgICAgfQogICAgICAgIGFydGlmYWN0 +SWQgPSB1cGxvYWRSZXN1bHQuaWQ7CiAgICAgICAgdHJ1c3RlZERpZ2VzdCA9IHVwbG9hZFJlc3Vs +dC5kaWdlc3Q7CiAgICAgICAgdHJ1c3RlZFNpemUgPSB1cGxvYWRSZXN1bHQuc2l6ZTsKICAgICAg +ICBjb3JlLmluZm8oYFVwbG9hZGVkIGFydGlmYWN0ICIke2FydGlmYWN0TmFtZX0iIChpZD0ke2Fy +dGlmYWN0SWQgPz8gIm4vYSJ9LCBzaXplPSR7dXBsb2FkUmVzdWx0LnNpemUgPz8gdG90YWxTaXpl +fUIpYCk7CgogICAgICAgIC8vIENvbnN0cnVjdCB0aGUgYXJ0aWZhY3QgVVJMIGZyb20gdGhlIGFy +dGlmYWN0IElEIGFuZCBHaXRIdWIgY29udGV4dC4KICAgICAgICBpZiAoYXJ0aWZhY3RJZCkgewog +ICAgICAgICAgY29uc3Qgc2VydmVyVXJsID0gcHJvY2Vzcy5lbnYuR0lUSFVCX1NFUlZFUl9VUkwg +fHwgImh0dHBzOi8vZ2l0aHViLmNvbSI7CiAgICAgICAgICBjb25zdCByZXBvc2l0b3J5ID0gcHJv +Y2Vzcy5lbnYuR0lUSFVCX1JFUE9TSVRPUlkgfHwgIiI7CiAgICAgICAgICBjb25zdCBydW5JZCA9 +IHByb2Nlc3MuZW52LkdJVEhVQl9SVU5fSUQgfHwgIiI7CiAgICAgICAgICBpZiAocmVwb3NpdG9y +eSAmJiBydW5JZCkgewogICAgICAgICAgICBhcnRpZmFjdFVybCA9IG5ldyBVUkwoYC8ke3JlcG9z +aXRvcnl9L2FjdGlvbnMvcnVucy8ke3J1bklkfS9hcnRpZmFjdHMvJHthcnRpZmFjdElkfWAsIHNl +cnZlclVybCkudG9TdHJpbmcoKTsKICAgICAgICAgICAgY29yZS5pbmZvKGBBcnRpZmFjdCBVUkw6 +ICR7YXJ0aWZhY3RVcmx9YCk7CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICB9IGNhdGNoIChl +cnIpIHsKICAgICAgICByZXR1cm4gewogICAgICAgICAgc3VjY2VzczogZmFsc2UsCiAgICAgICAg +ICBlcnJvcjogYCR7RVJSX1ZBTElEQVRJT059OiB1cGxvYWRfYXJ0aWZhY3Q6IGZhaWxlZCB0byB1 +cGxvYWQgYXJ0aWZhY3QgIiR7YXJ0aWZhY3ROYW1lfSI6ICR7Z2V0RXJyb3JNZXNzYWdlKGVycil9 +YCwKICAgICAgICB9OwogICAgICB9CiAgICB9IGVsc2UgewogICAgICAvLyBFbWl0IGEgc3RhZ2Vk +IG1vZGUgcHJldmlldyBzdW1tYXJ5LgogICAgICBsZXQgc3VtbWFyeUNvbnRlbnQgPSAiIyMg8J+O +rSBTdGFnZWQgTW9kZTogVXBsb2FkIEFydGlmYWN0IFByZXZpZXdcblxuIjsKICAgICAgc3VtbWFy +eUNvbnRlbnQgKz0gIlRoZSBmb2xsb3dpbmcgYXJ0aWZhY3QgdXBsb2FkIHdvdWxkIGJlIHBlcmZv +cm1lZCBpZiBzdGFnZWQgbW9kZSB3YXMgZGlzYWJsZWQ6XG5cbiI7CiAgICAgIHN1bW1hcnlDb250 +ZW50ICs9IGAqKkFydGlmYWN0IE5hbWU6KiogJHthcnRpZmFjdE5hbWV9XG5cbmA7CiAgICAgIHN1 +bW1hcnlDb250ZW50ICs9IGAqKkZpbGVzICgke2ZpbGVzLmxlbmd0aH0pOioqXG5cbmA7CiAgICAg +IGZvciAoY29uc3QgZmlsZSBvZiBmaWxlcykgewogICAgICAgIHN1bW1hcnlDb250ZW50ICs9IGAt +IFxgJHtmaWxlfVxgXG5gOwogICAgICB9CiAgICAgIHN1bW1hcnlDb250ZW50ICs9IGBcbioqVG90 +YWwgU2l6ZToqKiAke3RvdGFsU2l6ZX0gYnl0ZXNcblxuYDsKICAgICAgc3VtbWFyeUNvbnRlbnQg +Kz0gYCoqUmV0ZW50aW9uOioqICR7cmV0ZW50aW9uRGF5c30gZGF5c1xuXG5gOwogICAgICBzdW1t +YXJ5Q29udGVudCArPSBgPiDihLnvuI8gVXBsb2FkIHNraXBwZWQgKHN0YWdlZCBtb2RlIGFjdGl2 +ZSlcblxuYDsKCiAgICAgIGF3YWl0IGNvcmUuc3VtbWFyeS5hZGRSYXcoc3VtbWFyeUNvbnRlbnQp +LndyaXRlKCk7CiAgICAgIGNvcmUuaW5mbygi8J+TnSBVcGxvYWQgYXJ0aWZhY3QgcHJldmlldyB3 +cml0dGVuIHRvIHN0ZXAgc3VtbWFyeSIpOwogICAgfQoKICAgIGlmIChmYWN0b3J5Q2xhaW0gJiYg +IU9iamVjdC5oYXNPd24ocmVzb2x2ZXIsIHRtcElkKSkgcmVzb2x2ZXJbdG1wSWRdID0gYXJ0aWZh +Y3ROYW1lOwoKICAgIC8vIFNldCBzdGVwIG91dHB1dHMgc28gZG93bnN0cmVhbSBqb2JzIGNhbiBy +ZWZlcmVuY2UgdGhlIHRtcCBJRC4KICAgIGNvbnN0IG91dHB1dFByZWZpeCA9IGZhY3RvcnlDbGFp +bSA/IGBjbGFpbV8ke3BhdGguYmFzZW5hbWUoY2xhaW1BcnRpZmFjdFBhdGgoIiIsIGZhY3RvcnlD +bGFpbSkpfV9gIDogIiI7CiAgICBjb3JlLnNldE91dHB1dChgJHtvdXRwdXRQcmVmaXh9c2xvdF8k +e2l9X3RtcF9pZGAsIHRtcElkKTsKICAgIGNvcmUuc2V0T3V0cHV0KGAke291dHB1dFByZWZpeH1z +bG90XyR7aX1fZmlsZV9jb3VudGAsIFN0cmluZyhmaWxlcy5sZW5ndGgpKTsKICAgIGNvcmUuc2V0 +T3V0cHV0KGAke291dHB1dFByZWZpeH1zbG90XyR7aX1fc2l6ZV9ieXRlc2AsIFN0cmluZyh0b3Rh +bFNpemUpKTsKICAgIGlmIChhcnRpZmFjdElkICE9PSB1bmRlZmluZWQpIHsKICAgICAgY29yZS5z +ZXRPdXRwdXQoYCR7b3V0cHV0UHJlZml4fXNsb3RfJHtpfV9hcnRpZmFjdF9pZGAsIFN0cmluZyhh +cnRpZmFjdElkKSk7CiAgICB9CiAgICBpZiAoYXJ0aWZhY3RVcmwpIHsKICAgICAgY29yZS5zZXRP +dXRwdXQoYCR7b3V0cHV0UHJlZml4fXNsb3RfJHtpfV9hcnRpZmFjdF91cmxgLCBhcnRpZmFjdFVy +bCk7CiAgICB9CgogICAgc2xvdEluZGV4Kys7CgogICAgLy8gVXBkYXRlIHRoZSBjb3VudCBvdXRw +dXQuCiAgICBjb3JlLnNldE91dHB1dChgJHtvdXRwdXRQcmVmaXh9dXBsb2FkX2FydGlmYWN0X2Nv +dW50YCwgU3RyaW5nKHNsb3RJbmRleCkpOwoKICAgIC8vIFdyaXRlL3VwZGF0ZSByZXNvbHZlciBt +YXBwaW5nIHNvIGRvd25zdHJlYW0gc3RlcHMgY2FuIHJlc29sdmUgdG1wIElEcyB0byBhcnRpZmFj +dCBuYW1lcy4KICAgIHRyeSB7CiAgICAgIGNvbnN0IHJlc29sdmVyRmlsZSA9IHNjb3BlZEFydGlm +YWN0RmlsZW5hbWUoUkVTT0xWRVJfRklMRSk7CiAgICAgIGZzLm1rZGlyU3luYyhwYXRoLmRpcm5h +bWUocmVzb2x2ZXJGaWxlKSwgeyByZWN1cnNpdmU6IHRydWUgfSk7CiAgICAgIGlmIChmYWN0b3J5 +Q2xhaW0pIGFzc2VydENsYWltQXJ0aWZhY3REaXJlY3RvcnkocGF0aC5kaXJuYW1lKHJlc29sdmVy +RmlsZSkpOwogICAgICBmcy53cml0ZUZpbGVTeW5jKHJlc29sdmVyRmlsZSwgSlNPTi5zdHJpbmdp +ZnkocmVzb2x2ZXIsIG51bGwsIDIpKTsKICAgICAgY29yZS5pbmZvKGBXcm90ZSBhcnRpZmFjdCBy +ZXNvbHZlciBtYXBwaW5nIHRvICR7cmVzb2x2ZXJGaWxlfWApOwogICAgfSBjYXRjaCAoZXJyKSB7 +CiAgICAgIGNvcmUud2FybmluZyhgRmFpbGVkIHRvIHdyaXRlIGFydGlmYWN0IHJlc29sdmVyIGZp +bGU6ICR7Z2V0RXJyb3JNZXNzYWdlKGVycil9YCk7CiAgICB9CgogICAgY29uc3QgcmVzdWx0ID0g +ewogICAgICBzdWNjZXNzOiB0cnVlLAogICAgICBzdGFnZWQ6IGlzU3RhZ2VkLAogICAgICB0bXBJ +ZCwKICAgICAgdGVtcG9yYXJ5SWQ6IHRtcElkLAogICAgICBhcnRpZmFjdE5hbWUsCiAgICAgIGFy +dGlmYWN0SWQsCiAgICAgIGFydGlmYWN0VXJsLAogICAgICBzbG90SW5kZXg6IGksCiAgICB9Owog +ICAgaWYgKGZhY3RvcnlDbGFpbSAmJiAhaXNTdGFnZWQgJiYgYXJ0aWZhY3RJZCAmJiB0eXBlb2Yg +dHJ1c3RlZERpZ2VzdCA9PT0gInN0cmluZyIgJiYgL14oPzpzaGEyNTY6KT9bYS1mMC05XXs2NH0k +Ly50ZXN0KHRydXN0ZWREaWdlc3QpKSB7CiAgICAgIHByaXZhdGVEZWxpdmVyeVJlY2VpcHRzLnNl +dChyZXN1bHQsIHsKICAgICAgICAuLi5mYWN0b3J5SWRlbnRpdHksCiAgICAgICAgcmVwb3NpdG9y +eTogcHJvY2Vzcy5lbnYuR0lUSFVCX1JFUE9TSVRPUlksCiAgICAgICAgcnVuX2lkOiBwcm9jZXNz +LmVudi5HSVRIVUJfUlVOX0lELAogICAgICAgIG5hbWU6IGFydGlmYWN0TmFtZSwKICAgICAgICBp +ZDogYXJ0aWZhY3RJZCwKICAgICAgICBkaWdlc3Q6IHRydXN0ZWREaWdlc3QucmVwbGFjZSgvXnNo +YTI1NjovLCAiIiksCiAgICAgICAgc2l6ZTogdHJ1c3RlZFNpemUsCiAgICAgICAgdXJsOiBhcnRp +ZmFjdFVybCwKICAgICAgfSk7CiAgICB9CiAgICByZXR1cm4gcmVzdWx0OwogIH07Cn0KCmFzeW5j +IGZ1bmN0aW9uIHZlcmlmeUFydGlmYWN0RGVsaXZlcnkoeyBjbGFpbSwgcmVzdWx0LCBnaXRodWIg +fSkgewogIGNvbnN0IHJlY2VpcHQgPSByZXN1bHQgJiYgcHJpdmF0ZURlbGl2ZXJ5UmVjZWlwdHMu +Z2V0KHJlc3VsdCk7CiAgaWYgKCFyZWNlaXB0TWF0Y2hlc0NsYWltKHJlY2VpcHQsIGNsYWltKSB8 +fCAhcmVjZWlwdC5ydW5faWQpIHJldHVybiB7IHZlcmlmaWVkOiBmYWxzZSB9OwogIGNvbnN0IFtv +d25lciwgcmVwb10gPSByZWNlaXB0LnJlcG9zaXRvcnkuc3BsaXQoIi8iKTsKICBjb25zdCB7IGRh +dGEgfSA9IGF3YWl0IGdpdGh1Yi5yZXN0LmFjdGlvbnMuZ2V0QXJ0aWZhY3QoeyBvd25lciwgcmVw +bywgYXJ0aWZhY3RfaWQ6IHJlY2VpcHQuaWQgfSk7CiAgaWYgKAogICAgZGF0YS5pZCAhPT0gcmVj +ZWlwdC5pZCB8fAogICAgZGF0YS5uYW1lICE9PSByZWNlaXB0Lm5hbWUgfHwKICAgIGRhdGEuZXhw +aXJlZCAhPT0gZmFsc2UgfHwKICAgIFN0cmluZyhkYXRhLndvcmtmbG93X3J1bj8uaWQpICE9PSBy +ZWNlaXB0LnJ1bl9pZCB8fAogICAgZGF0YS5kaWdlc3QgIT09IGBzaGEyNTY6JHtyZWNlaXB0LmRp +Z2VzdH1gIHx8CiAgICAocmVjZWlwdC5zaXplICE9PSB1bmRlZmluZWQgJiYgZGF0YS5zaXplX2lu +X2J5dGVzICE9PSByZWNlaXB0LnNpemUpCiAgKQogICAgcmV0dXJuIHsgdmVyaWZpZWQ6IGZhbHNl +IH07CiAgcmV0dXJuIHsKICAgIHZlcmlmaWVkOiB0cnVlLAogICAgY2xhaW1faGFuZGxlOiBjbGFp +bS5oYW5kbGUsCiAgICByZXNvdXJjZTogeyBraW5kOiAiYXJ0aWZhY3QiLCByZXBvc2l0b3J5OiBy +ZWNlaXB0LnJlcG9zaXRvcnksIGlkOiBTdHJpbmcocmVjZWlwdC5pZCksIHRhcmdldF9ydW5faWQ6 +IHJlY2VpcHQucnVuX2lkLCBuYW1lOiByZWNlaXB0Lm5hbWUsIGRpZ2VzdDogZGF0YS5kaWdlc3Qs +IHVybDogcmVjZWlwdC51cmwgfSwKICAgIGV2aWRlbmNlOiB7IHNvdXJjZTogImdpdGh1Yl9hcnRp +ZmFjdF9hcGkiLCBkaWdlc3Q6IGRhdGEuZGlnZXN0LCBydW5faWQ6IHJlY2VpcHQucnVuX2lkLCBz +aXplOiBkYXRhLnNpemVfaW5fYnl0ZXMgfSwKICB9Owp9Cgptb2R1bGUuZXhwb3J0cyA9IHsgbWFp +biwgdmVyaWZ5QXJ0aWZhY3REZWxpdmVyeSB9Owo= diff --git a/upstreaming/gh-aw-compat/tests/upload_artifact_work_queue.test.cjs b/upstreaming/gh-aw-compat/tests/upload_artifact_work_queue.test.cjs new file mode 100644 index 00000000000..f23871a2f7a --- /dev/null +++ b/upstreaming/gh-aw-compat/tests/upload_artifact_work_queue.test.cjs @@ -0,0 +1,340 @@ +// @ts-check +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import { createRequire } from "node:module"; +import fs from "node:fs"; +import path from "node:path"; +const require = createRequire(import.meta.url); +const { authorizeWorkerClaim, reconcileWorkerClaim } = require("./finish_work_queue_claim.cjs"); +const { claimArtifactPath, scopedArtifactFilename, withClaimExecution } = require("./work_queue_claim_scope.cjs"); +const { queueFixture, REF, REPOSITORY, WORKFLOW } = require("./work_queue_lifecycle.test_helpers.cjs"); +const { main: writeSnapshot } = require("./write_work_queue_snapshot.cjs"); +let root; +let runtime; +let upload; +let originalEnv; +let originalGlobals; +const digest = "b".repeat(64); + +beforeEach(() => { + originalEnv = { ...process.env }; + originalGlobals = { core: global.core, context: global.context, github: global.github, __createArtifactClient: global.__createArtifactClient }; + root = fs.mkdtempSync(path.join(fs.realpathSync(process.cwd()), ".gh-aw-artifact-claims-")); + Object.assign(process.env, { RUNNER_TEMP: root, GH_AW_ARTIFACT_RESOLVER_FILE: path.join(root, "resolver.json"), GITHUB_REPOSITORY: REPOSITORY, GITHUB_RUN_ID: "42", GITHUB_SERVER_URL: "https://github.com" }); + delete process.env.GH_AW_WORK_QUEUE_ENABLED; + delete process.env.GH_AW_WORK_QUEUE_ROLE; + delete process.env.GH_AW_SAFE_OUTPUTS_STAGED; + global.core = { info: vi.fn(), warning: vi.fn(), setOutput: vi.fn(), summary: { addRaw: vi.fn().mockReturnThis(), write: vi.fn().mockResolvedValue() } }; + upload = vi.fn().mockResolvedValue({ id: 101, size: 6, digest }); + global.__createArtifactClient = () => ({ uploadArtifact: upload }); + delete require.cache[require.resolve("./upload_artifact.cjs")]; + runtime = require("./upload_artifact.cjs"); +}); + +afterEach(() => { + process.env = originalEnv; + Object.assign(global, originalGlobals); + fs.rmSync(root, { recursive: true, force: true }); + delete require.cache[require.resolve("./upload_artifact.cjs")]; + vi.restoreAllMocks(); +}); + +function setup(count = 1, host = "github.com", selector = {}) { + const fixture = queueFixture({ + count, + bound: true, + workDefaults: { + payload: { + effect_contract: { version: 1, outputs: [{ type: "upload_artifact", min: 0, max: 1 }] }, + resource_scope: { version: 1, resources: [{ repository: REPOSITORY, host, repository_id: "7", ...selector }] }, + }, + }, + }); + const options = { + assignment: fixture.assignment, + githubClient: fixture.githubClient, + context: fixture.workerContext, + workflowRef: `${REPOSITORY}/${WORKFLOW}@${REF}`, + finishIntentPath: path.join(root, "finish.jsonl"), + readWorkQueueLog: fixture.readWorkQueueLog, + publishWorkQueueRequest: fixture.publishWorkQueueRequest, + }; + global.context = fixture.workerContext; + global.github = fixture.githubClient; + const effects = new Map(fixture.assignment.claims.map(member => [member.handle, []])); + const execute = (handle, callback, scope = {}) => + withClaimExecution({ assignment: fixture.assignment, claim_handle: handle, authorize: request => authorizeWorkerClaim({ ...options, ...request }), effects: effects.get(handle), ...scope }, callback); + const complete = async () => { + fs.writeFileSync( + options.finishIntentPath, + fixture.assignment.claims.map(member => JSON.stringify({ version: 3, kind: "finish", intent_id: `finish:${member.handle}`, parameters: { outcome: "completed" }, ...(count === 1 ? {} : { claim_handle: member.handle }) })).join("\n") + ); + return reconcileWorkerClaim(options); + }; + const stage = async handle => + execute(handle, () => { + const directory = claimArtifactPath(path.join(root, "gh-aw", "safeoutputs", "upload-artifacts"), handle); + fs.mkdirSync(directory, { recursive: true }); + fs.writeFileSync(path.join(directory, "report.txt"), `${handle}-own`); + return directory + path.sep; + }); + return { fixture, options, effects, execute, complete, stage }; +} + +describe("upload_artifact actual disabled/single/multi-Claim entrypoints", () => { + it("retains legacy names, outputs, file roots and resolver IDs with queue disabled and stray inputs", async () => { + process.env.GH_AW_WORK_QUEUE_ENABLED = "false"; + process.env.GH_AW_WORK_QUEUE_ROLE = "worker"; + global.context = { payload: { inputs: { work_queue_assignment: null } } }; + global.github = { + rest: { + repos: { + get: vi.fn(() => { + throw new Error("Disabled upload must not resolve queue authority"); + }), + }, + }, + }; + const directory = path.join(root, "gh-aw", "safeoutputs", "upload-artifacts"); + fs.mkdirSync(directory, { recursive: true }); + fs.writeFileSync(path.join(directory, "report.txt"), "legacy"); + const handler = await runtime.main({}); + const result = await handler({ type: "upload_artifact", path: "report.txt", name: "legacy", temporary_id: "aw_shared", claim_handle: "ignored-ordinary-field" }); + expect(result).toMatchObject({ success: true, artifactName: "legacy", artifactId: 101, temporaryId: "aw_shared" }); + expect(upload).toHaveBeenCalledWith("legacy", [path.join(directory, "report.txt")], directory + path.sep, { retentionDays: 30 }); + expect(global.github.rest.repos.get).not.toHaveBeenCalled(); + expect(global.core.setOutput).toHaveBeenCalledWith("slot_0_tmp_id", "aw_shared"); + expect(global.core.setOutput).toHaveBeenCalledWith("upload_artifact_count", "1"); + expect(JSON.parse(fs.readFileSync(process.env.GH_AW_ARTIFACT_RESOLVER_FILE, "utf8"))).toEqual({ aw_shared: "legacy" }); + }); + + it("keeps the disabled staging root cached at module load as on main", async () => { + const directory = path.join(root, "gh-aw", "safeoutputs", "upload-artifacts"); + fs.mkdirSync(directory, { recursive: true }); + fs.writeFileSync(path.join(directory, "report.txt"), "legacy"); + process.env.RUNNER_TEMP = path.join(root, "later-environment"); + const handler = await runtime.main({}); + expect((await handler({ type: "upload_artifact", path: "report.txt" })).success).toBe(true); + expect(upload.mock.calls[0][2]).toBe(directory + path.sep); + }); + + it("requires durable Completion before an implicit singleton upload and verifies the original native artifact", async () => { + const f = setup(); + const directory = await f.stage("h1"); + const handler = await f.execute("h1", () => runtime.main({})); + const message = { type: "upload_artifact", path: "report.txt", name: "report", temporary_id: "aw_shared" }; + await expect(f.execute("h1", () => handler(message))).rejects.toThrow(/Completion|authorized/); + expect(upload).not.toHaveBeenCalled(); + expect(f.effects.get("h1")).toEqual([]); + await f.complete(); + const result = await f.execute("h1", () => handler(message)); + expect(result.success).toBe(true); + expect(upload.mock.calls[0][2]).toBe(directory); + expect(result.artifactName).toMatch(/^claim-[a-f0-9]{64}-report$/); + expect(f.effects.get("h1")).toMatchObject([{ outcome: "succeeded", id: "101", claim_handle: "h1" }]); + const read = vi.fn().mockResolvedValue({ data: { id: 101, name: result.artifactName, expired: false, workflow_run: { id: 42 }, digest: `sha256:${digest}`, size_in_bytes: 6 } }); + const nativeUrl = result.artifactUrl; + result.artifactUrl = "https://untrusted.invalid/replaced"; + const proof = await f.execute("h1", () => runtime.verifyArtifactDelivery({ claim: f.fixture.assignment.claims[0], result, github: { rest: { actions: { getArtifact: read } } } }), { closedEffectChannel: true }); + expect(proof).toMatchObject({ verified: true, claim_handle: "h1", resource: { target_run_id: "42", url: nativeUrl } }); + expect(read).toHaveBeenCalledWith({ owner: "owner", repo: "repo", artifact_id: 101 }); + expect((await f.execute("h1", () => runtime.verifyArtifactDelivery({ claim: f.fixture.assignment.claims[0], result: { ...result }, github: {} }))).verified).toBe(false); + }); + + it.each([ + { selector: { repository_id: "8" }, runId: "42" }, + { selector: { run_id: "43" }, runId: "42" }, + { selector: {}, runId: "43" }, + ])("rejects a foreign repository selector or worker run before upload: %j", async ({ selector, runId }) => { + const f = setup(1, "github.com", selector); + await f.stage("h1"); + await f.complete(); + process.env.GITHUB_RUN_ID = runId; + const handler = await f.execute("h1", () => runtime.main({})); + const result = await f.execute("h1", () => handler({ type: "upload_artifact", path: "report.txt" })); + expect(result.success).toBe(false); + expect(upload).not.toHaveBeenCalled(); + expect(f.effects.get("h1")).toEqual([]); + }); + + it("authorizes Claim artifact uploads on the configured enterprise host", async () => { + process.env.GITHUB_SERVER_URL = "https://contoso.example"; + const f = setup(1, "contoso.example"); + await f.stage("h1"); + await f.complete(); + const handler = await f.execute("h1", () => runtime.main({})); + const result = await f.execute("h1", () => handler({ type: "upload_artifact", path: "report.txt", name: "report" })); + expect(result.success).toBe(true); + expect(f.effects.get("h1")).toMatchObject([{ outcome: "succeeded", claim_handle: "h1" }]); + }); + + it("isolates explicit multi-Claim file roots, resolver IDs and failures without narrowing the original assignment", async () => { + const f = setup(2); + const roots = [await f.stage("h1"), await f.stage("h2")]; + await f.complete(); + const handlers = await Promise.all(["h1", "h2"].map(handle => f.execute(handle, () => runtime.main({})))); + await expect(f.execute("h1", () => handlers[0]({ type: "upload_artifact", path: "report.txt" }))).rejects.toThrow(/claim_handle is required/); + upload.mockRejectedValueOnce(new Error("independent upload failure")); + const first = await f.execute("h1", () => handlers[0]({ type: "upload_artifact", claim_handle: "h1", path: "report.txt", name: "failed", temporary_id: "aw_shared" })); + expect(first).toMatchObject({ success: false, error: expect.stringContaining("independent upload failure") }); + const second = await f.execute("h2", () => handlers[1]({ type: "upload_artifact", claim_handle: "h2", path: "report.txt", name: "second", temporary_id: "aw_shared" })); + expect(second.success).toBe(true); + const retry = await f.execute("h1", () => handlers[0]({ type: "upload_artifact", claim_handle: "h1", path: "report.txt", name: "retry", temporary_id: "aw_shared" })); + expect(retry.success).toBe(true); + expect(upload.mock.calls.map(call => call[2])).toEqual([roots[0], roots[1], roots[0]]); + expect(f.effects.get("h1").map(effect => effect.outcome)).toEqual(["unknown", "succeeded"]); + expect(f.effects.get("h2").map(effect => effect.outcome)).toEqual(["succeeded"]); + for (const [index, handle] of ["h1", "h2"].entries()) { + const resolver = await f.execute(handle, () => scopedArtifactFilename(process.env.GH_AW_ARTIFACT_RESOLVER_FILE)); + expect(JSON.parse(fs.readFileSync(resolver, "utf8"))).toEqual({ aw_shared: index ? second.artifactName : retry.artifactName }); + } + expect(fs.existsSync(process.env.GH_AW_ARTIFACT_RESOLVER_FILE)).toBe(false); + expect(global.core.setOutput.mock.calls.map(([name]) => name)).not.toContain("upload_artifact_count"); + expect((await f.execute("h2", () => runtime.verifyArtifactDelivery({ claim: f.fixture.assignment.claims[1], result: retry, github: {} }))).verified).toBe(false); + }); + + it.each([null, undefined, "", "foreign"])("rejects a supplied invalid singleton selector %j before touching files or effects", async claim_handle => { + const f = setup(); + await f.stage("h1"); + await f.complete(); + const handler = await f.execute("h1", () => runtime.main({})); + await expect(f.execute("h1", () => handler({ type: "upload_artifact", claim_handle, path: "report.txt" }))).rejects.toThrow(); + expect(upload).not.toHaveBeenCalled(); + expect(f.effects.get("h1")).toEqual([]); + }); + + it("denies foreign immutable member selectors, reused factories and closed write channels", async () => { + const f = setup(2); + await f.stage("h1"); + await f.stage("h2"); + await f.complete(); + const ordinary = await runtime.main({}); + const scoped = await f.execute("h1", () => runtime.main({})); + const message = { type: "upload_artifact", claim_handle: "h1", path: "report.txt" }; + await expect(f.execute("h1", () => ordinary(message))).rejects.toThrow(/original Claim/); + await expect(f.execute("h2", () => scoped({ ...message, claim_handle: "h2" }))).rejects.toThrow(/original Claim/); + await expect(f.execute("h1", () => scoped({ ...message, work_id: f.fixture.assignment.claims[1].work_id }))).rejects.toThrow(/work_id conflicts/); + expect((await f.execute("h1", () => scoped(message), { closedEffectChannel: true })).success).toBe(false); + expect(upload).not.toHaveBeenCalled(); + expect(f.effects.get("h1")).toEqual([]); + }); + + it.each([ + { count: 1, enabled: "false", role: "invalid" }, + { count: 2, enabled: "false", role: "invalid" }, + { count: 1, enabled: "true", role: "observer" }, + { count: 2, enabled: "true", role: "observer" }, + ])("preserves the private $count-Claim frame after ambient ENABLED=$enabled ROLE=$role changes", async ({ count, enabled, role }) => { + const f = setup(count); + const directory = await f.stage("h1"); + await f.complete(); + Object.assign(process.env, { GH_AW_WORK_QUEUE_ENABLED: "true", GH_AW_WORK_QUEUE_ROLE: "worker", GH_AW_WORK_QUEUE_SNAPSHOT: path.join(root, "absent-ambient-snapshot.json") }); + let handler; + await f.execute("h1", async () => { + handler = await runtime.main({}); + process.env.GH_AW_WORK_QUEUE_ENABLED = enabled; + process.env.GH_AW_WORK_QUEUE_ROLE = role; + for (const claim_handle of count === 1 ? ["foreign"] : ["h2", "foreign"]) { + await expect(handler({ type: "upload_artifact", claim_handle, path: "report.txt" })).rejects.toThrow(); + } + if (count === 2) await expect(handler({ type: "upload_artifact", path: "report.txt" })).rejects.toThrow(/claim_handle is required/); + expect(upload).not.toHaveBeenCalled(); + expect((await handler({ type: "upload_artifact", ...(count === 1 ? {} : { claim_handle: "h1" }), path: "report.txt" })).success).toBe(true); + }); + expect(upload).toHaveBeenCalledOnce(); + expect(upload.mock.calls[0][2]).toBe(directory); + expect(f.effects.get("h1")).toMatchObject([{ outcome: "succeeded", claim_handle: "h1" }]); + if (count === 2) expect(f.effects.get("h2")).toEqual([]); + expect(global.core.setOutput.mock.calls.map(([name]) => name)).not.toContain("upload_artifact_count"); + expect(fs.existsSync(process.env.GH_AW_ARTIFACT_RESOLVER_FILE)).toBe(false); + const deny = vi.fn().mockResolvedValue({ authorized: false }); + await expect(f.execute("h1", () => handler({ type: "upload_artifact", ...(count === 1 ? {} : { claim_handle: "h1" }), path: "report.txt" }), { authorize: deny })).rejects.toThrow(/authorized|authorization|denied/); + expect(deny).toHaveBeenCalledOnce(); + expect(upload).toHaveBeenCalledOnce(); + expect(f.effects.get("h1")).toHaveLength(1); + }); + + it("suppresses a cancelled member at the actual upload entrypoint without consuming its sibling's upload budget", async () => { + const f = setup(2); + await f.stage("h1"); + await f.stage("h2"); + fs.writeFileSync( + f.options.finishIntentPath, + f.fixture.assignment.claims.map((member, i) => JSON.stringify({ version: 3, kind: "finish", intent_id: `finish:${member.handle}`, claim_handle: member.handle, parameters: { outcome: i ? "completed" : "cancelled" } })).join("\n") + ); + await reconcileWorkerClaim(f.options); + const first = await f.execute("h1", () => runtime.main({})); + await expect(f.execute("h1", () => first({ type: "upload_artifact", claim_handle: "h1", path: "report.txt" }))).rejects.toMatchObject({ code: "claim_cancelled", suppressed: true }); + const second = await f.execute("h2", () => runtime.main({})); + expect((await f.execute("h2", () => second({ type: "upload_artifact", claim_handle: "h2", path: "report.txt" }))).success).toBe(true); + expect(upload).toHaveBeenCalledOnce(); + expect(f.effects.get("h1")).toEqual([]); + }); + + it.each(["claim-root", "nested-parent"])("rejects a restored %s alias into a sibling's artifact namespace before uploading", async alias => { + const f = setup(2); + const firstRoot = await f.stage("h1"); + const siblingRoot = await f.stage("h2"); + await f.complete(); + const handler = await f.execute("h1", () => runtime.main({})); + let filename = "report.txt"; + if (alias === "claim-root") { + fs.rmSync(firstRoot, { recursive: true }); + fs.symlinkSync(siblingRoot, path.resolve(firstRoot), "dir"); + } else { + fs.symlinkSync(siblingRoot, path.join(firstRoot, "restored-alias"), "dir"); + filename = "restored-alias/report.txt"; + } + await expect(f.execute("h1", () => handler({ type: "upload_artifact", claim_handle: "h1", path: filename }))).rejects.toThrow(/redirects|escapes/); + expect(upload).not.toHaveBeenCalled(); + expect(f.effects.get("h1")).toEqual([]); + expect(fs.readFileSync(path.join(siblingRoot, "report.txt"), "utf8")).toBe("h2-own"); + }); + + it.each(["id", "name", "expired", "workflow_run", "digest", "size_in_bytes"])("does not verify a native artifact with changed %s readback", async field => { + const f = setup(); + await f.stage("h1"); + await f.complete(); + const result = await f.execute("h1", async () => { + const handler = await runtime.main({}); + return handler({ type: "upload_artifact", path: "report.txt" }); + }); + expect(result.success).toBe(true); + const data = { id: 101, name: result.artifactName, expired: false, workflow_run: { id: 42 }, digest: `sha256:${digest}`, size_in_bytes: 6 }; + data[field] = { id: 102, name: "foreign-name", expired: true, workflow_run: { id: 43 }, digest: `sha256:${"c".repeat(64)}`, size_in_bytes: 7 }[field]; + const read = vi.fn().mockResolvedValue({ data }); + const proof = await f.execute("h1", () => runtime.verifyArtifactDelivery({ claim: f.fixture.assignment.claims[0], result, github: { rest: { actions: { getArtifact: read } } } }), { closedEffectChannel: true }); + expect(proof).toEqual({ verified: false }); + expect(read).toHaveBeenCalledOnce(); + }); + + it.each([1, 2])("does not upload through an unscoped factory when a trusted %i-Claim worker snapshot exists", async count => { + const f = setup(count); + await f.complete(); + process.env.GH_AW_WORK_QUEUE_ENABLED = "true"; + process.env.GH_AW_WORK_QUEUE_ROLE = "worker"; + process.env.GH_AW_WORK_QUEUE_SNAPSHOT = path.join(root, "snapshot.json"); + await writeSnapshot({ ...f.options, snapshotPath: process.env.GH_AW_WORK_QUEUE_SNAPSHOT, role: "worker", core: global.core }); + await expect(runtime.main({})).rejects.toThrow(/original per-Claim execution context/); + expect(upload).not.toHaveBeenCalled(); + expect([...f.effects.values()].flat()).toEqual([]); + }); + + it.each([1, 2])("previews %i completed Claims without artifacts or trusted delivery receipts, and handles empty selections", async count => { + const f = setup(count); + for (const member of f.fixture.assignment.claims) await f.stage(member.handle); + await f.complete(); + for (const member of f.fixture.assignment.claims) { + await f.execute(member.handle, async () => { + const handler = await runtime.main({ staged: true, "default-if-no-files": "ignore" }); + const selector = count === 1 ? {} : { claim_handle: member.handle }; + expect(await handler({ type: "upload_artifact", ...selector, filters: { include: ["missing-*"] } })).toMatchObject({ success: false, skipped: true }); + const result = await handler({ type: "upload_artifact", ...selector, path: "report.txt" }); + expect(result).toMatchObject({ success: true, slotIndex: 0 }); + expect((await runtime.verifyArtifactDelivery({ claim: member, result, github: {} })).verified).toBe(false); + }); + } + expect(upload).not.toHaveBeenCalled(); + expect([...f.effects.values()].flat()).toEqual([]); + expect(global.core.summary.write).toHaveBeenCalledTimes(count); + }); +}); diff --git a/upstreaming/gh_aw_compat.py b/upstreaming/gh_aw_compat.py new file mode 100644 index 00000000000..addf9c0646a --- /dev/null +++ b/upstreaming/gh_aw_compat.py @@ -0,0 +1,52 @@ +# SPDX-FileCopyrightText: 2026 The RISE Project +# SPDX-License-Identifier: MIT +"""Apply the approved, hash-pinned gh-aw v1.2.2 native artifact fix. + +Run only in trusted safe_outputs job preparation, before any handler loads. +Never reads agent artifacts. Both the source and resulting handler are pinned; +unknown source, symlinks, failed application or unexpected output abort the job. +""" +from __future__ import annotations + +import hashlib +from pathlib import Path +import subprocess +import tempfile + +SOURCE_SHA256 = "5713a810aacb0c748eebb787876e21c64400fc675d966c234c44e318c5f7a52b" +PATCHED_SHA256 = "40dab6558f2a3620cf46061044b5d8f73516f500ccf4baf6a2a36a6017fa6fca" +PATCH = Path(__file__).with_name("gh-aw-compat") / "native-artifact.patch" + + +def apply(actions: Path) -> str: + actions = actions.resolve(strict=True) + handler = actions / "upload_artifact.cjs" + if handler.is_symlink() or not handler.is_file(): + raise ValueError("native artifact handler must be a regular file") + digest = hashlib.sha256(handler.read_bytes()).hexdigest() + if digest == PATCHED_SHA256: + return "already patched" + if digest != SOURCE_SHA256: + raise ValueError(f"unexpected gh-aw artifact handler SHA-256: {digest}") + # Apply outside any source checkout: git apply otherwise interprets paths + # relative to its repository root. Never replace the runtime until the + # complete candidate has passed the output hash check. + with tempfile.TemporaryDirectory(prefix="native-artifact-compat-") as tmp: + candidate = Path(tmp) / handler.name + candidate.write_bytes(handler.read_bytes()) + for check in (True, False): + subprocess.run(["git", "apply", "-p4", *(["--check"] if check else []), str(PATCH)], + cwd=tmp, check=True, capture_output=True) + data = candidate.read_bytes() + if hashlib.sha256(data).hexdigest() != PATCHED_SHA256: + raise ValueError("patched artifact handler SHA-256 does not match") + handler.write_bytes(data) + return "patched" + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("actions", type=Path) + args = parser.parse_args() + print(apply(args.actions)) diff --git a/upstreaming/queue_result.py b/upstreaming/queue_result.py index 214b63898ef..11a2f62a095 100644 --- a/upstreaming/queue_result.py +++ b/upstreaming/queue_result.py @@ -33,7 +33,9 @@ import subprocess from dataclasses import dataclass -PROPOSAL_ARTIFACT_SUFFIX = "upstreaming-proposal" +# Native safe-output tool accepts path, not a name override. Uploading the +# upstreaming-out directory yields claim--upstreaming-out. +PROPOSAL_ARTIFACT_SUFFIX = "upstreaming-out" GH_AW_VERSION = "v1.2.2" @@ -126,7 +128,16 @@ def replay(gh_aw: str, repo: str, timeout: int = 600) -> dict: # Network/auth failures and ledger validation failures look alike here; # either way nothing may be published now, and retrying is safe. raise OSError(f"gh aw work-queue replay failed: {p.stderr.strip()[-300:]}") - return json.loads(p.stdout) + return replay_output(p) + + +def replay_output(result: subprocess.CompletedProcess) -> dict: + """The v1.2.2 CLI emits replay JSON on stderr; accept stdout on versions + that use it, but only a complete JSON object, never mixed diagnostics.""" + value = json.loads(result.stdout if result.stdout.strip() else result.stderr) + if not isinstance(value, dict) or not isinstance(value.get("works"), dict): + raise ValueError("replay output is not a queue projection") + return value def queue_work_states(gh_aw: str, repo: str, timeout: int = 600) -> dict[str, str]: @@ -139,7 +150,7 @@ def queue_work_states(gh_aw: str, repo: str, timeout: int = 600) -> dict[str, st if "queue_missing" in p.stderr: return {} raise OSError(f"gh aw work-queue replay failed: {p.stderr.strip()[-300:]}") - works = (json.loads(p.stdout).get("works") or {}).values() + works = (replay_output(p).get("works") or {}).values() return {w["graph_id"]: w.get("state") or "unknown" for w in works if w.get("graph_id")} diff --git a/upstreaming/tests/test_gh_aw_compat.py b/upstreaming/tests/test_gh_aw_compat.py new file mode 100644 index 00000000000..09e940d5671 --- /dev/null +++ b/upstreaming/tests/test_gh_aw_compat.py @@ -0,0 +1,38 @@ +# SPDX-FileCopyrightText: 2026 The RISE Project +# SPDX-License-Identifier: MIT +"""Fail-closed installation of the approved native artifact compatibility fix.""" +import base64 +import hashlib +from pathlib import Path +import tempfile +import unittest + +from upstreaming import gh_aw_compat + +# Base64 preserves exact upstream bytes, including non-ASCII comments, for +# the pinned input hash without adding those comments to project prose. +FIXTURE = Path(__file__).parents[1] / "gh-aw-compat/tests/upload_artifact.v1.2.2.cjs.b64" + + +class TestNativeArtifactPatch(unittest.TestCase): + def test_exact_source_and_output_and_idempotency(self): + with tempfile.TemporaryDirectory() as tmp: + actions = Path(tmp) + handler = actions / "upload_artifact.cjs" + handler.write_bytes(base64.decodebytes(FIXTURE.read_bytes())) + self.assertEqual(gh_aw_compat.apply(actions), "patched") + self.assertEqual(hashlib.sha256(handler.read_bytes()).hexdigest(), gh_aw_compat.PATCHED_SHA256) + self.assertEqual(gh_aw_compat.apply(actions), "already patched") + + def test_unknown_source_and_symlink_rejected_without_changes(self): + with tempfile.TemporaryDirectory() as tmp: + actions = Path(tmp) + handler = actions / "upload_artifact.cjs" + handler.write_text("unexpected") + with self.assertRaises(ValueError): + gh_aw_compat.apply(actions) + self.assertEqual(handler.read_text(), "unexpected") + handler.unlink() + handler.symlink_to(FIXTURE) + with self.assertRaises(ValueError): + gh_aw_compat.apply(actions) diff --git a/upstreaming/tests/test_pipeline.py b/upstreaming/tests/test_pipeline.py index ea28023b9cc..5f2ad6d0e67 100644 --- a/upstreaming/tests/test_pipeline.py +++ b/upstreaming/tests/test_pipeline.py @@ -121,7 +121,7 @@ def test_full_loop(self): "works": {"w1": {"claim_id": "c1", "barrier": "verified", "result_commit_id": "q_r", "result": { "version": 1, "outputs": [{"type": "upload_artifact", "resource": { "kind": "artifact", "repository": "riseproject-dev/python-wheels", "id": "900", - "target_run_id": "4242", "name": "claim-x-upstreaming-proposal", "digest": digest}}]}}}, + "target_run_id": "4242", "name": "claim-x-upstreaming-out", "digest": digest}}]}}}, "claims": {"c1": {"work_id": "w1", "claim_id": "c1", "dispatch_id": "d1", "state": "completed"}}, "dispatches": {"d1": {"run": {"run_id": "4242", "run_attempt": 1, "workflow": WF}}}} art = queue_result.resolve(projection, work_id="w1", claim_id="c1", dispatch_id="d1", diff --git a/upstreaming/tests/test_queue_result.py b/upstreaming/tests/test_queue_result.py index b07d79526b8..70be01f1f47 100644 --- a/upstreaming/tests/test_queue_result.py +++ b/upstreaming/tests/test_queue_result.py @@ -20,7 +20,7 @@ def projection(): "result_commit_id": "q_r", "result": {"version": 1, "outputs": [{"type": "upload_artifact", "resource": { "kind": "artifact", "repository": "o/r", "id": "55", "target_run_id": "100", - "name": "claim-abc-upstreaming-proposal", "digest": DIGEST}}]}}}, + "name": "claim-abc-upstreaming-out", "digest": DIGEST}}]}}}, "claims": {"c1": {"kind": "Claim", "work_id": "w1", "claim_id": "c1", "dispatch_id": "d1", "handle": "h", "state": "completed"}}, "dispatches": {"d1": {"dispatch_id": "d1", "state": "bound", "run": { @@ -34,6 +34,19 @@ def resolve(p, **kw): return qr.resolve(p, **args) +class TestReplayOutput(unittest.TestCase): + def test_projection_on_stdout_or_stderr(self): + import json + import subprocess + data = json.dumps(projection()) + for stdout, stderr in ((data, ""), ("", data)): + p = subprocess.CompletedProcess([], 0, stdout, stderr) + self.assertEqual(qr.replay_output(p), projection()) + for data in ('{}', '[]', 'warning\n{}'): + with self.assertRaises(ValueError): + qr.replay_output(subprocess.CompletedProcess([], 0, "", data)) + + class TestResolve(unittest.TestCase): def test_ok(self): a = resolve(projection()) diff --git a/upstreaming/work.py b/upstreaming/work.py index 440abb40ed4..d8a38e19659 100644 --- a/upstreaming/work.py +++ b/upstreaming/work.py @@ -31,7 +31,7 @@ INVESTIGATOR_PROFILE = "upstreaming-investigator" PROFILE_WORKFLOWS = {WORKER_PROFILE: ".github/workflows/upstreaming-worker.lock.yml", INVESTIGATOR_PROFILE: ".github/workflows/upstreaming-investigator.lock.yml"} -PROPOSAL_ARTIFACT = "upstreaming-proposal" +PROPOSAL_ARTIFACT = "upstreaming-out" WRITE_TASKS = {"development_patch", "development_repair", "upstream_revision"} ALLOWED_OPERATIONS = { From 4ba2a9e50b02f96ac8864891c7ca73cba92ebe13 Mon Sep 17 00:00:00 2001 From: Ludovic Henry Date: Thu, 19 Nov 2026 00:19:02 +0100 Subject: [PATCH 2/2] upstreaming: install native artifact compatibility patch before trusted handlers Use supported safe_outputs pre-steps at the exact workflow revision. Keep v1.2.2 pins and regenerate locks. Run native handler and resource-scope regressions in validation. --- .../workflows/upstreaming-investigator.lock.yml | 11 ++++++++++- .github/workflows/upstreaming-investigator.md | 14 +++++++++++++- .github/workflows/upstreaming-validate.yml | 3 +++ .github/workflows/upstreaming-worker.lock.yml | 11 ++++++++++- .github/workflows/upstreaming-worker.md | 14 +++++++++++++- 5 files changed, 49 insertions(+), 4 deletions(-) diff --git a/.github/workflows/upstreaming-investigator.lock.yml b/.github/workflows/upstreaming-investigator.lock.yml index 892f0b7601d..df4e7037526 100644 --- a/.github/workflows/upstreaming-investigator.lock.yml +++ b/.github/workflows/upstreaming-investigator.lock.yml @@ -1,4 +1,4 @@ -# gh-aw-metadata: {"schema_version":"v4","frontmatter_hash":"f4ea3169104ff81492749017dbd373640c4886ec234473ff88bbbe05525d97c5","body_hash":"97fa4ba35fee3e16bf0d04a2182e641b907bfc710bd8ae2a46aef68e86a1d27c","compiler_version":"v1.2.2","strict":true,"agent_id":"pi","agent_model":"anthropic/claude-sonnet-5-5","engine_versions":{"pi":"1.5.0"}} +# gh-aw-metadata: {"schema_version":"v4","frontmatter_hash":"ccb6f55d5f353390a64abbac472a1405f8c44e54b0de575b238623c853bd2777","body_hash":"d0715764cb1774a8cffde73da3a3f88d45f58373382bb6107328e09126bbc7d8","compiler_version":"v1.2.2","strict":true,"agent_id":"pi","agent_model":"anthropic/claude-sonnet-5-5","engine_versions":{"pi":"1.5.0"}} # gh-aw-manifest: {"version":1,"secrets":["ANTHROPIC_API_KEY","COPILOT_GITHUB_TOKEN","GH_AW_DEFAULT_OTLP_ENDPOINT","GH_AW_DEFAULT_OTLP_HEADERS","GH_AW_GITHUB_MCP_SERVER_TOKEN","GH_AW_GITHUB_TOKEN","GITHUB_TOKEN"],"actions":[{"repo":"actions/checkout","sha":"3d3c42e5aac5ba805825da76410c181273ba90b1","version":"v7.0.1"},{"repo":"actions/download-artifact","sha":"9000827ccba6bdab643e8b6fd33ac0654aef8333","version":"v8.0.2"},{"repo":"actions/github-script","sha":"3a2844b7e9c422d3c10d287c895573f7108da1b3","version":"v9.0.0"},{"repo":"actions/setup-node","sha":"949feb2413d6458794dcd2491c4babbbce0c15c1","version":"v7.1.0"},{"repo":"actions/upload-artifact","sha":"043fb46d1a93c77aae656e7c1c64a875d1fc6a0a","version":"v7.0.1"},{"repo":"actions/upload-artifact","sha":"cf430e030ddbb5b0abf93d22962f4752f3646cd9","version":"v7.0.2"},{"repo":"astral-sh/setup-uv","sha":"20cfd1bf945f4377ade1205e4dbc17946fc9a30d","version":"v10.0.1"},{"repo":"github/gh-aw-actions/setup","sha":"53d0749e19424a918acd82b4d140264ce48f2f14","version":"v1.2.2"}],"containers":[{"image":"ghcr.io/github/gh-aw-firewall/agent:0.29.11","digest":"sha256:8774a73c351395b41d2ad0af4ddb4689007c67de3cd08bd9f43bb8a0e300690e","pinned_image":"ghcr.io/github/gh-aw-firewall/agent:0.29.11@sha256:8774a73c351395b41d2ad0af4ddb4689007c67de3cd08bd9f43bb8a0e300690e"},{"image":"ghcr.io/github/gh-aw-firewall/api-proxy:0.29.11","digest":"sha256:88d2d0e315a504d93fd4fb8847fd0f6b7f4469f41a6fc6047b3dc9654c56ab2c","pinned_image":"ghcr.io/github/gh-aw-firewall/api-proxy:0.29.11@sha256:88d2d0e315a504d93fd4fb8847fd0f6b7f4469f41a6fc6047b3dc9654c56ab2c"},{"image":"ghcr.io/github/gh-aw-firewall/squid:0.29.11","digest":"sha256:861739ecf924dd2db5e5fb652db2ad82aaafd1615623297ddabc8f41a36b2847","pinned_image":"ghcr.io/github/gh-aw-firewall/squid:0.29.11@sha256:861739ecf924dd2db5e5fb652db2ad82aaafd1615623297ddabc8f41a36b2847"},{"image":"ghcr.io/github/gh-aw-mcpg:v0.5.6","digest":"sha256:342cd624e1f179d91be2de7a146fc4f387092e62e6c8a47506d7932e113d2311","pinned_image":"ghcr.io/github/gh-aw-mcpg:v0.5.6@sha256:342cd624e1f179d91be2de7a146fc4f387092e62e6c8a47506d7932e113d2311"},{"image":"ghcr.io/github/gh-aw-node","digest":"sha256:8735428c2d4e602f90781ba0c571c400e8ff93c7ee1508a75d71f87e34e415cc","pinned_image":"ghcr.io/github/gh-aw-node@sha256:8735428c2d4e602f90781ba0c571c400e8ff93c7ee1508a75d71f87e34e415cc"},{"image":"ghcr.io/github/github-mcp-server:v2.1.0","digest":"sha256:f6056fc10bfffcc8c81a6417a2e9ca12808647e8dd6049642a4feaadee0e0f8a","pinned_image":"ghcr.io/github/github-mcp-server:v2.1.0@sha256:f6056fc10bfffcc8c81a6417a2e9ca12808647e8dd6049642a4feaadee0e0f8a"}],"mcp_servers":[{"name":"github","tools":["actions_get","actions_list","get_commit","get_file_contents","get_job_logs","get_latest_release","get_pull_request","get_pull_request_comments","get_pull_request_diff","get_pull_request_files","get_pull_request_review_comments","get_pull_request_reviews","get_pull_request_status","get_release_by_tag","get_tag","list_branches","list_commits","list_pull_requests","list_releases","list_starred_repositories","list_tags","pull_request_read","search_code","search_pull_requests","search_repositories"]},{"name":"safeoutputs","tools":["noop","report_incomplete","report_missing_data","report_missing_tool","upload_artifact"]},{"name":"work-queue","tools":["work_queue_claim_finish","work_queue_dispatch_next","work_queue_explain","work_queue_read","work_queue_submit"]}],"threat_detection":{"mode":"enabled"},"admission":false,"work_queue":{"worker":true,"logical_contract":"82c3ee46d18c53dc51ea7f1027f5264e3b980a362690d05af7a51d844fdbedfe"},"agent_metadata":{}} # This file was automatically generated by gh-aw (v1.2.2). DO NOT EDIT. To debug this workflow, load the skill at https://github.com/github/gh-aw/blob/main/debug.md # @@ -2164,6 +2164,15 @@ jobs: GH_AW_INFO_AWF_VERSION: "v0.29.11" GH_AW_INFO_ENGINE_ID: "pi" GH_AW_SETUP_AW_CONTEXT: ${{ inputs.aw_context }} + - name: Check out trusted native artifact compatibility patch + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + path: native-artifact-compat + persist-credentials: false + ref: ${{ github.sha }} + sparse-checkout: upstreaming + - name: Apply hash-pinned gh-aw v1.2.2 native artifact fix + run: python3 native-artifact-compat/upstreaming/gh_aw_compat.py "$RUNNER_TEMP/gh-aw/actions" - name: Mask OTLP telemetry headers run: bash "${RUNNER_TEMP}/gh-aw/actions/mask_otlp_headers.sh" - name: Download agent output artifact diff --git a/.github/workflows/upstreaming-investigator.md b/.github/workflows/upstreaming-investigator.md index 757cde3a1e7..50172648d18 100644 --- a/.github/workflows/upstreaming-investigator.md +++ b/.github/workflows/upstreaming-investigator.md @@ -83,6 +83,17 @@ pre-agent-steps: git config user.email "noreply@riseproject.dev" echo "checked out $(git rev-parse HEAD) into ./fork" jobs: + safe_outputs: + pre-steps: + - name: Check out trusted native artifact compatibility patch + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + ref: ${{ github.sha }} + persist-credentials: false + path: native-artifact-compat + sparse-checkout: upstreaming + - name: Apply hash-pinned gh-aw v1.2.2 native artifact fix + run: python3 native-artifact-compat/upstreaming/gh_aw_compat.py "$RUNNER_TEMP/gh-aw/actions" record: # Ordinary trusted job, not a safe output. An investigation never pushes, # so there is no fork token and no environment: this job only checks the @@ -166,7 +177,8 @@ one Claim; use its `handle` as `claim_handle` on every safe output and on Write these files into `upstreaming-out/` at the top of the workspace (next to `fork/`, not inside it) and upload them with a single `upload_artifact` -call: `{"path": "upstreaming-out", "name": "upstreaming-proposal"}`: +call: `{"path": "upstreaming-out"}` (the native handler names the artifact +`claim--upstreaming-out`): - `dossier.json`: the facts a human needs to approve the contribution's scope, each with exact file paths or URLs as evidence: diff --git a/.github/workflows/upstreaming-validate.yml b/.github/workflows/upstreaming-validate.yml index e709797a645..4e5d58877a6 100644 --- a/.github/workflows/upstreaming-validate.yml +++ b/.github/workflows/upstreaming-validate.yml @@ -42,6 +42,9 @@ jobs: - name: Unit and acceptance tests run: uv run --no-project --with-requirements upstreaming/requirements.txt python -m unittest discover -s upstreaming/tests -t . -v + - name: Native artifact compatibility regression tests (pinned gh-aw v1.2.2) + run: sh upstreaming/gh-aw-compat/check.sh + - name: Validate committed state run: uv run --no-project --with-requirements upstreaming/requirements.txt python -m upstreaming validate-state diff --git a/.github/workflows/upstreaming-worker.lock.yml b/.github/workflows/upstreaming-worker.lock.yml index 8c43e2aba5c..75734be1332 100644 --- a/.github/workflows/upstreaming-worker.lock.yml +++ b/.github/workflows/upstreaming-worker.lock.yml @@ -1,4 +1,4 @@ -# gh-aw-metadata: {"schema_version":"v4","frontmatter_hash":"74c7e50b8060448ee99c6581d501ac0faf393f8c4a1161230843cbd214201e6f","body_hash":"21bb8d3c90ccfd39d0b6c62ebd2590112a1905700d7863053eb1473c271d691e","compiler_version":"v1.2.2","strict":true,"agent_id":"pi","agent_model":"anthropic/claude-opus-5-5","engine_versions":{"pi":"1.5.0"}} +# gh-aw-metadata: {"schema_version":"v4","frontmatter_hash":"e8a5ffebbb1c0adc68b936ee2c5994e587c41e6b6a749d1d82db6fba05395e60","body_hash":"aba9fe55065285e086249136f792c602de9b578c93a74f12c18c0f552f3faea3","compiler_version":"v1.2.2","strict":true,"agent_id":"pi","agent_model":"anthropic/claude-opus-5-5","engine_versions":{"pi":"1.5.0"}} # gh-aw-manifest: {"version":1,"secrets":["ANTHROPIC_API_KEY","COPILOT_GITHUB_TOKEN","GH_AW_DEFAULT_OTLP_ENDPOINT","GH_AW_DEFAULT_OTLP_HEADERS","GH_AW_GITHUB_MCP_SERVER_TOKEN","GH_AW_GITHUB_TOKEN","GITHUB_TOKEN","RISEPROJECT_APP_PRIVATE_KEY"],"actions":[{"repo":"actions/checkout","sha":"3d3c42e5aac5ba805825da76410c181273ba90b1","version":"v7.0.1"},{"repo":"actions/create-github-app-token","sha":"64ab729a6294000f5aa4a4bc0b73d1f32bc45510","version":"v3.3.0"},{"repo":"actions/download-artifact","sha":"9000827ccba6bdab643e8b6fd33ac0654aef8333","version":"v8.0.2"},{"repo":"actions/github-script","sha":"3a2844b7e9c422d3c10d287c895573f7108da1b3","version":"v9.0.0"},{"repo":"actions/setup-node","sha":"949feb2413d6458794dcd2491c4babbbce0c15c1","version":"v7.1.0"},{"repo":"actions/upload-artifact","sha":"043fb46d1a93c77aae656e7c1c64a875d1fc6a0a","version":"v7.0.1"},{"repo":"actions/upload-artifact","sha":"cf430e030ddbb5b0abf93d22962f4752f3646cd9","version":"v7.0.2"},{"repo":"astral-sh/setup-uv","sha":"20cfd1bf945f4377ade1205e4dbc17946fc9a30d","version":"v10.0.1"},{"repo":"github/gh-aw-actions/setup","sha":"53d0749e19424a918acd82b4d140264ce48f2f14","version":"v1.2.2"}],"containers":[{"image":"ghcr.io/github/gh-aw-firewall/agent:0.29.11","digest":"sha256:8774a73c351395b41d2ad0af4ddb4689007c67de3cd08bd9f43bb8a0e300690e","pinned_image":"ghcr.io/github/gh-aw-firewall/agent:0.29.11@sha256:8774a73c351395b41d2ad0af4ddb4689007c67de3cd08bd9f43bb8a0e300690e"},{"image":"ghcr.io/github/gh-aw-firewall/api-proxy:0.29.11","digest":"sha256:88d2d0e315a504d93fd4fb8847fd0f6b7f4469f41a6fc6047b3dc9654c56ab2c","pinned_image":"ghcr.io/github/gh-aw-firewall/api-proxy:0.29.11@sha256:88d2d0e315a504d93fd4fb8847fd0f6b7f4469f41a6fc6047b3dc9654c56ab2c"},{"image":"ghcr.io/github/gh-aw-firewall/squid:0.29.11","digest":"sha256:861739ecf924dd2db5e5fb652db2ad82aaafd1615623297ddabc8f41a36b2847","pinned_image":"ghcr.io/github/gh-aw-firewall/squid:0.29.11@sha256:861739ecf924dd2db5e5fb652db2ad82aaafd1615623297ddabc8f41a36b2847"},{"image":"ghcr.io/github/gh-aw-mcpg:v0.5.6","digest":"sha256:342cd624e1f179d91be2de7a146fc4f387092e62e6c8a47506d7932e113d2311","pinned_image":"ghcr.io/github/gh-aw-mcpg:v0.5.6@sha256:342cd624e1f179d91be2de7a146fc4f387092e62e6c8a47506d7932e113d2311"},{"image":"ghcr.io/github/gh-aw-node","digest":"sha256:8735428c2d4e602f90781ba0c571c400e8ff93c7ee1508a75d71f87e34e415cc","pinned_image":"ghcr.io/github/gh-aw-node@sha256:8735428c2d4e602f90781ba0c571c400e8ff93c7ee1508a75d71f87e34e415cc"},{"image":"ghcr.io/github/github-mcp-server:v2.1.0","digest":"sha256:f6056fc10bfffcc8c81a6417a2e9ca12808647e8dd6049642a4feaadee0e0f8a","pinned_image":"ghcr.io/github/github-mcp-server:v2.1.0@sha256:f6056fc10bfffcc8c81a6417a2e9ca12808647e8dd6049642a4feaadee0e0f8a"}],"mcp_servers":[{"name":"github","tools":["actions_get","actions_list","get_commit","get_file_contents","get_job_logs","get_latest_release","get_pull_request","get_pull_request_comments","get_pull_request_diff","get_pull_request_files","get_pull_request_review_comments","get_pull_request_reviews","get_pull_request_status","get_release_by_tag","get_tag","list_branches","list_commits","list_pull_requests","list_releases","list_starred_repositories","list_tags","pull_request_read","search_code","search_pull_requests","search_repositories"]},{"name":"safeoutputs","tools":["noop","report_incomplete","report_missing_data","report_missing_tool","upload_artifact"]},{"name":"work-queue","tools":["work_queue_claim_finish","work_queue_dispatch_next","work_queue_explain","work_queue_read","work_queue_submit"]}],"threat_detection":{"mode":"enabled"},"admission":false,"work_queue":{"worker":true,"logical_contract":"82c3ee46d18c53dc51ea7f1027f5264e3b980a362690d05af7a51d844fdbedfe"},"agent_metadata":{}} # This file was automatically generated by gh-aw (v1.2.2). DO NOT EDIT. To debug this workflow, load the skill at https://github.com/github/gh-aw/blob/main/debug.md # @@ -2213,6 +2213,15 @@ jobs: GH_AW_INFO_AWF_VERSION: "v0.29.11" GH_AW_INFO_ENGINE_ID: "pi" GH_AW_SETUP_AW_CONTEXT: ${{ inputs.aw_context }} + - name: Check out trusted native artifact compatibility patch + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + path: native-artifact-compat + persist-credentials: false + ref: ${{ github.sha }} + sparse-checkout: upstreaming + - name: Apply hash-pinned gh-aw v1.2.2 native artifact fix + run: python3 native-artifact-compat/upstreaming/gh_aw_compat.py "$RUNNER_TEMP/gh-aw/actions" - name: Mask OTLP telemetry headers run: bash "${RUNNER_TEMP}/gh-aw/actions/mask_otlp_headers.sh" - name: Download agent output artifact diff --git a/.github/workflows/upstreaming-worker.md b/.github/workflows/upstreaming-worker.md index 2921dc9e137..0b2277e8b29 100644 --- a/.github/workflows/upstreaming-worker.md +++ b/.github/workflows/upstreaming-worker.md @@ -83,6 +83,17 @@ pre-agent-steps: git config user.email "noreply@riseproject.dev" echo "checked out $(git rev-parse HEAD) into ./fork" jobs: + safe_outputs: + pre-steps: + - name: Check out trusted native artifact compatibility patch + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + ref: ${{ github.sha }} + persist-credentials: false + path: native-artifact-compat + sparse-checkout: upstreaming + - name: Apply hash-pinned gh-aw v1.2.2 native artifact fix + run: python3 native-artifact-compat/upstreaming/gh_aw_compat.py "$RUNNER_TEMP/gh-aw/actions" publish: # Ordinary trusted job, not a safe output. Gated on the compiled # safe_outputs outcome, then on the exact Claim's verified Result as @@ -214,7 +225,8 @@ one Claim; use its `handle` as `claim_handle` on every safe output and on Write these files into `upstreaming-out/` at the top of the workspace (next to `fork/`, not inside it) and upload them with a single `upload_artifact` -call: `{"path": "upstreaming-out", "name": "upstreaming-proposal"}`: +call: `{"path": "upstreaming-out"}` (the native handler names the artifact +`claim--upstreaming-out`): - `proposal.json`: a JSON object matching `upstreaming/schemas/proposal.schema.json` in the control repository.