loki-mode 11.7.1 → 11.9.1

package/autonomy/trigger-server.py

@@ -38,6 +38,7 @@ Usage:
 """
 
 import argparse
+import base64
 import collections
 import hashlib
 import hmac
@@ -55,8 +56,10 @@ import subprocess
 import sys
 import threading
 import time
-from datetime import datetime
+import urllib.parse
+from datetime import datetime, timezone
 from pathlib import Path
+from urllib.request import Request, urlopen
 
 # Receipt attestation. Imported by path because trigger-server.py runs as a
 # script from an arbitrary cwd, so a bare `import receipt_jwt` would depend on
@@ -412,6 +415,12 @@ CHILD_ENV_DENYLIST = (
     "LOKI_API_TOKEN_FILE",
     "LOKI_SENTRY_WEBHOOK_SECRET",
     "SENTRY_CLIENT_SECRET",
+    "SLACK_SIGNING_SECRET",
+    "SLACK_BOT_TOKEN",
+    "LINEAR_WEBHOOK_SECRET",
+    "LINEAR_API_KEY",
+    "JIRA_WEBHOOK_SECRET",
+    "TEAMS_SECURITY_TOKEN",
 )
 
 
@@ -577,6 +586,14 @@ def handle_workflow_run_event(payload, dry_run=False):
     return summary, status
 
 
+def brief_start_args(brief):
+    """argv for a delegated PR run. `--brief` forces brief mode so the text is
+    never reclassified as a PRD path or issue URL, and `--pr --detach` are only
+    honored by `loki start` in brief mode because cmd_start routes them through
+    the worktree + PR path."""
+    return ["start", "--brief", brief, "--pr", "--detach"]
+
+
 def handle_job_event(payload, dry_run=False):
     """Handle a remotely-submitted job: loki start <spec> --detach.
 
@@ -588,7 +605,11 @@ def handle_job_event(payload, dry_run=False):
     spec = payload.get("spec")
     if not valid_spec(spec):
         return None, "rejected (invalid spec)"
-    args = ["start", spec.strip(), "--detach"]
+    # Jira/Teams delegation sets pr=True: receipt-gated PR run, never a deploy.
+    if payload.get("pr") is True:
+        args = brief_start_args(spec.strip())
+    else:
+        args = ["start", spec.strip(), "--detach"]
     summary = "job %s: %s" % (payload.get("job_id", "?"), spec.strip())
     # A remote submitter gates CI on this, so report the BUILD's outcome, not
     # merely that a build was launched. "fired" (launched) and "passed" must
@@ -622,6 +643,250 @@ def validate_sentry_signature(secret, body, signature_header):
     return constant_time_equals(expected, signature_header.strip().lower())
 
 
