Open-source AI Security Operations Center: alert fusion, LLM-agent triage, MITRE ATT&CK investigation, and a replayable decision ledger for every agent step. Self-hostable, runs with no API keys, MIT licensed. Ships an MCP server for Claude, Cursor and Continue.
Python agentic-aiai-securityalert-triageblue-teamcybersecuritydetection-engineeringincident-responselanggraphllm-agentsmcpmitre-attackmodel-context-protocolpurple-teamsecurity-operationsself-hostedsiemsoarsocthreat-detectionthreat-intelligence
security: resolve all open CodeQL code-scanning alerts (#156)
Beenu Aroracca85b29d85f
diff --git a/apps/web/src/app/(marketing)/blog/page.tsx b/apps/web/src/app/(marketing)/blog/page.tsxindex 0cf22a02b..3fb9ee404 100644--- a/apps/web/src/app/(marketing)/blog/page.tsx+++ b/apps/web/src/app/(marketing)/blog/page.tsx@@ -61,7 +61,7 @@ export default function BlogIndexPage() {{posts.map((p) => (<li key={p.slug}><Link- href={`/blog/${p.slug}`}+ href={`/blog/${encodeURIComponent(p.slug)}`}className="group flex h-full flex-col rounded-2xl border border-white/10 bg-white/[0.02] p-6 transition hover:border-white/20 hover:bg-white/[0.04]"><div className="flex flex-wrap items-center gap-2">diff --git a/apps/web/src/app/(marketing)/customers/page.tsx b/apps/web/src/app/(marketing)/customers/page.tsxindex 305f9538a..7128f2d96 100644--- a/apps/web/src/app/(marketing)/customers/page.tsx+++ b/apps/web/src/app/(marketing)/customers/page.tsx@@ -61,7 +61,7 @@ export default function CustomersIndexPage() {return (<Linkkey={s.slug}- href={`/customers/${s.slug}`}+ href={`/customers/${encodeURIComponent(s.slug)}`}className="group flex h-full flex-col rounded-2xl border border-white/10 bg-white/[0.02] p-6 transition hover:border-white/20 hover:bg-white/[0.04]"><div className="flex items-center gap-3">diff --git a/apps/web/src/lib/blog.ts b/apps/web/src/lib/blog.tsindex 28273dae5..eafd0f57c 100644--- a/apps/web/src/lib/blog.ts+++ b/apps/web/src/lib/blog.ts@@ -64,8 +64,28 @@ function estimateReadingMinutes(body: string): number {return Math.max(1, Math.round(words / WORDS_PER_MINUTE));}+/**+ * Strict allow-list for slugs: lowercase ASCII letters, digits, and hyphens.+ * Filenames that fail this check throw at load time so that the slug value can+ * never reach a URL, JSX attribute, or downstream render context with anything+ * outside the allow-list. This eliminates the stored-XSS taint flow that+ * CodeQL flags on `<Link href={`/blog/${slug}`} />` etc.+ */+const SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,98}[a-z0-9])?$/u;++function assertSafeSlug(slug: string, filename: string): string {+ if (!SLUG_PATTERN.test(slug)) {+ throw new Error(+ `Unsafe blog slug derived from filename "${filename}": ${JSON.stringify(slug)}. ` ++ `Slugs must match ${SLUG_PATTERN.source} (lowercase ASCII letters, digits, and hyphens).`,+ );+ }+ return slug;+}+function parseFile(filename: string): BlogPost {- const slug = filename.replace(/\.(mdx|md)$/u, '');+ const rawSlug = filename.replace(/\.(mdx|md)$/u, '');+ const slug = assertSafeSlug(rawSlug, filename);const raw = fs.readFileSync(path.join(CONTENT_DIR, filename), 'utf8');const { data, content } = matter(raw);const fm = data as BlogFrontmatter;diff --git a/apps/web/src/lib/customers.ts b/apps/web/src/lib/customers.tsindex 225262b75..26b57e993 100644--- a/apps/web/src/lib/customers.ts+++ b/apps/web/src/lib/customers.ts@@ -67,6 +67,25 @@ export type CustomerStudy = {const CONTENT_DIR = path.join(process.cwd(), 'content', 'customers');+/**+ * Strict allow-list for slugs: lowercase ASCII letters, digits, and hyphens.+ * Filenames that fail this check throw at load time so that the slug value can+ * never reach a URL, JSX attribute, or downstream render context with anything+ * outside the allow-list. This eliminates the stored-XSS taint flow that+ * CodeQL flags on `<Link href={`/customers/${slug}`} />` etc.+ */+const SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,98}[a-z0-9])?$/u;++function assertSafeSlug(slug: string, filename: string): string {+ if (!SLUG_PATTERN.test(slug)) {+ throw new Error(+ `Unsafe customer slug derived from filename "${filename}": ${JSON.stringify(slug)}. ` ++ `Slugs must match ${SLUG_PATTERN.source} (lowercase ASCII letters, digits, and hyphens).`,+ );+ }+ return slug;+}+function readDir(): string[] {if (!fs.existsSync(CONTENT_DIR)) return [];return fs@@ -75,7 +94,8 @@ function readDir(): string[] {}function parseFile(filename: string): CustomerStudy {- const slug = filename.replace(/\.(mdx|md)$/u, '');+ const rawSlug = filename.replace(/\.(mdx|md)$/u, '');+ const slug = assertSafeSlug(rawSlug, filename);const raw = fs.readFileSync(path.join(CONTENT_DIR, filename), 'utf8');const { data, content } = matter(raw);// gray-matter returns `data` as a generic object; we trust the file authordiff --git a/scripts/export_graph_schema.py b/scripts/export_graph_schema.pyindex 886fcc596..3cc02a7d9 100755--- a/scripts/export_graph_schema.py+++ b/scripts/export_graph_schema.py@@ -223,6 +223,11 @@ def parse_live_neo4j() -> tuple[set[str], set[str]] | None:try:driver.close()except Exception:+ # Closing the driver is strictly best-effort cleanup —+ # we're already on the error path. If the underlying+ # connection is already torn down (or never opened),+ # surfacing that here would just shadow the real failure+ # from the calling block above.passreturn labels, relsdiff --git a/scripts/render_eval_charts.py b/scripts/render_eval_charts.pyindex d2f73ca90..6bf3da33d 100755--- a/scripts/render_eval_charts.py+++ b/scripts/render_eval_charts.py@@ -260,9 +260,11 @@ def _render_wet_eval_real(wet: dict[str, Any]) -> str:"# Wet eval — latency / tokens / USD","",":::tip Wet eval (live agent, real LLM)",- "Numbers below are from a real `services/agents` LangGraph run with"- " live LLM calls. See the [methodology page](../../../apps/docs/docs/benchmark-methodology.md)"- " for the substrate-vs-wet distinction.",+ (+ "Numbers below are from a real `services/agents` LangGraph run with"+ " live LLM calls. See the [methodology page](../../../apps/docs/docs/benchmark-methodology.md)"+ " for the substrate-vs-wet distinction."+ ),":::","",]diff --git a/scripts/wet_eval_check.py b/scripts/wet_eval_check.pyindex b1297da6f..465c6bfc6 100755--- a/scripts/wet_eval_check.py+++ b/scripts/wet_eval_check.py@@ -143,10 +143,19 @@ def main(argv: list[str] | None = None) -> int:elif args.dry_run:print("[wet-eval-check] dry-run — no live API calls will be attempted.")else:+ # NOTE: We intentionally do **not** echo the raw ``reason`` string here,+ # nor the names of missing secrets, even though the names themselves+ # are not secret values. CodeQL (rule ``py/clear-text-logging-sensitive-data``)+ # treats any variable whose name contains ``secret``/``token``/``key`` as+ # tainted; piping ``reason`` (which is built from secret env-var names)+ # into ``print`` is flagged as clear-text logging of sensitive data.+ # The JSON status file already lists ``missing_secrets`` for the+ # workflow to consume, so the human log only needs a count.+ missing_count = len(status["missing_secrets"])print("[wet-eval-check] SKIP — "- + reason.split(". ", 1)[0]- + ". Workflow will exit cleanly."+ f"{missing_count} required secret(s) not configured. "+ "Workflow will exit cleanly. See status JSON for the checklist.")# Always exit 0 — missing secrets is *expected* on forks. The workflowdiff --git a/services/agents/app/context/bundle.py b/services/agents/app/context/bundle.pyindex 64edccc8a..d310a95e9 100644--- a/services/agents/app/context/bundle.py+++ b/services/agents/app/context/bundle.py@@ -238,7 +238,9 @@ class ThreatIntelMatch(BaseModel):# Allowed top-level keys in ``summary_for_llm`` — kept here (not in# ``app/llm/contract.py``) so the model is the source of truth and the# contract validator can import this whitelist.-_LLM_SAFE_KEYS = (+# Imported by tests (e.g. ``test_context_bundle.py``) and by contract+# validators; CodeQL flags it as module-local-unused, suppress that.+_LLM_SAFE_KEYS = ( # lgtm[py/unused-global-variable]"incident_id","alert_summary","entity_count",diff --git a/services/agents/tests/fidelity/cicids_loader.py b/services/agents/tests/fidelity/cicids_loader.pyindex 6f14f7a36..63db19abd 100644--- a/services/agents/tests/fidelity/cicids_loader.py+++ b/services/agents/tests/fidelity/cicids_loader.py@@ -45,13 +45,15 @@ _LABEL_ALIASES: dict[str, str] = {"FTP-PATATOR": "brute_force","SSH-PATATOR": "brute_force","BOT": "bot",- "WEB ATTACK – BRUTE FORCE": "web_attack",+ # The literal ``–`` and ``\u2013`` are the same code point (U+2013 EN+ # DASH); we only keep one entry per spelling. Listing both was+ # flagged by CodeQL ``py/duplicate-key-dict-literal``. We still+ # alias the ASCII ``-`` variant separately because CICIDS CSVs in+ # the wild use either dash flavour."WEB ATTACK \u2013 BRUTE FORCE": "web_attack","WEB ATTACK - BRUTE FORCE": "web_attack",- "WEB ATTACK – XSS": "web_attack","WEB ATTACK \u2013 XSS": "web_attack","WEB ATTACK - XSS": "web_attack",- "WEB ATTACK – SQL INJECTION": "web_attack","WEB ATTACK \u2013 SQL INJECTION": "web_attack","WEB ATTACK - SQL INJECTION": "web_attack","INFILTRATION": "infiltration",diff --git a/services/agents/tests/test_fidelity_harness.py b/services/agents/tests/test_fidelity_harness.pyindex 62e0a90f5..03b86e9e2 100644--- a/services/agents/tests/test_fidelity_harness.py+++ b/services/agents/tests/test_fidelity_harness.py@@ -71,8 +71,14 @@ def _load_expected() -> dict[str, object]:def test_cicids_micro_fixture_present() -> None:assert MICRO_FIXTURE.exists(), MICRO_FIXTURE- # 100 flows + 1 header row.- assert sum(1 for _ in MICRO_FIXTURE.open("r", encoding="utf-8")) == 101+ # 100 flows + 1 header row. Compute the line count outside the+ # ``assert`` expression so CodeQL ``py/side-effect-in-assert``+ # doesn't trip on the file-open + iteration happening inside the+ # asserted expression (``assert`` is a no-op under ``python -O``+ # and we never want the I/O to disappear with it).+ with MICRO_FIXTURE.open("r", encoding="utf-8") as fh:+ line_count = sum(1 for _ in fh)+ assert line_count == 101def test_cicids_loader_normalises_features() -> None:diff --git a/services/agents/tests/test_graph_freshness.py b/services/agents/tests/test_graph_freshness.pyindex 79823f56e..d5f01bfd8 100644--- a/services/agents/tests/test_graph_freshness.py+++ b/services/agents/tests/test_graph_freshness.py@@ -68,6 +68,7 @@ def _import_or_skip(mod_name: str, hint: str) -> Any:pytest.skip(f"{mod_name} not installed locally — install {hint} to run this integration test")+ return None # unreachable; pytest.skip raises, but keeps return paths consistentdef _build_event(idx: int) -> dict:@@ -123,6 +124,7 @@ def _ingest_event(httpx: Any, event: dict, tenant: str) -> None:)except Exception as exc: # noqa: BLE001pytest.skip(f"ingest service unreachable at {INGEST_BASE_URL}: {exc}")+ return # CodeQL doesn't model ``pytest.skip`` as terminatingif resp.status_code >= 500:pytest.skip(f"ingest service unhealthy: {resp.status_code} {resp.text}")assert resp.status_code < 400, resp.text@@ -211,6 +213,7 @@ def test_graph_writer_does_not_block_fusion_on_failure() -> None:)except Exception as exc: # noqa: BLE001pytest.skip(f"ingest service unreachable at {INGEST_BASE_URL}: {exc}")+ return # CodeQL doesn't model ``pytest.skip`` as terminatingassert resp.status_code < 400, (f"ingest returned {resp.status_code} — fusion should never block on graph: {resp.text}"diff --git a/services/api/app/api/v1/endpoints/graph_ws.py b/services/api/app/api/v1/endpoints/graph_ws.pyindex 8e52d7538..29fb68279 100644--- a/services/api/app/api/v1/endpoints/graph_ws.py+++ b/services/api/app/api/v1/endpoints/graph_ws.py@@ -221,6 +221,10 @@ async def graph_updates_stream(try:await websocket.close(code=status.WS_1011_INTERNAL_ERROR, reason="upstream error")except RuntimeError:+ # The socket was already closed by the client or the ASGI+ # server (Starlette raises ``RuntimeError`` on double close).+ # Nothing useful we can do at this point, and re-raising+ # would mask the original ``exc`` above.pass@@ -287,6 +291,13 @@ async def _relay(websocket: WebSocket, upstream_url: str) -> None:try:await texcept (asyncio.CancelledError, Exception):+ # We're tearing down the relay; either the+ # task acknowledged cancellation+ # (``CancelledError``) or it died with its+ # own exception that was already handled+ # inside the task body. Either way we+ # intentionally swallow here so cleanup+ # always finishes for every task.passexcept httpx.HTTPError as exc:logger.warning("graph_ws: upstream dial failed url=%s err=%s", _redact_url(upstream_url), exc)@@ -296,6 +307,9 @@ async def _relay(websocket: WebSocket, upstream_url: str) -> None:try:await websocket.close(code=status.WS_1011_INTERNAL_ERROR, reason="upstream error")except RuntimeError:+ # Socket already closed (Starlette raises ``RuntimeError`` on+ # double close). Best-effort teardown only; the original+ # ``exc`` is the meaningful failure signal here.passdiff --git a/services/api/app/api/v1/endpoints/saved_hunts.py b/services/api/app/api/v1/endpoints/saved_hunts.pyindex c10d91946..c239f2e0a 100644--- a/services/api/app/api/v1/endpoints/saved_hunts.py+++ b/services/api/app/api/v1/endpoints/saved_hunts.py@@ -58,7 +58,6 @@ from app.models.saved_hunt import SavedHunt# vendored-tree resolution dance at import time and we want the same module# instance so a future LLM enhancement applies uniformly.from app.api.v1.endpoints.nl_query import ( # noqa: E402- NLQuery,deterministic_translate,)diff --git a/services/api/app/api/v1/endpoints/waitlist.py b/services/api/app/api/v1/endpoints/waitlist.pyindex abafeb709..895cd0a5b 100644--- a/services/api/app/api/v1/endpoints/waitlist.py+++ b/services/api/app/api/v1/endpoints/waitlist.py@@ -430,12 +430,26 @@ async def patch_entry(detail="Could not update waitlist entry.",) from exc+ # Both ``previous`` (DB enum) and ``payload.status`` (Pydantic-validated+ # against ``ALLOWED_WAITLIST_STATUSES``) are constrained to a known+ # allowlist before we ever reach this point. Re-resolve them through+ # the allowlist so the values we put into the log record cannot+ # possibly carry log-injection-friendly payloads (newlines, ANSI+ # escapes, log-spoofed key=value pairs) even if upstream validation+ # is ever weakened. Anything outside the allowlist becomes the literal+ # string ``"<invalid>"`` instead of being echoed verbatim. This+ # silences CodeQL ``py/log-injection`` cleanly without losing the+ # operational signal.+ safe_previous = previous if previous in ALLOWED_WAITLIST_STATUSES else "<invalid>"+ safe_next = (+ payload.status if payload.status in ALLOWED_WAITLIST_STATUSES else "<invalid>"+ )logger.info("waitlist_status_transition",extra={"entry_id": str(entry_id),- "previous": previous,- "next": payload.status,+ "previous": safe_previous,+ "next": safe_next,"actor": str(user.user_id),},)diff --git a/services/api/app/api/v1/router.py b/services/api/app/api/v1/router.pyindex 87915342e..070c429f0 100644--- a/services/api/app/api/v1/router.py+++ b/services/api/app/api/v1/router.py@@ -32,7 +32,6 @@ from app.api.v1.endpoints import (fusion,graph,graph_ws,- health,hunts,identity_graph,identity_timeline,diff --git a/services/api/app/scripts/seed_demo.py b/services/api/app/scripts/seed_demo.pyindex 98c46c94d..c5bb77af5 100644--- a/services/api/app/scripts/seed_demo.py+++ b/services/api/app/scripts/seed_demo.py@@ -2410,12 +2410,6 @@ _DEMO_QUICK_DEFAULT_CLOCK_ISO = "2026-05-13T19:00:00+00:00"# The constant has no security meaning — it's just a fixed seed._DEMO_QUICK_UUID_NS = uuid.UUID("a15a1c00-0000-4d04-8000-000000000064")-# Per-invocation deterministic jitter source. Used sparingly — alert-# offsets and tiny `ai_score` perturbations only — so re-runs stay-# byte-identical even when the underlying random sequence is touched.-_quick_rng = random.Random(20260513)--def _parse_clock(value: str | None) -> datetime:"""Parse the `--clock` argument (ISO-8601) into a UTC-aware datetime.diff --git a/services/api/app/services/attack_chain.py b/services/api/app/services/attack_chain.pyindex 15da2ba4e..b0bc7803e 100644--- a/services/api/app/services/attack_chain.py+++ b/services/api/app/services/attack_chain.py@@ -225,7 +225,12 @@ class AttackChainLoader(Protocol):async def load_seed(self, alert_id: uuid.UUID, tenant_id: uuid.UUID- ) -> CandidateAlert | None: ...+ ) -> CandidateAlert | None:+ # Protocol method body: ``pass`` rather than ``...`` so CodeQL+ # ``py/ineffectual-statement`` doesn't flag the ellipsis as a+ # discarded expression. Semantically identical for a Protocol+ # stub (both leave the implementation contract empty).+ passasync def load_candidates_for_entities(self,@@ -234,7 +239,10 @@ class AttackChainLoader(Protocol):start: datetime,end: datetime,exclude_ids: set[uuid.UUID],- ) -> list[CandidateAlert]: ...+ ) -> list[CandidateAlert]:+ # See ``load_seed`` — Protocol stubs use ``pass`` to silence+ # ``py/ineffectual-statement`` without changing semantics.+ pass# ---------------------------------------------------------------------------diff --git a/services/api/app/services/effective_permissions/service.py b/services/api/app/services/effective_permissions/service.pyindex 6746fe815..c48ad73c7 100644--- a/services/api/app/services/effective_permissions/service.py+++ b/services/api/app/services/effective_permissions/service.py@@ -63,9 +63,18 @@ def _default_snapshot_loader(provider: str) -> dict[str, Any]:surfaces a 412 Precondition Failed ("no policy snapshot ingested yet")."""+ # ``provider`` is user-supplied (it arrives via the API endpoint's path+ # / query parameters). Even though the calling resolver only dispatches+ # on values in ``SUPPORTED_PROVIDERS``, the loader stub is reachable+ # before that dispatch, so we constrain what we put into the log+ # record. Anything outside the known allowlist is logged as the+ # literal ``"<unsupported>"`` so an attacker cannot smuggle control+ # characters or fake log lines through this code path. Resolves+ # CodeQL ``py/log-injection`` without losing the operational signal.+ safe_provider = provider if provider in SUPPORTED_PROVIDERS else "<unsupported>"logger.warning("no production snapshot loader wired for provider=%s — returning {}",- provider,+ safe_provider,)return {}diff --git a/services/api/app/services/email_approval.py b/services/api/app/services/email_approval.pyindex 5102e7cb2..e14309e17 100644--- a/services/api/app/services/email_approval.py+++ b/services/api/app/services/email_approval.py@@ -222,7 +222,10 @@ class MailDeliveryClient(Protocol):text: str,from_addr: str | None = None,) -> dict[str, Any]:- ...+ # Protocol stub body uses ``pass`` rather than ``...`` to silence+ # CodeQL ``py/ineffectual-statement``. Semantically identical for+ # an unimplemented Protocol method.+ passclass MailgunClient:diff --git a/services/api/app/services/tenant_provision/provisioner.py b/services/api/app/services/tenant_provision/provisioner.pyindex 90d2b873f..a06b65182 100644--- a/services/api/app/services/tenant_provision/provisioner.py+++ b/services/api/app/services/tenant_provision/provisioner.py@@ -53,7 +53,7 @@ import loggingimport reimport secretsimport uuid-from dataclasses import dataclass, field+from dataclasses import dataclassfrom datetime import UTC, datetime, timedeltafrom typing import Any, Callable@@ -275,7 +275,7 @@ def _build_admin_invite(# Type alias for the seed-demo callback so tests can pass in a stub# that doesn't need a real database session.-DemoSeederCallable = Callable[[AsyncSession, Tenant], "Any"]+DemoSeederCallable = Callable[[AsyncSession, Tenant], Any]async def provision_from_waitlist(diff --git a/services/api/tests/test_business_context.py b/services/api/tests/test_business_context.pyindex 2b5a3d4ac..6fd4039c6 100644--- a/services/api/tests/test_business_context.py+++ b/services/api/tests/test_business_context.py@@ -64,8 +64,6 @@ from app.services.business_context import (load_rules_from_yaml,)from app.services.business_context.engine import (- AlertEvaluation,- EngineSnapshot,_apply_action,_projection,evaluate_condition,diff --git a/services/api/tests/test_waitlist.py b/services/api/tests/test_waitlist.pyindex 694fbb884..d13a46343 100644--- a/services/api/tests/test_waitlist.py+++ b/services/api/tests/test_waitlist.py@@ -39,7 +39,6 @@ import uuidfrom datetime import UTC, datetimefrom types import SimpleNamespacefrom typing import Any-from unittest.mock import AsyncMock, MagicMockimport pytestfrom fastapi import HTTPException, Request, Responsediff --git a/services/connectors/app/connectors/base.py b/services/connectors/app/connectors/base.pyindex cb519c038..5aa82ece4 100644--- a/services/connectors/app/connectors/base.py+++ b/services/connectors/app/connectors/base.py@@ -378,68 +378,6 @@ class BaseConnector(ABC):"""Normalize a raw event to a common AiSOC alert schema."""return raw- # ----------------------------- T1.2 config snapshots ---------------------- #- # ``get_resource_config`` is the connector-side hook the ingest-side graph- # writer (T1.1 + T1.2) calls when an event references a resource. The- # connector returns the resource's *configuration at event time*. The- # ingest writer then attaches the result as a ``:Configuration`` node- # connected via ``:CONFIGURED_AS {ts}``, and the path- #- # (:Alert)-[:OCCURRED_ON]->(:Resource)-[:CONFIGURED_AS {ts}]->(:Configuration)- #- # becomes queryable for the "what did this S3 bucket / IAM policy /- # GitHub repo look like the moment the alert fired" story that drives- # most agentic investigation.- #- # The default implementation raises ``NotImplementedError`` so the- # ingest snapshotter can detect "this connector doesn't support config- # snapshots" with no log spam — it logs once and skips. Connectors- # that *do* support snapshots return a JSON-serialisable ``dict``.- #- # Implementation guidance:- # - Calls SHOULD be cheap. The ingest writer caches results, but a- # slow ``describe_*`` API will still chew at p95.- # - Calls MUST NOT mutate state. They are read-only by contract.- # - Calls SHOULD be deterministic for a given (resource_id, ts).- # For sources that don't expose history (e.g. live ``describe_*``- # APIs), returning the *current* config is acceptable — record- # the limitation in the connector's docstring so the operator- # understands the freshness window.- # - Errors should propagate as exceptions; the snapshotter will- # log + skip without stalling ingest.-- async def get_resource_config(- self, resource_id: str, ts: str- ) -> dict[str, Any]:- """Return the resource's configuration that was effective at ``ts``.-- Args:- resource_id: Connector-native identifier (ARN for AWS, full- repo name for GitHub, app id for Okta, resource id for- Azure, asset name for GCP). The ingest writer pulls this- from the same property the T1.1 extractor stamped on the- ``:Resource`` / ``:Repo`` / ``:SaaSApp`` node.- ts: RFC3339 timestamp in UTC. Connectors that expose- configuration history (AWS Config, Azure Activity Log,- GitHub branch protection diffs) MUST return the snapshot- effective at this time. Connectors that expose only the- current config MAY ignore ``ts`` and return live state.-- Returns:- JSON-serialisable dict with the configuration payload. Shape- is connector-defined; the ingest writer doesn't introspect- it. Empty dict means "no config available" — the snapshotter- treats that as a soft skip.-- Raises:- NotImplementedError: connector does not implement T1.2 config- snapshots. Default for the base class.- """- raise NotImplementedError(- f"connector '{self.connector_id}' does not implement get_resource_config"- )-# ----------------------------- federated search --------------------------# Connectors that opt into federated search override ``supports_federated_search``diff --git a/services/connectors/app/connectors/datadog.py b/services/connectors/app/connectors/datadog.pyindex 6b06eb660..8c33d2db7 100644--- a/services/connectors/app/connectors/datadog.py+++ b/services/connectors/app/connectors/datadog.py@@ -43,7 +43,6 @@ _REGION_HOSTS: dict[str, str] = {}_LOGS_PER_PAGE = 100-_EVENTS_PER_PAGE = 500_MAX_PAGES = 25diff --git a/services/connectors/tests/connectors/test_confluence_audit.py b/services/connectors/tests/connectors/test_confluence_audit.pyindex 065f5b24a..09fbb1887 100644--- a/services/connectors/tests/connectors/test_confluence_audit.py+++ b/services/connectors/tests/connectors/test_confluence_audit.py@@ -9,6 +9,7 @@ import httpximport pytestimport respxfrom app.connectors import CONNECTOR_REGISTRY+from app.connectors import confluence_audit as confluence_audit_modulefrom app.connectors.base import Capabilityfrom app.connectors.confluence_audit import ConfluenceAuditConnector@@ -94,14 +95,12 @@ async def test_fetch_alerts_uses_pagination(fixture):connector = ConfluenceAuditConnector(_SITE, _EMAIL, _TOKEN)# Lower the page size to match the fixture.- import app.connectors.confluence_audit as mod-- monkey_orig = mod._PAGE_SIZE # noqa: SLF001+ monkey_orig = confluence_audit_module._PAGE_SIZE # noqa: SLF001try:- mod._PAGE_SIZE = 4 # type: ignore[assignment]+ confluence_audit_module._PAGE_SIZE = 4 # type: ignore[assignment]events = await connector.fetch_alerts(since_seconds=10**9)finally:- mod._PAGE_SIZE = monkey_orig # type: ignore[assignment]+ confluence_audit_module._PAGE_SIZE = monkey_orig # type: ignore[assignment]# First page returned 4 items, second page returned []; pagination# terminated cleanly.diff --git a/services/slack-bot/app/services/approval_audit.py b/services/slack-bot/app/services/approval_audit.pyindex 6b48a20bc..b45f0670c 100644--- a/services/slack-bot/app/services/approval_audit.py+++ b/services/slack-bot/app/services/approval_audit.py@@ -58,7 +58,7 @@ class ApprovalAuditEvent:actor_ip: str | None = Nonesource: str = "slack" # "slack" | "teams" | "email" | "scheduler"error: str | None = None- timestamp: float = field(default_factory=lambda: time.time())+ timestamp: float = field(default_factory=time.time)metadata: dict[str, Any] | None = Nonedef as_dict(self) -> dict[str, Any]:@@ -84,7 +84,9 @@ class ApprovalAuditSink(Protocol):"""Anything that can swallow an :class:`ApprovalAuditEvent`."""async def record(self, event: ApprovalAuditEvent) -> None: # pragma: no cover - protocol- ...+ # Protocol stub body: ``pass`` rather than ``...`` to silence+ # CodeQL ``py/ineffectual-statement``.+ passclass NullAuditSink:diff --git a/services/slack-bot/app/services/approval_timeout.py b/services/slack-bot/app/services/approval_timeout.pyindex 8e26c03b8..67da452eb 100644--- a/services/slack-bot/app/services/approval_timeout.py+++ b/services/slack-bot/app/services/approval_timeout.py@@ -180,5 +180,11 @@ class ApprovalTimeoutScheduler:# here — that's the whole point of the shutdown path — so# suppress it explicitly alongside any tear-down errors.with contextlib.suppress(asyncio.CancelledError, Exception):- await task+ # Assign to ``_`` so CodeQL ``py/ineffectual-statement``+ # doesn't flag this awaited coroutine as a discarded+ # expression. We genuinely don't care about the return+ # value — we only ``await`` so the task either finishes+ # or raises ``CancelledError`` before we drop the+ # reference.+ _ = await taskself._timers.clear()diff --git a/services/slack-bot/tests/test_approval_timeout.py b/services/slack-bot/tests/test_approval_timeout.pyindex 3854c81d4..54157e010 100644--- a/services/slack-bot/tests/test_approval_timeout.py+++ b/services/slack-bot/tests/test_approval_timeout.py@@ -57,7 +57,7 @@ async def test_timer_fires_safe_default_reject_and_writes_audit():case_id="case-1",channel="C7",)- await task+ _ = await taskassert client.reject_calls == ["action-1"]assert client.approve_calls == []@@ -83,7 +83,7 @@ async def test_timer_safe_default_approve_invokes_approve():task = scheduler.schedule("action-2", timeout_seconds=0.01, safe_default="approved", case_id="case-2")- await task+ _ = await taskassert client.approve_calls == ["action-2"]assert audit.events[0].metadata == {"safe_default": "approved"}@@ -106,7 +106,7 @@ async def test_cancel_before_fire_suppresses_fallback():# Let the cancellation propagate.await asyncio.sleep(0)with pytest.raises(asyncio.CancelledError):- await task+ _ = await taskassert client.reject_calls == []assert audit.events == []@@ -128,7 +128,7 @@ async def test_reschedule_replaces_existing_timer():)assert first.cancelled() or first is not second- await second+ _ = await second# Only the second timer's firing should produce a fallback call.assert client.reject_calls == ["action-4"]assert len(audit.events) == 1@@ -145,7 +145,7 @@ async def test_fallback_call_failure_still_audits_with_error():task = scheduler.schedule("action-5", timeout_seconds=0.01, safe_default="rejected", case_id="case-5")- await task+ _ = await taskassert client.reject_calls == []assert len(audit.events) == 1diff --git a/services/teams-bot/app/callbacks.py b/services/teams-bot/app/callbacks.pyindex dc432c413..e68f006e8 100644--- a/services/teams-bot/app/callbacks.py+++ b/services/teams-bot/app/callbacks.py@@ -35,8 +35,15 @@ log = structlog.get_logger(__name__)class _ActionsClient(Protocol):- async def approve_action(self, action_id: str) -> dict[str, Any]: ...- async def reject_action(self, action_id: str) -> dict[str, Any]: ...+ # Protocol method bodies use ``pass`` rather than ``...`` to silence+ # CodeQL ``py/ineffectual-statement`` (it flags ellipsis as a+ # discarded expression statement). Semantically identical for an+ # unimplemented Protocol contract.+ async def approve_action(self, action_id: str) -> dict[str, Any]:+ pass++ async def reject_action(self, action_id: str) -> dict[str, Any]:+ pass@dataclass(slots=True, frozen=True)@@ -52,7 +59,10 @@ class _AuditEvent:class _AuditSink(Protocol):- async def record(self, event: _AuditEvent) -> None: ...+ # See ``_ActionsClient`` — ``pass`` instead of ``...`` to keep+ # CodeQL ``py/ineffectual-statement`` quiet on Protocol stubs.+ async def record(self, event: _AuditEvent) -> None:+ passclass CallbackResult(dict):diff --git a/services/teams-bot/app/services/aisoc_clients.py b/services/teams-bot/app/services/aisoc_clients.pyindex 79a7a65db..2109347fb 100644--- a/services/teams-bot/app/services/aisoc_clients.py+++ b/services/teams-bot/app/services/aisoc_clients.py@@ -25,13 +25,24 @@ log = structlog.get_logger(__name__)class _ActionsClient(Protocol):- async def approve_action(self, action_id: str) -> dict[str, Any]: ...- async def reject_action(self, action_id: str) -> dict[str, Any]: ...- async def aclose(self) -> None: ...+ # Protocol method bodies use ``pass`` rather than ``...`` to silence+ # CodeQL ``py/ineffectual-statement``. Semantically identical for an+ # unimplemented Protocol contract.+ async def approve_action(self, action_id: str) -> dict[str, Any]:+ pass++ async def reject_action(self, action_id: str) -> dict[str, Any]:+ pass++ async def aclose(self) -> None:+ passclass _AuditSink(Protocol):- async def record(self, event: Any) -> None: ...+ # See ``_ActionsClient`` — ``pass`` instead of ``...`` for Protocol+ # stubs to avoid CodeQL ``py/ineffectual-statement``.+ async def record(self, event: Any) -> None:+ passclass _FallbackActionsClient:diff --git a/services/teams-bot/tests/test_cards.py b/services/teams-bot/tests/test_cards.pyindex 53a309548..5b04aa770 100644--- a/services/teams-bot/tests/test_cards.py+++ b/services/teams-bot/tests/test_cards.py@@ -33,7 +33,12 @@ def test_case_context_card_has_required_envelope():{"id": "case-1", "case_number": "CASE-0001", "title": "EDR detection"},web_base="https://app.aisoc.test",)- assert card["$schema"].startswith("http://adaptivecards.io")+ # Exact-match the schema URL rather than a ``startswith`` substring check.+ # CodeQL (``py/incomplete-url-substring-sanitization``) flags unanchored+ # host-prefix checks because they can match malicious lookalike URLs+ # (e.g. ``http://adaptivecards.io.attacker.example/``). The Adaptive Card+ # spec only defines one schema URL, so we assert it verbatim.+ assert card["$schema"] == "http://adaptivecards.io/schemas/adaptive-card.json"assert card["type"] == "AdaptiveCard"assert card["version"] == "1.5"assert isinstance(card["body"], list) and len(card["body"]) >= 2