06d694eff2
All checks were successful
Build and Deploy / build-and-deploy (push) Successful in 41s
- Accept activity now includes required 'id' field (uuid-based) - Updated shared submodule: add_follower upserts to prevent IntegrityError Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
388 lines
13 KiB
Python
388 lines
13 KiB
Python
"""ActivityPub actor endpoints: profiles, outbox, inbox.
|
|
|
|
Ported from ~/art-dag/activity-pub/app/routers/users.py.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
import os
|
|
import uuid
|
|
|
|
import httpx
|
|
from quart import Blueprint, request, abort, Response, g, render_template
|
|
from sqlalchemy import select
|
|
|
|
from shared.services.registry import services
|
|
from shared.models.federation import ActorProfile, APInboxItem
|
|
from shared.browser.app.csrf import csrf_exempt
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
AP_CONTENT_TYPE = "application/activity+json"
|
|
|
|
|
|
def _domain() -> str:
|
|
return os.getenv("AP_DOMAIN", "rose-ash.com")
|
|
|
|
|
|
async def _fetch_remote_actor(actor_url: str) -> dict | None:
|
|
"""Fetch a remote actor's JSON-LD profile."""
|
|
try:
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
actor_url,
|
|
headers={"Accept": AP_CONTENT_TYPE},
|
|
)
|
|
if resp.status_code == 200:
|
|
return resp.json()
|
|
except Exception:
|
|
log.exception("Failed to fetch remote actor: %s", actor_url)
|
|
return None
|
|
|
|
|
|
async def _send_accept(
|
|
actor: ActorProfile,
|
|
follow_activity: dict,
|
|
follower_inbox: str,
|
|
) -> None:
|
|
"""Send an Accept activity back to the follower."""
|
|
from shared.utils.http_signatures import sign_request
|
|
|
|
domain = _domain()
|
|
username = actor.preferred_username
|
|
actor_url = f"https://{domain}/users/{username}"
|
|
|
|
accept_id = f"{actor_url}/activities/{uuid.uuid4()}"
|
|
accept = {
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
"id": accept_id,
|
|
"type": "Accept",
|
|
"actor": actor_url,
|
|
"object": follow_activity,
|
|
}
|
|
|
|
body_bytes = json.dumps(accept).encode()
|
|
key_id = f"{actor_url}#main-key"
|
|
|
|
from urllib.parse import urlparse
|
|
parsed = urlparse(follower_inbox)
|
|
headers = sign_request(
|
|
private_key_pem=actor.private_key_pem,
|
|
key_id=key_id,
|
|
method="POST",
|
|
path=parsed.path,
|
|
host=parsed.netloc,
|
|
body=body_bytes,
|
|
)
|
|
headers["Content-Type"] = AP_CONTENT_TYPE
|
|
|
|
try:
|
|
async with httpx.AsyncClient(timeout=15) as client:
|
|
resp = await client.post(
|
|
follower_inbox,
|
|
content=body_bytes,
|
|
headers=headers,
|
|
)
|
|
log.info("Accept → %s: %d", follower_inbox, resp.status_code)
|
|
except Exception:
|
|
log.exception("Failed to send Accept to %s", follower_inbox)
|
|
|
|
|
|
def register(url_prefix="/users"):
|
|
bp = Blueprint("actors", __name__, url_prefix=url_prefix)
|
|
|
|
@bp.get("/<username>")
|
|
async def profile(username: str):
|
|
actor = await services.federation.get_actor_by_username(g.s, username)
|
|
if not actor:
|
|
abort(404)
|
|
|
|
domain = _domain()
|
|
accept = request.headers.get("accept", "")
|
|
|
|
# AP JSON-LD response
|
|
if "application/activity+json" in accept or "application/ld+json" in accept:
|
|
actor_json = {
|
|
"@context": [
|
|
"https://www.w3.org/ns/activitystreams",
|
|
"https://w3id.org/security/v1",
|
|
],
|
|
"type": "Person",
|
|
"id": f"https://{domain}/users/{username}",
|
|
"name": actor.display_name or username,
|
|
"preferredUsername": username,
|
|
"summary": actor.summary or "",
|
|
"manuallyApprovesFollowers": False,
|
|
"inbox": f"https://{domain}/users/{username}/inbox",
|
|
"outbox": f"https://{domain}/users/{username}/outbox",
|
|
"followers": f"https://{domain}/users/{username}/followers",
|
|
"following": f"https://{domain}/users/{username}/following",
|
|
"publicKey": {
|
|
"id": f"https://{domain}/users/{username}#main-key",
|
|
"owner": f"https://{domain}/users/{username}",
|
|
"publicKeyPem": actor.public_key_pem,
|
|
},
|
|
"url": f"https://{domain}/users/{username}",
|
|
}
|
|
return Response(
|
|
response=json.dumps(actor_json),
|
|
content_type=AP_CONTENT_TYPE,
|
|
)
|
|
|
|
# HTML profile page
|
|
activities, total = await services.federation.get_outbox(
|
|
g.s, username, page=1, per_page=20,
|
|
)
|
|
return await render_template(
|
|
"federation/profile.html",
|
|
actor=actor,
|
|
activities=activities,
|
|
total=total,
|
|
)
|
|
|
|
@bp.get("/<username>/outbox")
|
|
async def outbox(username: str):
|
|
actor = await services.federation.get_actor_by_username(g.s, username)
|
|
if not actor:
|
|
abort(404)
|
|
|
|
domain = _domain()
|
|
actor_id = f"https://{domain}/users/{username}"
|
|
page_param = request.args.get("page")
|
|
|
|
if not page_param:
|
|
_, total = await services.federation.get_outbox(g.s, username, page=1, per_page=1)
|
|
return Response(
|
|
response=json.dumps({
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
"type": "OrderedCollection",
|
|
"id": f"{actor_id}/outbox",
|
|
"totalItems": total,
|
|
"first": f"{actor_id}/outbox?page=1",
|
|
}),
|
|
content_type=AP_CONTENT_TYPE,
|
|
)
|
|
|
|
page_num = int(page_param)
|
|
activities, total = await services.federation.get_outbox(
|
|
g.s, username, page=page_num, per_page=20,
|
|
)
|
|
|
|
items = []
|
|
for a in activities:
|
|
items.append({
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
"type": a.activity_type,
|
|
"id": a.activity_id,
|
|
"actor": actor_id,
|
|
"published": a.published.isoformat() if a.published else None,
|
|
"object": {
|
|
"type": a.object_type,
|
|
**(a.object_data or {}),
|
|
},
|
|
})
|
|
|
|
return Response(
|
|
response=json.dumps({
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
"type": "OrderedCollectionPage",
|
|
"id": f"{actor_id}/outbox?page={page_num}",
|
|
"partOf": f"{actor_id}/outbox",
|
|
"totalItems": total,
|
|
"orderedItems": items,
|
|
}),
|
|
content_type=AP_CONTENT_TYPE,
|
|
)
|
|
|
|
@csrf_exempt
|
|
@bp.post("/<username>/inbox")
|
|
async def inbox(username: str):
|
|
actor = await services.federation.get_actor_by_username(g.s, username)
|
|
if not actor:
|
|
abort(404)
|
|
|
|
body = await request.get_json()
|
|
if not body:
|
|
abort(400, "Invalid JSON")
|
|
|
|
activity_type = body.get("type", "")
|
|
from_actor_url = body.get("actor", "")
|
|
|
|
# Verify HTTP signature (best-effort — log but don't block yet
|
|
# while we validate our implementation against real servers)
|
|
sig_valid = False
|
|
try:
|
|
from shared.utils.http_signatures import verify_request_signature
|
|
req_headers = dict(request.headers)
|
|
sig_header = req_headers.get("Signature", "")
|
|
|
|
# Fetch remote actor to get their public key
|
|
remote_actor = await _fetch_remote_actor(from_actor_url)
|
|
if remote_actor and sig_header:
|
|
pub_key_pem = (remote_actor.get("publicKey") or {}).get("publicKeyPem")
|
|
if pub_key_pem:
|
|
sig_valid = verify_request_signature(
|
|
public_key_pem=pub_key_pem,
|
|
signature_header=sig_header,
|
|
method="POST",
|
|
path=f"/users/{username}/inbox",
|
|
headers=req_headers,
|
|
)
|
|
except Exception:
|
|
log.debug("Signature verification failed for %s", from_actor_url, exc_info=True)
|
|
|
|
if not sig_valid:
|
|
log.warning(
|
|
"Unverified inbox POST from %s (%s) — accepting anyway for now",
|
|
from_actor_url, activity_type,
|
|
)
|
|
|
|
# Load actor row for DB operations
|
|
actor_row = (
|
|
await g.s.execute(
|
|
select(ActorProfile).where(
|
|
ActorProfile.preferred_username == username
|
|
)
|
|
)
|
|
).scalar_one()
|
|
|
|
# Store raw inbox item
|
|
item = APInboxItem(
|
|
actor_profile_id=actor_row.id,
|
|
raw_json=body,
|
|
activity_type=activity_type,
|
|
from_actor=from_actor_url,
|
|
)
|
|
g.s.add(item)
|
|
await g.s.flush()
|
|
|
|
# Handle activity types inline
|
|
if activity_type == "Follow":
|
|
await _handle_follow(actor_row, body, from_actor_url)
|
|
elif activity_type == "Undo":
|
|
await _handle_undo(actor_row, body, from_actor_url)
|
|
elif activity_type in ("Like", "Announce"):
|
|
log.info("Received %s from %s (noted)", activity_type, from_actor_url)
|
|
|
|
# Mark as processed
|
|
item.state = "processed"
|
|
from datetime import datetime, timezone
|
|
item.processed_at = datetime.now(timezone.utc)
|
|
await g.s.flush()
|
|
|
|
return Response(status=202)
|
|
|
|
async def _handle_follow(
|
|
actor_row: ActorProfile,
|
|
body: dict,
|
|
from_actor_url: str,
|
|
) -> None:
|
|
"""Process a Follow activity: add follower, send Accept."""
|
|
remote_actor = await _fetch_remote_actor(from_actor_url)
|
|
if not remote_actor:
|
|
log.warning("Could not fetch remote actor for Follow: %s", from_actor_url)
|
|
return
|
|
|
|
follower_inbox = remote_actor.get("inbox")
|
|
if not follower_inbox:
|
|
log.warning("Remote actor has no inbox: %s", from_actor_url)
|
|
return
|
|
|
|
# Derive acct from preferredUsername@domain
|
|
remote_username = remote_actor.get("preferredUsername", "")
|
|
from urllib.parse import urlparse
|
|
remote_domain = urlparse(from_actor_url).netloc
|
|
follower_acct = f"{remote_username}@{remote_domain}" if remote_username else from_actor_url
|
|
|
|
pub_key = (remote_actor.get("publicKey") or {}).get("publicKeyPem")
|
|
|
|
# Add follower via service
|
|
await services.federation.add_follower(
|
|
g.s,
|
|
actor_row.preferred_username,
|
|
follower_acct=follower_acct,
|
|
follower_inbox=follower_inbox,
|
|
follower_actor_url=from_actor_url,
|
|
follower_public_key=pub_key,
|
|
)
|
|
|
|
log.info(
|
|
"New follower: %s → @%s",
|
|
follower_acct, actor_row.preferred_username,
|
|
)
|
|
|
|
# Send Accept
|
|
await _send_accept(actor_row, body, follower_inbox)
|
|
|
|
async def _handle_undo(
|
|
actor_row: ActorProfile,
|
|
body: dict,
|
|
from_actor_url: str,
|
|
) -> None:
|
|
"""Process an Undo activity (typically Undo Follow)."""
|
|
inner = body.get("object")
|
|
if not inner:
|
|
return
|
|
|
|
inner_type = inner.get("type") if isinstance(inner, dict) else None
|
|
if inner_type == "Follow":
|
|
# Derive acct
|
|
from urllib.parse import urlparse
|
|
remote_domain = urlparse(from_actor_url).netloc
|
|
remote_actor = await _fetch_remote_actor(from_actor_url)
|
|
remote_username = ""
|
|
if remote_actor:
|
|
remote_username = remote_actor.get("preferredUsername", "")
|
|
follower_acct = f"{remote_username}@{remote_domain}" if remote_username else from_actor_url
|
|
|
|
removed = await services.federation.remove_follower(
|
|
g.s, actor_row.preferred_username, follower_acct,
|
|
)
|
|
if removed:
|
|
log.info("Unfollowed: %s → @%s", follower_acct, actor_row.preferred_username)
|
|
else:
|
|
log.debug("Undo Follow: follower not found: %s", follower_acct)
|
|
else:
|
|
log.debug("Undo for %s — not handled", inner_type)
|
|
|
|
@bp.get("/<username>/followers")
|
|
async def followers(username: str):
|
|
actor = await services.federation.get_actor_by_username(g.s, username)
|
|
if not actor:
|
|
abort(404)
|
|
|
|
domain = _domain()
|
|
follower_list = await services.federation.get_followers(g.s, username)
|
|
|
|
return Response(
|
|
response=json.dumps({
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
"type": "OrderedCollection",
|
|
"id": f"https://{domain}/users/{username}/followers",
|
|
"totalItems": len(follower_list),
|
|
"orderedItems": [f.follower_actor_url for f in follower_list],
|
|
}),
|
|
content_type=AP_CONTENT_TYPE,
|
|
)
|
|
|
|
@bp.get("/<username>/following")
|
|
async def following(username: str):
|
|
actor = await services.federation.get_actor_by_username(g.s, username)
|
|
if not actor:
|
|
abort(404)
|
|
|
|
domain = _domain()
|
|
return Response(
|
|
response=json.dumps({
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
"type": "OrderedCollection",
|
|
"id": f"https://{domain}/users/{username}/following",
|
|
"totalItems": 0,
|
|
"orderedItems": [],
|
|
}),
|
|
content_type=AP_CONTENT_TYPE,
|
|
)
|
|
|
|
return bp
|