+# Slack and Linear delegation. Same signed-body contract as
+# loki-ts/src/contrib/slack_inbound.ts (signSlackBody/verifySlackSignature).
+SIGNATURE_MAX_SKEW_S = 300
+SLACK_REPLY_PREFIX = "https://hooks.slack.com/"
+LINEAR_API_URL = "https://api.linear.app/graphql"
+LINEAR_IDENTIFIER_RE = re.compile(r"^[A-Za-z][A-Za-z0-9]*-\d+$")
+NOTIFY_TIMEOUT_SECONDS = 10
+NOTIFY_TEXT_MAX = 1000
+
+
+def sign_slack_body(secret, timestamp, body):
+    """`v0=` + hex HMAC-SHA256 over `v0:<timestamp>:<raw body>` (bytes)."""
+    base = b"v0:" + str(timestamp).encode("utf-8") + b":" + body
+    return "v0=" + hmac.new(secret.encode("utf-8"), base, hashlib.sha256).hexdigest()
+
+
+def verify_slack_signature(secret, timestamp, body, signature, now=None):
+    """Fail closed: no secret, header, numeric timestamp or fresh window -> False."""
+    if not secret or not timestamp or not signature:
+        return False
+    if not re.fullmatch(r"[0-9]+", timestamp):
+        return False
+    now = time.time() if now is None else now
+    if abs(now - int(timestamp)) > SIGNATURE_MAX_SKEW_S:
+        return False
+    return constant_time_equals(sign_slack_body(secret, timestamp, body), signature)
+
+
+def verify_linear_signature(secret, body, signature):
+    """Linear-Signature: hex HMAC-SHA256 of the raw body. Freshness is checked
+    separately against the signed body's webhookTimestamp (linear_fresh)."""
+    if not secret or not signature:
+        return False
+    expected = hmac.new(secret.encode("utf-8"), body, hashlib.sha256).hexdigest()
+    return constant_time_equals(expected, signature.strip().lower())
+
+
+def linear_fresh(payload, now=None):
+    ts_val = payload.get("webhookTimestamp")
+    if isinstance(ts_val, bool) or not isinstance(ts_val, (int, float)):
+        return False
+    secs = ts_val / 1000.0 if ts_val > 1e11 else float(ts_val)
+    now = time.time() if now is None else now
+    return abs(now - secs) <= SIGNATURE_MAX_SKEW_S
+
+
+def resolve_chat_secrets(env, secret, api_token, sentry_secret):
+    """Return (slack_secret, linear_secret), blanking any that equals another
+    credential: each authenticates a different party and MUST differ."""
+    slack = env.get("SLACK_SIGNING_SECRET", "")
+    linear = env.get("LINEAR_WEBHOOK_SECRET", "")
+    others = [x for x in (secret, api_token, sentry_secret) if x]
+    slack_bad = bool(slack) and any(
+        constant_time_equals(slack, o) for o in others + ([linear] if linear else []))
+    linear_bad = bool(linear) and any(
+        constant_time_equals(linear, o) for o in others + ([slack] if slack else []))
+    if slack_bad:
+        logging.error("The Slack secret is identical to another credential. "
+                      "They MUST differ; disabling /slack.")
+    if linear_bad:
+        logging.error("The Linear secret is identical to another credential. "
+                      "They MUST differ; disabling /linear.")
+    return ("" if slack_bad else slack), ("" if linear_bad else linear)
+
+
+# Jira Cloud and Microsoft Teams delegation. Both enqueue a PR-only run.
+JIRA_KEY_RE = re.compile(r"^[A-Z][A-Z0-9_]*-\d+$")
+JIRA_EVENTS = ("jira:issue_created", "jira:issue_updated")
+JIRA_TRIGGER_FIELDS = ("assignee", "labels")
+DELEGATED_BRIEF_MAX = 1500
+HTML_TAG_RE = re.compile(r"<[^>]*>")
+
+
+def verify_jira_signature(secret, body, signature):
+    """X-Hub-Signature: `sha256=` + hex HMAC-SHA256 of the raw body. Jira sends
+    no timestamp, so replay is bounded by delivery-id dedup in the handler."""
+    if not secret or not signature:
+        return False
+    sig = signature.strip().lower()
+    if not sig.startswith("sha256="):
+        return False
+    expected = hmac.new(secret.encode("utf-8"), body, hashlib.sha256).hexdigest()
+    return constant_time_equals(expected, sig[len("sha256="):])
+
+
+def sign_teams_body(token, body):
+    """Base64 HMAC-SHA256 of the raw body, keyed by the base64-decoded token."""
+    key = base64.b64decode(token, validate=True)
+    return base64.b64encode(hmac.new(key, body, hashlib.sha256).digest()).decode("ascii")
+
+
+def verify_teams_signature(token, body, authorization):
+    """Authorization: `HMAC <base64>`. Fails closed on a bad token or header."""
+    if not token or not authorization:
+        return False
+    scheme, _, value = authorization.strip().partition(" ")
+    if scheme.upper() != "HMAC" or not value.strip():
+        return False
+    try:
+        expected = sign_teams_body(token, body)
+    except ValueError:
+        return False
+    return constant_time_equals(expected, value.strip())
+
+
+def teams_fresh(activity, now=None):
+    """The activity's ISO-8601 `timestamp` must be within the skew window."""
+    raw = activity.get("timestamp")
+    if not isinstance(raw, str) or not raw:
+        return False
+    try:
+        dt = datetime.fromisoformat(raw.strip().replace("Z", "+00:00"))
+    except ValueError:
+        return False
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    now = time.time() if now is None else now
+    return abs(now - dt.timestamp()) <= SIGNATURE_MAX_SKEW_S
+
+
+def _csv_set(value):
+    return frozenset(x.strip() for x in value.split(",") if x.strip())
+
+
+def _one_line(text, limit=DELEGATED_BRIEF_MAX):
+    text = " ".join(CONTROL_CHARS_RE.sub(" ", str(text or "")).split())
+    return text.encode("utf-8")[:limit].decode("utf-8", errors="ignore")
+
+
+def jira_trigger_matches(payload, assignees, labels):
+    """True when the issue is assigned to a configured user or carries a
+    configured label. An update only counts if it changed assignee or labels,
+    so unrelated edits never re-fire a run."""
+    issue = payload.get("issue")
+    fields = issue.get("fields") if isinstance(issue, dict) else None
+    if not isinstance(fields, dict):
+        return False
+    if payload.get("webhookEvent") == "jira:issue_updated":
+        items = (payload.get("changelog") or {}).get("items")
+        changed = ({i.get("field") for i in items if isinstance(i, dict)}
+                   if isinstance(items, list) else set())
+        if not changed.intersection(JIRA_TRIGGER_FIELDS):
+            return False
+    who = fields.get("assignee")
+    ids = set()
+    if isinstance(who, dict):
+        for k in ("accountId", "emailAddress", "displayName"):
+            if isinstance(who.get(k), str):
+                ids.add(who[k])
+    if ids.intersection(assignees):
+        return True
+    have = fields.get("labels")
+    return isinstance(have, list) and bool(
+        {x for x in have if isinstance(x, str)}.intersection(labels))
+
+
+def adf_text(node, out=None):
+    """Flatten an Atlassian Document Format tree to its text nodes."""
+    top = out is None
+    out = [] if top else out
+    if isinstance(node, dict):
+        if isinstance(node.get("text"), str):
+            out.append(node["text"])
+        for child in node.get("content") or []:
+            adf_text(child, out)
+    elif isinstance(node, list):
+        for child in node:
+            adf_text(child, out)
+    return " ".join(out) if top else None
+
+
+def build_jira_brief(issue):
+    fields = issue.get("fields") or {}
+    desc = fields.get("description")
+    if isinstance(desc, dict):
+        desc = adf_text(desc)
+    parts = ["Resolve Jira issue %s: %s." % (issue.get("key"), fields.get("summary") or "")]
+    if isinstance(desc, str) and desc.strip():
+        parts.append(desc)
+    parts.append("Reproduce with a regression test, then fix the root cause.")
+    return _one_line(" ".join(parts))
+
+
+def build_teams_brief(activity):
+    text = re.sub(r"<at>.*?</at>", " ", str(activity.get("text") or ""), flags=re.S)
+    return _one_line(HTML_TAG_RE.sub(" ", text))
+
+
+def resolve_delegation_secrets(env, others):
+    """Return (jira_secret, teams_token), blanking any equal to another
+    credential in `others` or to each other."""
+    jira = env.get("JIRA_WEBHOOK_SECRET", "")
+    teams = env.get("TEAMS_SECURITY_TOKEN", "")
+    others = [x for x in others if x]
+    out = []
+    for name, val, peer in (("Jira", jira, teams), ("Teams", teams, jira)):
+        bad = bool(val) and any(constant_time_equals(val, o)
+                                for o in others + ([peer] if peer else []))
+        if bad:
+            logging.error("The %s secret is identical to another credential. "
+                          "They MUST differ; disabling its route.", name)
+        out.append("" if bad else val)
+    return tuple(out)
+
+
+def _post_json(url, data, headers):
+    """POST JSON with a bounded timeout. Raises on any failure; callers log."""
+    req = Request(url, data=json.dumps(data).encode("utf-8"),
+                  headers=dict(headers, **{"Content-Type": "application/json"}),
+                  method="POST")
+    with urlopen(req, timeout=NOTIFY_TIMEOUT_SECONDS) as resp:
+        resp.read()
+
+
+def notify_job_complete(target, job_id, status, summary):
+    """Send a completion summary to a reply target captured after verification.
+
+    Never raises: a notifier failure must not fail the job. The Slack URL is
+    re-checked here as defense in depth.
+    """
+    if not isinstance(target, dict):
+        return
+    text = ("loki job %s finished: %s. %s" % (job_id, status, summary or "")).strip()
+    text = CONTROL_CHARS_RE.sub(" ", text)[:NOTIFY_TEXT_MAX]
+    try:
+        if target.get("kind") == "slack":
+            url = target.get("response_url", "")
+            if not (isinstance(url, str) and url.startswith(SLACK_REPLY_PREFIX)):
+                return
+            _post_json(url, {"response_type": "in_channel", "text": text}, {})
+        elif target.get("kind") == "linear":
+            key = os.environ.get("LINEAR_API_KEY", "")
+            issue_id = target.get("issue_id", "")
+            if not key or not isinstance(issue_id, str) or not issue_id:
+                return
+            _post_json(LINEAR_API_URL, {
+                "query": "mutation($i:String!,$b:String!){commentCreate(input:"
+                         "{issueId:$i,body:$b}){success}}",
+                "variables": {"i": issue_id, "b": text},
+            }, {"Authorization": key})
+    except Exception as e:  # notifier errors never fail a job
+        logging.warning("Completion notify for job %s failed: %s", job_id, e)
+
+
 def normalize_sentry_payload(payload):
     """Run the existing normalize_sentry_json over a Sentry webhook payload.
 
@@ -688,7 +953,7 @@ def handle_sentry_event(payload, dry_run=False):
     brief = build_sentry_brief(norm)
     if not valid_spec(brief):
         return None, "rejected (invalid brief)"
-    args = ["start", brief, "--pr", "--detach"]
+    args = brief_start_args(brief)
     summary = "sentry issue %s" % norm.get("number", "?")
     success = run_loki_command(args, dry_run=dry_run)
     status = "fired" if success else "error"
@@ -750,6 +1015,9 @@ class Dispatcher:
         self._job_max = max(1, job_history)
         self._jobs = collections.OrderedDict()
         self._jobs_lock = threading.Lock()
+        # Reply targets (Slack response_url / Linear issue) keyed by job_id,
+        # written only by the verified /slack and /linear handlers.
+        self._reply_targets = collections.OrderedDict()
         # Proof-attribution bookkeeping. The proof pointer is global to the
         # working directory, so a receipt only identifies a job when that job
         # was the only build that could have written it. All three are updated
@@ -887,6 +1155,17 @@ class Dispatcher:
             if summary:
                 entry["summary"] = summary
 
+    def set_reply_target(self, job_id, target):
+        """Store a verified reply target server side, bounded like _jobs."""
+        with self._jobs_lock:
+            self._reply_targets[job_id] = target
+            while len(self._reply_targets) > self._job_max:
+                self._reply_targets.popitem(last=False)
+
+    def pop_reply_target(self, job_id):
+        with self._jobs_lock:
+            return self._reply_targets.pop(job_id, None)
+
     def get_job(self, job_id):
         """Return a copy of the job record, or None if unknown/evicted.
 
