mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/feedback/bundle.py

@@ -0,0 +1,204 @@
+"""The diagnostics bundle a feedback report may carry (docs/feedback.mdx), built here so the Mac app can show it, word
+for word, before anything is sent."""
+
+import json
+import platform
+import re
+from collections import deque
+from pathlib import Path
+
+from .. import harness_api, secret_filter
+
+EVENTS = 150
+LOG_LINES = 200
+STRING_MAX = 400
+MAX_BYTES = 500_000
+MASK = "[masked]"
+# Event fields that are pictures or trees, never sent.
+DROP_KEYS = {"screenshot", "image", "frame", "frames", "png", "jpeg", "thumbnail", "elements", "tree", "source", "xml",
+             "accessibility", "dataUrl", "data_url", "audio"}
+
+_SCRUB = (
+    (re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)"), MASK),
+    (
+        re.compile(
+            r"https?://[^\s\"'<>]*(?:/webhooks?/|[?&](?:token|sig|signature|key|secret|code|access_token)=)[^\s\"'<>]*",
+            re.I), MASK),
+    (re.compile(r"\b(?:access|refresh|session|api|auth)[_-]?(?:token|key|secret)\b(\s*[:=]\s*)[\"']?[^\s,;\"']{6,}",
+                re.I), None),
+    (re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"), "<email>"),
+    (re.compile(r"\b[0-9A-Fa-f]{8}-[0-9A-Fa-f]{16}\b|\b[0-9a-fA-F]{40}\b"), "<UDID>"),
+)
+
+
+def scrub(text, emails=True):
+    """``text`` masked: secret_filter.redact, then what a log holds besides: private key blocks, webhook and signed
+    URLs, email addresses (``emails`` False keeps them), device UDIDs and the home folder's name."""
+    if not isinstance(text, str) or not text:
+        return text
+    out = secret_filter.redact(text)
+    for pattern, to in _SCRUB:
+        if not emails and to == "<email>":
+            continue
+        out = pattern.sub(lambda m: m.group(0)[:m.start(1) - m.start(0)] + m.group(1) + MASK, out) if to is None \
+            else pattern.sub(to, out)
+    home = str(Path.home())
+    if len(home) > 1:
+        out = out.replace(home, "~")
+    return out
+
+
+def _clean(value, depth=0):
+    """A JSON value with every string scrubbed and cut, pictures and trees dropped, and depth bounded."""
+    if isinstance(value, str):
+        if value.startswith("data:") or len(value) > 2000 and re.fullmatch(r"[A-Za-z0-9+/=\s]+", value[:2000]):
+            return "[omitted]"
+        text = scrub(value)
+        return text if len(text) <= STRING_MAX else text[:STRING_MAX] + "…"
+    if isinstance(value, bool) or value is None or isinstance(value, (int, float)):
+        return value
+    if depth >= 5:
+        return "[omitted]"
+    if isinstance(value, dict):
+        return {scrub(str(k))[:80]: _clean(v, depth + 1) for k, v in list(value.items())[:60]
+                if str(k) not in DROP_KEYS}
+    if isinstance(value, (list, tuple)):
+        return [_clean(v, depth + 1) for v in list(value)[:60]]
+    return scrub(str(value))[:STRING_MAX]
+
+
+def data_dir(runtime):
+    """The app's data folder when this agent was given one (the Mac app passes --data-dir), else None: a test or a CLI
+    agent never reads the real folder."""
+    config = getattr(runtime, "config", None)
+    value = getattr(config, "data_dir", None)
+    return Path(value) if value else None
+
+
+def connection_of(device):
+    if not isinstance(device, dict):
+        return None
+    if device.get("transport") == "wifi":
+        return "Wi-Fi"
+    return {"usb": "USB", "simulator": "Simulator", "wda": "WebDriverAgent address"}.get(device.get("kind"),
+                                                                                         device.get("kind"))
+
+
+def phone_of(runtime, run=None):
+    """{model, ios, connection} of the run's phone, else the default phone, else None."""
+    fleet = getattr(runtime, "fleet", None)
+    try:
+        devices = fleet.public() if fleet is not None else []
+    except Exception:  # noqa: BLE001 -- a fleet that can't answer leaves the phone out
+        devices = []
+    wanted = (run or {}).get("device")
+    device = next((d for d in devices if wanted and d.get("id") == wanted), None) \
+        or next((d for d in devices if d.get("default")), None) or (devices[0] if devices else None)
+    if not device:
+        return None
+    return {"model": device.get("modelName") or device.get("model"), "ios": device.get("ios"),
+            "connection": connection_of(device), "state": device.get("state")}
+
+
+def macos():
+    version = platform.mac_ver()[0]
+    return f"macOS {version}" if version else platform.system() or None
+
+
+def last_run(runtime, run_id=None):
+    """The run's public dict (with events): ``run_id``'s, else the newest. A run that stays on this Mac
+    (harness_api.stays_on_mac: Network X-ray's report) is never in a bundle."""
+    lock = getattr(runtime, "lock", None)
+    runs = getattr(runtime, "runs", None) or {}
+    if lock is not None:
+        with lock:
+            items = dict(runs)
+    else:
+        items = dict(runs)
+    items = {key: run for key, run in items.items() if not harness_api.stays_on_mac(getattr(run, "extras", None))}
+    run = items.get(run_id) if run_id else max(items.values(), key=lambda r: getattr(r, "created_at", 0), default=None)
+    if run is None:
+        return None
+    return run.public(include_events=True)
+
+
+def log_lines(directory, count=LOG_LINES):
+    """The last ``count`` lines of agent.log, scrubbed; [] when there's no log."""
+    if directory is None:
+        return []
+    path = directory / "logs" / "agent.log"
+    try:
+        size = path.stat().st_size
+        with path.open("rb") as handle:
+            handle.seek(max(0, size - 400_000))
+            tail = deque(handle.read().decode("utf-8", "replace").splitlines(), maxlen=count)
+    except OSError:
+        return []
+    return [_clean(line) for line in tail if line.strip()]
+
+
+def build(runtime, run_id=None, app_version=None):
+    """The bundle: app, phone, run and log, each masked, with no screenshot, frame or element tree. {text, bytes,
+    summary}."""
+    run = last_run(runtime, run_id)
+    if run_id and run is None:
+        from ..api_errors import APIError
+        raise APIError("That task isn't on this Mac anymore.", 404, "not_found")
+    bundle = {
+        "app": {"version": _clean(app_version) if app_version else None, "agent": _agent_version(),
+                "macos": macos(), "arch": platform.machine() or None},
+        "phone": phone_of(runtime, run),
+        "run": None,
+        "log": log_lines(data_dir(runtime)),
+    }
+    if run is not None:
+        events = list(run.get("events") or [])[-EVENTS:]
+        bundle["run"] = {"id": run.get("id"), "status": run.get("status"), "goal": _clean(run.get("goal")),
+                         "app": _clean(run.get("appName")), "engine": run.get("engine"),
+                         "createdAt": run.get("createdAt"), "finishedAt": run.get("finishedAt"),
+                         "eventCount": run.get("eventCount"), "events": [_clean(e) for e in events]}
+    text = json.dumps(bundle, indent=2, ensure_ascii=False)
+    # Over the limit: drop log lines, then events, from the oldest, until it fits.
+    while len(text.encode("utf-8")) > MAX_BYTES and (bundle["log"] or (bundle["run"] and bundle["run"]["events"])):
+        if bundle["log"]:
+            del bundle["log"][: max(1, len(bundle["log"]) // 4)]
+        else:
+            del bundle["run"]["events"][: max(1, len(bundle["run"]["events"]) // 4)]
+        text = json.dumps(bundle, indent=2, ensure_ascii=False)
+    return {"text": text, "bytes": len(text.encode("utf-8")),
+            "summary": {"events": len(bundle["run"]["events"]) if bundle["run"] else 0, "logLines": len(bundle["log"]),
+                        "runId": bundle["run"]["id"] if bundle["run"] else None, "phone": bundle["phone"],
+                        "macos": bundle["app"]["macos"]}}
+
+
+def _agent_version():
+    from .. import __version__
+    return __version__
+
+
+def check(text):
+    """The bundle text a report sends: the one the app showed, scrubbed again (idempotent), at most MAX_BYTES,
+    and a JSON object."""
+    if not isinstance(text, str) or not text:
+        raise ValueError("The diagnostics are the bundle Mobster showed")
+    try:
+        value = json.loads(text)
+    except ValueError:
+        raise ValueError("The diagnostics aren't the bundle Mobster showed") from None
+    if not isinstance(value, dict):
+        raise ValueError("The diagnostics aren't the bundle Mobster showed")
+    cleaned = json.dumps(_scrub_all(value), indent=2, ensure_ascii=False)
+    if len(cleaned.encode("utf-8")) > MAX_BYTES:
+        raise ValueError("The diagnostics are over 500 KB")
+    return cleaned
+
+
+def _scrub_all(value):
+    """Every string in a JSON value scrubbed again; nothing cut or dropped (the app showed exactly this)."""
+    if isinstance(value, str):
+        return scrub(value)
+    if isinstance(value, dict):
+        return {scrub(str(k)): _scrub_all(v) for k, v in value.items() if str(k) not in DROP_KEYS}
+    if isinstance(value, list):
+        return [_scrub_all(v) for v in value]
+    return value

mobile_agent/feedback/outbox.py

@@ -0,0 +1,196 @@
+"""Sending a feedback report to the account service, and keeping it here when it can't go yet (docs/feedback.mdx)."""
+
+import json
+import os
+import re
+import threading
+import time
+from pathlib import Path
+
+from ..api_errors import APIError
+
+TIMEOUT = 30.0
+MAX_ITEMS = 20
+MAX_REPORT_BYTES = 4_400_000
+DRAFT_ID = re.compile(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}")
+QUEUED_CODES = {"unreachable", "untrusted_server", "busy", "not_configured", "rate_limited", "error"}
+
+
+class SendError(Exception):
+    """The service refused or couldn't be reached."""
+
+    def __init__(self, code, status, message):
+        super().__init__(message)
+        self.code, self.status = code, status
+
+
+def _post(path, token, body, timeout=TIMEOUT):
+    from ..share import ShareError, call
+    try:
+        status, value = call("POST", path, token, body, timeout, limit=64_000)
+    except ShareError as error:
+        if error.code == "untrusted_server":
+            raise SendError("untrusted_server", 503, "Mobster couldn't verify its server, so it didn't send.") from None
+        raise SendError("unreachable", 503, "Mobster couldn't reach its server.") from None
+    if 200 <= status < 300:
+        return value
+    message = value.get("message") if isinstance(value.get("message"), str) else None
+    code = value.get("error") if isinstance(value.get("error"), str) else "error"
+    if status == 401:
+        raise SendError("session", 401, "Sign in to Mobster again to send this.")
+    if status == 429:
+        raise SendError("rate_limited", 429, message or "Mobster's server is busy. It sends this later.")
+    if status == 413:
+        raise SendError("too_large", 413, message or "That report is too large. Leave out the screenshot.")
+    if status in (400, 415):
+        raise SendError("invalid", 400, message or "Mobster's server refused that report.")
+    # A server without the route yet (404) or not set up for it (503 not_configured): it waits and goes later.
+    if status == 404 or status == 503 and code == "not_configured":
+        raise SendError("not_configured", 503, "Mobster's server isn't taking reports yet. It sends this later.")
+    raise SendError("busy" if status in (502, 503, 504) else "error", 503,
+                    message or "Mobster's server couldn't take the report. It sends this later.")
+
+
+def submit(report, token):
+    """Posts one report: {reference, kind, createdAt, forwarded}."""
+    body = json.dumps(report, ensure_ascii=False).encode("utf-8")
+    if len(body) > MAX_REPORT_BYTES:
+        raise SendError("too_large", 413, "That report is over 4.4 MB. Leave out the screenshot or crop it.")
+    value = _post("/api/feedback", token, body)
+    feedback = value.get("feedback")
+    if not isinstance(feedback, dict) or not isinstance(feedback.get("reference"), str):
+        raise SendError("error", 502, "Mobster's server answered without a reference. It sends this again later.")
+    return feedback
+
+
+class Outbox:
+    """Reports waiting to be sent: a folder of JSON files, or memory."""
+
+    def __init__(self, directory=None):
+        self.directory = Path(directory) if directory else None
+        self.memory = {}
+        self.lock = threading.Lock()
+
+    def _path(self, draft_id):
+        return self.directory / f"{draft_id}.json"
+
+    def _write(self, item):
+        if self.directory is None:
+            self.memory[item["draftId"]] = item
+            return
+        self.directory.mkdir(parents=True, exist_ok=True)
+        os.chmod(self.directory, 0o700)
+        path = self._path(item["draftId"])
+        tmp = path.with_suffix(".tmp")
+        fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(item, handle, ensure_ascii=False)
+        os.replace(tmp, path)
+
+    def items(self):
+        """Every waiting report, oldest first."""
+        if self.directory is None:
+            found = list(self.memory.values())
+        else:
+            found = []
+            for path in sorted(self.directory.glob("*.json")) if self.directory.is_dir() else []:
+                try:
+                    item = json.loads(path.read_text("utf-8"))
+                except (OSError, ValueError):
+                    continue
+                if isinstance(item, dict) and DRAFT_ID.fullmatch(str(item.get("draftId", ""))):
+                    found.append(item)
+        return sorted(found, key=lambda item: item.get("queuedAt", 0))
+
+    def put(self, report, error):
+        with self.lock:
+            waiting = self.items()
+            if len(waiting) >= MAX_ITEMS and not any(item["draftId"] == report["clientId"] for item in waiting):
+                raise APIError(f"{MAX_ITEMS} reports are already waiting to send. Delete one, or send them first.",
+                               409, "outbox_full")
+            self._write({"draftId": report["clientId"], "queuedAt": time.time(), "attempts": 1, "lastError": error,
+                         "report": report})
+
+    def touch(self, item, error):
+        with self.lock:
+            self._write({**item, "attempts": int(item.get("attempts", 0)) + 1, "lastError": error})
+
+    def remove(self, draft_id):
+        with self.lock:
+            if self.directory is None:
+                return self.memory.pop(draft_id, None) is not None
+            try:
+                self._path(draft_id).unlink()
+                return True
+            except FileNotFoundError:
+                return False
+
+    def public(self):
+        """What the app lists: no attachments, no description."""
+        return [{"draftId": item["draftId"], "kind": item["report"].get("kind"), "title": item["report"].get("title"),
+                 "queuedAt": int(item.get("queuedAt", 0) * 1000), "attempts": item.get("attempts", 0),
+                 "lastError": item.get("lastError"), "screenshot": bool(item["report"].get("screenshot")),
+                 "diagnostics": bool(item["report"].get("diagnostics"))} for item in self.items()]
+
+
+_outboxes = {}
+_outboxes_lock = threading.Lock()
+
+
+def outbox_for(runtime):
+    """The runtime's outbox: under its data folder when it has one (bundle.data_dir), else in memory."""
+    from .bundle import data_dir
+    with _outboxes_lock:
+        box = _outboxes.get(id(runtime))
+        if box is None or box[0] is not runtime:
+            directory = data_dir(runtime)
+            box = (runtime, Outbox(directory / "feedback" / "outbox" if directory else None))
+            _outboxes[id(runtime)] = box
+        return box[1]
+
+
+def send(runtime, report, token):
+    """Sends ``report`` now, or keeps it in the outbox when the service can't take it yet. The service answers a second
+    send of the same draft (``clientId``) with the same reference, so sending again never makes a second report."""
+    box = outbox_for(runtime)
+    try:
+        feedback = submit(report, token)
+    except SendError as error:
+        if error.code in QUEUED_CODES:
+            box.put(report, error.code)
+            return {"queued": True, "draftId": report["clientId"], "reason": str(error)}
+        raise APIError(str(error), error.status, error.code) from None
+    finally:
+        token = None
+    box.remove(report["clientId"])
+    return {"feedback": feedback, "queued": False}
+
+
+def flush(runtime, token):
+    """Tries every waiting report, oldest first; stops at the first one the service can't take now."""
+    box = outbox_for(runtime)
+    sent, error = [], None
+    try:
+        for item in box.items():
+            try:
+                feedback = submit(item["report"], token)
+            except SendError as problem:
+                if problem.code in QUEUED_CODES:
+                    box.touch(item, problem.code)
+                    error = str(problem)
+                    break
+                if problem.code == "session":
+                    error = str(problem)
+                    break
+                # The service refuses this report for good (a field it won't take): it would wait forever.
+                box.remove(item["draftId"])
+                error = f"Mobster couldn't send “{item['report'].get('title', '')}”: {problem}"
+                continue
+            box.remove(item["draftId"])
+            sent.append({"draftId": item["draftId"], "reference": feedback["reference"]})
+    finally:
+        token = None
+    out = {"sent": sent, "waiting": len(box.items())}
+    if error:
+        out["error"] = error
+    return out

mobile_agent/feedback/register.py

@@ -0,0 +1,9 @@
+"""Track ``feedback``'s registrations (tracks.load calls ``register(api)`` once per process, staged): the routes under
+/api/feedback (routes.py)."""
+
+from . import routes
+
+
+def register(api):
+    """``api`` is mobile_agent.harness_api."""
+    routes.register_routes()

mobile_agent/feedback/routes.py

@@ -0,0 +1,177 @@
+"""The local API for in-app feedback, under /api/feedback (api_routes, owner "feedback")."""
+
+import base64
+import json
+import re
+
+from ..api_errors import APIError
+from ..api_routes import Response, Route, register
+from ..service_support import needs_app
+from . import bundle, outbox
+
+MAX_BODY = 6_000_000
+KINDS = ("bug", "feature", "support")
+FIELDS = {"draftId", "kind", "title", "description", "email", "runId", "app", "screenshot", "diagnostics",
+          "accessToken"}
+APP_FIELDS = ("version", "macos", "connection", "phone", "ios")
+APP_ONLY = "Sending feedback is in Mobster for Mac."
+MASKS = re.compile(r"\[masked\]|••••••")
+
+
+def _json(request):
+    body = request.body
+    if isinstance(body, (bytes, bytearray)):
+        try:
+            body = json.loads(body)
+        except ValueError:
+            raise ValueError("The body must be a JSON object") from None
+    if not isinstance(body, dict):
+        raise ValueError("The body must be a JSON object")
+    return body
+
+
+def _token(body):
+    token = body.pop("accessToken", None)
+    if not isinstance(token, str) or not 16 <= len(token) <= 8192:
+        raise APIError("Sign in to Mobster to send feedback.", 401, "session")
+    return token
+
+
+def _masked(text, emails=True):
+    """(masked text, how many values it masked)."""
+    if not isinstance(text, str):
+        return text, 0
+    out = bundle.scrub(text, emails=emails)
+    return out, max(0, len(MASKS.findall(out)) - len(MASKS.findall(text)))
+
+
+def report_of(body):
+    """The report as it goes to the account service: checked, masked."""
+    unknown = set(body) - FIELDS
+    if unknown:
+        raise ValueError(f"{sorted(unknown)[0][:40]} isn't a feedback field")
+    draft = body.get("draftId")
+    if not isinstance(draft, str) or not outbox.DRAFT_ID.fullmatch(draft):
+        raise ValueError("draftId is the draft's id, a lowercase UUID")
+    if body.get("kind") not in KINDS:
+        raise ValueError("kind is bug, feature or support")
+    title = body.get("title")
+    if not isinstance(title, str) or not 1 <= len(title.strip()) <= 120:
+        raise ValueError("Add a title of 1 to 120 characters")
+    description = body.get("description") or ""
+    if not isinstance(description, str) or len(description) > 5000:
+        raise ValueError("Keep the description under 5,000 characters")
+    masked = 0
+    title, count = _masked(" ".join(title.split()), emails=False)
+    masked += count
+    description, count = _masked(description.strip(), emails=False)
+    masked += count
+    report = {"clientId": draft, "kind": body["kind"], "title": title[:120], "description": description}
+    email = body.get("email")
+    if email not in (None, ""):
+        if (not isinstance(email, str) or len(email) > 254
+                or not re.fullmatch(r"[^\s@]+@[^\s@]+\.[A-Za-z]{2,}", email.strip())):
+            raise ValueError("That reply-to email doesn't look right")
+        report["email"] = email.strip()
+    run_id = body.get("runId")
+    if run_id is not None:
+        if not isinstance(run_id, str) or not re.fullmatch(r"[a-f0-9]{12}", run_id):
+            raise ValueError("runId is a task's id")
+        report["runId"] = run_id
+    app = body.get("app")
+    if app is not None:
+        if not isinstance(app, dict) or set(app) - set(APP_FIELDS):
+            raise ValueError("app is {version, macos, connection, phone, ios}")
+        facts = {}
+        for key in APP_FIELDS:
+            value = app.get(key)
+            if value is None:
+                continue
+            if not isinstance(value, str):
+                raise ValueError(f"app.{key} is text")
+            text, count = _masked(" ".join(value.split())[:80])
+            masked += count
+            facts[key] = text
+        report["app"] = facts
+    shot = body.get("screenshot")
+    if shot is not None:
+        if (not isinstance(shot, dict) or set(shot) != {"type", "data"}
+                or shot["type"] not in ("image/png", "image/jpeg")
+                or not isinstance(shot["data"], str)):
+            raise ValueError("screenshot is {type: image/png or image/jpeg, data: base64}")
+        try:
+            raw = base64.b64decode(shot["data"], validate=True)
+        except ValueError:
+            raise ValueError("The screenshot isn't base64") from None
+        if len(raw) > 2_500_000:
+            raise APIError("That screenshot is over 2.5 MB. Crop it, or send the report without one.", 413, "too_large")
+        png, jpeg = raw[:8] == b"\x89PNG\r\n\x1a\n", raw[:3] == b"\xff\xd8\xff"
+        if not (png if shot["type"] == "image/png" else jpeg):
+            raise ValueError("The screenshot isn't the image it says it is")
+        report["screenshot"] = {"type": shot["type"], "data": shot["data"]}
+    diagnostics = body.get("diagnostics")
+    if diagnostics is not None:
+        before = len(MASKS.findall(diagnostics)) if isinstance(diagnostics, str) else 0
+        report["diagnostics"] = bundle.check(diagnostics)
+        masked += max(0, len(MASKS.findall(report["diagnostics"])) - before)
+    return report, masked
+
+
+def diagnostics(request):
+    body = request.body or {}
+    if set(body) - {"runId", "appVersion"}:
+        raise ValueError("The diagnostics take runId and appVersion")
+    run_id = body.get("runId")
+    if run_id is not None and (not isinstance(run_id, str) or not re.fullmatch(r"[a-f0-9]{12}", run_id)):
+        raise ValueError("runId is a task's id")
+    version = body.get("appVersion")
+    if version is not None and not isinstance(version, str):
+        raise ValueError("appVersion is text")
+    return Response.json(bundle.build(request.runtime, run_id=run_id, app_version=(version or "")[:80] or None))
+
+
+def send(request):
+    needs_app(request, APP_ONLY)
+    body = _json(request)
+    token = _token(body)
+    try:
+        report, masked = report_of(body)
+        answer = outbox.send(request.runtime, report, token)
+    finally:
+        token = None
+    return Response.json({**answer, "masked": masked}, 202 if answer["queued"] else 201)
+
+
+def waiting(request):
+    return Response.json({"items": outbox.outbox_for(request.runtime).public()})
+
+
+def flush(request):
+    needs_app(request, APP_ONLY)
+    body = request.body or {}
+    token = _token(body)
+    if body:
+        raise ValueError("Sending waiting reports takes only the account's accessToken")
+    try:
+        return Response.json(outbox.flush(request.runtime, token))
+    finally:
+        token = None
+
+
+def delete(request):
+    needs_app(request, APP_ONLY)
+    draft = request.params["draft"]
+    if not outbox.outbox_for(request.runtime).remove(draft):
+        raise APIError("That report isn't waiting to send.", 404, "not_found")
+    return Response.json({"deleted": draft})
+
+
+def register_routes():
+    for route in (Route("feedback", "POST", "/api/feedback/diagnostics", diagnostics),
+                  Route("feedback", "POST", "/api/feedback", send, body="raw", max_bytes=MAX_BODY),
+                  Route("feedback", "GET", "/api/feedback/outbox", waiting, body="none"),
+                  Route("feedback", "POST", "/api/feedback/outbox/flush", flush),
+                  Route("feedback", "DELETE",
+                        "/api/feedback/outbox/(?P<draft>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})",
+                        delete, body="none")):
+        register(route)