Files
StarPunk/starpunk/routes/micropub.py
T
PhilandClaude Opus 5.5 ab6ff60f5c feat: Micropub review fixes (v2.9.0)
- mp-syndicate-to/mp-slug read from JSON properties; absent means no
  crossposting
- Sanitize rendered HTML (nh3 allowlist)
- q=source/q=category need a posting scope; draft scope creates drafts;
  private/unlisted visibility saved as drafts
- Photos that can't be fetched or found fail the request; remote photos
  via the SSRF-checked, pinned fetcher
- JSON scalars wrapped, update delete values must be arrays
- bookmark-of stored; HTML content returned as {html} (migration 015)
- published stored as UTC, bad dates 400; malformed JSON 400
- Auth: case-insensitive Bearer, header+body 400, WWW-Authenticate

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 10:11:23 -07:00

213 lines
7.3 KiB
Python

"""
Micropub endpoint routes for StarPunk
Implements the W3C Micropub specification for creating posts via
external IndieWeb clients.
Endpoints:
GET/POST /micropub - Main Micropub endpoint
GET: Query operations (config, source, syndicate-to)
POST: Action operations (create in V1, update/delete in future)
Authentication:
Bearer token authentication required for all endpoints.
Token must have appropriate scope for requested operation.
References:
- W3C Micropub Specification: https://www.w3.org/TR/micropub/
- ADR-028: Micropub Implementation Strategy
- ADR-029: Micropub IndieAuth Integration Strategy
- ADR-064: Tokens are issued and verified by StarPunk itself
"""
from flask import Blueprint, current_app, request, make_response
from starpunk.micropub import (
MicropubError,
extract_bearer_token,
error_response,
handle_create,
handle_delete,
handle_update,
handle_query,
)
from starpunk.indieauth import verify_access_token, check_scope
# Create blueprint
bp = Blueprint("micropub", __name__)
@bp.route("/micropub", methods=["GET", "POST"])
def micropub_endpoint():
"""
Main Micropub endpoint for all operations
GET requests:
Handle query operations via q= parameter:
- q=config: Return server capabilities
- q=source&url={url}: Return post source
- q=syndicate-to: Return syndication targets
POST requests:
Handle action operations (form-encoded or JSON):
- action=create (or no action): Create new post
- action=update: Update existing post (JSON; replace/add/delete)
- action=delete / action=undelete: Delete or restore a post
Authentication:
Requires valid bearer token in Authorization header or
access_token parameter.
Returns:
GET: JSON response with query results
POST create: 201 Created with Location header
POST other: Error responses
Error responses follow OAuth 2.0 format:
{
"error": "error_code",
"error_description": "Human-readable description"
}
"""
# Extract and verify token
try:
token = extract_bearer_token(request)
except MicropubError as e:
return error_response(e.error, e.error_description, e.status_code)
if not token:
return error_response("unauthorized", "No access token provided", 401)
token_info = verify_access_token(token)
if not token_info:
return error_response("unauthorized", "Invalid or expired access token", 401)
# Handle query endpoints (GET requests)
if request.method == "GET":
try:
return handle_query(request.args, token_info)
except MicropubError as e:
return error_response(e.error, e.error_description, e.status_code)
except Exception as e:
current_app.logger.error(f"Micropub query error: {e}")
return error_response("server_error", "An unexpected error occurred", 500)
# Handle action endpoints (POST requests)
content_type = request.headers.get("Content-Type", "")
try:
# Parse request based on content type
if "application/json" in content_type:
# Malformed JSON is the client's error, not ours (v2.9.0)
data = request.get_json(silent=True)
if not isinstance(data, dict):
return error_response("invalid_request", "Request body must be a JSON object", 400)
action = data.get("action", "create")
else:
# Form-encoded or multipart (files handled separately)
data = request.form.to_dict(flat=False)
action = data.get("action", ["create"])[0]
# Route to appropriate handler
if action == "create":
return handle_create(data, token_info, files=request.files)
elif action == "update":
if "application/json" not in content_type:
return error_response("invalid_request", "Updates must be sent as JSON", 400)
return handle_update(data, token_info)
elif action in ("delete", "undelete"):
return handle_delete(data, token_info, undelete=(action == "undelete"))
else:
return error_response("invalid_request", f"Unknown action: {action}", 400)
except MicropubError as e:
return error_response(e.error, e.error_description, e.status_code)
except Exception as e:
current_app.logger.error(f"Micropub action error: {e}")
return error_response("server_error", "An unexpected error occurred", 500)
@bp.route('/micropub/media', methods=['POST'])
@bp.route('/media', methods=['POST']) # old path, kept for existing clients
def media_endpoint():
"""
Micropub media endpoint for file uploads
W3C Micropub Specification compliant media upload.
Accepts multipart/form-data with single file part named 'file'.
Returns:
201 Created with Location header on success
4xx/5xx error responses per OAuth 2.0 format
"""
from starpunk.media import save_media
# Extract and verify token
try:
token = extract_bearer_token(request)
except MicropubError as e:
return error_response(e.error, e.error_description, e.status_code)
if not token:
return error_response("unauthorized", "No access token provided", 401)
token_info = verify_access_token(token)
if not token_info:
return error_response("unauthorized", "Invalid or expired access token", 401)
# Check scope: "media", or "create" for older clients
scope = token_info.get("scope", "")
if not (check_scope("media", scope) or check_scope("create", scope)):
return error_response(
"insufficient_scope",
"Token lacks media or create scope",
403
)
# Validate content type
content_type = request.headers.get("Content-Type", "")
if "multipart/form-data" not in content_type:
return error_response(
"invalid_request",
"Content-Type must be multipart/form-data",
400
)
# Extract file
if 'file' not in request.files:
return error_response(
"invalid_request",
"No file provided. Use 'file' as the form field name.",
400
)
uploaded_file = request.files['file']
if not uploaded_file.filename:
return error_response(
"invalid_request",
"No filename provided",
400
)
try:
# Read file data
file_data = uploaded_file.read()
# Save media (validates, optimizes, generates variants)
media = save_media(file_data, uploaded_file.filename)
# Build media URL (normalize SITE_URL by removing trailing slash)
site_url = current_app.config.get("SITE_URL", "http://localhost:5000").rstrip('/')
media_url = f"{site_url}/media/{media['path']}"
# Return 201 with Location header (per W3C Micropub spec)
response = make_response("", 201)
response.headers["Location"] = media_url
return response
except ValueError as e:
# Validation errors (file too large, invalid format, etc.)
return error_response("invalid_request", str(e), 400)
except Exception as e:
return error_response("server_error", "Failed to process upload", 500)