@@ -980,6 +1259,9 @@ class Dispatcher:
                 )
                 if job_id:
                     self.record_job(job_id, status, summary or "")
+                    target = self.pop_reply_target(job_id)
+                    if target is not None:
+                        notify_job_complete(target, job_id, status, summary)
             finally:
                 self.queue.task_done()
 
@@ -998,6 +1280,16 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
     api_token = ""
     # Sentry integration client secret for /sentry. Distinct from both above.
     sentry_secret = ""
+    # Slack signing secret (/slack) and Linear webhook secret (/linear), each
+    # distinct from every other credential.
+    slack_secret = ""
+    linear_secret = ""
+    # Jira webhook secret (/jira), Teams outgoing-webhook token (/teams), and
+    # the Jira trigger filters (assignee ids/emails/names, labels).
+    jira_secret = ""
+    teams_secret = ""
+    jira_assignees = frozenset()
+    jira_labels = frozenset()
     dispatcher = None
     # Ed25519 key that attests receipts, and the retired public keys that keep
     # pre-rotation receipts verifiable. Both default to unconfigured, which
@@ -1278,8 +1570,21 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
             self._send_json(400, {"error": "invalid spec"})
             return
 
+        job_id = self._enqueue_job(spec.strip())
+        if job_id is None:
+            return
+        self._send_json(202, {"id": job_id, "status": "queued"})
+
+    def _enqueue_job(self, spec, reply_target=None, pr=False):
+        """Record and enqueue one validated job; shared by /jobs, /slack, /linear.
+
+        Returns the job id, or None after sending 429 when the queue is full.
+        reply_target must come from an already-verified request.
+        """
         job_id = secrets.token_urlsafe(12)
