id: runtime-end-of-life-guard
namespace: company.team
description: |
Scan a repository for pinned runtime, database and base OS versions, check each one against
endoflife.date, and open one GitHub issue per version that is past or close to end of life.
inputs:
- id: repository
type: STRING
displayName: Repository to scan
description: GitHub repository in owner/repo form. The default is a public repo
of Docker Compose samples with many old pins.
defaults: docker/awesome-compose
- id: branch
type: STRING
displayName: Branch
description: Branch to check out. Usually your default branch, since that is what ships.
defaults: master
- id: warn_days
type: INT
displayName: Warning window in days
description: A version whose end-of-life date is this many days away or fewer is
reported as eol_soon. Six months leaves time to plan an upgrade.
defaults: 180
- id: issue_repository
type: STRING
displayName: Repository that receives the issues
description: Where issues are opened, commented and closed, in owner/repo form.
Often the same as the scanned repository.
defaults: your-org/your-repo
- id: max_issues
type: INT
displayName: Max issues per run
description: Safety cap on new or escalated versions handled per run, worst
first. The rest stay out of the saved state, so the next run picks them
up.
defaults: 10
- id: dry_run
type: BOOL
displayName: Dry run
description: Log every issue the flow would open, comment on or close without
calling GitHub. Leave this on until the report looks right.
defaults: true
variables:
# Dry runs keep their own state, so switching to live runs still opens every issue.
state_key: "runtime_eol_{{ inputs.repository | replace({'/': '_', '-': '_', '.':
'_'}) }}{{ inputs.dry_run ? '_dry_run' : '' }}"
concurrency:
limit: 1
behavior: QUEUE
triggers:
- id: weekly
type: io.kestra.plugin.core.trigger.Schedule
description: End-of-life dates move slowly, so once a week is enough. Shipped
disabled; enable it after a manual run looks right.
cron: "0 7 * * 1"
disabled: true
- id: on_push
type: io.kestra.plugin.core.trigger.Webhook
description: Event-based scan. Point a GitHub push webhook (or a CI step) at
this URL so a Dockerfile or compose change is checked the moment it lands.
The key guards the URL, so keep it in a secret.
key: "{{ secret('EOL_GUARD_WEBHOOK_KEY') }}"
tasks:
- id: read_state
type: io.kestra.plugin.core.kv.Get
description: Versions this flow already reported for the repository, with the
status they had. Missing on the first run, which starts from nothing.
key: "{{ render(vars.state_key) }}"
errorOnMissing: false
- id: scan_repository
type: io.kestra.plugin.core.flow.WorkingDirectory
description: One directory so the version scan sees the files the clone just
checked out.
tasks:
- id: clone_repository
type: io.kestra.plugin.git.Clone
description: Shallow checkout of the branch. Add username and password (a token)
for a private repository.
url: "https://github.com/{{ inputs.repository }}.git"
branch: "{{ inputs.branch }}"
depth: 1
- id: find_pinned_versions
type: io.kestra.plugin.scripts.python.Script
description: >
Walks the checkout and lists every pinned version it can read:
Dockerfile FROM lines, image references in compose files, Kubernetes
manifests and Helm values, setup-python, setup-node and setup-go
versions in CI files, .python-version, .nvmrc, .node-version,
.tool-versions and the go directive in go.mod. Debian and Ubuntu
codenames in a tag (node:18-bullseye, eclipse-temurin:17-jre-focal)
count as a base OS pin too. Floating tags such as latest or lts are
listed separately, since there is no version to check. Standard
library only, so no pip install.
containerImage: python:3.12-slim
outputFiles:
- inventory.json
script: |
import json
import os
import re
IMAGE_PRODUCTS = {
"python": "python",
"node": "nodejs",
"golang": "go",
"postgres": "postgresql",
"mysql": "mysql",
"mariadb": "mariadb",
"redis": "redis",
"valkey/valkey": "valkey",
"mongo": "mongodb",
"nginx": "nginx",
"httpd": "apache-http-server",
"haproxy": "haproxy",
"traefik": "traefik",
"alpine": "alpine-linux",
"ubuntu": "ubuntu",
"debian": "debian",
"ruby": "ruby",
"php": "php",
"rust": "rust",
"eclipse-temurin": "eclipse-temurin",
"amazoncorretto": "amazon-corretto",
"tomcat": "tomcat",
"rabbitmq": "rabbitmq",
"memcached": "memcached",
"elasticsearch": "elasticsearch",
"docker.elastic.co/elasticsearch/elasticsearch": "elasticsearch",
"logstash": "logstash",
"docker.elastic.co/logstash/logstash": "logstash",
"kibana": "kibana",
"docker.elastic.co/kibana/kibana": "kibana",
"grafana/grafana": "grafana",
"prom/prometheus": "prometheus",
"quay.io/keycloak/keycloak": "keycloak",
"jenkins/jenkins": "jenkins",
"wordpress": "wordpress",
"nextcloud": "nextcloud",
"drupal": "drupal",
"mcr.microsoft.com/dotnet/sdk": "dotnet",
"mcr.microsoft.com/dotnet/aspnet": "dotnet",
"mcr.microsoft.com/dotnet/runtime": "dotnet",
"mcr.microsoft.com/dotnet/runtime-deps": "dotnet",
}
TOOL_PRODUCTS = {
"python": "python",
"nodejs": "nodejs",
"node": "nodejs",
"golang": "go",
"go": "go",
"ruby": "ruby",
"php": "php",
"rust": "rust",
"terraform": "terraform",
"kubectl": "kubernetes",
}
SETUP_KEYS = {"python-version": "python", "node-version": "nodejs", "go-version": "go"}
SKIP_DIRS = {".git", "node_modules", "vendor", ".venv", "venv", "dist", "build", "target"}
# Debian and Ubuntu codenames that show up as image tag suffixes, e.g. node:18-bullseye or eclipse-temurin:17-jre-focal.
BASE_OS = {
"stretch": "debian", "buster": "debian", "bullseye": "debian", "bookworm": "debian", "trixie": "debian",
"xenial": "ubuntu", "bionic": "ubuntu", "focal": "ubuntu", "jammy": "ubuntu", "noble": "ubuntu",
}
FLOATING = {"", "latest", "lts", "stable", "current", "alpine", "slim", "mainline"}
findings = []
floating = []
def record(product, version, path, line, source):
findings.append({"product": product, "version": version, "file": path, "line": line, "source": source})
def split_image(ref):
ref = ref.strip().strip("'\"")
if "${" in ref or "$" in ref:
return None, None
ref = ref.split("@", 1)[0]
name, tag = ref, ""
last = ref.rsplit("/", 1)[-1]
if ":" in last:
name, tag = ref.rsplit(":", 1)
for prefix in ("docker.io/library/", "docker.io/", "library/"):
if name.startswith(prefix):
name = name[len(prefix):]
return name, tag
def check_image(ref, path, line, source):
name, tag = split_image(ref)
if name is None or name not in IMAGE_PRODUCTS:
return
product = IMAGE_PRODUCTS[name]
for token in tag.split("-"):
if token in BASE_OS and not (product == BASE_OS[token] and tag.startswith(token)):
record(BASE_OS[token], "codename:" + token, path, line, "base OS of " + ref.strip())
match = re.match(r"v?(\d+(?:\.\d+)*)", tag)
if match:
record(product, match.group(1), path, line, source)
return
if product in ("debian", "ubuntu") and tag.split("-")[0] in BASE_OS:
record(product, "codename:" + tag.split("-")[0], path, line, source)
return
floating.append({"product": product, "image": ref.strip(), "file": path, "line": line})
for root, dirs, files in os.walk("."):
dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
for fname in files:
path = os.path.relpath(os.path.join(root, fname), ".")
lower = fname.lower()
is_dockerfile = lower == "dockerfile" or lower.startswith("dockerfile.") or lower.endswith(".dockerfile")
is_yaml = lower.endswith((".yml", ".yaml"))
is_pin = lower in (".python-version", ".nvmrc", ".node-version", ".tool-versions", "go.mod")
if not (is_dockerfile or is_yaml or is_pin):
continue
try:
with open(path, encoding="utf-8", errors="replace") as fh:
lines = fh.read().splitlines()
except OSError:
continue
stages = set()
for n, raw in enumerate(lines, start=1):
text = raw.split("#", 1)[0].strip() if not is_dockerfile else raw.strip()
if is_dockerfile and re.match(r"(?i)^from\s", text):
parts = [p for p in text.split()[1:] if not p.startswith("--")]
if not parts:
continue
if len(parts) >= 3 and parts[1].lower() == "as":
stages.add(parts[2].lower())
if parts[0].lower() in stages or parts[0].lower() == "scratch":
continue
check_image(parts[0], path, n, "Dockerfile FROM")
elif is_yaml:
image = re.match(r"^-?\s*image:\s*(\S+)", text)
if image:
check_image(image.group(1), path, n, "image reference")
continue
setup = re.match(r"^-?\s*(python-version|node-version|go-version):\s*(.+)$", text)
if setup:
product = SETUP_KEYS[setup.group(1)]
for value in re.findall(r"v?(\d+(?:\.\d+)*)", setup.group(2).replace("'", " ").replace('"', " ")):
record(product, value, path, n, "CI setup " + setup.group(1))
elif lower in (".python-version", ".nvmrc", ".node-version") and text:
product = "python" if lower == ".python-version" else "nodejs"
value = re.match(r"v?(\d+(?:\.\d+)*)", text)
if value:
record(product, value.group(1), path, n, lower)
elif lower == ".tool-versions" and text:
parts = text.split()
if len(parts) >= 2 and parts[0] in TOOL_PRODUCTS:
value = re.match(r"v?(\d+(?:\.\d+)*)", parts[1])
if value:
record(TOOL_PRODUCTS[parts[0]], value.group(1), path, n, ".tool-versions")
elif lower == "go.mod":
value = re.match(r"^go\s+(\d+\.\d+)", text)
if value:
record("go", value.group(1), path, n, "go.mod")
with open("inventory.json", "w", encoding="utf-8") as fh:
json.dump({"findings": findings, "floating": floating}, fh, indent=2)
print("version pins found: {}, floating tags: {}".format(len(findings), len(floating)))
- id: check_end_of_life
type: io.kestra.plugin.scripts.python.Script
description: >
Fetches the release cycles of each product once from the endoflife.date
API, matches every pinned version to its cycle, and classifies the cycle
as eol, eol_soon or supported. A cycle is actionable when it is new to the
risk list or moved from eol_soon to eol since the saved state, so a
version already reported stays quiet. Writes a Markdown report of
everything it found.
containerImage: python:3.12-slim
env:
WARN_DAYS: "{{ inputs.warn_days }}"
MAX_ISSUES: "{{ inputs.max_issues }}"
inputFiles:
inventory.json: "{{ outputs.find_pinned_versions.outputFiles['inventory.json'] }}"
previous.json: "{{ outputs.read_state.value ?? '' }}"
outputFiles:
- eol-report.md
script: |
import datetime
import json
import os
import urllib.error
import urllib.request
WARN_DAYS = int(os.environ.get("WARN_DAYS", "180"))
MAX_ISSUES = max(0, int(os.environ.get("MAX_ISSUES", "10")))
API = os.environ.get("EOL_API", "https://endoflife.date/api/v1/products/")
TODAY = datetime.datetime.now(datetime.timezone.utc).date()
RANK = {"eol": 2, "eol_soon": 1, "supported": 0}
with open("inventory.json", encoding="utf-8") as fh:
inventory = json.load(fh)
previous = {}
if os.path.exists("previous.json"):
text = open("previous.json", encoding="utf-8").read().strip()
if text:
previous = json.loads(text)
releases = {}
lookup_errors = []
for product in sorted({f["product"] for f in inventory["findings"]}):
request = urllib.request.Request(API + product + "/", headers={"User-Agent": "kestra-runtime-eol-guard"})
try:
with urllib.request.urlopen(request, timeout=30) as resp:
releases[product] = json.load(resp)["result"]["releases"]
except urllib.error.HTTPError as err:
lookup_errors.append("{} (HTTP {})".format(product, err.code))
if len(lookup_errors) == len({f["product"] for f in inventory["findings"]}) and lookup_errors:
raise SystemExit("endoflife.date lookups all failed: " + ", ".join(lookup_errors))
def match_cycle(product, version):
cycles = releases.get(product, [])
if version.startswith("codename:"):
word = version.split(":", 1)[1]
for rel in cycles:
if (rel.get("codename") or "").lower().split(" ")[0] == word:
return rel
return None
best = None
for rel in cycles:
name = rel["name"]
if version == name or version.startswith(name + "."):
if best is None or len(name) > len(best["name"]):
best = rel
if best is None:
# A major-only tag such as mysql:8 floats to the newest 8.x cycle. Releases are listed newest first.
for rel in cycles:
if rel["name"].startswith(version + "."):
return rel
return best
cycles = {}
untracked = []
for item in inventory["findings"]:
rel = match_cycle(item["product"], item["version"])
if rel is None:
if item["product"] in releases:
untracked.append(item)
continue
key = "{}@{}".format(item["product"], rel["name"])
entry = cycles.setdefault(key, {
"key": key,
"product": item["product"],
"cycle": rel["name"],
"eol_date": rel.get("eolFrom"),
"is_eol": bool(rel.get("isEol")),
"latest": (rel.get("latest") or {}).get("name"),
"locations": [],
})
entry["locations"].append("{}:{} ({}, {})".format(item["file"], item["line"], item["source"], item["version"]))
for entry in cycles.values():
days = None
if entry["eol_date"]:
days = (datetime.date.fromisoformat(entry["eol_date"]) - TODAY).days
entry["days_left"] = days
if entry["is_eol"] or (days is not None and days < 0):
entry["status"] = "eol"
elif days is not None and days <= WARN_DAYS:
entry["status"] = "eol_soon"
else:
entry["status"] = "supported"
ordered = sorted(cycles.values(), key=lambda e: (-RANK[e["status"]], e["days_left"] if e["days_left"] is not None else 99999, e["key"]))
at_risk = [e for e in ordered if e["status"] != "supported"]
# Only a runtime that is new to the risk list, or that moved from eol_soon to eol, needs a person to look at it.
actionable = [e for e in at_risk if RANK[e["status"]] > RANK.get(previous.get(e["key"], "supported"), 0)]
selected = actionable[:MAX_ISSUES]
deferred = actionable[MAX_ISSUES:]
cleared = sorted(k for k, s in previous.items() if s != "supported" and (k not in cycles or cycles[k]["status"] == "supported"))
# The next baseline records handled runtimes only, so anything over the cap is reported again next run.
handled = {e["key"] for e in selected}
state = {}
for e in at_risk:
if e["key"] in handled:
state[e["key"]] = e["status"]
elif e["key"] in previous:
state[e["key"]] = previous[e["key"]]
lines = ["# Runtime end-of-life report", "", "Checked on {} UTC against endoflife.date. Warning window: {} days.".format(TODAY, WARN_DAYS), ""]
lines.append("| Runtime | Cycle | Status | EOL date | Days left | Latest patch | Where |")
lines.append("| --- | --- | --- | --- | --- | --- | --- |")
for e in ordered:
lines.append("| {} | {} | {} | {} | {} | {} | {} |".format(
e["product"], e["cycle"], e["status"], e["eol_date"] or "not set", "" if e["days_left"] is None else e["days_left"],
e["latest"] or "", "<br>".join(e["locations"])))
if untracked:
lines += ["", "## Versions endoflife.date does not track", ""]
lines += ["- {} {} at {}:{}".format(u["product"], u["version"], u["file"], u["line"]) for u in untracked]
if inventory["floating"]:
lines += ["", "## Floating tags (no version to check)", ""]
lines += ["- `{}` at {}:{}".format(f["image"], f["file"], f["line"]) for f in inventory["floating"]]
if lookup_errors:
lines += ["", "## Lookups that failed", ""] + ["- " + e for e in lookup_errors]
with open("eol-report.md", "w", encoding="utf-8") as fh:
fh.write("\n".join(lines) + "\n")
def issue_view(e):
when = "reached end of life on {}".format(e["eol_date"]) if e["status"] == "eol" else "reaches end of life on {} ({} days left)".format(e["eol_date"], e["days_left"])
if e["status"] == "eol" and not e["eol_date"]:
when = "is marked end of life"
return json.dumps({
"key": e["key"],
"title": "End of life: {} {}".format(e["product"], e["cycle"]),
"status": e["status"],
"summary": "{} {} {}".format(e["product"], e["cycle"], when),
"latest": e["latest"] or "unknown",
"locations": "\n".join("- `{}`".format(loc) for loc in e["locations"]),
"product": e["product"],
})
verdict = {
"runtimes_checked": len(ordered),
"eol_count": sum(1 for e in ordered if e["status"] == "eol"),
"eol_soon_count": sum(1 for e in ordered if e["status"] == "eol_soon"),
"floating_count": len(inventory["floating"]),
"untracked_count": len(untracked),
"actionable_count": len(actionable),
"selected_count": len(selected),
"deferred_count": len(deferred),
"has_actionable": len(selected) > 0,
"selected_json": [issue_view(e) for e in selected],
"at_risk_list": ", ".join("{} ({})".format(e["key"], e["status"]) for e in at_risk) or "none",
"has_cleared": len(cleared) > 0,
"cleared_json": [json.dumps({"key": k, "title": "End of life: " + k.replace("@", " ")}) for k in cleared],
"cleared_list": ", ".join(cleared) or "none",
"state_json": json.dumps(state, sort_keys=True),
}
print("::" + json.dumps({"outputs": verdict}) + "::")
print("checked={runtimes_checked} eol={eol_count} eol_soon={eol_soon_count} actionable={actionable_count} selected={selected_count}".format(**verdict))
- id: log_summary
type: io.kestra.plugin.core.log.Log
description: Full counts next to what this run handles, so a capped run never
reads as complete.
message: |
{{ inputs.repository }}@{{ inputs.branch }}: {{ outputs.check_end_of_life.vars.runtimes_checked }} runtime cycle(s) checked, {{ outputs.check_end_of_life.vars.eol_count }} past end of life, {{ outputs.check_end_of_life.vars.eol_soon_count }} within {{ inputs.warn_days }} days.
At risk: {{ outputs.check_end_of_life.vars.at_risk_list }}
New or escalated since the last run: {{ outputs.check_end_of_life.vars.actionable_count }}, handled now: {{ outputs.check_end_of_life.vars.selected_count }}, left for the next run: {{ outputs.check_end_of_life.vars.deferred_count }}.
No longer at risk: {{ outputs.check_end_of_life.vars.cleared_list }}
Floating tags: {{ outputs.check_end_of_life.vars.floating_count }}. Versions endoflife.date does not track: {{ outputs.check_end_of_life.vars.untracked_count }}.
- id: report_at_risk
type: io.kestra.plugin.core.flow.If
description: Open or update one issue per new or escalated version.
condition: "{{ outputs.check_end_of_life.vars.has_actionable }}"
then:
- id: at_risk_mode
type: io.kestra.plugin.core.flow.If
condition: "{{ inputs.dry_run }}"
then:
- id: planned_issues
type: io.kestra.plugin.core.flow.Loop
values: "{{ outputs.check_end_of_life.vars.selected_json }}"
concurrencyLimit: 1
tasks:
- id: would_report
type: io.kestra.plugin.core.log.Log
message: |
DRY RUN would open or comment on "{{ fromJson(item.value).title }}" in {{ inputs.issue_repository }}:
{{ fromJson(item.value).summary }}. Latest patch of the cycle: {{ fromJson(item.value).latest }}.
{{ fromJson(item.value).locations }}
else:
- id: sync_issues
type: io.kestra.plugin.core.flow.Loop
values: "{{ outputs.check_end_of_life.vars.selected_json }}"
concurrencyLimit: 1
tasks:
- id: find_open_issue
type: io.kestra.plugin.github.issues.Search
description: The title is stable per product and cycle, so an issue left open by
an earlier run is found and updated instead of duplicated.
oauthToken: "{{ secret('GITHUB_TOKEN') }}"
repository: "{{ inputs.issue_repository }}"
query: "in:title \"{{ fromJson(item.value).title }}\""
open: true
fetchType: FETCH_ONE
- id: open_or_update
type: io.kestra.plugin.core.flow.If
condition: "{{ outputs.find_open_issue.size == 0 }}"
then:
- id: open_issue
type: io.kestra.plugin.github.issues.Create
description: One issue per product cycle, listing every file that pins it.
oauthToken: "{{ secret('GITHUB_TOKEN') }}"
repository: "{{ inputs.issue_repository }}"
title: "{{ fromJson(item.value).title }}"
labels:
- dependencies
- end-of-life
body: |
{{ fromJson(item.value).summary }}. After that date the project ships no more security fixes for it.
Pinned in `{{ inputs.repository }}` on `{{ inputs.branch }}`:
{{ fromJson(item.value).locations }}
Latest patch of this cycle: `{{ fromJson(item.value).latest }}`. Support windows for every cycle: https://endoflife.date/{{ fromJson(item.value).product }}
Opened by the Kestra flow `{{ flow.id }}`, execution `{{ execution.id }}`. The same flow closes this issue once no file pins this version any more.
else:
- id: comment_escalation
type: io.kestra.plugin.github.issues.Comment
description: The issue is already open, so the change of status (usually
eol_soon to eol) goes in as a comment.
oauthToken: "{{ secret('GITHUB_TOKEN') }}"
repository: "{{ inputs.issue_repository }}"
issueNumber: "{{ outputs.find_open_issue.row.number }}"
body: |
Status is now **{{ fromJson(item.value).status }}**: {{ fromJson(item.value).summary }}.
{{ fromJson(item.value).locations }}
Kestra execution `{{ execution.id }}`.
- id: close_cleared
type: io.kestra.plugin.core.flow.If
description: Close the issues of versions that no file pins any more, so the
backlog shrinks after each upgrade.
condition: "{{ outputs.check_end_of_life.vars.has_cleared }}"
then:
- id: cleared_mode
type: io.kestra.plugin.core.flow.If
condition: "{{ inputs.dry_run }}"
then:
- id: planned_closes
type: io.kestra.plugin.core.log.Log
message: "DRY RUN would close the open issue for each of these in {{
inputs.issue_repository }}: {{
outputs.check_end_of_life.vars.cleared_list }}"
else:
- id: close_issues
type: io.kestra.plugin.core.flow.Loop
values: "{{ outputs.check_end_of_life.vars.cleared_json }}"
concurrencyLimit: 1
tasks:
- id: find_cleared_issue
type: io.kestra.plugin.github.issues.Search
oauthToken: "{{ secret('GITHUB_TOKEN') }}"
repository: "{{ inputs.issue_repository }}"
query: "in:title \"{{ fromJson(item.value).title }}\""
open: true
fetchType: FETCH_ONE
- id: close_when_found
type: io.kestra.plugin.core.flow.If
condition: "{{ outputs.find_cleared_issue.size > 0 }}"
then:
- id: comment_cleared
type: io.kestra.plugin.github.issues.Comment
description: Say why the issue closes before closing it.
oauthToken: "{{ secret('GITHUB_TOKEN') }}"
repository: "{{ inputs.issue_repository }}"
issueNumber: "{{ outputs.find_cleared_issue.row.number }}"
body: "No file in `{{ inputs.repository }}` on `{{ inputs.branch }}` pins this
version any more. Closing from Kestra execution `{{
execution.id }}`."
- id: close_issue
type: io.kestra.plugin.core.http.Request
description: Closing goes over the GitHub REST API, because plugin-github has no
task that changes an issue's state.
method: PATCH
uri: "https://api.github.com/repos/{{ inputs.issue_repository }}/issues/{{
outputs.find_cleared_issue.row.number }}"
contentType: application/json
headers:
Authorization: "Bearer {{ secret('GITHUB_TOKEN') }}"
Accept: application/vnd.github+json
X-GitHub-Api-Version: "2022-11-28"
body: '{"state": "closed", "state_reason": "completed"}'
- id: save_state
type: io.kestra.plugin.core.kv.Set
description: Last on purpose. A failed run leaves the saved state alone, so
nothing is marked as reported unless the issue step finished.
key: "{{ render(vars.state_key) }}"
kvType: STRING
overwrite: true
value: "{{ outputs.check_end_of_life.vars.state_json }}"
errors:
- id: state_untouched
type: io.kestra.plugin.core.log.Log
level: ERROR
message: "Runtime end-of-life check failed for {{ inputs.repository }}@{{
inputs.branch }}. The saved state under {{ render(vars.state_key) }} was
not changed, so the next run reports the same versions again."
outputs:
- id: eol_count
type: INT
description: Runtime cycles already past end of life, e.g. 24.
value: "{{ outputs.check_end_of_life.vars.eol_count }}"
- id: eol_soon_count
type: INT
description: Runtime cycles reaching end of life inside the warning window, e.g. 1.
value: "{{ outputs.check_end_of_life.vars.eol_soon_count }}"
- id: actionable_count
type: INT
description: Cycles new to the risk list or escalated since the last run, e.g. 3.
value: "{{ outputs.check_end_of_life.vars.actionable_count }}"
- id: report
type: FILE
description: Markdown table of every pinned version with its cycle, status,
end-of-life date and the files that pin it.
value: "{{ outputs.check_end_of_life.outputFiles['eol-report.md'] }}"