Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.
Python agent-orchestrationaiai-agentschatopsdiscordlangchainmcpmicrosoft-teamsmulti-agentopen-sourceopenaiself-hostedslack
feat(security): security-workflow rollout (Socket-first + Renovate/Trivy) (#42)
Paul Abbazia7df3097da244
diff --git a/.github/dependabot.yml b/.github/dependabot.ymldeleted file mode 100644index 7a5145e2a..000000000--- a/.github/dependabot.yml+++ /dev/null@@ -1,62 +0,0 @@-version: 2--# Keeps dependencies patched across the three code trees plus the GitHub Actions-# we pin in workflows. Dependabot opens a PR per outdated (or vulnerable)-# dependency; those PRs run through PR CI (pr-ci.yml) like any other. Grouped-# where sensible to keep PR volume manageable.-#-# `cooldown` holds off on newly published versions for a week — a just-released-# (or freshly compromised) package version is the highest-risk moment, so we let-# it settle before proposing the bump. Security updates for known CVEs are NOT-# subject to cooldown, so real fixes still land promptly.-updates:- # Backend Python package (uv).- - package-ecosystem: uv- directory: /core- schedule:- interval: weekly- cooldown:- default-days: 7- open-pull-requests-limit: 10- groups:- python-deps:- patterns:- - '*'-- # Switchdash desktop app (pnpm workspace).- - package-ecosystem: npm- directory: /dash- schedule:- interval: weekly- cooldown:- default-days: 7- open-pull-requests-limit: 10- groups:- dash-deps:- patterns:- - '*'-- # Operator dashboard UI (npm).- - package-ecosystem: npm- directory: /gateway- schedule:- interval: weekly- cooldown:- default-days: 7- open-pull-requests-limit: 10- groups:- gateway-deps:- patterns:- - '*'-- # Versions of the actions pinned in .github/workflows/*.- - package-ecosystem: github-actions- directory: /- schedule:- interval: weekly- cooldown:- default-days: 7- groups:- github-actions:- patterns:- - '*'diff --git a/.github/renovate-security/.gitignore b/.github/renovate-security/.gitignorenew file mode 100644index 000000000..7a60b85e1--- /dev/null+++ b/.github/renovate-security/.gitignore@@ -0,0 +1,2 @@+__pycache__/+*.pycdiff --git a/.github/renovate-security/jira_client.py b/.github/renovate-security/jira_client.pynew file mode 100644index 000000000..ad32ed890--- /dev/null+++ b/.github/renovate-security/jira_client.py@@ -0,0 +1,408 @@+"""Tiny Jira REST client (stdlib only) for linking/creating vulnerability tickets.++Uses REST API v3 with basic auth (email + API token) against the SandboxAQ Jira+Cloud instance (sandboxquantum.atlassian.net): search via /rest/api/3/search/jql+(with a legacy fallback), create with an ADF description, assign, comment, remote+link and transition to Done. Stdlib-only so the CI step needs no extra pip install.++Every network call degrades gracefully: on any error it logs and returns an empty+result / None, so a Jira outage never fails the autofix run.++Vendored from ``root/scripts/socket-autofix/jira_client.py`` so this tool is+self-contained and independently mergeable (with one addition, ``field_value()``, for+verify-after-set routing). Once both tools land, the shared stdlib helpers (this+module, ``advisory.py``, ``codeowners.py``) should be extracted to a single+``root/scripts/lib/`` and imported by both.+"""++from __future__ import annotations++import base64+import dataclasses+import json+import os+import urllib.error+import urllib.parse+import urllib.request+from typing import Optional++DEFAULT_BASE = "https://sandboxquantum.atlassian.net"+# Vulnerabilities are tracked in the VULNMGMT project. Both search and create+# default here; the driver overrides them from JIRA_VULN_PROJECT when set.+SEARCH_PROJECTS = ("VULNMGMT",)+CREATE_PROJECT = "VULNMGMT"+++class JiraIssue:+ key: str+ summary: str+ url: str+ status: str = ""+ # Stable numeric issue id. Unlike `key`, it does NOT change when VULNMGMT+ # automation MOVES the issue to a BU project (VULNMGMT-496 -> QNV-7011), so all+ # post-create writes (route/verify/comment/remotelink/close) must key off id.+ id: str = ""+++class JiraClient:+ def __init__(self, base: str, email: str, token: str):+ self.base = base.rstrip("/")+ self._auth = base64.b64encode(f"{email}:{token}".encode()).decode()++ @classmethod+ def from_env(cls) -> Optional["JiraClient"]:+ email = os.environ.get("SBT_MACHINE_USER_EMAIL")+ token = os.environ.get("SBT_MACHINE_USER_JIRA_TOKEN")+ # `or DEFAULT_BASE` (not a get default): the workflow sets+ # JIRA_BASE_URL: ${{ vars.JIRA_BASE_URL }}, which is the EMPTY STRING when+ # the repo var is undefined. get(k, default) returns "" there (key present),+ # leaving base="" and every request URL schemeless. Treat empty as unset.+ base = os.environ.get("JIRA_BASE_URL") or DEFAULT_BASE+ if not (email and token):+ return None+ return cls(base, email, token)++ def _request(+ self, method: str, path: str, body: Optional[dict] = None+ ) -> Optional[dict]:+ url = f"{self.base}{path}"+ data = json.dumps(body).encode() if body is not None else None+ req = urllib.request.Request(url, data=data, method=method)+ req.add_header("Authorization", f"Basic {self._auth}")+ req.add_header("Accept", "application/json")+ if data is not None:+ req.add_header("Content-Type", "application/json")+ try:+ with urllib.request.urlopen(req, timeout=30) as resp:+ raw = resp.read().decode()+ return json.loads(raw) if raw else {}+ except urllib.error.HTTPError as e:+ detail = e.read().decode(errors="replace")[:500]+ print(f" ! jira {method} {path} -> HTTP {e.code}: {detail}")+ except Exception as e: # noqa: BLE001 - graceful degradation is the point+ print(f" ! jira {method} {path} failed: {e}")+ return None++ def search(self, jql: str, max_results: int = 20) -> list[JiraIssue]:+ # Atlassian Cloud replaced /rest/api/{2,3}/search with /rest/api/3/search/jql+ # (the old ones were removed in 2025). Try the current endpoint first, then+ # fall back to the legacy one for older/Server instances.+ params = urllib.parse.urlencode(+ {"jql": jql, "maxResults": max_results, "fields": "summary,status"}+ )+ data = self._request("GET", f"/rest/api/3/search/jql?{params}")+ if data is None:+ data = self._request("GET", f"/rest/api/2/search?{params}")+ if not data:+ return []+ out: list[JiraIssue] = []+ for issue in data.get("issues", []):+ key = issue.get("key", "")+ fields = issue.get("fields", {})+ out.append(+ JiraIssue(+ key=key,+ summary=fields.get("summary", ""),+ url=f"{self.base}/browse/{key}",+ status=(fields.get("status") or {}).get("name", ""),+ )+ )+ return out++ def create(+ self,+ summary: str,+ description: str,+ labels: Optional[list[str]] = None,+ project: str = CREATE_PROJECT,+ issue_type: str = "Task",+ epic_key: Optional[str] = None,+ ) -> Optional[JiraIssue]:+ # REST v3 requires an ADF description.+ fields = {+ "project": {"key": project},+ "summary": summary[:250],+ "description": _adf(description),+ "issuetype": {"name": issue_type},+ }+ if epic_key: # file under a vuln-tracking epic if one is configured+ fields["parent"] = {"key": epic_key}+ if labels:+ fields["labels"] = labels+ data = self._request("POST", "/rest/api/3/issue", {"fields": fields})+ if not data or "key" not in data:+ return None+ key = data["key"]+ return JiraIssue(+ key=key,+ summary=summary,+ url=f"{self.base}/browse/{key}",+ id=str(data.get("id") or ""),+ )++ def resolve_key(self, id_or_key: str) -> Optional[str]:+ """Current key for an issue id/key. After VULNMGMT automation MOVES a created+ issue to its BU project, the numeric id still resolves but returns the NEW key+ (e.g. QNV-7011). Used to stamp the real key into the PR body / close marker."""+ data = self._request(+ "GET", f"/rest/api/3/issue/{urllib.parse.quote(id_or_key)}?fields=key"+ )+ if isinstance(data, dict):+ return data.get("key")+ return None++ def myself(self) -> Optional[dict]:+ """The account this token authenticates as (email, displayName, accountId) —+ so permissions can be granted to the RIGHT account."""+ data = self._request("GET", "/rest/api/3/myself")+ return data if isinstance(data, dict) else None++ def find_account_id(self, query: str) -> Optional[str]:+ """Best-effort accountId lookup for a user by email or display name, so+ 'assign to aisim' works from a human-readable identifier. Returns None if+ the account can't be resolved (user search is permission-gated)."""+ q = urllib.parse.quote(query)+ data = self._request("GET", f"/rest/api/3/user/search?query={q}")+ if isinstance(data, list) and data:+ aid = data[0].get("accountId")+ return str(aid) if aid else None+ return None++ def project_exists(self, project_key: str) -> bool:+ """True if the account can browse `project_key` (GET project/{key} -> 200).+ Reliable existence/visibility check for filtering search keys — one bad key+ (e.g. a misspelled VULNMGMT) otherwise makes the whole JQL error -> empty.+ (project/search under-reports permission-scheme-granted projects, so we+ probe each key directly.)"""+ data = self._request(+ "GET", f"/rest/api/3/project/{urllib.parse.quote(project_key)}"+ )+ return isinstance(data, dict) and bool(data.get("key"))++ def field_allowed_values(self, project_key: str, field_id: str) -> list[str]:+ """Allowed option names for a select custom field in `project_key` (from+ createmeta). Empty if the field is free-text or has no restricted options."""+ it = self._request(+ "GET",+ f"/rest/api/3/issue/createmeta/{urllib.parse.quote(project_key)}/issuetypes",+ )+ if not isinstance(it, dict):+ return []+ ids = [+ v.get("id")+ for v in (it.get("values") or it.get("issueTypes") or [])+ if v.get("id")+ ]+ for tid in ids:+ data = self._request(+ "GET",+ f"/rest/api/3/issue/createmeta/{urllib.parse.quote(project_key)}"+ f"/issuetypes/{urllib.parse.quote(str(tid))}",+ )+ if not isinstance(data, dict):+ continue+ for field in data.get("values") or data.get("fields") or []:+ if field.get("fieldId") == field_id or field.get("key") == field_id:+ return [+ av.get("value") or av.get("name")+ for av in field.get("allowedValues", [])+ if (av.get("value") or av.get("name"))+ ]+ return []++ def issue_types(self, project_key: str) -> list[str]:+ """Issue-type names creatable in `project_key` (from createmeta) — used to+ pick a valid type, since a project may not offer 'Task'."""+ data = self._request(+ "GET",+ f"/rest/api/3/issue/createmeta/{urllib.parse.quote(project_key)}/issuetypes",+ )+ if not isinstance(data, dict):+ return []+ vals = data.get("values") or data.get("issueTypes") or []+ return [v.get("name", "") for v in vals if v.get("name")]++ def can_create_in(self, project_key: str) -> bool:+ """True if the authenticated account can create issues in `project_key`+ (createmeta returns issue types only for projects it can create in)."""+ data = self._request(+ "GET",+ f"/rest/api/3/issue/createmeta/{urllib.parse.quote(project_key)}/issuetypes",+ )+ if not isinstance(data, dict):+ return False+ return bool(data.get("values") or data.get("issueTypes"))++ def add_comment(self, key: str, text: str) -> bool:+ """Add an ADF comment to an issue. Best-effort (returns False on failure)."""+ data = self._request(+ "POST",+ f"/rest/api/3/issue/{urllib.parse.quote(key)}/comment",+ {"body": _adf(text)},+ )+ return data is not None++ def add_remote_link(self, key: str, url: str, title: str) -> bool:+ """Add/refresh a 'Web link' on the issue pointing at `url` (e.g. the fix PR).+ Idempotent: `globalId` = the url, so reruns update the same link instead of+ adding duplicates. Best-effort."""+ body = {"globalId": url, "object": {"url": url, "title": title[:250]}}+ data = self._request(+ "POST", f"/rest/api/3/issue/{urllib.parse.quote(key)}/remotelink", body+ )+ return data is not None++ def set_assignee(+ self,+ key: str,+ account_id: Optional[str] = None,+ name: Optional[str] = None,+ ) -> bool:+ """Assign an issue (e.g. to the aisim account). Jira Cloud wants an+ accountId; Server/DC wants a name/username. Try accountId first, then name.+ Best-effort — returns True if either shape is accepted."""+ ek = urllib.parse.quote(key)+ payloads = []+ if account_id:+ payloads.append({"accountId": account_id})+ if name:+ payloads.append({"name": name})+ for payload in payloads:+ data = self._request("PUT", f"/rest/api/3/issue/{ek}/assignee", payload)+ if data is not None:+ return True+ return False++ def transitions(self, key: str) -> list[dict]:+ data = self._request(+ "GET", f"/rest/api/3/issue/{urllib.parse.quote(key)}/transitions"+ )+ return data.get("transitions", []) if isinstance(data, dict) else []++ def close_issue(self, key: str, comment: Optional[str] = None) -> bool:+ """Transition an issue to a Done-category status (optionally commenting+ first). Picks the transition whose target status is in the 'done' category,+ else one named like Done/Closed/Resolved. Best-effort."""+ trs = self.transitions(key)+ chosen = None+ for t in trs:+ cat = ((t.get("to") or {}).get("statusCategory") or {}).get("key")+ if cat == "done":+ chosen = t+ break+ if not chosen:+ for t in trs:+ if t.get("name", "").strip().lower() in (+ "done",+ "close",+ "closed",+ "resolve",+ "resolved",+ ):+ chosen = t+ break+ if not chosen:+ print(+ f" ! jira {key}: no Done transition available "+ f"(transitions: {[t.get('name') for t in trs]})"+ )+ return False+ if comment:+ self.add_comment(key, comment)+ data = self._request(+ "POST",+ f"/rest/api/3/issue/{urllib.parse.quote(key)}/transitions",+ {"transition": {"id": chosen["id"]}},+ )+ return data is not None++ def find_field_id(self, name_substr: str) -> Optional[str]:+ """Best-effort: id of the first field whose name contains `name_substr`+ (case-insensitive), e.g. 'business unit' -> 'customfield_12345'. Lets the+ BU field be auto-discovered without hardcoding its custom-field id."""+ data = self._request("GET", "/rest/api/3/field")+ if not isinstance(data, list):+ return None+ want = name_substr.lower()+ for f in data:+ if want in str(f.get("name", "")).lower():+ fid = f.get("id")+ if fid:+ return str(fid)+ return None++ def set_field(self, key: str, field_id: str, value: str) -> bool:+ """Best-effort set of a field. We don't know the field's type, so try the+ single-select object shape ({"value": ...}) then a plain string. A 400 from+ the wrong shape just falls through to the next; returns True if either took."""+ ek = urllib.parse.quote(key)+ for payload in ({"value": value}, value):+ data = self._request(+ "PUT", f"/rest/api/3/issue/{ek}", {"fields": {field_id: payload}}+ )+ if data is not None:+ return True+ return False++ def field_value(self, key: str, field_id: str) -> Optional[str]:+ """Read a field's current value as a plain string (for verify-after-set).+ Unwraps the single-select ``{"value"/"name": ...}`` shape. Returns None if the+ field is unset or unreadable. GETs follow the redirect Jira serves when an+ issue has been MOVED to another project (so the original key still resolves)."""+ ek = urllib.parse.quote(key)+ fq = urllib.parse.quote(field_id)+ data = self._request("GET", f"/rest/api/3/issue/{ek}?fields={fq}")+ if not isinstance(data, dict):+ return None+ val = (data.get("fields") or {}).get(field_id)+ if isinstance(val, dict):+ return val.get("value") or val.get("name")+ return val+++def _adf(text: str) -> dict:+ """Wrap plain text (newline-separated) into an Atlassian Document Format doc,+ as REST v3 requires for issue descriptions."""+ content = []+ for line in text.split("\n"):+ node = {"type": "paragraph", "content": []}+ if line.strip():+ node["content"] = [{"type": "text", "text": line}]+ content.append(node)+ return {+ "type": "doc",+ "version": 1,+ "content": content or [{"type": "paragraph", "content": []}],+ }+++def _quote(term: str) -> str:+ """Escape a term for JQL text search (double-quote wrapped)."""+ return '"' + term.replace("\\", "\\\\").replace('"', '\\"') + '"'+++def build_search_jql(+ terms: list[str],+ repo: str = "",+ projects: tuple[str, ...] = SEARCH_PROJECTS,+ path: str = "",+) -> str:+ """JQL for open issues in the vuln projects mentioning any of `terms`+ (CVE/GHSA ids, package names) and, if given, the repo name and project `path`.++ Scoping by `path` is what keeps dedup per-project: a widely-shared CVE (urllib3,+ requests) lives in many projects' tickets, so matching on the advisory + repo+ alone would link every one of them onto a single project's PR. Requiring the+ manifest dir (which every ticket this tool creates carries in its summary) ties+ the search to the one ticket that actually tracks this project."""+ proj = ", ".join(projects)+ term_clause = " OR ".join(f"text ~ {_quote(t)}" for t in terms if t)+ jql = f"project in ({proj}) AND statusCategory != Done"+ if term_clause:+ jql += f" AND ({term_clause})"+ if repo:+ jql += f" AND text ~ {_quote(repo)}"+ if path:+ jql += f" AND text ~ {_quote(path)}"+ return jql + " ORDER BY updated DESC"diff --git a/.github/renovate-security/renovate_jira.py b/.github/renovate-security/renovate_jira.pynew file mode 100644index 000000000..9238baa76--- /dev/null+++ b/.github/renovate-security/renovate_jira.py@@ -0,0 +1,542 @@+#!/usr/bin/env python3+"""VULNMGMT/Jira ticketing for security PRs opened by Renovate and by+``tf_provider_scan.py``.++Renovate (and our Terraform-provider scanner) open the PRs; this driver adds the+Jira layer that mirrors ``socket-autofix``: for each freshly-opened ``renovate/*`` PR+it searches the VULNMGMT project for an existing ticket (path-scoped so a shared CVE+doesn't attach every project's ticket to one PR), links it or creates one, **routes+the created ticket to AISIM** by setting the Business Unit field+(``customfield_12236`` = "AISIM - AI & Simulation", which fires the VULNMGMT+automation that assigns the ``dept-ai_sim`` team), adds a PR web-link, and stamps a+tracking section + a ``<!-- renovate-jira-close: KEY -->`` marker into the PR body.+On merge the shared close-on-merge workflow transitions that ticket to Done.++Two modes:+ * ``--reconcile`` — the pull_request:opened path. Reads PR metadata (url, title,+ head ref, current body, changed files) and writes an updated body to+ ``--body-out`` for the workflow to apply with ``gh pr edit``. Idempotent: if the+ body already carries the close marker, nothing is done.+ * ``--close-jira KEYS`` — transition the given issues to Done (close-on-merge).++Stdlib-only and best-effort — a Jira outage logs and exits 0 so it never blocks a PR.+"""++from __future__ import annotations++import argparse+import json+import os+import sys+import time+from pathlib import Path+from typing import Optional++import jira_client++JIRA_CLOSE_MARKER = "renovate-jira-close"++# Labels that scope the standing tickets opened by --report (Trivy container/IaC+# scans). Kept distinct per engine so dedup/close only ever touch our own tickets.+_REPORT_ENGINE_LABELS = {+ "container": "container image",+ "iac": "Terraform misconfiguration",+}+_REPORT_BASE_LABEL = "renovate-security"++# Registry short-name / manager -> a human label for the ticket summary.+_ECO_LABELS = {+ "docker": "container image",+ "github-actions": "GitHub Actions",+ "circleci": "CircleCI orb",+ "terraform-provider": "Terraform provider",+ "renovate": "dependency",+}+++def _ecosystem(branch: str, files: list[str]) -> str:+ """Best-effort ecosystem label from the branch name / changed files."""+ if branch.startswith("renovate/tf-provider-"):+ return "terraform-provider"+ lowered = [f.lower() for f in files]+ if any(+ "dockerfile" in f or "docker-compose" in f or f.endswith(".dockerfile")+ for f in lowered+ ):+ return "docker"+ if any(+ f.startswith(".github/workflows/") or f.startswith(".github/actions/")+ for f in lowered+ ):+ return "github-actions"+ if any(f.startswith(".circleci/") for f in lowered):+ return "circleci"+ if any(f.endswith(".tf") or f.endswith(".terraform.lock.hcl") for f in lowered):+ return "terraform-provider"+ return "renovate"+++def _project_dir(files: list[str]) -> str:+ """Deepest directory common to all changed files — the 'project path' used to+ scope Jira dedup (Renovate groups one PR per dir, so files share a prefix)."""+ dirs = [str(Path(f).parent) for f in files if f]+ if not dirs:+ return ""+ if len(dirs) == 1:+ return dirs[0]+ parts = [d.split("/") for d in dirs]+ common: list[str] = []+ for seg in zip(*parts, strict=False):+ if len(set(seg)) == 1:+ common.append(seg[0])+ else:+ break+ return "/".join(common)+++def _read_files_arg(files_arg: str) -> list[str]:+ """--files may be a path to a newline-list (from `gh pr diff --name-only`) or a+ comma-separated inline list."""+ if not files_arg:+ return []+ p = Path(files_arg)+ if p.exists():+ return [ln.strip() for ln in p.read_text().splitlines() if ln.strip()]+ return [f.strip() for f in files_arg.split(",") if f.strip()]+++def _tracking_section(+ created: Optional[jira_client.JiraIssue],+ linked: list[jira_client.JiraIssue],+ assigned: bool,+) -> str:+ if linked:+ lines = "\n".join(+ f"- Linked existing: [{i.key}]({i.url}) — {i.summary} ({i.status})"+ for i in linked+ )+ elif created:+ lines = (+ f"- No open VULNMGMT ticket found; created [{created.key}]({created.url})"+ + (+ " and routed to its **Business Unit** for triage."+ if assigned+ else " (Business Unit routing field could not be set — a human may need to route it)."+ )+ )+ else:+ lines = (+ "- No open VULNMGMT ticket found and none created (Jira unavailable or "+ "disabled). Please file/track manually."+ )+ marker = f"\n<!-- {JIRA_CLOSE_MARKER}: {created.key} -->" if created else ""+ return f"\n\n## Vulnerability tracking (VULNMGMT)\n\n{lines}\n{marker}\n"+++def _dedup_projects(+ client: jira_client.JiraClient, create_project: str+) -> tuple[str, ...]:+ """Projects to scan when de-duplicating before create: the BU-split project+ (VULNMGMT) plus the legacy full-scope VULN project when visible. Probing+ visibility first avoids a JQL error from an `project in (...)` clause naming a+ project the account can't browse (which would drop dedup to empty and dup tickets).+ Override the legacy project via JIRA_LEGACY_PROJECT ("" disables it)."""+ projects = [create_project]+ legacy = os.environ.get("JIRA_LEGACY_PROJECT")+ legacy = "VULN" if legacy is None else legacy+ if legacy and legacy != create_project and client.project_exists(legacy):+ projects.append(legacy)+ return tuple(projects)+++def _route_aisim(+ client: jira_client.JiraClient, issue_id: str, orig_key: str+) -> tuple[bool, str]:+ """Set the Business Unit routing field and return (routed, settled_key).++ Right after creation the VULNMGMT automation CHURNS the issue for ~15s (observed in+ the changelog): a create-time rule clobbers the BU to a default (INFOSEC), assignee+ automation fires, and the issue is MOVED between the VULNMGMT project and the target+ BU project several times — its key changing each time+ (VULNMGMT-498 -> QNV-7012 -> VULNMGMT-499 -> QNV-7013). During every move the issue+ transiently 404s by BOTH key and id. So we:++ 1. set the BU field, re-asserting through the default-BU clobber and the mid-move+ 404s (each successful re-assert is what ultimately makes our value stick);+ 2. wait for the churn to settle — poll until the key is readable and unchanged+ across two consecutive polls;+ 3. read the settled BU to confirm routing.++ Every call keys off the STABLE numeric id (the key is a moving target). `routed` is+ best-effort: a read can still land mid-move, so callers must not treat False as+ 'definitely unrouted'. Tunable via JIRA_AISIM_VERIFY_ATTEMPTS / _VERIFY_SLEEP+ (tests pass sleep 0)."""+ field_id = os.environ.get("JIRA_AISIM_FIELD_ID") or "customfield_12236"+ field_value = os.environ.get("JIRA_AISIM_FIELD_VALUE") or "AISIM - AI & Simulation"+ attempts = int(os.environ.get("JIRA_AISIM_VERIFY_ATTEMPTS") or "4")+ sleep_s = float(os.environ.get("JIRA_AISIM_VERIFY_SLEEP") or "10")+ routed = False # verified by a read-back (only possible while still in VULNMGMT)+ set_ok = False # a set_field PUT was accepted (the honest routing signal from CI)+ if field_id and field_value:+ for _ in range(max(1, attempts)):+ if client.set_field(issue_id, field_id, field_value):+ set_ok = True+ time.sleep(sleep_s) # let the create-time default automation fire first+ if client.field_value(issue_id, field_id) == field_value:+ routed = True # survived a cycle+ break++ # Settle: wait for the move churn to stop so the key/reads are reliable. NOTE: the+ # sbt-machine account has no browse permission in the destination BU project, so+ # once the automation moves the issue out of VULNMGMT these reads 404 permanently;+ # this loop still resolves the final key WHEN the account is granted BU-project+ # access (the proper fix), and otherwise falls back to the original key.+ settled_key = client.resolve_key(issue_id) or orig_key+ last = settled_key+ for _ in range(max(1, attempts)):+ time.sleep(sleep_s)+ k = client.resolve_key(issue_id)+ if k:+ settled_key = k+ if k == last: # unchanged across two consecutive polls -> settled+ break+ last = k+ # Final confirm on the settled issue (impossible if the account can't browse the+ # destination project). Fall back to the write-succeeded signal: routing is driven+ # by the BU field we set, which the org automation then acts on.+ if field_id and not routed:+ routed = client.field_value(issue_id, field_id) == field_value+ routed = routed or set_ok++ account = os.environ.get("JIRA_AISIM_ACCOUNT_ID")+ user = os.environ.get("JIRA_AISIM_USER")+ if account:+ client.set_assignee(issue_id, account_id=account)+ elif user:+ aid = client.find_account_id(user)+ if not (aid and client.set_assignee(issue_id, account_id=aid)):+ client.set_assignee(issue_id, name=user)+ return routed, settled_key+++def reconcile(args) -> int:+ body = ""+ if args.body_file and Path(args.body_file).exists():+ body = Path(args.body_file).read_text()+ if f"{JIRA_CLOSE_MARKER}:" in body:+ print("PR already carries a renovate-jira-close marker; nothing to do.")+ return 0++ files = _read_files_arg(args.files)+ project_dir = _project_dir(files)+ eco = _ecosystem(args.branch, files)+ eco_label = _ECO_LABELS.get(eco, "dependency")+ repo_name = args.repo.split("/")[-1] if args.repo else ""++ client = jira_client.JiraClient.from_env()+ if client is None:+ print(" ! Jira creds not set; skipping ticket create/link.")+ return 0++ create_project = os.environ.get("JIRA_VULN_PROJECT") or jira_client.CREATE_PROJECT+ if not client.project_exists(create_project):+ print(f" ! VULNMGMT project {create_project} not visible; skipping.")+ return 0++ # Path-scoped dedup: link a pre-existing open ticket for this eco+path, else create.+ # Scan BOTH the new BU-split project (VULNMGMT) and the legacy full-scope VULN+ # project so we link an existing ticket instead of opening a duplicate.+ terms = [t for t in [eco_label, Path(project_dir).name] if t]+ jql = jira_client.build_search_jql(+ terms, repo=repo_name, projects=_dedup_projects(client, create_project),+ path=project_dir,+ )+ linked = client.search(jql) if project_dir else []++ created: Optional[jira_client.JiraIssue] = None+ assigned = False+ if not linked and not args.no_create:+ issue_type = os.environ.get("JIRA_ISSUE_TYPE") or ""+ if not issue_type:+ avail = client.issue_types(create_project)+ for pref in ("Task", "Bug", "Vulnerability", "Security", "Story"):+ if pref in avail:+ issue_type = pref+ break+ else:+ issue_type = avail[0] if avail else "Task"+ summary = (+ f"[{repo_name}] {eco_label} security update under {project_dir or '(repo)'}"+ )+ desc = (+ f"Automated by renovate-security. A {eco_label} security update was opened "+ f"on branch {args.branch}.\n\nPR: {args.pr_url}\nProject path: "+ f"{project_dir or '(repo root)'}\nTitle: {args.pr_title}"+ )+ aisim_label = os.environ.get("JIRA_AISIM_LABEL") or "aisim"+ created = client.create(+ summary,+ desc,+ labels=["renovate-security", repo_name, aisim_label],+ project=create_project,+ issue_type=issue_type,+ epic_key=os.environ.get("JIRA_VULN_EPIC") or None,+ )+ if created:+ # Route/verify/comment via the STABLE id: setting the BU fires automation+ # that moves the issue to the BU project, changing its key mid-flight.+ ref = created.id or created.key+ assigned, settled_key = _route_aisim(client, ref, created.key)+ # Stamp the settled post-move key so the PR body + close marker point at the+ # real ticket (e.g. QNV-7011), not the now-404 VULNMGMT-xxx key.+ if settled_key and settled_key != created.key:+ created.key = settled_key+ created.url = f"{client.base}/browse/{settled_key}"+ client.add_comment(+ ref,+ "renovate-security — VULNMGMT routing\n\n"+ + (+ "Business Unit set; VULNMGMT automation routes this to the owning "+ "team for triage."+ if assigned+ else "Could not set the Business Unit field — a human may "+ "need to route this ticket."+ )+ + f"\n\nContext — repo: {repo_name}; path: {project_dir}; PR: {args.pr_url}",+ )+ print(+ f" jira {created.key}: created; BU routing "+ f"{'set' if assigned else 'not set'}"+ )++ # PR web-link on every ticket we touched (stable id for the created one).+ link_refs = [i.key for i in linked] + (+ [created.id or created.key] if created else []+ )+ for ref in link_refs:+ client.add_remote_link(ref, args.pr_url, f"{args.pr_title}: {args.pr_url}")++ display_keys = [i.key for i in linked] + ([created.key] if created else [])+ if not display_keys:+ print(" no Jira ticket linked or created.")+ return 0++ new_body = body.rstrip() + _tracking_section(created, linked, assigned)+ if args.body_out:+ Path(args.body_out).write_text(new_body)+ print(+ f" wrote updated PR body -> {args.body_out} (keys: {','.join(display_keys)})"+ )+ return 0+++def _report_jql(+ projects: tuple[str, ...], engine_label: str, repo: str, path: str+) -> str:+ """Open standing tickets for one (engine, repo, path), scoped by our own labels so+ close/refresh never touches unrelated issues. Scans VULNMGMT + legacy VULN."""++ def q(t: str) -> str:+ return '"' + t.replace("\\", "\\\\").replace('"', '\\"') + '"'++ jql = (+ f"project in ({', '.join(projects)}) AND statusCategory != Done "+ f"AND labels = {q(_REPORT_BASE_LABEL)} AND text ~ {q(engine_label)}"+ )+ if repo:+ jql += f" AND text ~ {q(repo)}"+ if path:+ jql += f" AND text ~ {q(path)}"+ return jql + " ORDER BY updated DESC"+++def report(args) -> int:+ """Standing-ticket reconciliation for the Trivy scanners (no PR involved).++ For each report group produced by ``trivy_scan.py``: if it has findings and no open+ ticket exists, create one and route it to AISIM; if one already exists, refresh it+ with the current counts and a link to the scan run; if the group is now clean+ (``findings_count == 0``) and a ticket is open, close it. Best-effort throughout."""+ data = json.loads(Path(args.report_groups).read_text())+ engine = data.get("engine", "container")+ groups = data.get("groups", [])+ engine_label = _REPORT_ENGINE_LABELS.get(engine, "security")+ repo_name = args.repo.split("/")[-1] if args.repo else ""++ client = jira_client.JiraClient.from_env()+ if client is None:+ print(" ! Jira creds not set; skipping report ticketing.")+ return 0+ project = os.environ.get("JIRA_VULN_PROJECT") or jira_client.CREATE_PROJECT+ if not client.project_exists(project):+ print(f" ! VULNMGMT project {project} not visible; skipping.")+ return 0++ issue_type = os.environ.get("JIRA_ISSUE_TYPE") or ""+ if not issue_type:+ avail = client.issue_types(project)+ for pref in ("Task", "Bug", "Vulnerability", "Security", "Story"):+ if pref in avail:+ issue_type = pref+ break+ else:+ issue_type = avail[0] if avail else "Task"+ aisim_label = os.environ.get("JIRA_AISIM_LABEL") or "aisim"++ created = refreshed = closed = 0+ for g in groups:+ directory = g.get("key", "")+ count = int(g.get("findings_count", 0))+ existing = client.search(+ _report_jql(+ _dedup_projects(client, project), engine_label, repo_name, directory+ )+ )+ if count > 0:+ if existing:+ key = existing[0].key+ client.add_comment(+ key,+ f"renovate-security — {engine_label} scan refresh\n\n"+ f"{count} finding(s) still present under {directory}: "+ f"{g.get('severity_line', '')}.\n\nScan run: {args.run_url}",+ )+ if args.run_url:+ client.add_remote_link(+ key, args.run_url, f"Latest scan: {directory}"+ )+ refreshed += 1+ print(f" jira {key}: refreshed ({directory})")+ continue+ summary = f"[{repo_name}] {g.get('title', 'security findings')}"+ desc = (+ f"Automated by renovate-security ({engine_label} scan).\n\n"+ f"{_strip_md(g.get('body', ''))}\n\nRepo: {repo_name}\nPath: "+ f"{directory}\nScan run: {args.run_url}"+ )+ issue = client.create(+ summary,+ desc,+ labels=[_REPORT_BASE_LABEL, repo_name, engine, aisim_label],+ project=project,+ issue_type=issue_type,+ epic_key=os.environ.get("JIRA_VULN_EPIC") or None,+ )+ if not issue:+ print(f" ! could not create ticket for {directory}")+ continue+ ref = issue.id or issue.key+ assigned, settled_key = _route_aisim(client, ref, issue.key)+ if settled_key and settled_key != issue.key:+ issue.key = settled_key+ issue.url = f"{client.base}/browse/{settled_key}"+ client.add_comment(+ ref,+ "renovate-security — VULNMGMT routing\n\n"+ + (+ "Business Unit set; routed to the owning team."+ if assigned+ else "Could not set the Business Unit field — route manually."+ ),+ )+ if args.run_url:+ client.add_remote_link(ref, args.run_url, f"Scan: {directory}")+ created += 1+ routed = "set" if assigned else "not set"+ print(f" jira {issue.key}: created ({directory}); BU {routed}")+ elif existing:+ for iss in existing:+ if client.close_issue(+ iss.key,+ comment=(+ f"Closed by renovate-security: no {engine_label} findings "+ f"remain under {directory} (scan run {args.run_url})."+ ),+ ):+ closed += 1+ print(f" jira {iss.key}: closed — {directory} now clean")+ print(f"report: {created} created, {refreshed} refreshed, {closed} closed.")+ return 0+++def _strip_md(body: str) -> str:+ """Flatten a markdown body to plain text for a Jira ADF description (tables render+ poorly in ADF paragraphs; keep the human-readable lines)."""+ keep = []+ for ln in body.splitlines():+ s = ln.strip()+ if not s or set(s) <= set("|-") or s.startswith("|--"):+ continue+ keep.append(s.replace("|", " ").replace("`", ""))+ return "\n".join(keep)+++def close_jira(keys_arg: str) -> int:+ client = jira_client.JiraClient.from_env()+ if client is None:+ raise SystemExit(+ "--close-jira needs SBT_MACHINE_USER_EMAIL / SBT_MACHINE_USER_JIRA_TOKEN"+ )+ keys = [k.strip() for k in keys_arg.split(",") if k.strip()]+ failed = 0+ for key in keys:+ ok = client.close_issue(+ key, comment="Closed by renovate-security (fix PR merged)."+ )+ print(f" jira close {key}: {'ok' if ok else 'FAILED'}")+ failed += 0 if ok else 1+ if failed:+ # Best-effort: a merge must never be blocked by Jira. The marker key is the+ # VULNMGMT key at creation; if the account can't reach the (moved) BU-project+ # issue it 404s here and the owning team closes it on triage. Exit 0.+ print(+ f"::warning::{failed} ticket(s) could not be auto-closed "+ "(likely moved to a BU project the CI account can't access); "+ "the owning team will close on triage."+ )+ return 0+++def main(argv: Optional[list[str]] = None) -> int:+ ap = argparse.ArgumentParser(description=__doc__)+ ap.add_argument(+ "--reconcile", action="store_true", help="create/link a ticket for a PR"+ )+ ap.add_argument(+ "--report",+ action="store_true",+ help="standing-ticket reconcile from a trivy_scan.py report-groups JSON",+ )+ ap.add_argument(+ "--report-groups", default="", help="path to the report-groups JSON (--report)"+ )+ ap.add_argument("--run-url", default="", help="scan run URL to link on tickets")+ ap.add_argument(+ "--close-jira", default="", help="ops: comma-separated keys -> Done"+ )+ ap.add_argument("--pr-url", default="")+ ap.add_argument("--pr-title", default="Security update")+ ap.add_argument("--branch", default="", help="PR head ref")+ ap.add_argument("--body-file", default="", help="path to the current PR body")+ ap.add_argument("--body-out", default="", help="write the updated PR body here")+ ap.add_argument("--files", default="", help="changed files (path to list, or CSV)")+ ap.add_argument("--repo", default="", help="owner/repo")+ ap.add_argument("--no-create", action="store_true", help="link only; never create")+ args = ap.parse_args(argv)++ if args.close_jira:+ return close_jira(args.close_jira)+ if args.report:+ if not args.report_groups:+ raise SystemExit("--report requires --report-groups")+ return report(args)+ if args.reconcile:+ if not args.pr_url:+ raise SystemExit("--reconcile requires --pr-url")+ return reconcile(args)+ ap.error("nothing to do: pass --reconcile, --report or --close-jira")+ return 2+++if __name__ == "__main__":+ sys.exit(main())diff --git a/.github/renovate-security/trivy_scan.py b/.github/renovate-security/trivy_scan.pynew file mode 100644index 000000000..691d41043--- /dev/null+++ b/.github/renovate-security/trivy_scan.py@@ -0,0 +1,601 @@+#!/usr/bin/env python3+"""Trivy-backed security scanner for the two ecosystems that have **no version-bump+CVE feed** Renovate/OSV can act on directly: **container base images** and **Terraform+misconfiguration**.++Why this exists (see ``README.md`` for the full rationale):++* **Container images** have no "tag -> CVE" feed — a container's vulnerabilities live+ in the OS packages and libraries *inside* the image, so the feed is delivered by+ *scanning the resolved image* against NVD + GHSA + the distro security trackers.+ Renovate stays the sole *updater* (it opens the digest/patch bump PRs); this scanner+ is the *detector*: it scans each Dockerfile's base image and reports fixable CVEs so+ they get a VULNMGMT ticket routed to AISIM, and it gates Renovate's container PRs.+* **Terraform misconfiguration** is a config-risk axis (open security groups,+ unencrypted buckets), not a dependency-version CVE — so it can't drive a version+ bump. ``trivy config`` finds these; we ticket the HIGH/CRITICAL ones.++This module only **detects, groups and reports**. It never edits files or opens bump+PRs (that would race Renovate). Ticketing is done by ``renovate_jira.py --report`` off+the report-group JSON this emits; the workflows also render a job summary from it.++Two modes, one CLI:+ * ``--mode image`` — discover base images from Dockerfiles, ``trivy image`` each.+ * ``--mode config`` — ``trivy config`` over the Terraform tree.++Stdlib-only. Every Trivy invocation is best-effort: a failure for one image/target+logs and yields no findings for it rather than aborting the scan.+"""++from __future__ import annotations++import argparse+import dataclasses+import hashlib+import json+import re+import subprocess # noqa: S404 - we invoke the trivy CLI with a fixed argv (no shell)+import sys+from pathlib import Path+from typing import Callable, Optional++# Container image refs we never scan: templated (resolved at build time, not a real+# image), the empty "scratch" base, and private registries that need auth (mirrors the+# renovate.json5 skip of the Artifact Registry images). Overridable via --skip-prefix.+_DEFAULT_SKIP_PREFIXES = ("us-central1-docker.pkg.dev/", ".pkg.dev/")+_TF_SUBDIR = "root/infra/terraform"++# Trivy severities we consider; anything below the --min-severity floor is dropped.+_SEV_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3, "unknown": 4}+_SEV_ICON = {+ "critical": "🔴",+ "high": "🟠",+ "medium": "🟡",+ "low": "⚪",+ "unknown": "❔",+}++SIGNATURE_MARKER = "renovate-trivy-signature"+ENGINE_IMAGE = "container"+ENGINE_CONFIG = "iac"+++# --------------------------------------------------------------------------- #+# Data model+# --------------------------------------------------------------------------- #+class Finding:+ directory: str # repo-relative dir (Dockerfile's parent, or the .tf's dir)+ target: str # image ref (image mode) or file path (config mode)+ vuln_id: str # CVE / GHSA / AVD id+ severity: str # critical | high | medium | low | unknown (lowercased)+ title: str+ pkg: str = "" # affected package (image) or resource/type (config)+ installed: str = "" # installed version (image only)+ fixed: str = "" # fixed version (image only)+ kind: str = ENGINE_IMAGE # image | iac++ def to_json(self) -> dict:+ return dataclasses.asdict(self)+++def severity_rank(sev: str) -> int:+ return _SEV_ORDER.get((sev or "").lower(), 4)+++def severity_badge(sev: str) -> str:+ s = (sev or "unknown").lower()+ return f"{_SEV_ICON.get(s, '❔')} {s.capitalize()}"+++def _engine_noun(engine: str) -> str:+ return "container image" if engine == ENGINE_IMAGE else "Terraform misconfiguration"+++# --------------------------------------------------------------------------- #+# Dockerfile discovery (image mode)+# --------------------------------------------------------------------------- #+_FROM_RE = re.compile(+ r"^\s*FROM\s+(?:--platform=\S+\s+)?(\S+)(?:\s+AS\s+(\S+))?\s*$",+ re.IGNORECASE,+)+++def _is_dockerfile(path: Path) -> bool:+ n = path.name.lower()+ return n == "dockerfile" or n.endswith(".dockerfile") or n.startswith("dockerfile.")+++def find_dockerfiles(repo_root: Path) -> list[Path]:+ return sorted(p for p in repo_root.rglob("*") if p.is_file() and _is_dockerfile(p))+++def is_scannable(ref: str, skip_prefixes: tuple[str, ...]) -> bool:+ """A base image ref we can meaningfully scan: a concrete public image, not a+ build-arg-templated ref, the ``scratch`` base, or a private/authed registry."""+ if not ref or "$" in ref: # ${BASE_IMAGE}, $VERSION, etc.+ return False+ if ref.lower() == "scratch":+ return False+ return not any(pre in ref for pre in skip_prefixes)+++def base_images(text: str, skip_prefixes: tuple[str, ...]) -> list[str]:+ """External base images referenced by a Dockerfile's ``FROM`` lines.++ Multi-stage aware: a ``FROM x AS build`` declares the stage alias ``build``; a later+ ``FROM build`` refers to that stage, not an external image, so it's excluded. The+ result is de-duplicated, order-preserving, and filtered by :func:`is_scannable`."""+ stages: set[str] = set()+ out: list[str] = []+ for line in text.splitlines():+ m = _FROM_RE.match(line)+ if not m:+ continue+ ref, alias = m.group(1), m.group(2)+ if ref not in stages and is_scannable(ref, skip_prefixes) and ref not in out:+ out.append(ref)+ if alias:+ stages.add(alias)+ return out+++def images_by_dir(+ repo_root: Path,+ skip_prefixes: tuple[str, ...] = _DEFAULT_SKIP_PREFIXES,+ only_dirs: Optional[set[str]] = None,+) -> dict[str, list[str]]:+ """Map ``dir -> [base image refs]`` across every Dockerfile. ``dir`` is the+ Dockerfile's parent (repo-relative), matching Renovate's ``packageFileDir`` grouping+ and the tf-provider tool's per-directory PRs. ``only_dirs`` limits discovery to the+ given dirs (used by the PR gate to scan just what changed)."""+ out: dict[str, list[str]] = {}+ for df in find_dockerfiles(repo_root):+ rel_dir = str(df.parent.relative_to(repo_root))+ if only_dirs is not None and rel_dir not in only_dirs:+ continue+ refs = base_images(df.read_text(errors="replace"), skip_prefixes)+ if not refs:+ continue+ merged = dict.fromkeys(out.get(rel_dir, []))+ for r in refs:+ merged[r] = None+ out[rel_dir] = list(merged)+ return out+++# --------------------------------------------------------------------------- #+# Trivy boundary+# --------------------------------------------------------------------------- #+TrivyRunner = Callable[[list[str]], Optional[str]]+++def _run_trivy(argv: list[str]) -> Optional[str]:+ """Invoke the trivy CLI with a fixed argv (no shell) and return stdout, or None on+ failure. Trivy exits non-zero when it finds vulns with --exit-code set; we never set+ it here (detection is non-blocking), so a non-zero code is a real error."""+ try:+ proc = subprocess.run( # noqa: S603 - fixed argv, no shell, trusted binary+ argv,+ capture_output=True,+ text=True,+ timeout=600,+ )+ except (OSError, subprocess.SubprocessError) as e:+ print(f" ! trivy {' '.join(argv[1:3])} failed to run: {e}")+ return None+ if proc.returncode != 0:+ print(f" ! trivy exited {proc.returncode}: {proc.stderr.strip()[:400]}")+ return None+ return proc.stdout+++def _min_sev_csv(min_severity: str) -> str:+ floor = severity_rank(min_severity)+ keep = [s.upper() for s, r in _SEV_ORDER.items() if r <= floor and s != "unknown"]+ return ",".join(keep)+++# --------------------------------------------------------------------------- #+# Trivy JSON -> Findings+# --------------------------------------------------------------------------- #+def parse_image_results(text: str, directory: str, ref: str) -> list[Finding]:+ """Parse ``trivy image --format json`` output into fixable-vuln findings for one+ image. Only vulnerabilities with a FixedVersion are kept (Trivy is run with+ --ignore-unfixed, but we also guard here so offline fixtures behave the same)."""+ try:+ data = json.loads(text or "{}")+ except json.JSONDecodeError as e:+ print(f" ! trivy image json parse failed for {ref}: {e}")+ return []+ out: list[Finding] = []+ for res in data.get("Results") or []:+ for v in res.get("Vulnerabilities") or []:+ fixed = v.get("FixedVersion") or ""+ if not fixed:+ continue+ out.append(+ Finding(+ directory=directory,+ target=ref,+ vuln_id=v.get("VulnerabilityID") or "",+ severity=(v.get("Severity") or "unknown").lower(),+ title=(v.get("Title") or v.get("Description") or "").strip()[:200],+ pkg=v.get("PkgName") or "",+ installed=v.get("InstalledVersion") or "",+ fixed=fixed,+ kind=ENGINE_IMAGE,+ )+ )+ return out+++def parse_config_results(text: str, repo_root: Path) -> list[Finding]:+ """Parse ``trivy config --format json`` output into misconfiguration findings.+ Only failed checks (Status == FAIL) are kept; the directory is the target file's+ parent, relative to the repo root when possible."""+ try:+ data = json.loads(text or "{}")+ except json.JSONDecodeError as e:+ print(f" ! trivy config json parse failed: {e}")+ return []+ out: list[Finding] = []+ for res in data.get("Results") or []:+ target = res.get("Target") or ""+ directory = _rel_dir(target, repo_root)+ for mc in res.get("Misconfigurations") or []:+ if (mc.get("Status") or "").upper() not in ("", "FAIL"):+ continue+ out.append(+ Finding(+ directory=directory,+ target=target,+ vuln_id=mc.get("ID") or mc.get("AVDID") or "",+ severity=(mc.get("Severity") or "unknown").lower(),+ title=(mc.get("Title") or mc.get("Message") or "").strip()[:200],+ pkg=(mc.get("Type") or ""),+ kind=ENGINE_CONFIG,+ )+ )+ return out+++def _rel_dir(target: str, repo_root: Path) -> str:+ """Directory of a trivy target path, made repo-relative when it sits under the+ repo (trivy config emits repo-relative or absolute paths depending on how it's+ invoked)."""+ if not target:+ return ""+ p = Path(target)+ if p.is_absolute():+ try:+ p = p.relative_to(repo_root)+ except ValueError:+ pass+ d = str(p.parent)+ return "" if d == "." else d+++# --------------------------------------------------------------------------- #+# Scan orchestration+# --------------------------------------------------------------------------- #+def scan_images(+ imgs_by_dir: dict[str, list[str]],+ min_severity: str = "high",+ trivy_bin: str = "trivy",+ runner: TrivyRunner = _run_trivy,+) -> list[Finding]:+ """Scan each unique base image once (cached across dirs) and attribute its findings+ to every directory that uses it."""+ sev = _min_sev_csv(min_severity)+ cache: dict[str, list[Finding]] = {}+ out: list[Finding] = []+ for directory in sorted(imgs_by_dir):+ for ref in imgs_by_dir[directory]:+ if ref not in cache:+ argv = [+ trivy_bin, "image",+ "--quiet", "--format", "json",+ "--scanners", "vuln",+ "--ignore-unfixed",+ "--severity", sev,+ ref,+ ] # fmt: skip+ raw = runner(argv)+ cache[ref] = parse_image_results(raw or "{}", directory, ref)+ for f in cache[ref]:+ out.append(dataclasses.replace(f, directory=directory))+ return out+++def scan_config(+ repo_root: Path,+ tf_subdir: str = _TF_SUBDIR,+ min_severity: str = "high",+ trivy_bin: str = "trivy",+ runner: TrivyRunner = _run_trivy,+ only_dirs: Optional[set[str]] = None,+) -> list[Finding]:+ target = repo_root / tf_subdir+ if not target.exists():+ target = repo_root+ argv = [+ trivy_bin, "config",+ "--quiet", "--format", "json",+ "--severity", _min_sev_csv(min_severity),+ str(target),+ ] # fmt: skip+ raw = runner(argv)+ findings = parse_config_results(raw or "{}", repo_root)+ if only_dirs is not None:+ findings = [f for f in findings if f.directory in only_dirs]+ return findings+++# --------------------------------------------------------------------------- #+# Grouping + report rendering+# --------------------------------------------------------------------------- #+def group_by_dir(findings: list[Finding]) -> dict[str, list[Finding]]:+ out: dict[str, list[Finding]] = {}+ for f in findings:+ out.setdefault(f.directory, []).append(f)+ return out+++def _counts(findings: list[Finding]) -> dict[str, int]:+ c: dict[str, int] = {}+ for f in findings:+ c[f.severity] = c.get(f.severity, 0) + 1+ return c+++def _counts_line(counts: dict[str, int]) -> str:+ parts = [+ f"{severity_badge(s)}: {counts[s]}"+ for s in ("critical", "high", "medium", "low", "unknown")+ if counts.get(s)+ ]+ return " · ".join(parts) or "none"+++def _signature(findings: list[Finding]) -> str:+ basis = "\n".join(sorted(f"{f.target}|{f.vuln_id}|{f.fixed}" for f in findings))+ return hashlib.sha256(basis.encode()).hexdigest()[:16]+++def _image_rows(findings: list[Finding]) -> str:+ rows = []+ for f in sorted(+ findings, key=lambda x: (severity_rank(x.severity), x.target, x.vuln_id)+ ):+ cve = (+ f"[{f.vuln_id}](https://nvd.nist.gov/vuln/detail/{f.vuln_id})"+ if f.vuln_id.upper().startswith("CVE-")+ else f.vuln_id or "—"+ )+ rows.append(+ f"| {severity_badge(f.severity)} | {cve} | `{f.target}` | "+ f"`{f.pkg}` | {f.installed} → {f.fixed} |"+ )+ return "\n".join(rows)+++def _config_rows(findings: list[Finding]) -> str:+ rows = []+ for f in sorted(+ findings, key=lambda x: (severity_rank(x.severity), x.target, x.vuln_id)+ ):+ aid = (+ f"[{f.vuln_id}](https://avd.aquasec.com/misconfig/{f.vuln_id.lower()})"+ if f.vuln_id.upper().startswith("AVD-")+ else f.vuln_id or "—"+ )+ rows.append(+ f"| {severity_badge(f.severity)} | {aid} | {f.title} | `{f.target}` |"+ )+ return "\n".join(rows)+++def _render_body(directory: str, findings: list[Finding], engine: str) -> str:+ counts = _counts(findings)+ n = len(findings)+ if engine == ENGINE_IMAGE:+ head = (+ f"**{n}** fixable container-image vulnerabilit{'y' if n == 1 else 'ies'} "+ f"in the base image(s) used by `{directory}`."+ )+ table = (+ "| Severity | CVE | Image | Package | Installed → Fixed |\n"+ "|----------|-----|-------|---------|-------------------|\n"+ + _image_rows(findings)+ )+ note = (+ "Fixes land via Renovate's digest/patch bump PRs for these images; a CVE "+ "needing a minor/major base-image change requires a manual bump."+ )+ else:+ head = (+ f"**{n}** Terraform misconfiguration{'s' if n != 1 else ''} "+ f"(HIGH/CRITICAL) under `{directory}`."+ )+ table = (+ "| Severity | Check | Title | File |\n"+ "|----------|-------|-------|------|\n" + _config_rows(findings)+ )+ note = "These are configuration-level risks and require a manual code change."+ return (+ f"## What\n\n{head}\n\nSeverity breakdown: {_counts_line(counts)}\n\n"+ f"## Findings\n\n{table}\n\n<sub>Detected by Trivy "+ f"({'image' if engine == ENGINE_IMAGE else 'config'} scanner). {note}</sub>\n"+ )+++def build_report_groups(+ findings: list[Finding], engine: str, scanned_dirs: Optional[list[str]] = None+) -> list[dict]:+ """One report group per directory, for the ticket layer + job summary. When+ ``scanned_dirs`` is given, dirs that were scanned but produced no findings are+ emitted with ``findings_count: 0`` so ``renovate_jira.py --report`` can CLOSE a+ now-clean standing ticket."""+ by_dir = group_by_dir(findings)+ groups: list[dict] = []+ dirs = sorted(set(by_dir) | set(scanned_dirs or []))+ for directory in dirs:+ fs = by_dir.get(directory, [])+ counts = _counts(fs)+ groups.append(+ {+ "key": directory,+ "engine": engine,+ "signature": _signature(fs),+ "findings_count": len(fs),+ "severity_counts": counts,+ "severity_line": _counts_line(counts),+ "title": (+ f"{_engine_noun(engine)} security findings "+ f"under {directory or '(repo)'}"+ ),+ "body": _render_body(directory, fs, engine) if fs else "",+ "findings": [f.to_json() for f in fs],+ }+ )+ return groups+++def render_summary(groups: list[dict], engine: str) -> str:+ """A compact GitHub-Actions job-summary (markdown) for the scan."""+ label = (+ "Container image" if engine == ENGINE_IMAGE else "Terraform misconfiguration"+ )+ with_findings = [g for g in groups if g["findings_count"]]+ total = sum(g["findings_count"] for g in groups)+ if not with_findings:+ return f"### {label} scan\n\n✅ No findings at or above the severity floor.\n"+ lines = [+ f"### {label} scan\n",+ f"**{total}** finding(s) across **{len(with_findings)}** director"+ f"{'y' if len(with_findings) == 1 else 'ies'}.\n",+ "| Directory | Findings | Severity |",+ "|-----------|----------|----------|",+ ]+ for g in sorted(with_findings, key=lambda x: -x["findings_count"]):+ lines.append(f"| `{g['key']}` | {g['findings_count']} | {g['severity_line']} |")+ return "\n".join(lines) + "\n"+++# --------------------------------------------------------------------------- #+# Main+# --------------------------------------------------------------------------- #+def find_repo_root(start: Path) -> Path:+ for p in [start, *start.parents]:+ if (p / ".git").exists() or (p / "root" / "conda-lock.yml").exists():+ return p+ raise SystemExit("could not locate repo root (no .git above cwd)")+++def _load_findings_json(path: str) -> list[Finding]:+ raw = json.loads(Path(path).read_text())+ return [+ Finding(+ directory=d.get("directory", ""),+ target=d.get("target", ""),+ vuln_id=d.get("vuln_id", ""),+ severity=d.get("severity", "unknown"),+ title=d.get("title", ""),+ pkg=d.get("pkg", ""),+ installed=d.get("installed", ""),+ fixed=d.get("fixed", ""),+ kind=d.get("kind", ENGINE_IMAGE),+ )+ for d in raw+ ]+++def main(argv: Optional[list[str]] = None) -> int:+ ap = argparse.ArgumentParser(description=__doc__)+ ap.add_argument("--mode", choices=["image", "config"], required=True)+ ap.add_argument("--repo-root", type=Path, default=None)+ ap.add_argument(+ "--min-severity",+ default="high",+ choices=["critical", "high", "medium", "low"],+ help="lowest severity to report (default high)",+ )+ ap.add_argument("--trivy-bin", default="trivy")+ ap.add_argument("--tf-subdir", default=_TF_SUBDIR)+ ap.add_argument(+ "--paths",+ default="",+ help="comma-separated dirs to limit the scan to (PR gate); default all",+ )+ ap.add_argument(+ "--skip-prefix",+ action="append",+ default=[],+ help="extra image-ref substring to skip (repeatable)",+ )+ ap.add_argument("--report-output", default="", help="write report-group JSON here")+ ap.add_argument("--summary-output", default="", help="write a job-summary md here")+ ap.add_argument(+ "--findings-json",+ default="",+ help="offline: build report groups from a precomputed findings list",+ )+ ap.add_argument(+ "--trivy-json",+ default="",+ help="offline (config mode): parse a captured trivy JSON instead of running it",+ )+ args = ap.parse_args(argv)++ repo_root = (args.repo_root or find_repo_root(Path.cwd())).resolve()+ engine = ENGINE_IMAGE if args.mode == "image" else ENGINE_CONFIG+ only = (+ {p.strip() for p in args.paths.split(",") if p.strip()} if args.paths else None+ )+ skip_prefixes = _DEFAULT_SKIP_PREFIXES + tuple(args.skip_prefix)++ scanned_dirs: list[str] = []+ if args.findings_json:+ findings = _load_findings_json(args.findings_json)+ scanned_dirs = sorted({f.directory for f in findings})+ elif args.mode == "image":+ imgs = images_by_dir(repo_root, skip_prefixes, only_dirs=only)+ scanned_dirs = sorted(imgs)+ findings = scan_images(imgs, args.min_severity, args.trivy_bin)+ else: # config+ if args.trivy_json:+ findings = parse_config_results(+ Path(args.trivy_json).read_text(), repo_root+ )+ if only is not None:+ findings = [f for f in findings if f.directory in only]+ else:+ findings = scan_config(+ repo_root,+ args.tf_subdir,+ args.min_severity,+ args.trivy_bin,+ only_dirs=only,+ )+ scanned_dirs = sorted({f.directory for f in findings})++ groups = build_report_groups(findings, engine, scanned_dirs=scanned_dirs)+ n = sum(g["findings_count"] for g in groups)+ print(f"trivy {args.mode} scan: {n} finding(s) across {len(scanned_dirs)} dir(s).")+ for g in groups:+ if g["findings_count"]:+ print(f" {g['key']}: {g['findings_count']} [{g['severity_line']}]")++ if args.report_output:+ Path(args.report_output).write_text(+ json.dumps({"engine": engine, "groups": groups}, indent=2)+ )+ print(f"wrote report groups -> {args.report_output}")+ if args.summary_output:+ Path(args.summary_output).write_text(render_summary(groups, engine))+ return 0+++if __name__ == "__main__":+ sys.exit(main())diff --git a/.github/workflows/container_security.yml b/.github/workflows/container_security.ymlnew file mode 100644index 000000000..38f482ab7--- /dev/null+++ b/.github/workflows/container_security.yml@@ -0,0 +1,153 @@+name: Container image security (Trivy)+# Container base images have NO "tag -> CVE" feed — a container's vulnerabilities live+# in the OS packages/libraries inside it, so the feed is delivered by SCANNING the+# resolved image (Trivy: NVD + GHSA + distro trackers). Renovate stays the sole updater+# (it opens the digest/patch bump PRs); this workflow is the detector + gate:+# * scheduled/dispatch: scan every Dockerfile's base image -> open/refresh/close a+# standing VULNMGMT ticket per project dir (routed to AISIM). No PRs.+# * pull_request (renovate/* container PRs): scan the bumped base image(s) and report+# remaining fixable CVEs as a non-blocking PR comment + job summary.+# See .github/renovate-security/README.md. Never gates merge (report-only).+on:+ schedule:+ - cron: "43 6 * * 2" # Tuesdays 06:43 UTC (off the top of the hour on purpose)+ workflow_dispatch:+ inputs:+ min_severity:+ description: "Lowest severity to report (critical|high|medium|low)"+ default: "high"+ required: false+ dry_run:+ description: "Scan + summary only; open/refresh no tickets"+ type: boolean+ default: false+ required: false+ pull_request:+ types: [opened, synchronize, reopened]+ paths:+ - "**/Dockerfile"+ - "**/*.dockerfile"+ - "**/Dockerfile.*"++permissions:+ contents: read+ pull-requests: write+ issues: write++jobs:+ scan-all:+ # Scheduled / manual full sweep -> standing VULNMGMT tickets.+ if: ${{ github.event_name != 'pull_request' }}+ runs-on: ubuntu-latest+ timeout-minutes: 90+ steps:+ - name: Checkout repo+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6++ - name: Setup Python+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0+ with:+ python-version: "3.12"++ - name: Install Trivy+ uses: aquasecurity/setup-trivy@81e514348e19b6112ce2a7e3ecbafe19c1e1f567 # v0.3.1+ with:+ version: v0.72.0 # pinned past the poisoned v0.69.4/.5/.6 supply-chain builds++ - name: Scan base images+ id: scan+ shell: bash -eo pipefail {0}+ env:+ IN_MIN_SEV: ${{ github.event.inputs.min_severity }}+ run: |+ python .github/renovate-security/trivy_scan.py --mode image \+ --min-severity "${IN_MIN_SEV:-high}" \+ --report-output /tmp/container-groups.json \+ --summary-output /tmp/container-summary.md+ cat /tmp/container-summary.md >> "$GITHUB_STEP_SUMMARY" || true++ - name: Open / refresh / close VULNMGMT tickets+ if: ${{ github.event.inputs.dry_run != 'true' }}+ shell: bash -eo pipefail {0}+ env:+ REPO: ${{ github.repository }}+ RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}+ SBT_MACHINE_USER_EMAIL: ${{ secrets.SBT_MACHINE_USER_EMAIL }}+ SBT_MACHINE_USER_JIRA_TOKEN: ${{ secrets.SBT_MACHINE_USER_JIRA_TOKEN }}+ JIRA_BASE_URL: ${{ vars.JIRA_BASE_URL }}+ JIRA_VULN_PROJECT: ${{ vars.JIRA_VULN_PROJECT }}+ JIRA_VULN_EPIC: ${{ vars.JIRA_VULN_EPIC }}+ JIRA_AISIM_ACCOUNT_ID: ${{ vars.JIRA_AISIM_ACCOUNT_ID }}+ JIRA_AISIM_USER: ${{ vars.JIRA_AISIM_USER }}+ JIRA_AISIM_LABEL: "cg-aqtiveguard"+ JIRA_AISIM_FIELD_ID: ${{ vars.JIRA_AISIM_FIELD_ID }}+ JIRA_AISIM_FIELD_VALUE: "CG - AqtiveGuard" # baked BU (org has no repo vars)+ run: |+ if [ -z "${SBT_MACHINE_USER_JIRA_TOKEN:-}" ]; then+ echo "::warning::Jira creds not set; skipping ticketing."+ exit 0+ fi+ python .github/renovate-security/renovate_jira.py --report \+ --report-groups /tmp/container-groups.json \+ --repo "${REPO}" --run-url "${RUN_URL}"++ gate:+ # Non-blocking scan of the base image(s) a renovate/* PR bumps to.+ if: >-+ github.event_name == 'pull_request' &&+ startsWith(github.event.pull_request.head.ref, 'renovate/')+ runs-on: ubuntu-latest+ timeout-minutes: 30+ steps:+ - name: Checkout PR head+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6+ with:+ ref: ${{ github.event.pull_request.head.sha }}++ - name: Setup Python+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0+ with:+ python-version: "3.12"++ - name: Install Trivy+ uses: aquasecurity/setup-trivy@81e514348e19b6112ce2a7e3ecbafe19c1e1f567 # v0.3.1+ with:+ version: v0.72.0++ - name: Scan changed images + comment+ shell: bash -eo pipefail {0}+ env:+ GH_TOKEN: ${{ github.token }}+ PR_NUMBER: ${{ github.event.pull_request.number }}+ run: |+ # Directories of the Dockerfiles this PR changed.+ dirs=""+ while IFS= read -r f; do+ b="$(basename "$f")"; lb="${b,,}"+ case "$lb" in+ dockerfile|*.dockerfile|dockerfile.*) dirs="${dirs}$(dirname "$f")"$'\n';;+ esac+ done < <(gh pr diff "${PR_NUMBER}" --name-only || true)+ dirs="$(printf '%s' "$dirs" | grep -v '^$' | sort -u | paste -sd, - || true)"+ if [ -z "$dirs" ]; then+ echo "No changed Dockerfiles; nothing to scan."+ exit 0+ fi+ echo "Scanning dirs: $dirs"+ python .github/renovate-security/trivy_scan.py --mode image \+ --paths "$dirs" --min-severity high \+ --report-output /tmp/gate-groups.json \+ --summary-output /tmp/gate-summary.md+ cat /tmp/gate-summary.md >> "$GITHUB_STEP_SUMMARY" || true+ n="$(python -c 'import json,sys;print(sum(g["findings_count"] for g in json.load(open("/tmp/gate-groups.json"))["groups"]))' 2>/dev/null || echo 0)"+ if [ "${n:-0}" != "0" ]; then+ {+ echo "🔎 **Trivy container scan** found ${n} fixable HIGH/CRITICAL CVE(s) still present in the bumped base image(s). This is informational and does **not** block merge.";+ echo;+ cat /tmp/gate-summary.md;+ } > /tmp/gate-comment.md+ gh pr comment "${PR_NUMBER}" --body-file /tmp/gate-comment.md \+ || echo "::warning::could not post gate comment"+ else+ echo "No remaining fixable HIGH/CRITICAL CVEs in the bumped image(s)."+ fidiff --git a/.github/workflows/renovate.yml b/.github/workflows/renovate.ymlnew file mode 100644index 000000000..3f8d5f41c--- /dev/null+++ b/.github/workflows/renovate.yml@@ -0,0 +1,75 @@+name: Renovate+# Self-hosted Renovate for the ecosystems Socket does NOT cover (containers, GitHub+# Actions, CircleCI orbs). Policy lives in renovate.json5 at the repo root; see+# root/scripts/renovate-security/README.md for the rationale (security-focused,+# minimally invasive, minimumReleaseAge guard, one PR per project+ecosystem).+#+# Terraform PROVIDER security is a separate job (tf_provider_security.yml). VULNMGMT+# ticketing for the PRs this opens is handled by renovate_jira.yml (pull_request).+#+# Not a required check; never gates merge.+on:+ schedule:+ - cron: "37 5 * * 1" # Mondays 05:37 UTC (off the top of the hour on purpose)+ workflow_dispatch:+ inputs:+ dry_run:+ description: "Dry run: compute updates but open no PRs"+ type: boolean+ default: false+ required: false+ log_level:+ description: "Renovate log level (info|debug)"+ default: "info"+ required: false++permissions:+ contents: write+ pull-requests: write+ issues: write++jobs:+ renovate:+ runs-on: ubuntu-latest+ timeout-minutes: 60+ env:+ # Gate the App-token step without referencing a missing secret in an `if:`.+ BOT_CLIENT_ID: ${{ secrets.AUTOFIX_PR_BOT_CLIENT_ID }}+ steps:+ - name: Checkout repo+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6++ - name: Generate PR-bot App token+ # Preferred over GITHUB_TOKEN: a PR opened with GITHUB_TOKEN does NOT trigger+ # CircleCI (we want the project's real build to validate the fix) and would not+ # trigger renovate_jira.yml either. Falls back to GITHUB_TOKEN if unset.+ id: apptoken+ if: ${{ env.BOT_CLIENT_ID != '' }}+ uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1+ with:+ client-id: ${{ secrets.AUTOFIX_PR_BOT_CLIENT_ID }}+ private-key: ${{ secrets.AUTOFIX_PR_BOT_APP_PRIVATE_KEY }}++ - name: Resolve dry-run flag+ id: cfg+ shell: bash -eo pipefail {0}+ env:+ IN_DRY_RUN: ${{ github.event.inputs.dry_run }}+ run: |+ dry=""+ [ "${IN_DRY_RUN:-}" = "true" ] && dry="full"+ echo "dry=${dry}" >> "$GITHUB_OUTPUT"++ - name: Run Renovate+ uses: renovatebot/github-action@3064367f740a1a91cca218698a63902689cce200 # v46.1.20+ with:+ configurationFile: renovate.json5+ token: ${{ steps.apptoken.outputs.token || github.token }}+ env:+ # Only this repo; config is the in-repo renovate.json5.+ RENOVATE_REPOSITORIES: ${{ github.repository }}+ RENOVATE_DRY_RUN: ${{ steps.cfg.outputs.dry }}+ # Actions/OSV vulnerability data (Actions are in the GitHub advisory DB).+ LOG_LEVEL: ${{ github.event.inputs.log_level || 'info' }}+ # Let Renovate resolve CODEOWNERS reviewers and read Dependabot alerts.+ RENOVATE_GITHUB_TOKEN: ${{ steps.apptoken.outputs.token || github.token }}diff --git a/.github/workflows/renovate_jira.yml b/.github/workflows/renovate_jira.ymlnew file mode 100644index 000000000..973bc06c6--- /dev/null+++ b/.github/workflows/renovate_jira.yml@@ -0,0 +1,113 @@+name: Renovate - VULNMGMT tickets+# VULNMGMT/Jira ticketing for the security PRs opened by Renovate and by+# tf_provider_security.yml. On open: search/link or create a ticket, route it to AISIM+# (Business Unit field), link the PR, and stamp the body with a+# `<!-- renovate-jira-close: KEY -->` marker. On merge: transition the created+# ticket(s) to Done. Covers both engines via the shared `renovate/` branch prefix.+#+# App-token PRs (from the two workflows above) DO trigger pull_request events, so this+# runs automatically. Uses only the stdlib Jira client.+on:+ pull_request:+ types: [opened, reopened, closed]++permissions:+ contents: read+ pull-requests: write++jobs:+ create-ticket:+ # Freshly-opened renovate/* PRs (not merges).+ if: >-+ github.event.action != 'closed' &&+ startsWith(github.event.pull_request.head.ref, 'renovate/')+ runs-on: ubuntu-latest+ steps:+ - name: Checkout base (for the tool)+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6+ with:+ ref: ${{ github.event.pull_request.base.ref }}++ - name: Setup Python+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0+ with:+ python-version: "3.12"++ - name: Create / link VULNMGMT ticket+ env:+ GH_TOKEN: ${{ github.token }}+ PR_NUMBER: ${{ github.event.pull_request.number }}+ PR_URL: ${{ github.event.pull_request.html_url }}+ PR_TITLE: ${{ github.event.pull_request.title }}+ PR_HEAD_REF: ${{ github.event.pull_request.head.ref }}+ # Untrusted PR body -> via env, written to a file, never interpolated.+ PR_BODY: ${{ github.event.pull_request.body }}+ REPO: ${{ github.repository }}+ SBT_MACHINE_USER_EMAIL: ${{ secrets.SBT_MACHINE_USER_EMAIL }}+ SBT_MACHINE_USER_JIRA_TOKEN: ${{ secrets.SBT_MACHINE_USER_JIRA_TOKEN }}+ JIRA_BASE_URL: ${{ vars.JIRA_BASE_URL }}+ JIRA_VULN_PROJECT: ${{ vars.JIRA_VULN_PROJECT }}+ JIRA_VULN_EPIC: ${{ vars.JIRA_VULN_EPIC }}+ JIRA_AISIM_ACCOUNT_ID: ${{ vars.JIRA_AISIM_ACCOUNT_ID }}+ JIRA_AISIM_USER: ${{ vars.JIRA_AISIM_USER }}+ JIRA_AISIM_LABEL: "cg-aqtiveguard"+ JIRA_AISIM_FIELD_ID: ${{ vars.JIRA_AISIM_FIELD_ID }}+ JIRA_AISIM_FIELD_VALUE: "CG - AqtiveGuard" # baked BU (org has no repo vars)+ run: |+ set -euo pipefail+ if [ -z "${SBT_MACHINE_USER_JIRA_TOKEN:-}" ]; then+ echo "::warning::Jira creds not set; skipping ticket creation for PR #${PR_NUMBER}."+ exit 0+ fi+ printf '%s' "${PR_BODY:-}" > /tmp/pr-body.md+ gh pr diff "${PR_NUMBER}" --name-only > /tmp/pr-files.txt || true+ python .github/renovate-security/renovate_jira.py --reconcile \+ --pr-url "${PR_URL}" --pr-title "${PR_TITLE}" --branch "${PR_HEAD_REF}" \+ --body-file /tmp/pr-body.md --body-out /tmp/pr-body.new \+ --files /tmp/pr-files.txt --repo "${REPO}"+ # Only edit the PR if the tool actually rewrote the body (added a marker).+ if [ -f /tmp/pr-body.new ] && ! cmp -s /tmp/pr-body.md /tmp/pr-body.new; then+ gh pr edit "${PR_NUMBER}" --body-file /tmp/pr-body.new \+ || echo "::warning::could not update PR body for #${PR_NUMBER}"+ fi++ close-ticket:+ # Merged renovate/* PRs -> close the ticket the automation created.+ if: >-+ github.event.action == 'closed' &&+ github.event.pull_request.merged == true &&+ startsWith(github.event.pull_request.head.ref, 'renovate/')+ runs-on: ubuntu-latest+ steps:+ - name: Checkout base (for the tool)+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6+ with:+ ref: ${{ github.event.pull_request.base.ref }}++ - name: Setup Python+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0+ with:+ python-version: "3.12"++ - name: Close linked VULNMGMT ticket(s)+ env:+ PR_BODY: ${{ github.event.pull_request.body }}+ PR_NUMBER: ${{ github.event.pull_request.number }}+ SBT_MACHINE_USER_EMAIL: ${{ secrets.SBT_MACHINE_USER_EMAIL }}+ SBT_MACHINE_USER_JIRA_TOKEN: ${{ secrets.SBT_MACHINE_USER_JIRA_TOKEN }}+ JIRA_BASE_URL: ${{ vars.JIRA_BASE_URL }}+ run: |+ set -euo pipefail+ keys="$(printf '%s' "${PR_BODY:-}" \+ | grep -oE 'renovate-jira-close: [A-Z0-9,-]+' \+ | head -1 | sed 's/renovate-jira-close: //' || true)"+ if [ -z "${keys:-}" ]; then+ echo "No renovate-jira-close marker in PR #${PR_NUMBER}; nothing to close."+ exit 0+ fi+ if [ -z "${SBT_MACHINE_USER_JIRA_TOKEN:-}" ]; then+ echo "::warning::Jira creds not set; cannot close ${keys}"+ exit 0+ fi+ echo "Closing Jira ticket(s) for merged PR #${PR_NUMBER}: ${keys}"+ python .github/renovate-security/renovate_jira.py --close-jira "${keys}"diff --git a/.github/workflows/socket_cve_fix.yml b/.github/workflows/socket_cve_fix.ymlnew file mode 100644index 000000000..99de82e8a--- /dev/null+++ b/.github/workflows/socket_cve_fix.yml@@ -0,0 +1,75 @@+name: Socket Fix+# Socket CVE autofix for this repo's LANGUAGE ecosystems (npm, py). Socket-first:+# Socket owns language packages; Renovate (renovate.json5) covers only infra+# (Actions/Docker/CircleCI/Terraform) and Trivy covers image/IaC CVEs.+on:+ schedule:+ - cron: '15 2 1 * *' # Runs at 02:15 on day 1 of the month+ - cron: '15 12 * * 0' # Runs at 12:15 on Sunday+ workflow_dispatch: #Allow manual run+permissions:+ contents: write+ pull-requests: write+ issues: write+jobs:+ socket-fix:+ runs-on: ubuntu-latest++ steps:+ - name: Checkout repo+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6+ with:+ fetch-depth: ${{ github.event_name == 'pull_request' && 2 || 0 }}++ - name: Setup Python+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0+ with:+ python-version: '3.12'++ - name: Install uv+ uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0++ - name: Setup Node+ uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0+ with:+ node-version: '20'++ - name: Install npm socket CLI+ run: npm i -g socket++ - name: Install pnpm+ run: npm i -g pnpm++ - name: Install Socket CLI+ run: pip install socketsecurity --upgrade++ - name: Generate github App Token #Generate short-lived Installation Access Token+ id: generate-token+ uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1+ with:+ client-id: ${{ secrets.AUTOFIX_PR_BOT_CLIENT_ID }}+ private-key: ${{ secrets.AUTOFIX_PR_BOT_APP_PRIVATE_KEY }}++ - name: Run Socket Fix CLI monthly for major fixes+ env:+ SOCKET_CLI_GITHUB_TOKEN: ${{ steps.generate-token.outputs.token }}+ SOCKET_CLI_GIT_USER_EMAIL: socket-fix[bot]@users.noreply.github.com+ SOCKET_CLI_GIT_USER_NAME: socket-fix[bot]+ SOCKET_CLI_API_TOKEN: ${{ secrets.SOCKET_KEY }}+ SOCKET_SECURITY_API_KEY: ${{ secrets.SOCKET_KEY }}+ GH_API_TOKEN: ${{ steps.generate-token.outputs.token }}+ CI: true+ if: github.event.schedule == '15 2 1 * *' || github.event_name == 'workflow_dispatch'+ run: socket fix --minimum-release-age 2w --all++ - name: Run Socket Fix CLI weekly for minor fixes+ env:+ SOCKET_CLI_GITHUB_TOKEN: ${{ steps.generate-token.outputs.token }}+ SOCKET_CLI_GIT_USER_EMAIL: socket-fix[bot]@users.noreply.github.com+ SOCKET_CLI_GIT_USER_NAME: socket-fix[bot]+ SOCKET_CLI_API_TOKEN: ${{ secrets.SOCKET_KEY }}+ SOCKET_SECURITY_API_KEY: ${{ secrets.SOCKET_KEY }}+ GH_API_TOKEN: ${{ steps.generate-token.outputs.token }}+ CI: true+ if: github.event.schedule == '15 12 * * 0'+ run: socket fix --minimum-release-age 3d --all --no-major-updatesdiff --git a/renovate.json5 b/renovate.json5new file mode 100644index 000000000..a59bb04eb--- /dev/null+++ b/renovate.json5@@ -0,0 +1,48 @@+{+ // Security-focused, minimally invasive Renovate for switch. COMPLEMENTARY to+ // Socket (language packages); Renovate owns only the infra ecosystems below.+ "$schema": "https://docs.renovatebot.com/renovate-schema.json",+ "extends": ["config:recommended", ":dependencyDashboard"],+ "onboarding": false,+ "enabledManagers": ["dockerfile", "docker-compose", "github-actions"],+ "minimumReleaseAge": "7 days",+ "internalChecksFilter": "strict",+ "reviewersFromCodeOwners": true,+ "osvVulnerabilityAlerts": true,+ "vulnerabilityAlerts": { "enabled": true, "labels": ["security"] },+ "labels": ["renovate", "dependencies", "security"],+ "branchPrefix": "renovate/",+ "packageRules": [+ {+ "description": "Security-only baseline: disable everything; vuln alerts override.",+ "matchPackageNames": ["*"],+ "enabled": false+ },+ {+ "description": "Containers: pin digests + digest refresh + patch tags only.",+ "matchManagers": ["dockerfile", "docker-compose"],+ "matchUpdateTypes": ["pin", "digest", "patch"],+ "enabled": true,+ "pinDigests": true+ },+ {+ "description": "GitHub Actions: pin SHAs + digest/patch refresh.",+ "matchManagers": ["github-actions"],+ "matchUpdateTypes": ["pin", "digest", "patch"],+ "enabled": true,+ "pinDigests": true+ },+ {+ "description": "Skip private Artifact Registry images (need registry auth).",+ "matchDatasources": ["docker"],+ "matchPackageNames": ["/^.*-docker\\.pkg\\.dev\\//"],+ "enabled": false+ },+ {+ "description": "One PR per directory + ecosystem.",+ "matchManagers": ["dockerfile", "docker-compose", "github-actions"],+ "additionalBranchPrefix": "{{packageFileDir}}-",+ "groupName": "{{manager}} {{packageFileDir}}"+ }+ ]+}diff --git a/socket.yml b/socket.ymlnew file mode 100644index 000000000..1ccf05586--- /dev/null+++ b/socket.yml@@ -0,0 +1,5 @@+# top level version field is required+version: 2++githubApp:+ disableCommentsAndCheckRuns: false