-        job = {"spec": spec.strip(), "job_id": job_id}
+        job = {"spec": spec, "job_id": job_id}
+        if pr:
+            job["pr"] = True
 
         # Record BEFORE enqueueing. A worker can pick the job up the instant
         # submit() returns and write "running"/"fired"; record_job is
@@ -1288,6 +1593,8 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
         # forever. On the 429 path below the record is unreachable (no id is
         # handed out) and the store is bounded, so nothing leaks.
         self.dispatcher.record_job(job_id, "queued", job["spec"])
+        if reply_target is not None:
+            self.dispatcher.set_reply_target(job_id, reply_target)
 
         # Enforce the existing queue bound so a submit storm cannot fork
         # unbounded builds. 429 (not a silent drop) tells the client to retry.
@@ -1295,13 +1602,207 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
             logging.warning(
                 "Queue full; shedding job submit from %s", self.address_string()
             )
+            self.dispatcher.pop_reply_target(job_id)
             log_event(JOB_EVENT, "", "", "rejected (queue full)")
             self._send_json(429, {"error": "server busy, retry later"})
-            return
+            return None
 
         log_event(JOB_EVENT, "", job["spec"], "queued")
+        return job_id
+
+    def _handle_slack(self):
+        """POST /slack -- signed slash command; enqueues a job, ephemeral reply."""
+        body = self._read_body()
+        if body is None:
+            return
+        if not self.slack_secret:
+            log_event(JOB_EVENT, "", "", "rejected (no slack signing secret configured)")
+            self._send_json(503, {"error": "SLACK_SIGNING_SECRET not configured"})
+            return
+        if not verify_slack_signature(
+                self.slack_secret,
+                self.headers.get("X-Slack-Request-Timestamp", ""),
+                body, self.headers.get("X-Slack-Signature", "")):
+            logging.warning("Invalid Slack signature from %s", self.address_string())
+            log_event(JOB_EVENT, "", "", "rejected (invalid slack signature)")
+            self._send_json(401, {"error": "invalid signature"})
+            return
+        # Verified from here on.
+        ctype = (self.headers.get("Content-Type", "") or "").lower()
+        if "json" in ctype:
+            try:
+                data = json.loads(body)
+            except ValueError:
+                self._send_json(400, {"error": "invalid JSON"})
+                return
+            if isinstance(data, dict) and data.get("type") == "url_verification":
+                self._send_json(200, {"challenge": str(data.get("challenge", ""))})
+                return
+            self._send_json(400, {"error": "unsupported slack payload"})
+            return
+        form = urllib.parse.parse_qs(body.decode("utf-8", errors="replace"))
+        text = (form.get("text") or [""])[0]
+        if not valid_spec(text):
+            log_event(JOB_EVENT, "", "", "rejected (invalid slack spec)")
+            self._send_json(200, {"response_type": "ephemeral",
+                                  "text": "Usage: /loki <spec>. Spec must be a "
+                                          "one-line brief or ref, not starting with '-'."})
+            return
+        response_url = (form.get("response_url") or [""])[0]
+        target = {"kind": "slack"}
+        if response_url.startswith(SLACK_REPLY_PREFIX):
+            target["response_url"] = response_url
+        job_id = self._enqueue_job(text.strip(), target)
+        if job_id is None:
+            return
+        self._send_json(200, {"response_type": "ephemeral",
+                              "text": "Queued loki job %s" % job_id})
+
+    def _handle_linear(self):
+        """POST /linear -- signed Linear issue webhook; enqueues linear:<identifier>."""
+        body = self._read_body()
+        if body is None:
+            return
+        if not self.linear_secret:
+            log_event(JOB_EVENT, "", "", "rejected (no linear webhook secret configured)")
+            self._send_json(503, {"error": "LINEAR_WEBHOOK_SECRET not configured"})
+            return
+        if not verify_linear_signature(
+                self.linear_secret, body, self.headers.get("Linear-Signature", "")):
+            logging.warning("Invalid Linear signature from %s", self.address_string())
+            log_event(JOB_EVENT, "", "", "rejected (invalid linear signature)")
+            self._send_json(401, {"error": "invalid signature"})
+            return
+        try:
+            payload = json.loads(body)
+        except ValueError:
+            self._send_json(400, {"error": "invalid JSON"})
+            return
+        if not isinstance(payload, dict):
+            self._send_json(400, {"error": "payload must be a JSON object"})
+            return
+        if not linear_fresh(payload):
+            log_event(JOB_EVENT, "", "", "rejected (stale linear timestamp)")
+            self._send_json(401, {"error": "stale or missing webhookTimestamp"})
+            return
+        data = payload.get("data")
+        if (payload.get("type") != "Issue" or payload.get("action") != "create"
+                or not isinstance(data, dict)):
+            self._send_json(200, {"status": "skipped"})
+            return
+        ident = data.get("identifier")
+        if not isinstance(ident, str) or not LINEAR_IDENTIFIER_RE.match(ident):
+            self._send_json(400, {"error": "invalid issue identifier"})
+            return
+        if self.dispatcher.seen_delivery(self.headers.get("Linear-Delivery", "")):
+            self._send_json(200, {"status": "duplicate"})
+            return
+        spec = "linear:%s" % ident
+        if not valid_spec(spec):
+            self._send_json(400, {"error": "invalid spec"})
+            return
+        issue_id = data.get("id")
+        target = {"kind": "linear",
+                  "issue_id": issue_id if isinstance(issue_id, str) else ""}
+        job_id = self._enqueue_job(spec, target)
+        if job_id is None:
+            return
+        self._send_json(202, {"id": job_id, "status": "queued"})
+
+    def _handle_jira(self):
+        """POST /jira -- signed Jira Cloud webhook; enqueues a PR-only run."""
+        body = self._read_body()
+        if body is None:
+            return
+        if not self.jira_secret:
+            log_event(JOB_EVENT, "", "", "rejected (no jira webhook secret configured)")
+            self._send_json(503, {"error": "JIRA_WEBHOOK_SECRET not configured"})
+            return
+        if not verify_jira_signature(
+                self.jira_secret, body, self.headers.get("X-Hub-Signature", "")):
+            logging.warning("Invalid Jira signature from %s", self.address_string())
+            log_event(JOB_EVENT, "", "", "rejected (invalid jira signature)")
+            self._send_json(401, {"error": "invalid signature"})
+            return
+        try:
+            payload = json.loads(body)
+        except ValueError:
+            self._send_json(400, {"error": "invalid JSON"})
+            return
+        if not isinstance(payload, dict):
+            self._send_json(400, {"error": "payload must be a JSON object"})
+            return
+        if (payload.get("webhookEvent") not in JIRA_EVENTS
+                or not jira_trigger_matches(
+                    payload, self.jira_assignees, self.jira_labels)):
+            self._send_json(200, {"status": "skipped"})
+            return
+        issue = payload["issue"]
+        key = issue.get("key")
+        if not isinstance(key, str) or not JIRA_KEY_RE.match(key):
+            self._send_json(400, {"error": "invalid issue key"})
+            return
+        brief = build_jira_brief(issue)
+        if not valid_spec(brief):
+            self._send_json(400, {"error": "invalid brief"})
+            return
+        # Jira has no signed timestamp, and the delivery id header is not covered
+        # by the HMAC, so also dedup on a hash of the signed body: a captured body
+        # cannot be replayed by changing or dropping the header.
+        dup_id = self.dispatcher.seen_delivery(
+            self.headers.get("X-Atlassian-Webhook-Identifier", ""))
+        dup_body = self.dispatcher.seen_delivery(
+            "jira-body:" + hashlib.sha256(body).hexdigest())
+        if dup_id or dup_body:
+            self._send_json(200, {"status": "duplicate"})
+            return
+        job_id = self._enqueue_job(brief, pr=True)
+        if job_id is None:
+            return
         self._send_json(202, {"id": job_id, "status": "queued"})
 
