From 712af2839d627be4e48be229dc6e0c2b762d9c8a Mon Sep 17 00:00:00 2001 From: Joren de Graaf Date: Thu, 22 Oct 2026 10:27:11 +0200 Subject: [PATCH] latest changes incl grocery list --- fireworks_detect/MCP_README.md | 25 ++ .../__pycache__/admin.cpython-312.pyc | Bin 20030 -> 20545 bytes .../__pycache__/mcp.cpython-312.pyc | Bin 0 -> 16625 bytes .../__pycache__/models.cpython-312.pyc | Bin 36025 -> 36977 bytes fireworks_detect/admin.py | 12 +- .../management/commands/create_mcp_token.py | 25 ++ fireworks_detect/mcp.py | 225 ++++++++++++++++++ .../migrations/0016_mcpaccesstoken.py | 27 +++ fireworks_detect/models.py | 13 + fireworks_detect/test_mcp.py | 85 +++++++ myproject/__pycache__/urls.cpython-312.pyc | Bin 1911 -> 2021 bytes myproject/urls.py | 2 + 12 files changed, 413 insertions(+), 1 deletion(-) create mode 100644 fireworks_detect/MCP_README.md create mode 100644 fireworks_detect/__pycache__/mcp.cpython-312.pyc create mode 100644 fireworks_detect/management/commands/create_mcp_token.py create mode 100644 fireworks_detect/mcp.py create mode 100644 fireworks_detect/migrations/0016_mcpaccesstoken.py create mode 100644 fireworks_detect/test_mcp.py diff --git a/fireworks_detect/MCP_README.md b/fireworks_detect/MCP_README.md new file mode 100644 index 0000000..4176513 --- /dev/null +++ b/fireworks_detect/MCP_README.md @@ -0,0 +1,25 @@ +# BoomCast read-only MCP + +The stateless Streamable HTTP endpoint is `POST /mcp/` on the **existing Django web server**. The normal local development command uses `127.0.0.1:8000`; MCP needs no second port or process. Use the public HTTPS Django origin for a remote client. Do not expose the local HTTP listener directly. + +Run migrations, then issue a separate credential for an active user who has both `fireworks_detect.view_event` and `fireworks_detect.view_pendingevent` permissions: + +```sh +python manage.py migrate +python manage.py create_mcp_token USERNAME --name "My MCP client" +``` + +The command prints the token once. Configure the MCP client with a Streamable HTTP URL such as `https://django.jorendegraaf.eu/mcp/` and header `Authorization: Bearer bmcp_...`. Refresh the client's MCP tools after configuring it. A sensor `ss_...` Bearer token, browser login cookie, or anonymous request cannot access the endpoint. To revoke a credential, set its `McpAccessToken.revoked_at` in Django admin/shell (or delete the record). Removing either Django view permission or deactivating the user also denies access. MCP uses the same Django user permission backend as admin; no write permissions are needed. + +Available tools: `submissions_list`, `submissions_get`, `submissions_stats`, and `pending_summary`. Date filters use `YYYY-MM-DD` and apply to review date. A query covers at most 366 days; if omitted, the default is the most recent 366 days. List pages are capped at 100 items and offset 10,000. The endpoint is limited to 120 requests per minute per user. It accepts JSON responses for MCP initialize, tool discovery and tool calls. It supports no write methods or server state changes. + +Only approved `Event` rows are individually available. The existing review workflow **deletes denied `PendingEvent` rows**, so historical denial statistics and manually confirmed sound classes do not exist in the current data model. MCP reports `review_outcome: approved`, `confirmed_classification: null`, and `confirmed_classification_available: false` rather than treating a YAMNet prediction as a human confirmation. Pending results contain counts only. The only location field is the existing H3 cell or a cell calculated using the configured H3 resolution; exact coordinates, audio, filenames, free-text locations, notes, sensor identity, and raw classifier responses are omitted. + +For a quick protocol check after client setup: + +```sh +curl -sS https://django.jorendegraaf.eu/mcp/ \ + -H "Authorization: Bearer $BOOMCAST_MCP_TOKEN" \ + -H 'Content-Type: application/json' \ + -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' +``` diff --git a/fireworks_detect/__pycache__/admin.cpython-312.pyc b/fireworks_detect/__pycache__/admin.cpython-312.pyc index da5be5c8d62022ecff1e860c1e145caecd22d829..7cdac6e441ea4713991c5a025f0bb61faca550b1 100644 GIT binary patch delta 4426 zcmb7Hdu)@}758;)$B7d=F9+vsVw~Uv=jkMbqzNG;B!QZeK%rs7nD`5X*>QS5Crbh? zp=Cprh6n1v(O>_%PteZPcnklV}*gTskCEk=iJYEI8er- z==Ys_9`|w1J?C6sIK?iWX6Cn3QxN+^#>Q&5_Q()2j#s+e>)N;6QJxmap( zYc(4*fh^=(=lHt*3e}`cT5*oi_B6OYYGtF=GO6NRg33Fmel-1+u@wrnmOLBkGxfMKdipx>4c(J0seuB9ia5mxNgd`;gEQvYr6P?#=esW->ZD2r><*nf_NpN3R z&kDg_pDnR|eIVh8rr$83bLo}LIJM!nKxk;#rBigHvcwhLus8T3gxeC%2 z2k$}3mHIH>aSw{1KBdS+CsMcG3%gUSxtnn;Q&z84x79*&f?{|%MOGc!5;dkCU~X~u zTnW6NRCW{4WyGL8Lm#7(>>mvbh4G>UCB74WW^Oi+fIHw*bFno*8l=nhD5(ybh8wiria?%pef^-AB}tOxQs@ zf+t{G#&fC{cSL70uCq>YDB%P0hLR#n!*ZDW!e1W7nqV66k3>efC;`H|+)p#@As9fw zvT%UtgK$5~wM`{y{2ama2#R^nD3>F?*gP_)-MREJt2kAD2#1sAb);{f*Kdy=w0>P% zNS+pla%mN9MU|o(@$}c#XvIjpE$Cp@5dMRqlRUAIXMq!P!$9e|kJej~mkdL5P;qM+RoOhaXjuDS;wvrOUUf|y=`KYw> zPPpP6V={D?G_xPTS4%qbM@dO1`^O|Dv2R;@dq-a%W~y*lIeb`h(jXjm3J#T)u#xEN zr7IKiOKEa(uUtsQU3E9yDRY^=NeXKAN1f#-*=Dt6P#@-*1V(}j2zUY1rI1#P*eCde zEJYNfe`JJ*$D{!N6$)hP0CxIQE5QULx=Y!&q0;?IGP!B8ZoM=-0oCQ%(GT1;tnU)? zu*c~F$mQ{iDv8_MdcED=4T~4%ze5AXfa*h^v*IM|uUx^t3olo`bcj}TS(hZGlIS0Z zU=x!?Ll6lTOH9<}i3AJDNw-hE_hUr8MsSLNDz9QtXW|pYnIzao@H7II!;HClI8Iyw zZ*;mUgQ=-J4i~F`y8KZALW9Wy_;*=>_YIn0zD8qTU2>+Sr=Z;}EhjU?BRB`z+8T8a zGq{Hw=&SwU(HCW_r`q)Mg)P8wkE38=<6BU&&{Ih5EL`?@Out-YfgS0Q7QJZUfP3BP z+uvHSBB}?$Wn6k(YUOIs#7WQ6u$N#-3B5)(v7#fv){*fV{cw6xT64FxvZ>%~!F~sci zc9ThMPj%acJ~q9ZP_z0?TN|n=NnH|F$36Itb7^A>!u{2+v-aqj#xR>Ji@8lsHOp^6 zN0XghhQX%oSkW#teadn#(P|=xI*AgA`$M8Wfp?zBu6Y;92U1Bbpn9>NrMY_ta$4-{ zDy(UFHAtD{by*%7hbCHMp}+l}hN83e5w(y|H)wd3;10o(P<=!^g5N+(>z~w6eFToR zcUV7I+nhG?Acn?(dBt@EqW$R^tnb{?O1Ff63jrTtNAaVu!MIxY67nW(o%H(jh9i=A zLsvBKm4>D95#I74{JHJd+Y@k7C2=4;9FfK&=%|e}PYSh#`C6AeHY5-22}&4mQ6?2L zKAZ8;=HpV3-rwAdHnCKQz0l0?uXT2I1M=I~h(3YO?xII0+c(-vOybt5`A(0yN2bnM z(64uyZsW?a3h_TJdSQIM>(K0i1yLf=(mpr9ias(rf^V|>sH^CGAt~Y)S6$6Q5q&d7 zWl289)x)`R$VgF7_&zv0dJ^e!amHY*;}@B!B>OEbV!&Swa(Eb@ep}jl^XDVXji?bH zT=;S4O7k$%C@uNV5^5sXM2?@<}4l#^8ZtgQBT9geVZ z%?HliRnG3gGhJPe8My0R)g~=%|FHwNv)g0R{~s2;u(MlK$wTCXg@&L8@8Pe{EYkcB zoz_Yel_xc3j~%XMWJmA`+RBXxcj0S2jj1AR#CJ7t8Lsr)Vx4etV@sMSgI}R_3JK0b z@}^v$ok;ORtA(f?1k@2lM-nAkB)_;{>UPB~5o^a+iqDMAp>SX{D7EkkTpa&3@?YTj zP3~5|7I(<}+J6eXrYXH`&}h@9tVatE7alji%ZmP?H8AU|&OhXqy^~uutHHr+f<|k< QP3+ql(F>anG7;jE3Hnh5(x@lV1ZADC_g0X6_PwU3$TE@C=wEVGlY_N0g=On~D zIxG44+;h+4-gE9b_xjD}+0VYkoNqfESqA(hUp+Vcx0WN$BDVjC?~TRG5VnUM(VCIk zK_4?14YF-`1BuQ3$et5S=NJvE3}NR%L)Zl#VEjZ4+=4_nFnVzvP5YoBG z%S-WWw!sEn{K!pjMLy0H$PFhlblWFVP6r!P7Q;qwMIp+}zl%&$O6Db_*Ia}$#nWD` z3sW=IIOE2dlIfZ5X54FOv~V{d4wPhE~d_t(3It_UA^3Msf>`W)wh` zF^}S6ZX0Kk7mTLAGaLNV6oEbFHu#!#Yn~THc_o6xxCg%ik_9eXS|QU`Vx2NvM~(qD zTe|GL0x1DGu*BxJ)Qe$qht1Ad6AWkm(WY5;MdWB$fpuABtR?wa)_m5mkfdA)8VgPt zHIpJocWD{%ox_R|nH~>cKmtt&6ZP;zM+Ka*+gUAKw0E(3D42H$4qNh9@&YnoMJ;(q zRWysdFQTZ*R0e-Q@VUGqIG-}cdywXx2q_c#0<{7-=O}=aj`jnzq3dRZNy9}~J{M7V5Qmb3SK$}0 zCa58(MbKPa4u#{f=y*_%4bLTRraq8Wg3eG=S%M;nIu$)Bjj+R3oV@AW$=bB6AzXkehl3$i%HUK>{9%GY1WfpP z`m$+Rp+q+YR+LhJ`Bs825j=t*nK&m} zfp-g~EjmeKl^}tjId>+wq6UXTqiTZ73a2$l=9JbPQ9g#l3FmT>_sqz*CO6GLY7~JL zOP7qAv8h=zjfS{76J0R5SFp{{?`~%MVB9S+1zvPZ7OExQ3FqBa7O~ecxZ$p0Yr$J` zol3Fvy9>u@H5uY4Xtwy5V=@m$!kSr7{El33xLR7p9tKBQ3#(5qEAujoW{QPIWY|^i zZ|_1|nr*kN1`|B0pjA=I_MwEL#zzE?FGrENh5QV>Q(nQg!N=tRG}%?rV_^qje@!!+ zNS>?-G8P4wZy@_Q+DI0GouC9FzMA5LMAAvt=8edT651^X6N=1vJG|^0W5ZBh*TtTP zN9$Iikz;iQdNg|Ar*%*3(Krg5rCPQt`M6Y0L_)pU}vgo)^Eb5hG<8Z5?F!{>D7WU97r}ID?b#Gq9awd{ zWBzMY&@3n(xrfKS(BZFU&%!qUR}YX!sUWSsG;3%`jl^S$Xn&$sQZarP3dAy|t*9WZyg1;&X>(3>1<$z^&~#^I^f*Ggv+#eYd! zw_iEk5NxXq94B2pLr4WAYua|wHy~PbT2nYrHVBTv*|rwl{dshcPk==q+=IymdsW%&npfgXssK_6e*vCrZ?nI0o5p%a<$X2!P@@W#bmVM(ZB~mY(R^*`+od~8 z&zIQg3pAvgD7_J0ARfW@;CP2m-}8m!Z#x>90oBc)YVF zc!k&>5PV1=+NF?Unk%9x2{{-VjRe*BV{(j_l7t@t536pT7{dCD-b7~4hSeS+kN4UY zxYhY;Q8S8Znf)?$znypsO2(8!czf}2)|%uG#@Te+yV6zT6K(G=s54RWkQ`IuyeB*o zi8bw+)(=J_yZ5N4ptXA|wx6$ef6m;eXd$Aq+KCe7{1Q>0z_*tcw!DMn9R;R0P_tNS zdPRQ(A1?K6|lOcb#adPcNDDOF=C-yR2>-mIjfXmBk=8JcOi5sv0`At$6SKcki?%(94BgGFR zOd0up{Lb zKMluv^YfOWQmP;(^$uu*)4d*c39j}o#!D(bP+31)K6jQps!w?P=#3hPt1>W0kzE`j zy#e5ZuyVny`dzAz^s8s}d)AcL#o?XR|AJav*(V*iidJS@j$Vh^_e`>8RuiN6D*Ftz zG;?r7Rzso^^dhYzTQ)*q_$665U%AzX+mOq=<>| zIJZgs+txJ_4=1AX5?+Tc@z0>V4qF0^c^i%Y!tq8U{zOE4&)~aeNxm6)f|+Q2{{z>@ BjL-l8 diff --git a/fireworks_detect/__pycache__/mcp.cpython-312.pyc b/fireworks_detect/__pycache__/mcp.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90b8a8215e57364119431ef4302559f66bd7630e GIT binary patch literal 16625 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 literal 0 HcmV?d00001 diff --git a/fireworks_detect/__pycache__/models.cpython-312.pyc b/fireworks_detect/__pycache__/models.cpython-312.pyc index b376f577cab2bdba6f2240ce0c92d8a681f7682d..4066546dab2d165a235f6b36090ec99bebdc204e 100644 GIT binary patch delta 696 zcmY+A(MwZN9LLYS-nH6och2QD-lbFUlln z!l=-ft@GeSM*1e`gW*F3J>*LTy=*aN8fS)iZK|2=1GPcw4o{wMauGyHwn%W$|j zEpzb1jDWYo9+Dm;&fv{)Cys`EIM?E2cziq5hHr#i*v|Q#_T5uE3^f5DF5tk^wkNt> zx9>W3*hbN%^H~sYPM?;YHDOenAJ8;tnlWP*rj|y=;DVv4Q%NXk2w1Ff9 zRlVCtCDYRA&>cyw-?=8G-~vRFX&DHblJyWuNL`dH`czNNGi4ZanrcQZWloz{>QxgZ zNpDCXt)LXeYl4`}A{R}XDS{Mx1X^PX5(3cF*hg3Jz<_Am06Oy+Zwalw4Nz>l3uHFB z#9o!iLv(f&CTcv{=^gU^KVOfcm=;o$-$Z1JM3e!CE#5UbFXzO7f+uvTbGyY@XV!Dsp9ZV!QzLv-*egP8JFaHBLHNe#X delta 79 zcmeykfNAGUCce|Wyj%=GV7%! timedelta(days=366)): + raise ValueError("date range must be ordered and at most 366 days") + if not end: + end = min(timezone.localdate(), start + timedelta(days=366)) if start else timezone.localdate() + if not start: + start = end - timedelta(days=366) + outcome = args.get("review_outcome") + if outcome is not None and outcome != "approved": + raise ValueError("review_outcome must be approved") + classification = args.get("classification") + if classification is not None and (not isinstance(classification, str) or not 1 <= len(classification) <= 255): + raise ValueError("classification must be a nonempty label") + queryset = Event.objects.all() + if start: + queryset = queryset.filter(approved_at__date__gte=start) + if end: + queryset = queryset.filter(approved_at__date__lte=end) + if classification: + queryset = queryset.filter(classifier_response__predictions__0__class=classification) + return queryset + + +def _validate(name, args): + schema = next((item["inputSchema"] for item in TOOLS if item["name"] == name), None) + if schema is None: + raise ValueError("Unknown tool") + if not isinstance(args, dict) or set(args) - set(schema["properties"]) or set(schema.get("required", [])) - set(args): + raise ValueError("Invalid tool arguments") + for key in ("limit", "offset", "id"): + if key in args and (type(args[key]) is not int or args[key] < (1 if key != "offset" else 0) or args[key] > (100 if key == "limit" else 10000 if key == "offset" else 2147483647)): + raise ValueError(f"Invalid {key}") + + +def _call(name, args): + _validate(name, args) + if name == "pending_summary": + counts = {} + for pending in PendingEvent.objects.only("classifier_response").iterator(chunk_size=500): + label = _label(pending) + counts[label] = counts.get(label, 0) + 1 + return {"total": sum(counts.values()), "by_predicted_classification": counts} + if name == "submissions_get": + event = Event.objects.filter(pk=args["id"]).first() + if event is None: + raise LookupError("Reviewed submission not found") + return _detail(event) + queryset = _filters(args) + if name == "submissions_list": + limit, offset = args.get("limit", 25), args.get("offset", 0) + return {"total": queryset.count(), "limit": limit, "offset": offset, + "items": [_summary(item) for item in queryset.order_by("-approved_at", "-pk")[offset:offset + limit]]} + if name == "submissions_stats": + days = list(queryset.annotate(day=TruncDate("approved_at")).values("day").annotate(count=Count("pk")).order_by("day")[:367]) + classes = {} + for event in queryset.only("classifier_response").iterator(chunk_size=500): + label = _label(event) + classes[label] = classes.get(label, 0) + 1 + return {"total": sum(classes.values()), "by_day": [{"date": row["day"].isoformat(), "count": row["count"]} for row in days], + "by_predicted_classification": classes, "by_review_outcome": {"approved": sum(classes.values())}, + "confirmed_classification_available": False} + raise ValueError("Unknown tool") + + +def _principal(request): + header = request.headers.get("Authorization", "") + if not header.startswith("Bearer "): + return None + token = header[7:].strip() + if not token.startswith("bmcp_") or len(token) > 120: + return None + from .models import McpAccessToken + digest = hashlib.sha256(token.encode()).hexdigest() + credential = McpAccessToken.objects.select_related("user").filter(token_hash=digest, revoked_at__isnull=True).first() + if not credential or not credential.user.is_active: + return None + return credential.user + + +@csrf_exempt +def mcp_endpoint(request): + if request.method != "POST": + response = JsonResponse({"detail": "POST only"}, status=405) + response["Allow"] = "POST" + return response + origin = request.headers.get("Origin") + if origin: + parsed = urlsplit(origin) + if parsed.scheme not in ("http", "https") or parsed.netloc != request.get_host(): + return JsonResponse({"detail": "Origin not allowed"}, status=403) + user = _principal(request) + if user is None: + response = JsonResponse({"detail": "MCP Bearer token required"}, status=401) + response["WWW-Authenticate"] = 'Bearer realm="BoomCast MCP"' + return response + if not user.has_perm("fireworks_detect.view_event") or not user.has_perm("fireworks_detect.view_pendingevent"): + return JsonResponse({"detail": "Review read permissions required"}, status=403) + key = f"boomcast-mcp:{user.pk}" + if not cache.add(key, 1, 60): + try: + count = cache.incr(key) + except ValueError: + cache.set(key, 1, 60) + count = 1 + if count > 120: + response = JsonResponse({"detail": "Rate limit exceeded"}, status=429) + response["Retry-After"] = "60" + return response + if (request.META.get("CONTENT_LENGTH") or "").isdigit() and int(request.META["CONTENT_LENGTH"]) > 65536: + return JsonResponse(_error(-32600, "Request too large"), status=413) + if len(request.body) > 65536: + return JsonResponse(_error(-32600, "Request too large"), status=413) + try: + message = json.loads(request.body) + except (ValueError, UnicodeDecodeError): + return JsonResponse(_error(-32700, "Invalid JSON"), status=400) + if not isinstance(message, dict) or message.get("jsonrpc") != "2.0" or not isinstance(message.get("method"), str): + return JsonResponse(_error(-32600, "Invalid request"), status=400) + request_id, method = message.get("id"), message["method"] + if method == "notifications/initialized" and "id" not in message: + from django.http import HttpResponse + return HttpResponse(status=202) + if "id" not in message or not (isinstance(request_id, (str, int)) and not isinstance(request_id, bool)): + return JsonResponse(_error(-32600, "Request ID required"), status=400) + if method == "initialize": + result = {"protocolVersion": PROTOCOL_VERSION, "capabilities": {"tools": {}}, "serverInfo": {"name": "boomcast-readonly", "version": "1.0.0"}} + elif method == "tools/list": + result = {"tools": TOOLS} + elif method == "tools/call": + params = message.get("params") + if not isinstance(params, dict) or not isinstance(params.get("name"), str): + return JsonResponse(_error(-32602, "Invalid tool call", request_id)) + try: + output = _call(params["name"], params.get("arguments", {})) + except ValueError as error: + result = {"content": [{"type": "text", "text": str(error)}], "isError": True} + except LookupError: + result = {"content": [{"type": "text", "text": "Reviewed submission not found"}], "isError": True} + else: + result = {"content": [{"type": "text", "text": json.dumps(output, ensure_ascii=False)}], "structuredContent": output} + else: + return JsonResponse(_error(-32601, "Method not found", request_id)) + response = JsonResponse(_reply(request_id, result)) + response["Cache-Control"] = "no-store" + return response diff --git a/fireworks_detect/migrations/0016_mcpaccesstoken.py b/fireworks_detect/migrations/0016_mcpaccesstoken.py new file mode 100644 index 0000000..d7e0df8 --- /dev/null +++ b/fireworks_detect/migrations/0016_mcpaccesstoken.py @@ -0,0 +1,27 @@ +# Generated by Django 6.1.1 on 2026-10-16 15:29 + +import django.db.models.deletion +from django.conf import settings +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('fireworks_detect', '0015_burstsession_burstcapture'), + migrations.swappable_dependency(settings.AUTH_USER_MODEL), + ] + + operations = [ + migrations.CreateModel( + name='McpAccessToken', + fields=[ + ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ('name', models.CharField(max_length=100)), + ('token_hash', models.CharField(max_length=64, unique=True)), + ('created_at', models.DateTimeField(auto_now_add=True)), + ('revoked_at', models.DateTimeField(blank=True, null=True)), + ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='boomcast_mcp_tokens', to=settings.AUTH_USER_MODEL)), + ], + ), + ] diff --git a/fireworks_detect/models.py b/fireworks_detect/models.py index 5855a74..7a1503b 100644 --- a/fireworks_detect/models.py +++ b/fireworks_detect/models.py @@ -489,3 +489,16 @@ class FieldNoteAssociation(models.Model): if not self._state.adding: raise ValidationError("Association history is append-only.") return super().save(*args, **kwargs) + + +class McpAccessToken(models.Model): + """Revocable credential for read-only MCP access; never stores the raw token.""" + + user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="boomcast_mcp_tokens") + name = models.CharField(max_length=100) + token_hash = models.CharField(max_length=64, unique=True) + created_at = models.DateTimeField(auto_now_add=True) + revoked_at = models.DateTimeField(null=True, blank=True) + + def __str__(self): + return f"{self.user}: {self.name}" diff --git a/fireworks_detect/test_mcp.py b/fireworks_detect/test_mcp.py new file mode 100644 index 0000000..69585f9 --- /dev/null +++ b/fireworks_detect/test_mcp.py @@ -0,0 +1,85 @@ +import hashlib +import json + +from django.contrib.auth.models import Permission, User +from django.test import TestCase, override_settings +from django.urls import reverse + +from .models import Event, McpAccessToken, PendingEvent, Sensor + + +@override_settings(ALLOWED_HOSTS=["testserver"]) +class McpTests(TestCase): + def setUp(self): + self.url = reverse("boomcast_mcp") + self.user = User.objects.create_user("review_reader", password="unused") + self.user.user_permissions.add(*Permission.objects.filter(codename__in=["view_event", "view_pendingevent"], content_type__app_label="fireworks_detect")) + self.token = "bmcp_test_read_only" + McpAccessToken.objects.create(user=self.user, name="test", token_hash=hashlib.sha256(self.token.encode()).hexdigest()) + self.pending = PendingEvent.objects.create(original_filename="private.wav", classifier_response={"predictions": [{"class": "Fireworks", "score": 0.9}]}, latitude="52.123456", longitude="5.123456") + self.event = Event.objects.create(original_filename="reviewed.wav", classifier_response={"predictions": [{"class": "Fireworks", "score": 0.8}]}, latitude="52.123456", longitude="5.123456") + + def call(self, method, params=None, token=None): + return self.client.post(self.url, data=json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params or {}}), content_type="application/json", HTTP_AUTHORIZATION=f"Bearer {token or self.token}") + + def result(self, name, args=None): + return self.call("tools/call", {"name": name, "arguments": args or {}}).json()["result"] + + def test_discovery_and_reviewed_only(self): + self.assertEqual(self.call("initialize").json()["result"]["serverInfo"]["name"], "boomcast-readonly") + self.assertEqual(len(self.call("tools/list").json()["result"]["tools"]), 4) + listing = self.result("submissions_list")["structuredContent"] + self.assertEqual(listing["total"], 1) + self.assertEqual(listing["items"][0]["id"], self.event.pk) + self.assertNotIn("private.wav", json.dumps(listing)) + other_pending = PendingEvent.objects.create(original_filename="another-private.wav", classifier_response={}) + self.assertTrue(self.result("submissions_get", {"id": other_pending.pk})["isError"]) + + def test_pending_is_aggregate_only(self): + result = self.result("pending_summary")["structuredContent"] + self.assertEqual(result, {"total": 1, "by_predicted_classification": {"Fireworks": 1}}) + self.assertNotIn("private.wav", json.dumps(result)) + + def test_details_are_privacy_limited(self): + result = self.result("submissions_get", {"id": self.event.pk})["structuredContent"] + self.assertEqual(result["predictions"][0]["score"], 0.8) + for key in ("latitude", "longitude", "audio_file", "original_filename", "sensor", "location", "device_metadata"): + self.assertNotIn(key, result) + self.assertIsNotNone(result["generalized_location_h3"]) + + def test_pagination_filter_and_stats(self): + Event.objects.create(original_filename="other.wav", classifier_response={"predictions": [{"class": "Thunder", "score": 0.7}]}) + self.assertEqual(self.result("submissions_list", {"limit": 1, "offset": 1})["structuredContent"]["total"], 2) + filtered = self.result("submissions_list", {"classification": "Thunder"})["structuredContent"] + self.assertEqual(filtered["total"], 1) + stats = self.result("submissions_stats")["structuredContent"] + self.assertEqual(stats["by_predicted_classification"], {"Fireworks": 1, "Thunder": 1}) + self.assertEqual(stats["by_review_outcome"], {"approved": 2}) + self.assertTrue(self.result("submissions_list", {"limit": 101})["isError"]) + self.assertTrue(self.result("submissions_stats", {"date_from": "2020-01-01", "date_to": "2026-01-01"})["isError"]) + + def test_auth_permissions_and_no_mutations(self): + self.assertEqual(self.client.post(self.url, data="{}", content_type="application/json").status_code, 401) + sensor = Sensor.objects.create(name="test sensor") + self.assertEqual(self.call("tools/list", token=sensor.issue_token()).status_code, 401) + self.user.user_permissions.clear() + self.assertEqual(self.call("tools/list").status_code, 403) + self.user.is_superuser = True + self.user.save(update_fields=["is_superuser"]) + self.assertEqual(self.call("tools/call", {"name": "approve", "arguments": {}}).json()["result"]["isError"], True) + self.assertEqual(PendingEvent.objects.count(), 1) + self.assertEqual(self.client.get(self.url, HTTP_AUTHORIZATION=f"Bearer {self.token}").status_code, 405) + + def test_revocation_inactive_user_and_origin(self): + self.assertEqual(self.call("tools/list", token="bmcp_wrong").status_code, 401) + self.assertEqual(self.client.post(self.url, data='{"jsonrpc":"2.0","id":1,"method":"tools/list"}', content_type="application/json", HTTP_AUTHORIZATION=f"Bearer {self.token}", HTTP_ORIGIN="https://evil.example").status_code, 403) + self.user.is_active = False + self.user.save(update_fields=["is_active"]) + self.assertEqual(self.call("tools/list").status_code, 401) + self.user.is_active = True + self.user.save(update_fields=["is_active"]) + credential = McpAccessToken.objects.get(user=self.user) + from django.utils import timezone + credential.revoked_at = timezone.now() + credential.save(update_fields=["revoked_at"]) + self.assertEqual(self.call("tools/list").status_code, 401) diff --git a/myproject/__pycache__/urls.cpython-312.pyc b/myproject/__pycache__/urls.cpython-312.pyc index 202b8ab43764edffa9cc643f994e025ab52b203c..b2296990be0672f17bcb9bd37a10247a1e5b0bd8 100644 GIT binary patch delta 652 zcmey)_mp4#G%qg~0}vc`x|G$y%E0g##DM`pDC2XVuGnGSw=835pwnFHKv5?KyfeEHau91QpE{$f84A5_!DYBCfFp9Fv zf!Xq4wgQ-~2x3bsr3$1dqv=xt%d3Lq&DByxQq?TJrDYME|>S*dtZeW_m%afa25TBZtQjnjSS29_c*;JbaD58IhCn-NaH#xDm zBp%4sWW2?amzbMc#hH_smtLBfo~mEO2lVLVcxDeq{>>|xB^VhMCLd&3uPKt2S(I9y zUzA-OpORXVnp~m>)Lz5`RC|j%BQ+-{U#~1PwY<29cXA!8j3~&ATfDicxk;%-#ZVdk z$?IABxj@kiikV`w$sTM<(z%0g~z5m@Nxt%YoR^@~HwT3TXNi z!SYHVd2{7dp%fJ~dDT?@6g7lcI!}~LstiyMcZzx{Z;D1LQg2`D9*lgO-!MxsGRjS6WnIt5ospW8 zldo5nnOa_4#54IWtBfc}!!6$2)ZC=hqGG5F-()_velC5W3@C7m)h91!Q{qv&%V2qz hLFpqK11sm`Cv2BEBzgIn8n{2mP2R_@%%Tfa2mll;WKIA8 diff --git a/myproject/urls.py b/myproject/urls.py index 9b237ba..7b90384 100644 --- a/myproject/urls.py +++ b/myproject/urls.py @@ -7,11 +7,13 @@ from django.urls import include, path, re_path from django.views.static import serve from fireworks_detect.views import dashboard_view, submit_sensor_pending +from fireworks_detect.mcp import mcp_endpoint from hello.views import hello_view from members.language_views import set_anonymous_language from members.views import register urlpatterns = [ + path("mcp/", mcp_endpoint, name="boomcast_mcp"), path("language/", set_anonymous_language, name="set_anonymous_language"), path("admin/", admin.site.urls), path("login/", auth_views.LoginView.as_view(template_name="members/login.html"), name="login"),