+    def _handle_teams(self):
+        """POST /teams -- Teams outgoing webhook; enqueues a PR-only run."""
+        body = self._read_body()
+        if body is None:
+            return
+        if not self.teams_secret:
+            log_event(JOB_EVENT, "", "", "rejected (no teams security token configured)")
+            self._send_json(503, {"error": "TEAMS_SECURITY_TOKEN not configured"})
+            return
+        if not verify_teams_signature(
+                self.teams_secret, body, self.headers.get("Authorization", "")):
+            logging.warning("Invalid Teams signature from %s", self.address_string())
+            log_event(JOB_EVENT, "", "", "rejected (invalid teams signature)")
+            self._send_json(401, {"error": "invalid signature"})
+            return
+        try:
+            activity = json.loads(body)
+        except ValueError:
+            self._send_json(400, {"error": "invalid JSON"})
+            return
+        if not isinstance(activity, dict):
+            self._send_json(400, {"error": "payload must be a JSON object"})
+            return
+        if not teams_fresh(activity):
+            log_event(JOB_EVENT, "", "", "rejected (stale teams timestamp)")
+            self._send_json(401, {"error": "stale or missing timestamp"})
+            return
+        brief = build_teams_brief(activity)
+        if not valid_spec(brief):
+            self._send_json(200, {"type": "message",
+                                  "text": "Usage: @loki <brief>. One-line brief, "
+                                          "not starting with '-'."})
+            return
+        act_id = activity.get("id")
+        if self.dispatcher.seen_delivery(act_id if isinstance(act_id, str) else ""):
+            self._send_json(200, {"type": "message", "text": "Duplicate, already queued."})
+            return
+        job_id = self._enqueue_job(brief, pr=True)
+        if job_id is None:
+            return
+        self._send_json(200, {"type": "message", "text": "Queued loki job %s" % job_id})
+
     def _handle_sentry(self):
         """POST /sentry -- Sentry alert, HMAC-verified, enqueues a fix run."""
         body = self._read_body()
@@ -1347,6 +1848,18 @@ class WebhookHandler(http.server.BaseHTTPRequestHandler):
         if path == "/sentry":
             self._handle_sentry()
             return
+        if path == "/slack":
+            self._handle_slack()
+            return
+        if path == "/linear":
+            self._handle_linear()
+            return
+        if path == "/jira":
+            self._handle_jira()
+            return
+        if path == "/teams":
+            self._handle_teams()
+            return
         if path != "/webhook":
             self._send_json(404, {"error": "not found"})
             return
@@ -1527,6 +2040,16 @@ def main():
         )
         sentry_secret = ""
 
+    # Slack/Linear secrets: env only. Each must differ from every other
+    # credential, since each authenticates a different party.
+    slack_secret, linear_secret = resolve_chat_secrets(
+        os.environ, secret, api_token, sentry_secret)
+
+    jira_secret, teams_secret = resolve_delegation_secrets(
+        os.environ, [secret, api_token, sentry_secret, slack_secret, linear_secret])
+    WebhookHandler.jira_assignees = _csv_set(os.environ.get("JIRA_ASSIGNEES", ""))
+    WebhookHandler.jira_labels = _csv_set(os.environ.get("JIRA_LABELS", ""))
+
     # Persist resolved values, but never write the secret to disk.
     config["port"] = port
     config["dry_run"] = dry_run
@@ -1541,6 +2064,10 @@ def main():
     WebhookHandler.secret = secret
     WebhookHandler.api_token = api_token
     WebhookHandler.sentry_secret = sentry_secret
+    WebhookHandler.slack_secret = slack_secret
+    WebhookHandler.linear_secret = linear_secret
+    WebhookHandler.jira_secret = jira_secret
+    WebhookHandler.teams_secret = teams_secret
     WebhookHandler.dispatcher = dispatcher
 
     signing_key, signing_kid = load_signing_key(auto_generate=False)
@@ -1587,6 +2114,24 @@ def main():
             "No Sentry secret configured: POST /sentry is rejected with 503. "
             "Set LOKI_SENTRY_WEBHOOK_SECRET or SENTRY_CLIENT_SECRET."
         )
+    if not slack_secret:
+        logging.warning(
+            "No Slack signing secret configured: POST /slack is rejected with "
+            "503. Set SLACK_SIGNING_SECRET."
+        )
+    if not linear_secret:
+        logging.warning(
+            "No Linear webhook secret configured: POST /linear is rejected with "
+            "503. Set LINEAR_WEBHOOK_SECRET."
+        )
+    if not jira_secret:
+        logging.warning(
+            "No Jira webhook secret configured: POST /jira is rejected with "
+            "503. Set JIRA_WEBHOOK_SECRET.")
+    if not teams_secret:
+        logging.warning(
+            "No Teams security token configured: POST /teams is rejected with "
+            "503. Set TEAMS_SECURITY_TOKEN.")
     if not secret:
         logging.warning(
             "No webhook secret configured: ALL webhooks will be rejected with "