Compare commits

..
2 Commits
Author SHA1 Message Date
PhilandClaude Opus 5.5 e8c1b03980 feat: Likes and reposts (v2.5.0)
Build Container / build (push) Successful in 6s
Micropub like-of/repost-of with optional comment; likes on /likes, off the
home page and feeds; reposts in the stream. Native favourites/boosts on
GoToSocial and likes/reposts/quotes on Bluesky when the target is on that
network, link posts for other reposts. Fix double slash in outgoing
webmention source URLs. ADR-068.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 20:16:21 -06:00
PhilandClaude Opus 5.5 0d3a5cd519 feat: Micropub update, delete/undelete, drafts, replies (v2.4.0)
Build Container / build (push) Successful in 6s
Update (replace/add/delete) for content, name, category, photo,
in-reply-to, post-status; soft delete with undelete; post-status drafts;
in-reply-to; multipart and remote photos; q=source lists and properties[];
q=category; media scope. Fix media endpoint 404 at the advertised
/micropub/media path. ADR-067.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 19:53:18 -06:00
25 changed files with 1374 additions and 251 deletions

No files matched your search

+38
View File
@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased]
## [2.5.0] - 2026-11-01
### Added
- **Likes and reposts** via Micropub `like-of` / `repost-of` (ADR-068); a comment is optional
- Likes are kept off the home page and feeds and listed on a new `/likes` page (linked in the header)
- Reposts appear in the stream and feeds with a "🔁 Reposted" line
- The liked/reposted post's title and author are fetched and shown; it is sent a webmention
- GoToSocial: likes/reposts of fediverse posts become native favourites/boosts; reposts of other pages (or with a comment) post "🔁 title url"
- Bluesky: likes/reposts of Bluesky posts become native likes/reposts; a repost with a comment is a quote post; reposts of other pages post with a link card
- Likes of ordinary web pages are not crossposted; deleting a like/repost undoes it everywhere
- Migration 013: `notes.like_of`, `notes.repost_of`
### Fixed
- Outgoing webmentions named posts `https://site//note/<slug>` (double slash)
### Notes
- The GoToSocial token needs the extra scopes `read:search` and `write:favourites`
## [2.4.0] - 2026-10-31
### Added
- **Micropub update** (`action=update`, JSON): replace/add/delete for `content`, `name`, `category`, `photo`, `in-reply-to`, `post-status`; edits follow to crossposts (ADR-067)
- **Micropub delete and undelete**: soft delete, restorable; crossposts are removed and re-posted
- **Drafts** via `post-status: draft`; **replies** via `in-reply-to`
- Photos uploaded in a multipart create request; photos hosted elsewhere are downloaded (public addresses only, 20 MB cap)
- `q=source` without `url` lists recent posts (drafts included, `limit`/`offset`); `properties[]` filter; returns photos, syndication links, reply and post status
- `q=category` (tag suggestions, optional `filter`); `q=config` lists supported queries and post types
- Media endpoint accepts the `media` scope
### Fixed
- Media endpoint was advertised at `/micropub/media` but served at `/media` (404 for clients); now both work
- Unsupported Micropub types (e.g. `h=event`) were silently stored as notes; now rejected
## [2.3.3] - 2026-10-31
### Fixed
@@ -0,0 +1,34 @@
# ADR-067: Micropub update, delete, drafts and replies
## Status
Accepted (v2.4.0, 2026-10-31)
## Context
The Micropub endpoint could only create published notes. Apps could not edit
or delete posts, drafts and replies were dropped, and photos sent with the
post or hosted elsewhere were lost.
## Decision
1. **Update** (JSON only, `update` scope). Supported properties are the ones a
note can store: `content`, `name` (the `# Heading` first line),
`category`, `photo`, `in-reply-to`, `post-status`. Anything else is a 400,
not silently ignored. Order: delete, then replace, then add (`add` only for
`category` and `photo`). Success is 204.
2. **Delete is soft** (`delete` scope) so `undelete` can restore the note and
its file from `.trash/`. Crossposts are removed on delete and posted again
on undelete.
3. **Drafts**: `post-status: draft` creates an unpublished note; crossposts
wait until it is published.
4. **Photos**: multipart uploads are saved like media-endpoint uploads; remote
URLs are downloaded only from public IP addresses, up to 20 MB, max 4.
5. **Queries**: `q=source` returns everything create accepts (round-trip);
without `url` it lists recent posts, drafts included, for editing apps.
`q=category` lists tags by use.
## Consequences
- `published` (backdating) can be set on create but not changed by update.
- Likes, reposts and bookmarks remain unsupported (round 2).
@@ -0,0 +1,32 @@
# ADR-068: Likes and reposts
## Status
Accepted (v2.5.0, 2026-11-01). Bookmarks were considered and declined.
## Decision
1. **Storage.** `notes.like_of` / `notes.repost_of` (migration 013). The note's
content is an optional comment and may be empty.
2. **Display.** Likes stay off the home page and feeds and are listed on
`/likes`. Reposts appear in the stream and feeds. Both show the target's
fetched title and author (the reply-context cache) and carry
`u-like-of` / `u-repost-of`. The target is sent a webmention.
3. **Crossposting, per target.**
| | Target is a post on that network | Anything else |
|---|---|---|
| Like | native favourite / like | nothing |
| Repost, no comment | native boost / repost | "🔁 title url" post |
| Repost, with comment | Bluesky quote post; GoToSocial status | comment + "🔁 title url" post |
GoToSocial finds fediverse posts with `/api/v2/search?resolve=true`
(needs `read:search`; favourites need `write:favourites`). Bluesky
recognises `bsky.app/profile/<actor>/post/<rkey>` URLs. Native actions
are stored as `favourite:<id>` / `reblog:<id>` or the like/repost record
URI, and deleting the note undoes them.
## Consequences
- Editing a like/repost doesn't change a native favourite/boost.
- A repost with a comment can't be a GoToSocial boost (no quote posts there).
+8
View File
@@ -0,0 +1,8 @@
-- Migration 013: Likes and reposts (v2.5.0, ADR-068)
-- A note with like_of is a like; with repost_of, a repost. Content is the
-- optional comment and may be empty.
ALTER TABLE notes ADD COLUMN like_of TEXT;
ALTER TABLE notes ADD COLUMN repost_of TEXT;
CREATE INDEX IF NOT EXISTS idx_notes_like_of ON notes(like_of);
+1 -1
View File
@@ -464,5 +464,5 @@ def create_app(config=None):
# Package version (Semantic Versioning 2.0.0)
# See docs/standards/versioning-strategy.md for details
__version__ = "2.3.3"
__version__ = "2.5.0"
__version_info__ = (2, 1, 0)
+2 -2
View File
@@ -198,7 +198,7 @@ def generate_atom_streaming(
yield f' <link rel="enclosure" type="{_escape_xml(mime_type)}" href="{_escape_xml(media_url)}" length="{size}"{title_attr}/>\n'
# Content - include media as HTML (per Q24)
if note.html:
if note.feed_html:
# Build HTML content with media at top
html_content = ""
@@ -212,7 +212,7 @@ def generate_atom_streaming(
html_content += '</div>'
# Add text content below media
html_content += note.html
html_content += note.feed_html
# HTML content - escaped
yield ' <content type="html">'
+2 -2
View File
@@ -267,7 +267,7 @@ def _build_item_object(site_url: str, note: Note) -> Dict[str, Any]:
# Add content (HTML or text)
# Per Q24: Include media as HTML in content_html
if note.html:
if note.feed_html:
content_html = ""
# Add media at top if present (v1.2.0 Phase 3)
@@ -280,7 +280,7 @@ def _build_item_object(site_url: str, note: Note) -> Dict[str, Any]:
content_html += '</div>'
# Add text content below media
content_html += note.html
content_html += note.feed_html
item["content_html"] = content_html
else:
item["content_text"] = note.content
+2 -2
View File
@@ -137,7 +137,7 @@ def generate_rss(
html_content += '</div>'
# Add text content below media
html_content += clean_html_for_rss(note.html)
html_content += clean_html_for_rss(note.feed_html)
# feedgen automatically wraps content in CDATA for RSS
fe.description(html_content)
@@ -278,7 +278,7 @@ def generate_rss_streaming(
html_content += '</div>'
# Add text content below media
html_content += clean_html_for_rss(note.html)
html_content += clean_html_for_rss(note.feed_html)
# Build item XML
item_xml = f""" <item>
+440 -161
View File
@@ -10,6 +10,8 @@ Functions:
extract_title: Get the explicit title (name) from Micropub properties
extract_tags: Get category tags from Micropub properties
handle_create: Process Micropub create action
handle_update: Process Micropub update action (v2.4.0)
handle_delete: Process Micropub delete / undelete actions (v2.4.0)
handle_query: Process Micropub query endpoints
extract_bearer_token: Get token from Authorization header or form
@@ -29,7 +31,10 @@ from typing import Optional
from flask import Request, current_app, jsonify
from starpunk.models import split_title
from starpunk.notes import create_note, get_note, InvalidNoteDataError, NoteNotFoundError
from starpunk.notes import (
create_note, delete_note, get_note, list_notes, undelete_note, update_note,
InvalidNoteDataError, NoteNotFoundError,
)
from starpunk.indieauth import check_scope
from starpunk.utils import absolute_url_for
@@ -137,6 +142,8 @@ def normalize_properties(data: dict) -> dict:
# Form format - convert to properties dict
properties = {}
for key, value in data.items():
if hasattr(value, "filename") or (isinstance(value, list) and value and hasattr(value[0], "filename")):
continue # uploaded files are handled separately
# Skip reserved Micropub parameters
if key.startswith("mp-") or key in ["action", "url", "access_token", "h"]:
continue
@@ -258,6 +265,51 @@ def extract_published_date(properties: dict) -> Optional[datetime]:
# Action Handlers
MAX_PHOTOS = 4 # ADR-057
MAX_REMOTE_PHOTO_BYTES = 20 * 1024 * 1024
# Properties we can store, and so can be updated (v2.4.0)
UPDATABLE = {"content", "name", "category", "in-reply-to", "post-status", "photo"}
def _first(value):
if isinstance(value, list):
return value[0] if value else None
return value
def _require_scope(token_info: dict, *scopes: str) -> None:
granted = token_info.get("scope", "")
if not any(check_scope(s, granted) for s in scopes):
raise MicropubError(
"insufficient_scope", f"Token lacks {' or '.join(scopes)} scope", status_code=403
)
def extract_post_status(properties: dict) -> bool:
"""post-status: 'draft' -> unpublished; 'published' or absent -> published"""
status = _first(properties.get("post-status"))
if status in (None, "", "published"):
return True
if status == "draft":
return False
raise MicropubValidationError(f"Unsupported post-status: {status}")
def extract_url_property(properties: dict, name: str) -> Optional[str]:
"""A URL property (in-reply-to, like-of, repost-of): string or h-cite"""
value = _first(properties.get(name))
if isinstance(value, dict): # h-cite
value = _first((value.get("properties") or {}).get("url")) or value.get("value")
value = (value or "").strip() if isinstance(value, str) else ""
if value and not value.startswith(("http://", "https://")):
raise MicropubValidationError(f"{name} must be an http(s) URL")
return value or None
def extract_in_reply_to(properties: dict) -> Optional[str]:
return extract_url_property(properties, "in-reply-to")
def extract_photos(properties: dict) -> list[dict[str, str]]:
"""
@@ -265,101 +317,172 @@ def extract_photos(properties: dict) -> list[dict[str, str]]:
Handles both simple URL strings and structured photo objects with alt text.
Args:
properties: Normalized Micropub properties dict
Returns:
List of dicts with 'url' and optional 'alt' keys
Examples:
>>> # Simple URL
>>> extract_photos({'photo': ['https://example.com/photo.jpg']})
[{'url': 'https://example.com/photo.jpg', 'alt': ''}]
>>> # With alt text
>>> extract_photos({'photo': [{'value': 'https://example.com/photo.jpg', 'alt': 'Sunset'}]})
[{'url': 'https://example.com/photo.jpg', 'alt': 'Sunset'}]
"""
photos = properties.get("photo", [])
result = []
for photo in photos:
for photo in properties.get("photo", []):
if isinstance(photo, str):
# Simple URL string
result.append({'url': photo, 'alt': ''})
elif isinstance(photo, dict):
# Structured object with value and alt
url = photo.get('value') or photo.get('url', '')
alt = photo.get('alt', '')
if url:
result.append({'url': url, 'alt': alt})
result.append({'url': url, 'alt': photo.get('alt', '')})
return result
def _attach_photos_to_note(note_id: int, photos: list[dict[str, str]]) -> None:
"""
Attach photos to a note by URL
def _public_address(host: str) -> bool:
"""True if every address the host resolves to is public (no SSRF into the LAN)"""
import ipaddress
import socket
Photos must already exist on this server (uploaded via media endpoint).
External URLs are accepted but stored as-is (no download).
try:
infos = socket.getaddrinfo(host, None)
except socket.gaierror:
return False
for info in infos:
ip = ipaddress.ip_address(info[4][0])
if not ip.is_global:
return False
return bool(infos)
Args:
note_id: ID of the note to attach to
photos: List of dicts with 'url' and 'alt' keys
"""
def _fetch_remote_photo(url: str) -> Optional[int]:
"""Download a photo hosted elsewhere into the media library. Returns media id."""
from urllib.parse import urlparse
import httpx
from starpunk.media import save_media
parsed = urlparse(url)
if parsed.scheme not in ("http", "https") or not parsed.hostname:
return None
if not current_app.config.get("TESTING") and not _public_address(parsed.hostname):
current_app.logger.warning(f"Refusing to fetch photo from non-public address: {url}")
return None
try:
with httpx.stream("GET", url, timeout=20.0, follow_redirects=True) as response:
response.raise_for_status()
data = bytearray()
for chunk in response.iter_bytes():
data += chunk
if len(data) > MAX_REMOTE_PHOTO_BYTES:
raise ValueError("photo too large")
name = parsed.path.rsplit("/", 1)[-1] or "photo.jpg"
return save_media(bytes(data), name)["id"]
except Exception as e:
current_app.logger.warning(f"Could not fetch photo {url}: {e}")
return None
def _media_id_for_url(url: str) -> Optional[int]:
"""Media id for a photo URL: ours by path, or downloaded if hosted elsewhere"""
from starpunk.database import get_db
site_url = current_app.config.get("SITE_URL", "http://localhost:5000").rstrip('/')
if url.startswith(site_url) or url.startswith('/media/'):
path = url[len(site_url):] if url.startswith(site_url) else url
if path.startswith('/media/'):
path = path[len('/media/'):]
row = get_db(current_app).execute("SELECT id FROM media WHERE path = ?", (path,)).fetchone()
if row:
return row[0]
current_app.logger.warning(f"Photo URL not found in media: {url}")
return None
return _fetch_remote_photo(url)
def _save_uploads(files) -> list[dict]:
"""Photos uploaded in a multipart create request -> [{'media_id', 'alt'}]"""
from starpunk.media import save_media
result = []
for key in ("photo", "photo[]"):
for upload in (files.getlist(key) if files else []):
if upload and upload.filename:
try:
result.append({"media_id": save_media(upload.read(), upload.filename)["id"], "alt": ""})
except ValueError as e:
raise MicropubValidationError(f"Invalid photo {upload.filename}: {e}")
return result
def _resolve_photos(photos: list[dict]) -> tuple[list[int], list[str]]:
"""Photo dicts ({'url'|'media_id', 'alt'}) -> (media ids, captions), max 4"""
if len(photos) > MAX_PHOTOS:
current_app.logger.warning(
f"Micropub received {len(photos)} photos, truncating to {MAX_PHOTOS} per ADR-057"
)
media_ids, captions = [], []
for photo in photos:
if len(media_ids) == MAX_PHOTOS:
break
media_id = photo.get("media_id") or _media_id_for_url(photo["url"])
if media_id:
media_ids.append(media_id)
captions.append(photo.get("alt", ""))
return media_ids, captions
def _attach_photos_to_note(note_id: int, photos: list[dict]) -> None:
"""Attach photos (by URL or uploaded media id) to a note, replacing any others"""
from starpunk.media import attach_media_to_note
# Normalize SITE_URL by stripping trailing slash for consistent comparison
site_url = current_app.config.get("SITE_URL", "http://localhost:5000").rstrip('/')
db = get_db(current_app)
media_ids = []
captions = []
# Log warning if photos are being truncated
if len(photos) > 4:
current_app.logger.warning(
f"Micropub create received {len(photos)} photos, truncating to 4 per ADR-057"
)
for photo in photos[:4]: # Max 4 photos per ADR-057
url = photo['url']
alt = photo.get('alt', '')
# Check if URL is on our server
if url.startswith(site_url) or url.startswith('/media/'):
# Extract path from URL
if url.startswith(site_url):
path = url[len(site_url):]
else:
path = url
# Remove leading /media/ if present
if path.startswith('/media/'):
path = path[7:]
# Look up media by path
row = db.execute(
"SELECT id FROM media WHERE path = ?",
(path,)
).fetchone()
if row:
media_ids.append(row[0])
captions.append(alt)
else:
current_app.logger.warning(f"Photo URL not found in media: {url}")
else:
# External URL - log but don't fail
current_app.logger.info(f"External photo URL ignored: {url}")
if media_ids:
media_ids, captions = _resolve_photos(photos)
if media_ids or not photos:
attach_media_to_note(note_id, media_ids, captions)
def handle_create(data: dict, token_info: dict):
def _note_photos(note) -> list[dict]:
"""A note's current photos as Micropub photo dicts"""
from starpunk.media import get_note_media
site_url = current_app.config.get("SITE_URL", "http://localhost:5000").rstrip('/')
return [
{"url": f"{site_url}/media/{m['path']}", "alt": m.get("caption") or "", "media_id": m["id"]}
for m in get_note_media(note.id)
]
def _check_type(data: dict) -> None:
"""Only h-entry is supported"""
h = _first(data.get("h"))
kind = _first(data.get("type"))
if (h and h != "entry") or (kind and kind != "h-entry"):
raise MicropubValidationError(f"Only h-entry posts are supported (got {h or kind})")
def _note_from_url(url: Optional[str], deleted: bool = False):
"""Find the note a URL points at (/note/<slug> on this site)"""
from urllib.parse import urlparse
from starpunk.database import get_db
if not url:
raise MicropubValidationError("No url provided")
site = urlparse(current_app.config.get("SITE_URL", ""))
parsed = urlparse(url)
if parsed.netloc and site.netloc and parsed.netloc != site.netloc:
raise MicropubValidationError("URL is not on this site")
parts = [p for p in parsed.path.split("/") if p]
if len(parts) != 2 or parts[0] not in ("note", "notes"):
raise MicropubValidationError("URL is not a post on this site")
slug = parts[1]
if deleted:
row = get_db(current_app).execute(
"SELECT id FROM notes WHERE slug = ? AND deleted_at IS NOT NULL", (slug,)
).fetchone()
if row is None:
raise MicropubError("not_found", "No deleted post at that URL", 404)
return slug
note = get_note(slug=slug)
if note is None:
raise MicropubError("not_found", "Post not found", 404)
return note
def handle_create(data: dict, token_info: dict, files=None):
"""
Handle Micropub create action
@@ -369,32 +492,24 @@ def handle_create(data: dict, token_info: dict):
Args:
data: Raw request data (form or JSON)
token_info: Authenticated token information (me, client_id, scope)
files: Uploaded files for multipart requests (v2.4.0)
Returns:
Tuple of (response_body, status_code, headers)
Raises:
MicropubError: If scope insufficient or creation fails
"""
# Check scope
if not check_scope("create", token_info.get("scope", "")):
raise MicropubError(
"insufficient_scope", "Token lacks create scope", status_code=403
)
_require_scope(token_info, "create")
_check_type(data)
# Extract mp-slug BEFORE normalizing properties (it's not a property!)
# mp-slug is a Micropub server extension parameter that gets filtered during normalization
# mp-slug and mp-syndicate-to are server commands, not properties
custom_slug = None
if isinstance(data, dict) and 'mp-slug' in data:
# Handle both form-encoded (list) and JSON (could be string or list)
slug_value = data.get('mp-slug')
if isinstance(slug_value, list) and slug_value:
custom_slug = slug_value[0]
elif isinstance(slug_value, str):
custom_slug = slug_value
# mp-syndicate-to is also a server command, not a property (v2.1.0).
# Absent means "all targets"; present means exactly those.
# Absent means "all targets"; present means exactly those (v2.1.0)
requested_targets = None
if isinstance(data, dict):
for key in ("mp-syndicate-to", "mp-syndicate-to[]"):
@@ -404,54 +519,178 @@ def handle_create(data: dict, token_info: dict):
value if isinstance(value, list) else [value]
)
# Normalize and extract properties
try:
properties = normalize_properties(data)
content = extract_content(properties)
like_of = extract_url_property(properties, "like-of")
repost_of = extract_url_property(properties, "repost-of")
if like_of and repost_of:
raise MicropubValidationError("A post can't be both a like and a repost")
# Likes and reposts may come without a comment (v2.5.0)
has_content = any(
(c.strip() if isinstance(c, str) else (c.get("text") or c.get("html") or "").strip())
for c in properties.get("content", []) if c
)
content = extract_content(properties) if has_content or not (like_of or repost_of) else ""
title = extract_title(properties)
tags = extract_tags(properties)
published_date = extract_published_date(properties)
photos = extract_photos(properties) # v1.4.0
except MicropubValidationError as e:
raise e
published = extract_post_status(properties)
in_reply_to = extract_in_reply_to(properties)
photos = extract_photos(properties) + _save_uploads(files)
except MicropubError:
raise
except Exception as e:
current_app.logger.error(f"Property extraction failed: {e}")
raise MicropubValidationError(f"Failed to parse request: {str(e)}")
# Create note using existing CRUD
try:
note = create_note(
content=add_title_heading(content, title),
published=True, # Micropub posts are published by default
published=published,
created_at=published_date,
custom_slug=custom_slug,
tags=tags if tags else None # Pass tags to create_note (v1.3.0)
tags=tags if tags else None,
in_reply_to=in_reply_to,
like_of=like_of,
repost_of=repost_of,
)
# Attach photos if present (v1.4.0)
if photos:
_attach_photos_to_note(note.id, photos)
# Crosspost after photos are attached (v2.1.0)
# Crosspost after photos are attached (v2.1.0); drafts wait until published
from starpunk.syndication import get_targets, resolve_targets, select_targets
if requested_targets is None:
select_targets(note.id, list(get_targets()))
else:
select_targets(note.id, resolve_targets(requested_targets))
permalink = absolute_url_for("public.note", slug=note.slug)
# Return 201 Created with Location header
return "", 201, {"Location": permalink}
return "", 201, {"Location": absolute_url_for("public.note", slug=note.slug)}
except InvalidNoteDataError as e:
raise MicropubValidationError(str(e))
except MicropubError:
raise
except Exception as e:
current_app.logger.error(f"Failed to create note via Micropub: {e}")
raise MicropubError(
"server_error", "Failed to create post", status_code=500
)
raise MicropubError("server_error", "Failed to create post", status_code=500)
def handle_update(data: dict, token_info: dict):
"""
Handle Micropub update action (v2.4.0)
JSON body: {"action": "update", "url": ..., "replace": {...},
"add": {...}, "delete": [...] or {...}}. Edits follow to crossposts.
"""
from starpunk.syndication import note_changed
_require_scope(token_info, "update")
note = _note_from_url(_first(data.get("url")))
replace = data.get("replace") or {}
add = data.get("add") or {}
delete = data.get("delete") or {}
if not isinstance(replace, dict) or not isinstance(add, dict) or not isinstance(delete, (dict, list)):
raise MicropubValidationError("replace and add must be objects; delete an object or list")
for prop, values in list(replace.items()) + list(add.items()):
if not isinstance(values, list):
raise MicropubValidationError(f"Values for {prop} must be an array")
touched = set(replace) | set(add) | set(delete)
unsupported = sorted(touched - UPDATABLE)
if unsupported:
raise MicropubValidationError(f"Updating {', '.join(unsupported)} is not supported")
if set(add) - {"category", "photo"}:
raise MicropubValidationError("Only category and photo can be added to")
title, body = split_title(note.content)
tags = [t["display_name"] for t in note.tags]
photos = _note_photos(note)
changes = {}
# Removals first, then replacements, then additions
if isinstance(delete, list):
for prop in delete:
if prop == "name":
title = None
elif prop == "content":
raise MicropubValidationError("content can't be deleted")
elif prop == "category":
tags = []
elif prop == "photo":
photos = []
elif prop == "in-reply-to":
changes["in_reply_to"] = ""
elif prop == "post-status":
changes["published"] = True
else:
for prop, values in delete.items():
if prop == "category":
drop = {v.lower() for v in values}
tags = [t for t in tags if t.lower() not in drop]
elif prop == "photo":
drop = {p["url"] for p in extract_photos({"photo": values})}
photos = [p for p in photos if p["url"] not in drop]
else:
raise MicropubValidationError(f"Can't delete individual values of {prop}")
if "content" in replace:
body = extract_content(replace)
if "name" in replace:
title = extract_title(replace)
if "category" in replace:
tags = extract_tags(replace)
if "photo" in replace:
photos = extract_photos(replace)
if "in-reply-to" in replace:
changes["in_reply_to"] = extract_in_reply_to(replace) or ""
if "post-status" in replace:
changes["published"] = extract_post_status(replace)
if "category" in add:
known = {t.lower() for t in tags}
tags += [t for t in extract_tags(add) if t.lower() not in known]
if "photo" in add:
photos += extract_photos(add)
new_content = add_title_heading(body, title)
if new_content != note.content:
changes["content"] = new_content
if {"category"} & touched:
changes["tags"] = tags
try:
if changes:
update_note(id=note.id, **changes)
if "photo" in touched:
_attach_photos_to_note(note.id, photos)
note_changed(note.id)
except InvalidNoteDataError as e:
raise MicropubValidationError(str(e))
except MicropubError:
raise
except Exception as e:
current_app.logger.error(f"Failed to update note via Micropub: {e}")
raise MicropubError("server_error", "Failed to update post", status_code=500)
return "", 204
def handle_delete(data: dict, token_info: dict, undelete: bool = False):
"""Handle Micropub delete / undelete (v2.4.0). Deletes are soft so they can be undone."""
_require_scope(token_info, "delete")
url = _first(data.get("url"))
try:
if undelete:
undelete_note(_note_from_url(url, deleted=True))
else:
delete_note(id=_note_from_url(url).id, soft=True)
except MicropubError:
raise
except Exception as e:
current_app.logger.error(f"Micropub {'undelete' if undelete else 'delete'} failed: {e}")
raise MicropubError("server_error", "Failed to change post", status_code=500)
return "", 204
def _syndicate_to() -> list:
@@ -461,82 +700,122 @@ def _syndicate_to() -> list:
return [{"uid": t.uid, "name": t.name} for t in get_targets().values()]
def handle_query(args: dict, token_info: dict):
def note_to_mf2(note, wanted: Optional[list] = None) -> dict:
"""
A note as Microformats2 JSON, the inverse of create
A '# Heading' first line is the title, returned as name.
"""
from starpunk.syndication import get_note_syndications
title, content = split_title(note.content)
props = {
"content": [content],
"published": [note.created_at.isoformat()],
"url": [absolute_url_for("public.note", slug=note.slug)],
"post-status": ["published" if note.published else "draft"],
}
if title:
props["name"] = [title]
if note.tags:
props["category"] = [tag["display_name"] for tag in note.tags]
if getattr(note, "in_reply_to", None):
props["in-reply-to"] = [note.in_reply_to]
if getattr(note, "like_of", None):
props["like-of"] = [note.like_of]
if getattr(note, "repost_of", None):
props["repost-of"] = [note.repost_of]
photos = _note_photos(note)
if photos:
props["photo"] = [{"value": p["url"], "alt": p["alt"]} for p in photos]
synced = [s["remote_url"] for s in get_note_syndications(note.id) if s.get("remote_url")]
if synced:
props["syndication"] = synced
if wanted:
return {"properties": {k: v for k, v in props.items() if k in wanted}}
return {"type": ["h-entry"], "properties": props}
def _all_categories(prefix: str = "") -> list:
"""Tags in use, most used first (q=category)"""
from starpunk.database import get_db
rows = get_db(current_app).execute(
"""
SELECT t.display_name, COUNT(nt.note_id) AS uses
FROM tags t LEFT JOIN note_tags nt ON nt.tag_id = t.id
GROUP BY t.id ORDER BY uses DESC, t.display_name
"""
).fetchall()
prefix = prefix.lower()
return [r["display_name"] for r in rows if not prefix or prefix in r["display_name"].lower()]
QUERIES = ["config", "source", "syndicate-to", "category"]
def handle_query(args, token_info: dict):
"""
Handle Micropub query endpoints
Supports:
- q=config: Return server configuration
- q=source: Return post source in Microformats2 JSON
- q=syndicate-to: Return syndication targets
- q=config: Server configuration
- q=source&url=...[&properties[]=...]: One post in Microformats2 JSON
- q=source (no url) [&limit=N&offset=N]: Recent posts, drafts included
- q=syndicate-to: Crosspost targets
- q=category[&filter=...]: Tags in use
Args:
args: Query string arguments
token_info: Authenticated token information
Returns:
Tuple of (response, status_code)
args: Query arguments (werkzeug MultiDict or plain dict)
"""
def get_list(key):
if hasattr(args, "getlist"):
return args.getlist(key) + args.getlist(f"{key}[]")
value = args.get(key) or args.get(f"{key}[]")
return value if isinstance(value, list) else ([value] if value else [])
q = args.get("q")
if q == "config":
# Return server configuration with media endpoint (v1.4.0)
site_url = current_app.config.get("SITE_URL", "http://localhost:5000").rstrip('/')
config = {
return jsonify({
"media-endpoint": f"{site_url}/micropub/media",
"syndicate-to": _syndicate_to(),
"q": QUERIES,
"post-types": [
{"type": "note", "name": "Note", "properties": ["content"]},
{"type": "photo", "name": "Photo", "properties": ["photo"]}
{"type": "article", "name": "Article", "properties": ["name", "content"]},
{"type": "photo", "name": "Photo", "properties": ["photo"]},
{"type": "reply", "name": "Reply", "properties": ["in-reply-to", "content"]},
{"type": "like", "name": "Like", "properties": ["like-of"]},
{"type": "repost", "name": "Repost", "properties": ["repost-of", "content"]},
],
}
return jsonify(config), 200
}), 200
elif q == "source":
# Return source of a specific post
if q == "source":
url = args.get("url")
if not url:
return error_response("invalid_request", "No URL provided")
# Extract slug from URL
wanted = get_list("properties")
if url:
try:
note = _note_from_url(url)
except MicropubError as e:
return error_response("invalid_request" if e.status_code == 400 else e.error,
e.error_description, e.status_code)
return jsonify(note_to_mf2(note, wanted)), 200
try:
# URL format: https://example.com/note/{slug}
slug = url.rstrip("/").split("/")[-1]
note = get_note(slug)
limit = max(1, min(int(args.get("limit", 10)), 50))
offset = max(0, int(args.get("offset", 0)))
except ValueError:
return error_response("invalid_request", "limit and offset must be numbers")
notes = list_notes(published_only=False, limit=limit, offset=offset)
items = [note_to_mf2(n, wanted) for n in notes]
return jsonify({"items": items}), 200
# Check if note exists
if note is None:
return error_response("invalid_request", "Post not found")
except NoteNotFoundError:
return error_response("invalid_request", "Post not found")
except Exception as e:
current_app.logger.error(f"Failed to get note source: {e}")
return error_response("server_error", "Failed to retrieve post")
# Convert note to Micropub Microformats2 format. A '# Heading' first
# line is the title, returned as name (mirrors how create stores it).
title, content = split_title(note.content)
mf2 = {
"type": ["h-entry"],
"properties": {
"content": [content],
"published": [note.created_at.isoformat()],
"url": [absolute_url_for("public.note", slug=note.slug)],
},
}
if title:
mf2["properties"]["name"] = [title]
# Add tags if present (v1.3.0)
if note.tags:
mf2["properties"]["category"] = [tag["display_name"] for tag in note.tags]
return jsonify(mf2), 200
elif q == "syndicate-to":
if q == "syndicate-to":
return jsonify({"syndicate-to": _syndicate_to()}), 200
else:
return error_response("invalid_request", f"Unknown query: {q}")
if q == "category":
return jsonify({"categories": _all_categories(args.get("filter") or "")}), 200
return error_response("invalid_request", f"Unknown query: {q}")
+35
View File
@@ -134,6 +134,8 @@ class Note:
deleted_at: Optional[datetime] = None
content_hash: Optional[str] = None
in_reply_to: Optional[str] = None # v1.6.0: URL being replied to
like_of: Optional[str] = None # v2.5.0: URL liked (this note is a like)
repost_of: Optional[str] = None # v2.5.0: URL reposted (this note is a repost)
_cached_content: Optional[str] = field(
default=None, repr=False, compare=False, init=False
)
@@ -192,6 +194,8 @@ class Note:
_data_dir=data_dir,
content_hash=data.get("content_hash"),
in_reply_to=data.get("in_reply_to"),
like_of=data.get("like_of"),
repost_of=data.get("repost_of"),
)
@property
@@ -367,12 +371,43 @@ class Note:
excerpt = excerpt[:last_space]
excerpt += "..."
if not excerpt and self.reacts_to:
# A like or repost with no comment
verb = "Liked" if self.kind == "like" else "Reposted"
return f"{verb} {self.reacts_to}"
return excerpt
except (FileNotFoundError, OSError):
# If file doesn't exist, return slug
return self.slug
@property
def kind(self) -> str:
"""'like', 'repost' or 'note' (v2.5.0)"""
if self.like_of:
return "like"
if self.repost_of:
return "repost"
return "note"
@property
def reacts_to(self) -> Optional[str]:
"""The URL a like or repost points at"""
return self.like_of or self.repost_of
@property
def feed_html(self) -> str:
"""HTML for feeds: a repost/like line, then the note's own HTML"""
from html import escape
if not self.reacts_to:
return self.html
verb = "Liked" if self.kind == "like" else "Reposted"
url = escape(self.reacts_to, quote=True)
line = f'<p>{"★" if self.kind == "like" else "🔁"} {verb} <a href="{url}">{url}</a></p>'
return line + (self.html or "")
@property
def permalink(self) -> str:
"""
+87 -20
View File
@@ -139,7 +139,9 @@ def create_note(
created_at: Optional[datetime] = None,
custom_slug: Optional[str] = None,
tags: Optional[list[str]] = None,
in_reply_to: Optional[str] = None
in_reply_to: Optional[str] = None,
like_of: Optional[str] = None,
repost_of: Optional[str] = None,
) -> Note:
"""
Create a new note
@@ -203,7 +205,11 @@ def create_note(
- created_at and updated_at set to same value initially
"""
# 1. VALIDATION (before any changes)
if not content or not content.strip():
# Likes and reposts may have no comment (v2.5.0)
if like_of and repost_of:
raise InvalidNoteDataError("like_of", like_of, "A note can't be both a like and a repost")
content = content or ""
if not content.strip() and not (like_of or repost_of):
raise InvalidNoteDataError(
"content", content, "Content cannot be empty or whitespace-only"
)
@@ -264,10 +270,10 @@ def create_note(
try:
db.execute(
"""
INSERT INTO notes (slug, file_path, published, created_at, updated_at, content_hash, in_reply_to)
VALUES (?, ?, ?, ?, ?, ?, ?)
INSERT INTO notes (slug, file_path, published, created_at, updated_at, content_hash, in_reply_to, like_of, repost_of)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
""",
(slug, file_path_rel, published, created_at, updated_at, content_hash, in_reply_to),
(slug, file_path_rel, published, created_at, updated_at, content_hash, in_reply_to, like_of, repost_of),
)
db.commit()
except Exception as e:
@@ -322,33 +328,36 @@ def create_note(
from starpunk.webmention_sender import queue_webmentions_for_note
db_path = Path(current_app.config["DATABASE_PATH"])
site_url = current_app.config["SITE_URL"]
note_url = f"{site_url}/note/{slug}"
from starpunk.utils import absolute_url_for
note_url = absolute_url_for("public.note", slug=slug)
# Get rendered HTML from note
html_content = note.html
# Queue webmentions (best-effort, failures logged but don't fail note creation)
# The reply/like/repost target is notified first (v2.5.0)
queue_webmentions_for_note(
db_path=db_path,
note_id=note_id,
note_url=note_url,
content_html=html_content,
in_reply_to=in_reply_to
in_reply_to=in_reply_to or like_of or repost_of
)
except Exception as e:
# Webmention queueing failure should not prevent note creation
current_app.logger.warning(f"Failed to queue webmentions for note {slug}: {e}")
# 12. FETCH REPLY CONTEXT (v1.6.0 Phase 3)
# Fetch context if this is a reply
if in_reply_to:
# Fetch context for the post being replied to, liked or reposted
context_url = in_reply_to or like_of or repost_of
if context_url:
try:
from starpunk.reply_context import fetch_reply_context
db_path = Path(current_app.config["DATABASE_PATH"])
site_url = current_app.config["SITE_URL"]
# Fetch context (best-effort, failures logged but don't fail note creation)
fetch_reply_context(db_path, in_reply_to, site_url)
fetch_reply_context(db_path, context_url, site_url)
except Exception as e:
# Reply context fetch failure should not prevent note creation
current_app.logger.warning(f"Failed to fetch reply context for {in_reply_to}: {e}")
@@ -472,6 +481,7 @@ def list_notes(
offset: int = 0,
order_by: str = "created_at",
order_dir: str = "DESC",
likes: Optional[bool] = None,
) -> list[Note]:
"""
List notes with filtering and pagination
@@ -564,6 +574,11 @@ def list_notes(
params = []
if published_only:
query += " AND published = 1"
# likes: None = all notes, False = leave likes out, True = only likes (v2.5.0)
if likes is True:
query += " AND like_of IS NOT NULL"
elif likes is False:
query += " AND like_of IS NULL"
# Add ordering (safe because order_by validated above)
query += f" ORDER BY {order_by} {order_dir}"
@@ -663,12 +678,9 @@ def update_note(
if content is None and published is None and tags is None and in_reply_to is None:
raise ValueError("Must provide at least one of content, published, tags, or in_reply_to to update")
# Validate content if provided
if content is not None:
if not content or not content.strip():
raise InvalidNoteDataError(
"content", content, "Content cannot be empty or whitespace-only"
)
# Validate content if provided (checked against the note below for
# likes/reposts, whose comment may be empty)
empty_content = content is not None and not content.strip()
# 2. GET EXISTING NOTE
# Phase 6: Load content to get old HTML for webmention URL diffing
@@ -678,6 +690,11 @@ def update_note(
identifier = slug if slug is not None else id
raise NoteNotFoundError(identifier)
if empty_content and not (existing_note.like_of or existing_note.repost_of):
raise InvalidNoteDataError(
"content", content, "Content cannot be empty or whitespace-only"
)
# 3. SETUP
updated_at = datetime.utcnow()
data_dir = Path(current_app.config["DATA_PATH"])
@@ -815,13 +832,14 @@ def update_note(
from starpunk.webmention_sender import queue_webmentions_for_note
db_path = Path(current_app.config["DATABASE_PATH"])
site_url = current_app.config["SITE_URL"]
note_url = f"{site_url}/note/{updated_note.slug}"
from starpunk.utils import absolute_url_for
note_url = absolute_url_for("public.note", slug=updated_note.slug)
# Get rendered HTML from updated note (if published)
html_content = updated_note.html if updated_note.published else None
# Determine in_reply_to (use new value if provided, otherwise existing)
reply_to = in_reply_to if in_reply_to is not None else updated_note.in_reply_to
reply_to = (in_reply_to if in_reply_to is not None else updated_note.in_reply_to) or updated_note.like_of or updated_note.repost_of
# Queue webmentions (best-effort)
# Pass old_html for URL diffing (Phase 6)
@@ -838,8 +856,8 @@ def update_note(
current_app.logger.warning(f"Failed to queue webmentions for note {updated_note.slug}: {e}")
# 9. FETCH REPLY CONTEXT (v1.6.0 Phase 3)
# Fetch context if in_reply_to changed and is not None
if in_reply_to is not None:
# Fetch context if in_reply_to changed and is set ("" clears it)
if in_reply_to:
try:
from starpunk.reply_context import fetch_reply_context
db_path = Path(current_app.config["DATABASE_PATH"])
@@ -1034,3 +1052,52 @@ def delete_note(
# 6. RETURN (no value)
return None
def undelete_note(slug: str) -> Note:
"""
Restore a soft-deleted note (v2.4.0, Micropub undelete)
Moves the file back from .trash/ and clears deleted_at. Crossposts are
queued again, so a note deleted from them is posted again.
Raises:
NoteNotFoundError: If there is no soft-deleted note with this slug
"""
import shutil
from starpunk.utils import TRASH_DIR_NAME
db = get_db(current_app)
row = db.execute(
"SELECT id, file_path, created_at FROM notes WHERE slug = ? AND deleted_at IS NOT NULL",
(slug,),
).fetchone()
if row is None:
raise NoteNotFoundError(slug)
data_dir = Path(current_app.config["DATA_PATH"])
note_path = data_dir / row["file_path"]
if not note_path.exists():
# delete_note_file put it in .trash/<year>/<month>/<name>
parts = Path(row["file_path"]).parts
candidates = []
if "notes" in parts and len(parts) > parts.index("notes") + 2:
i = parts.index("notes")
candidates.append(data_dir / TRASH_DIR_NAME / parts[i + 1] / parts[i + 2] / note_path.name)
candidates += sorted((data_dir / TRASH_DIR_NAME).glob(f"*/*/{note_path.name}"))
source = next((c for c in candidates if c.exists()), None)
if source is None:
raise NoteSyncError("undelete", f"Trashed file not found for {slug}", "Cannot restore note file")
note_path.parent.mkdir(parents=True, exist_ok=True)
shutil.move(str(source), str(note_path))
db.execute("UPDATE notes SET deleted_at = NULL WHERE id = ?", (row["id"],))
db.commit()
try:
from starpunk.syndication import note_changed
note_changed(row["id"])
except Exception as e:
current_app.logger.warning(f"Failed to queue syndication after undelete: {e}")
return get_note(slug=slug)
+1 -1
View File
@@ -277,7 +277,7 @@ def update_note_submit(note_id: int):
published = "published" in request.form
tags_input = request.form.get("tags", "")
if not content:
if not content and not existing_note.reacts_to: # likes/reposts may have no comment
flash("Content cannot be empty", "error")
return redirect(url_for("admin.edit_note_form", note_id=note_id))
+18 -18
View File
@@ -27,6 +27,8 @@ from starpunk.micropub import (
extract_bearer_token,
error_response,
handle_create,
handle_delete,
handle_update,
handle_query,
)
from starpunk.indieauth import verify_access_token, check_scope
@@ -49,8 +51,8 @@ def micropub_endpoint():
POST requests:
Handle action operations (form-encoded or JSON):
- action=create (or no action): Create new post
- action=update: Update existing post (not supported in V1)
- action=delete: Delete post (not supported in V1)
- 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
@@ -79,7 +81,7 @@ def micropub_endpoint():
# Handle query endpoints (GET requests)
if request.method == "GET":
try:
return handle_query(request.args.to_dict(), token_info)
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:
@@ -95,23 +97,19 @@ def micropub_endpoint():
data = request.get_json() or {}
action = data.get("action", "create")
else:
# Form-encoded or multipart (V1 only supports form-encoded)
# 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)
return handle_create(data, token_info, files=request.files)
elif action == "update":
# V1: Update not supported
return error_response(
"invalid_request", "Update action not supported in V1", 400
)
elif action == "delete":
# V1: Delete not supported
return error_response(
"invalid_request", "Delete action not supported in V1", 400
)
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)
@@ -122,7 +120,8 @@ def micropub_endpoint():
return error_response("server_error", "An unexpected error occurred", 500)
@bp.route('/media', methods=['POST'])
@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
@@ -145,11 +144,12 @@ def media_endpoint():
if not token_info:
return error_response("unauthorized", "Invalid or expired access token", 401)
# Check scope (create scope allows media upload)
if not check_scope("create", token_info.get("scope", "")):
# 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 create scope",
"Token lacks media or create scope",
403
)
+34 -3
View File
@@ -64,7 +64,7 @@ def _get_cached_notes():
# Cache expired or empty, fetch fresh notes
max_items = current_app.config.get("FEED_MAX_ITEMS", 50)
notes = list_notes(published_only=True, limit=max_items)
notes = list_notes(published_only=True, limit=max_items, likes=False)
# Batch load media and tags for all notes (v1.5.0 Phase 3)
# Reduces query count from O(n) to O(1) for both media and tags
@@ -249,8 +249,8 @@ def index():
from starpunk.media import get_note_media
from starpunk.tags import get_note_tags
# Get recent published notes (limit 20)
notes = list_notes(published_only=True, limit=20)
# Get recent published notes (limit 20); likes have their own page (v2.5.0)
notes = list_notes(published_only=True, limit=20, likes=False)
# Attach media and tags to each note for display
for note in notes:
@@ -262,9 +262,38 @@ def index():
tags = get_note_tags(note.id)
object.__setattr__(note, '_cached_tags', tags)
attach_contexts(notes)
return render_template("index.html", notes=notes)
def attach_contexts(notes) -> None:
"""Give likes and reposts the fetched context of the post they point at"""
from starpunk.webmention_queries import get_reply_context
for note in notes:
context = None
if note.reacts_to:
try:
context = get_reply_context(note.reacts_to)
except Exception:
context = None
object.__setattr__(note, 'context', context)
@bp.route("/likes")
def likes():
"""Likes, kept off the home page and feeds (v2.5.0)"""
from starpunk.media import get_note_media
from starpunk.tags import get_note_tags
notes = list_notes(published_only=True, limit=50, likes=True)
for note in notes:
object.__setattr__(note, 'media', get_note_media(note.id))
object.__setattr__(note, '_cached_tags', get_note_tags(note.id))
attach_contexts(notes)
return render_template("likes.html", notes=notes)
@bp.route("/note/<slug>")
def note(slug: str):
"""
@@ -334,6 +363,7 @@ def note(slug: str):
from starpunk.syndication import get_note_syndications
syndications = [s for s in get_note_syndications(note_obj.id) if s["state"] == "synced"]
attach_contexts([note_obj])
return render_template(
"note.html",
@@ -384,6 +414,7 @@ def tag(tag: str):
for note in notes:
media = get_note_media(note.id)
object.__setattr__(note, 'media', media)
attach_contexts(notes)
return render_template(
"tag.html",
+137 -10
View File
@@ -113,21 +113,56 @@ class MastodonClient:
# Interface used by the reconcile loop
can_edit = True
NATIVE = ("favourite", "reblog") # remote_id prefixes for likes/boosts (v2.5.0)
def find_status(self, url: str) -> Optional[str]:
"""Local id of a fediverse post, fetching it if needed; None if the URL isn't one"""
try:
response = self._call("GET", "/api/v2/search", params={
"q": url, "resolve": "true", "type": "statuses", "limit": 1,
})
except RemoteGone:
return None
statuses = response.json().get("statuses") or []
return statuses[0]["id"] if statuses else None
def _prepare(self, post: "Post") -> tuple:
if post.kind == "repost":
return compose_repost_text(post, post.note.content, post.max_chars), []
text = compose_text(post.note, post.permalink, post.tags, post.max_chars)
media_ids = [self.upload_media(f["path"], f["mime_type"], f["description"]) for f in post.media]
return text, media_ids
def create(self, post: "Post", key: str, retrying: bool = False) -> dict:
if post.kind in ("like", "repost") and post.target_url:
# Native favourite/boost when the target is a fediverse post; a
# repost with a comment is posted as a status so the comment stays
commented = bool(post.note.content.strip())
if post.kind == "like" or not commented:
status_id = self.find_status(post.target_url)
if status_id:
action = "favourite" if post.kind == "like" else "reblog"
self._call("POST", f"/api/v1/statuses/{status_id}/{action}")
return {"id": f"{action}:{status_id}", "url": None}
if post.kind == "like":
return {"id": None, "url": None} # nothing to like here
text, media_ids = self._prepare(post)
return self.create_status(text, media_ids, idempotency_key=key)
def update(self, remote_id: str, post: "Post") -> dict:
if remote_id.split(":", 1)[0] in self.NATIVE:
return {"id": remote_id, "url": None} # a favourite/boost has nothing to edit
text, media_ids = self._prepare(post)
return self.update_status(remote_id, text, media_ids)
def delete(self, remote_id: str) -> None:
action, _, status_id = remote_id.partition(":")
if action in self.NATIVE and status_id:
try:
self._call("POST", f"/api/v1/statuses/{status_id}/un{action}")
except RemoteGone:
pass
return
self.delete_status(remote_id)
@@ -229,18 +264,21 @@ class BlueskyClient:
image["aspectRatio"] = {"width": width, "height": height}
return image
def _record(self, post: "Post") -> dict:
text = compose_text(post.note, post.permalink, post.tags, post.max_chars,
body=plain_text(post.note.content))
record = {
"$type": self.POST,
"text": text,
"createdAt": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z",
}
@staticmethod
def _now() -> str:
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
def _record(self, post: "Post", text: Optional[str] = None, embed: Optional[dict] = None) -> dict:
if text is None:
text = compose_text(post.note, post.permalink, post.tags, post.max_chars,
body=plain_text(post.note.content))
record = {"$type": self.POST, "text": text, "createdAt": self._now()}
facets = bluesky_facets(text)
if facets:
record["facets"] = facets
if post.media:
if embed is not None:
record["embed"] = embed
elif post.media:
record["embed"] = {"$type": "app.bsky.embed.images",
"images": [self._image(m) for m in post.media]}
else:
@@ -251,6 +289,54 @@ class BlueskyClient:
}}
return record
_POST_URL = re.compile(r"^https://bsky\.app/profile/([^/]+)/post/([^/?#]+)")
def resolve_post(self, url: str) -> Optional[dict]:
"""{'uri', 'cid'} of a Bluesky post URL; None if the URL isn't one"""
m = self._POST_URL.match(url or "")
if not m:
return None
actor, rkey = m.groups()
if not actor.startswith("did:"):
actor = self._call("GET", "com.atproto.identity.resolveHandle",
params={"handle": actor}).json()["did"]
uri = f"at://{actor}/{self.POST}/{rkey}"
posts = self._call("GET", "app.bsky.feed.getPosts", params={"uris": uri}).json().get("posts") or []
return {"uri": uri, "cid": posts[0]["cid"]} if posts else None
def _create(self, collection: str, record: dict) -> str:
response = self._call("POST", "com.atproto.repo.createRecord",
json={"repo": self.did or self.identifier, "collection": collection,
"record": record})
return response.json()["uri"]
def _react(self, post: "Post") -> dict:
"""Like, repost or quote a Bluesky post; fall back to a link post for reposts"""
comment = plain_text(post.note.content) if post.note.content.strip() else ""
subject = self.resolve_post(post.target_url)
if subject and post.kind == "like":
uri = self._create("app.bsky.feed.like", {
"$type": "app.bsky.feed.like", "subject": subject, "createdAt": self._now()})
return {"id": uri, "url": None}
if subject and not comment:
uri = self._create("app.bsky.feed.repost", {
"$type": "app.bsky.feed.repost", "subject": subject, "createdAt": self._now()})
return {"id": uri, "url": None}
if subject: # repost with a comment -> quote post
text = comment if len(comment) <= post.max_chars else \
comment[:post.max_chars - 1].rsplit(" ", 1)[0].rstrip() + "…"
uri = self._create(self.POST, self._record(
post, text=text, embed={"$type": "app.bsky.embed.record", "record": subject}))
return {"id": uri, "url": self._web_url(uri)}
if post.kind == "like":
return {"id": None, "url": None} # not a Bluesky post: nothing to like
text = compose_repost_text(post, comment, post.max_chars)
embed = {"$type": "app.bsky.embed.external", "external": {
"uri": post.target_url, "title": (post.target_title or post.target_url)[:300],
"description": ""}}
uri = self._create(self.POST, self._record(post, text=text, embed=embed))
return {"id": uri, "url": self._web_url(uri)}
def _web_url(self, uri: str) -> str:
rkey = uri.rsplit("/", 1)[1]
return f"https://bsky.app/profile/{self.handle or self.did}/post/{rkey}"
@@ -265,6 +351,11 @@ class BlueskyClient:
return None
def create(self, post: "Post", key: str, retrying: bool = False) -> dict:
if post.kind in ("like", "repost") and post.target_url:
if not self.did:
with self._lock:
self._login()
return self._react(post)
if retrying:
if not self.did:
with self._lock:
@@ -327,6 +418,24 @@ class Post:
tags: List[str]
max_chars: int
media: List[dict] = field(default_factory=list)
kind: str = "note" # note, like or repost (v2.5.0)
target_url: Optional[str] = None # what a like/repost points at
target_title: Optional[str] = None # its fetched title, if any
def compose_repost_text(post: "Post", comment: str, max_chars: int) -> str:
"""'comment' then '🔁 title' and the URL; the comment is shortened to fit"""
title = post.target_title or "Reposted"
tail = f"🔁 {title}\n{post.target_url}"
if len(tail) > max_chars:
tail = f"🔁 {post.target_url}"
comment = (comment or "").strip()
if not comment:
return tail
room = max_chars - len(tail) - 2
if len(comment) > room:
comment = comment[:max(room - 1, 0)].rsplit(" ", 1)[0].rstrip() + "…"
return f"{comment}\n\n{tail}" if room > 1 else tail
_client_cache: Dict[str, object] = {}
@@ -615,6 +724,21 @@ def _fail(db, row, error: SyndicationError) -> None:
)
def _target_title(url: Optional[str]) -> Optional[str]:
"""Fetched title of a liked/reposted post, if we have one"""
if not url:
return None
try:
from starpunk.webmention_queries import get_reply_context
context = get_reply_context(url) or {}
except Exception:
return None
title = context.get("title") or ""
if not title and context.get("author_name"):
title = f"Post by {context['author_name']}"
return " ".join(title.split())[:200] or None
def _reconcile(row, target: Target) -> tuple:
"""Bring the remote post in line with the note. Returns (remote_id, remote_url)."""
from starpunk.notes import get_note
@@ -637,7 +761,10 @@ def _reconcile(row, target: Target) -> tuple:
permalink=f"{site}/note/{note.slug}",
tags=[t["display_name"] for t in get_note_tags(note.id)],
max_chars=target.max_chars,
media=_media_files(note.id, target.max_media),
media=_media_files(note.id, target.max_media) if note.kind == "note" else [],
kind=note.kind,
target_url=note.reacts_to,
target_title=_target_title(note.reacts_to),
)
if row["remote_id"]:
+11
View File
@@ -92,6 +92,17 @@ main { flex: 1; margin-bottom: var(--spacing-xl); }
.e-content ul, .e-content ol { margin: 0 0 var(--spacing-md) 1.25rem; }
.e-content img { max-width: 100%; height: auto; }
.e-content h1, .e-content h2, .e-content h3 { font-family: var(--font-body); }
.reaction { margin-bottom: var(--spacing-sm); font-size: 0.9375rem; color: var(--color-text-light); overflow-wrap: anywhere; }
.reaction-verb { font-weight: 600; margin-right: 0.25rem; }
.reaction-like .reaction-verb { color: #c2410c; }
.reaction-repost .reaction-verb { color: #15803d; }
.reaction a { color: var(--color-text); font-weight: 500; }
.reaction a:hover { color: var(--color-link); }
.reaction-by { margin-left: 0.25rem; }
@media (prefers-color-scheme: dark) {
.reaction-like .reaction-verb { color: #fb923c; }
.reaction-repost .reaction-verb { color: #4ade80; }
}
.read-more { margin: var(--spacing-sm) 0 0; font-size: 0.9375rem; }
.note-meta { display: flex; flex-wrap: wrap; align-items: baseline; gap: 0 0.4rem; margin-top: var(--spacing-sm); color: var(--color-text-light); font-size: 0.8125rem; }
+6 -3
View File
@@ -12,12 +12,15 @@
<form action="{{ url_for('admin.update_note_submit', note_id=note.id) }}" method="POST" class="note-form">
<div class="form-group">
<label for="content">Content (Markdown)</label>
{% if note.reacts_to %}
<p class="note-meta">{{ '★ Like of' if note.kind == 'like' else '🔁 Repost of' }} <a href="{{ note.reacts_to }}">{{ note.reacts_to }}</a></p>
{% endif %}
<label for="content">{% if note.reacts_to %}Comment (optional, Markdown){% else %}Content (Markdown){% endif %}</label>
<textarea
id="content"
name="content"
rows="20"
required
rows="{{ 6 if note.reacts_to else 20 }}"
{% if not note.reacts_to %}required{% endif %}
autofocus
>{{ note.content }}</textarea>
<small>Use Markdown syntax for formatting</small>
+1
View File
@@ -38,6 +38,7 @@
<a class="site-title" href="/">{{ config.SITE_NAME }}</a>
<nav class="site-nav">
<a href="/">Home</a>
<a href="{{ url_for('public.likes') }}">Likes</a>
<a href="{{ url_for('public.feed') }}">RSS</a>
{% if g.me %}
<a href="{{ url_for('admin.dashboard') }}">Admin</a>
+22
View File
@@ -0,0 +1,22 @@
{% extends "base.html" %}
{% from "partials/note_preview.html" import note_preview %}
{% block title %}Likes · {{ config.SITE_NAME }}{% endblock %}
{% block content %}
<div class="h-feed">
<h1 class="p-name page-title">Likes</h1>
{% if notes %}
{% for note in notes %}
{{ note_preview(note, author) }}
{% endfor %}
{% else %}
<p class="empty-state">Nothing liked yet.</p>
{% endif %}
<nav class="note-nav">
<a href="/">← All notes</a>
</nav>
</div>
{% endblock %}
+3
View File
@@ -1,5 +1,6 @@
{% extends "base.html" %}
{% from "partials/media.html" import display_media %}
{% from "partials/reaction.html" import reaction %}
{% block title %}{% if note.content.strip().startswith('#') %}{{ note.title }}{% else %}{{ note.excerpt|truncate(60) }}{% endif %} · {{ config.SITE_NAME }}{% endblock %}
@@ -38,6 +39,8 @@
</div>
{% endif %}
{{ reaction(note) }}
{# u-photo placement: Per draft spec, u-photo must be direct child of h-entry, #}
{# NOT inside e-content. Media is rendered ABOVE e-content to meet this requirement. #}
{{ display_media(note.media) }}
+4 -1
View File
@@ -1,5 +1,6 @@
{# One note in a list (home, tag pages). v2.3.0 #}
{% from "partials/media.html" import display_media %}
{% from "partials/reaction.html" import reaction %}
{% macro note_preview(note, author) %}
<article class="h-entry note-preview">
{# Notes starting with a # heading have a title (Q22) #}
@@ -8,6 +9,8 @@
<h2 class="p-name"><a href="{{ absolute_url_for('public.note', slug=note.slug) }}">{{ note.title }}</a></h2>
{% endif %}
{{ reaction(note) }}
{{ display_media(note.media) }}
{% if has_explicit_title %}
@@ -16,7 +19,7 @@
<p>{{ note.excerpt }}</p>
</div>
<p class="read-more"><a href="{{ absolute_url_for('public.note', slug=note.slug) }}">Read more →</a></p>
{% else %}
{% elif note.html %}
<div class="e-content">
{{ note.html|safe }}
</div>
+12
View File
@@ -0,0 +1,12 @@
{# "Liked" / "Reposted" line for likes and reposts (v2.5.0) #}
{% macro reaction(note) %}
{% if note.reacts_to %}
{% set ctx = note.context if note.context is defined else None %}
{% if ctx and ctx.title %}{% set label = ctx.title %}{% elif ctx and ctx.content_snippet %}{% set label = ctx.content_snippet|striptags|truncate(90) %}{% elif ctx and (ctx.author_name or ctx.site_name) %}{% set label = 'a post' %}{% else %}{% set label = note.reacts_to %}{% endif %}
<p class="reaction reaction-{{ note.kind }}">
<span class="reaction-verb">{% if note.kind == 'like' %}★ Liked{% else %}🔁 Reposted{% endif %}</span>
<a class="{{ 'u-like-of' if note.kind == 'like' else 'u-repost-of' }}" href="{{ note.reacts_to }}">{{ label }}</a>
{% if ctx and (ctx.author_name or ctx.site_name) %}<span class="reaction-by">by {{ ctx.author_name or ctx.site_name }}</span>{% endif %}
</p>
{% endif %}
{% endmacro %}
+223
View File
@@ -0,0 +1,223 @@
"""
Likes and reposts (v2.5.0, ADR-068)
Fake GoToSocial and Bluesky servers check that likes/reposts of their own
posts become native favourites/boosts/likes/reposts, and everything else
falls back (reposts) or is skipped (likes).
"""
import json
import httpx
import pytest
from starpunk import create_app, syndication
from starpunk.indieauth import create_access_token
from starpunk.notes import delete_note, get_note
from starpunk.syndication import BlueskyClient, MastodonClient, get_note_syndications, process_due
SITE = "https://blog.example.com"
GTS = "https://social.example.com"
FEDI_POST = "https://mastodon.example/@alice/111"
BSKY_POST = "https://bsky.app/profile/alice.example/post/3abc"
WEB_PAGE = "https://someblog.example/2026/a-post"
class FakeGTS:
def __init__(self):
self.calls = []
self.statuses = {}
def __call__(self, request):
path = request.url.path
self.calls.append((request.method, path))
if path == "/api/v2/search":
q = request.url.params["q"]
return httpx.Response(200, json={"statuses": [{"id": "s1"}] if q == FEDI_POST else []})
if path in ("/api/v1/statuses/s1/favourite", "/api/v1/statuses/s1/unfavourite",
"/api/v1/statuses/s1/reblog", "/api/v1/statuses/s1/unreblog"):
return httpx.Response(200, json={"id": "s1"})
if path == "/api/v1/statuses" and request.method == "POST":
sid = f"p{len(self.statuses) + 1}"
self.statuses[sid] = json.loads(request.content)
return httpx.Response(200, json={"id": sid, "url": f"{GTS}/@phil/statuses/{sid}"})
if path.startswith("/api/v1/statuses/") and request.method == "DELETE":
self.statuses.pop(path.rsplit("/", 1)[1], None)
return httpx.Response(200, json={})
return httpx.Response(500)
class FakePDS:
def __init__(self):
self.records = {}
self.calls = []
def __call__(self, request):
nsid = request.url.path.removeprefix("/xrpc/")
self.calls.append(nsid)
if nsid == "com.atproto.server.createSession":
return httpx.Response(200, json={"did": "did:plc:me", "handle": "me.example",
"accessJwt": "a", "refreshJwt": "r"})
if nsid == "com.atproto.identity.resolveHandle":
return httpx.Response(200, json={"did": "did:plc:alice"})
if nsid == "app.bsky.feed.getPosts":
return httpx.Response(200, json={"posts": [{"uri": request.url.params["uris"], "cid": "cid1"}]})
if nsid == "com.atproto.repo.createRecord":
body = json.loads(request.content)
uri = f"at://did:plc:me/{body['collection']}/r{len(self.records) + 1}"
self.records[uri] = body["record"]
return httpx.Response(200, json={"uri": uri, "cid": "c"})
if nsid == "com.atproto.repo.deleteRecord":
body = json.loads(request.content)
self.records.pop(f"at://{body['repo']}/{body['collection']}/{body['rkey']}", None)
return httpx.Response(200, json={})
return httpx.Response(500, json={"error": nsid})
@pytest.fixture
def gts():
return FakeGTS()
@pytest.fixture
def pds():
return FakePDS()
@pytest.fixture
def app(tmp_path, gts, pds):
data = tmp_path / "data"
app = create_app({
"TESTING": True, "SITE_URL": SITE, "ADMIN_ME": "https://example.com", "SESSION_SECRET": "x",
"DATA_PATH": data, "NOTES_PATH": data / "notes", "DATABASE_PATH": data / "starpunk.db",
"GOTOSOCIAL_URL": GTS, "GOTOSOCIAL_ACCESS_TOKEN": "t",
"BLUESKY_HANDLE": "me.example", "BLUESKY_APP_PASSWORD": "p", "BLUESKY_SERVICE": "https://pds.example",
"FEED_CACHE_ENABLED": False,
})
# The feed's note list is cached at module level across apps
from starpunk.routes import public
public._feed_cache["notes"] = None
public._feed_cache["timestamp"] = None
syndication._client_cache[GTS] = MastodonClient(GTS, "t", http=httpx.Client(transport=httpx.MockTransport(gts)))
syndication._client_cache["bluesky:https://pds.example:me.example"] = BlueskyClient(
"https://pds.example", "me.example", "p", http=httpx.Client(transport=httpx.MockTransport(pds)))
yield app
syndication._client_cache.clear()
@pytest.fixture
def post(app, monkeypatch):
# Don't fetch contexts from the network
monkeypatch.setattr("starpunk.reply_context.fetch_reply_context", lambda *a, **k: None)
with app.test_request_context():
token = create_access_token("https://quill.example/", "create update delete")["access_token"]
client = app.test_client()
def _post(**props):
response = client.post("/micropub", json={"type": ["h-entry"], "properties": props},
headers={"Authorization": f"Bearer {token}"})
assert response.status_code == 201, response.get_json()
location = response.headers["Location"]
with app.app_context():
note = get_note(slug=location.rsplit("/", 1)[1])
process_due(limit=10)
rows = {r["target"]: r for r in get_note_syndications(note.id)}
return note, rows
return _post
def page(app, path):
return app.test_client().get(path).data.decode()
class TestSite:
def test_like_without_comment(self, app, post):
note, _ = post(**{"like-of": [WEB_PAGE]})
assert note.kind == "like" and note.content == ""
assert note.slug not in page(app, "/")
likes = page(app, "/likes")
assert f'class="u-like-of" href="{WEB_PAGE}"' in likes and "★ Liked" in likes
assert note.slug not in page(app, "/feed.json")
def test_repost_in_stream_and_feed(self, app, post):
note, _ = post(**{"repost-of": [WEB_PAGE], "content": ["Worth a read"]})
home = page(app, "/")
assert f'class="u-repost-of" href="{WEB_PAGE}"' in home and "Worth a read" in home
feed = json.loads(page(app, "/feed.json"))
item = next(i for i in feed["items"] if note.slug in i["url"])
assert "Reposted" in item["content_html"] and WEB_PAGE in item["content_html"]
def test_webmention_goes_to_target_with_clean_url(self, app, post, monkeypatch):
sent = {}
monkeypatch.setattr("starpunk.webmention_sender.queue_webmentions_for_note",
lambda **kw: sent.update(kw) or 0)
app.config["WEBMENTION_ENABLED"] = True
note, _ = post(**{"like-of": [WEB_PAGE]})
assert sent["in_reply_to"] == WEB_PAGE
assert sent["note_url"] == f"{SITE}/note/{note.slug}" # no double slash
def test_both_kinds_rejected(self, app, post):
with pytest.raises(AssertionError):
post(**{"like-of": [WEB_PAGE], "repost-of": [WEB_PAGE]})
class TestGoToSocial:
def test_like_of_fediverse_post_favourites(self, app, post, gts):
note, rows = post(**{"like-of": [FEDI_POST]})
assert rows["gotosocial"]["remote_id"] == "favourite:s1"
assert rows["gotosocial"]["remote_url"] is None
with app.test_request_context():
delete_note(id=note.id)
process_due(limit=10)
assert ("POST", "/api/v1/statuses/s1/unfavourite") in gts.calls
def test_like_of_web_page_is_not_crossposted(self, app, post, gts):
_, rows = post(**{"like-of": [WEB_PAGE]})
assert rows["gotosocial"]["state"] == "synced" and rows["gotosocial"]["remote_id"] is None
assert gts.statuses == {}
def test_repost_boosts(self, app, post, gts):
_, rows = post(**{"repost-of": [FEDI_POST]})
assert rows["gotosocial"]["remote_id"] == "reblog:s1"
def test_repost_with_comment_posts_status(self, app, post, gts):
_, rows = post(**{"repost-of": [FEDI_POST], "content": ["So true"]})
(status,) = gts.statuses.values()
assert status["status"].startswith("So true") and FEDI_POST in status["status"]
assert ("POST", "/api/v1/statuses/s1/reblog") not in gts.calls
def test_repost_of_web_page_posts_link(self, app, post, gts):
post(**{"repost-of": [WEB_PAGE]})
(status,) = gts.statuses.values()
assert status["status"].startswith("🔁") and WEB_PAGE in status["status"]
class TestBluesky:
def test_like_of_bluesky_post(self, app, post, pds):
note, rows = post(**{"like-of": [BSKY_POST]})
uri = rows["bluesky"]["remote_id"]
assert "/app.bsky.feed.like/" in uri
assert pds.records[uri]["subject"] == {"uri": "at://did:plc:alice/app.bsky.feed.post/3abc", "cid": "cid1"}
with app.test_request_context():
delete_note(id=note.id)
process_due(limit=10)
assert uri not in pds.records
def test_like_of_web_page_skipped(self, app, post, pds):
_, rows = post(**{"like-of": [WEB_PAGE]})
assert rows["bluesky"]["remote_id"] is None and pds.records == {}
def test_repost_and_quote(self, app, post, pds):
_, rows = post(**{"repost-of": [BSKY_POST]})
assert "/app.bsky.feed.repost/" in rows["bluesky"]["remote_id"]
_, rows = post(**{"repost-of": [BSKY_POST], "content": ["Great thread"]})
record = pds.records[rows["bluesky"]["remote_id"]]
assert record["text"] == "Great thread"
assert record["embed"] == {"$type": "app.bsky.embed.record",
"record": {"uri": "at://did:plc:alice/app.bsky.feed.post/3abc", "cid": "cid1"}}
def test_repost_of_web_page_posts_link_card(self, app, post, pds):
_, rows = post(**{"repost-of": [WEB_PAGE]})
record = pds.records[rows["bluesky"]["remote_id"]]
assert record["embed"]["external"]["uri"] == WEB_PAGE
assert record["text"].startswith("🔁")
+15 -27
View File
@@ -372,33 +372,21 @@ def test_micropub_missing_content(client, mock_valid_token):
assert data['error'] == 'invalid_request'
def test_micropub_unsupported_action(client, mock_valid_token):
"""Test unsupported actions (update, delete) return error"""
def test_micropub_update_delete_need_scope(client, mock_valid_token):
"""A create-only token can't update or delete (v2.4.0)"""
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
# Test update
response = client.post(
'/micropub',
json={
'action': 'update',
'url': 'https://example.com/note/123'
},
headers={'Authorization': 'Bearer valid_token'}
)
for action in ('update', 'delete', 'undelete'):
response = client.post(
'/micropub',
json={'action': action, 'url': 'https://example.com/note/123', 'replace': {}},
headers={'Authorization': 'Bearer valid_token'}
)
assert response.status_code == 403, action
assert response.get_json()['error'] == 'insufficient_scope'
def test_micropub_unknown_action(client, mock_valid_token):
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
response = client.post('/micropub', json={'action': 'frobnicate'},
headers={'Authorization': 'Bearer valid_token'})
assert response.status_code == 400
data = response.get_json()
assert 'not supported' in data['error_description']
# Test delete
response = client.post(
'/micropub',
json={
'action': 'delete',
'url': 'https://example.com/note/123'
},
headers={'Authorization': 'Bearer valid_token'}
)
assert response.status_code == 400
data = response.get_json()
assert 'not supported' in data['error_description']
+206
View File
@@ -0,0 +1,206 @@
"""
Micropub round 1 (v2.4.0): update, delete/undelete, drafts, replies,
multipart and remote photos, q=source lists and filters, q=category.
Uses real tokens from StarPunk's own IndieAuth server.
"""
import io
import httpx
import pytest
from PIL import Image
from starpunk import create_app
from starpunk.indieauth import create_access_token
from starpunk.notes import get_note
SITE = "https://blog.example.com"
@pytest.fixture
def app(tmp_path):
data = tmp_path / "data"
return create_app({
"TESTING": True, "SITE_URL": SITE, "ADMIN_ME": "https://example.com",
"SESSION_SECRET": "x", "DATA_PATH": data, "NOTES_PATH": data / "notes",
"DATABASE_PATH": data / "starpunk.db",
})
def auth(app, scope="create update delete media"):
with app.test_request_context():
token = create_access_token("https://quill.example/", scope)["access_token"]
return {"Authorization": f"Bearer {token}"}
@pytest.fixture
def client(app):
return app.test_client()
@pytest.fixture
def h(app):
return auth(app)
def jpeg(color="red"):
buf = io.BytesIO()
Image.new("RGB", (64, 48), color).save(buf, format="JPEG")
return buf.getvalue()
def create(client, h, **props):
body = {"type": ["h-entry"], "properties": {"content": ["Hello"], **props}}
response = client.post("/micropub", json=body, headers=h)
assert response.status_code == 201, response.get_json()
return response.headers["Location"]
def note_at(app, url):
with app.app_context():
return get_note(slug=url.rstrip("/").rsplit("/", 1)[1])
def source(client, h, url, *props):
query = f"/micropub?q=source&url={url}" + "".join(f"&properties[]={p}" for p in props)
return client.get(query, headers=h).get_json()
class TestCreate:
def test_draft(self, app, client, h):
url = create(client, h, **{"post-status": ["draft"]})
assert note_at(app, url).published is False
assert client.get(url.replace(SITE, "")).status_code == 404
def test_reply(self, app, client, h):
url = create(client, h, **{"in-reply-to": ["https://other.example/post/1"]})
assert note_at(app, url).in_reply_to == "https://other.example/post/1"
def test_multipart_photo(self, app, client, h):
response = client.post(
"/micropub",
data={"h": "entry", "content": "With a file", "photo": (io.BytesIO(jpeg()), "pic.jpg")},
headers=h, content_type="multipart/form-data",
)
assert response.status_code == 201
assert "photo" in source(client, h, response.headers["Location"])["properties"]
def test_remote_photo_is_downloaded(self, app, client, h, monkeypatch):
transport = httpx.MockTransport(lambda req: httpx.Response(200, content=jpeg("blue")))
monkeypatch.setattr(httpx, "stream", lambda method, url, **kw: httpx.Client(transport=transport).stream(method, url))
url = create(client, h, photo=[{"value": "https://photos.example/cat.jpg", "alt": "A cat"}])
(photo,) = source(client, h, url)["properties"]["photo"]
assert photo["value"].startswith(f"{SITE}/media/") and photo["alt"] == "A cat"
def test_only_h_entry(self, client, h):
response = client.post("/micropub", data={"h": "event", "content": "x"}, headers=h)
assert response.status_code == 400
class TestUpdate:
def update(self, client, h, url, **ops):
return client.post("/micropub", json={"action": "update", "url": url, **ops}, headers=h)
def test_replace_content_keeps_title(self, app, client, h):
url = create(client, h, name=["My Title"])
assert self.update(client, h, url, replace={"content": ["New body"]}).status_code == 204
props = source(client, h, url)["properties"]
assert props["name"] == ["My Title"] and props["content"] == ["New body"]
def test_replace_and_delete_name(self, app, client, h):
url = create(client, h)
self.update(client, h, url, replace={"name": ["Added"]})
assert note_at(app, url).content.startswith("# Added")
self.update(client, h, url, delete=["name"])
assert "name" not in source(client, h, url)["properties"]
def test_categories(self, app, client, h):
url = create(client, h, category=["one", "two"])
self.update(client, h, url, add={"category": ["three", "One"]})
assert source(client, h, url)["properties"]["category"] == ["one", "three", "two"]
self.update(client, h, url, delete={"category": ["two"]})
assert source(client, h, url)["properties"]["category"] == ["one", "three"]
self.update(client, h, url, delete=["category"])
assert "category" not in source(client, h, url)["properties"]
def test_post_status_and_reply(self, app, client, h):
url = create(client, h)
self.update(client, h, url, replace={"post-status": ["draft"], "in-reply-to": ["https://x.example/a"]})
note = note_at(app, url)
assert note.published is False and note.in_reply_to == "https://x.example/a"
self.update(client, h, url, delete=["in-reply-to", "post-status"])
note = note_at(app, url)
assert note.published is True and not note.in_reply_to
def test_photos(self, app, client, h):
uploaded = client.post("/micropub/media", data={"file": (io.BytesIO(jpeg()), "a.jpg")},
headers=h, content_type="multipart/form-data").headers["Location"]
url = create(client, h)
self.update(client, h, url, add={"photo": [{"value": uploaded, "alt": "Red"}]})
assert source(client, h, url)["properties"]["photo"] == [{"value": uploaded, "alt": "Red"}]
self.update(client, h, url, delete={"photo": [uploaded]})
assert "photo" not in source(client, h, url)["properties"]
def test_unsupported_property(self, client, h):
url = create(client, h)
response = self.update(client, h, url, replace={"published": ["2020-01-01T00:00:00Z"]})
assert response.status_code == 400 and "published" in response.get_json()["error_description"]
def test_unknown_post(self, client, h):
response = self.update(client, h, f"{SITE}/note/nope", replace={"content": ["x"]})
assert response.status_code == 404
def test_form_update_rejected(self, client, h):
url = create(client, h)
assert client.post("/micropub", data={"action": "update", "url": url}, headers=h).status_code == 400
class TestDelete:
def test_delete_and_undelete(self, app, client, h):
url = create(client, h, category=["kept"])
path = url.replace(SITE, "")
assert client.post("/micropub", data={"action": "delete", "url": url}, headers=h).status_code == 204
assert client.get(path).status_code == 404
response = client.post("/micropub", json={"action": "undelete", "url": url}, headers=h)
assert response.status_code == 204
assert client.get(path).status_code == 200
assert source(client, h, url)["properties"]["category"] == ["kept"]
def test_undelete_needs_a_deleted_post(self, client, h):
url = create(client, h)
assert client.post("/micropub", json={"action": "undelete", "url": url}, headers=h).status_code == 404
def test_delete_scope(self, app, client):
h = auth(app, "create")
url = create(client, h)
assert client.post("/micropub", data={"action": "delete", "url": url}, headers=h).status_code == 403
class TestQueries:
def test_source_properties_filter(self, client, h):
url = create(client, h, name=["T"], category=["x"])
data = source(client, h, url, "name", "category")
assert data == {"properties": {"name": ["T"], "category": ["x"]}}
def test_source_list_includes_drafts(self, client, h):
create(client, h, content=["first"])
create(client, h, content=["second"], **{"post-status": ["draft"]})
items = client.get("/micropub?q=source&limit=5", headers=h).get_json()["items"]
assert {i["properties"]["post-status"][0] for i in items} == {"published", "draft"}
def test_category(self, client, h):
create(client, h, category=["IndieWeb", "python"])
create(client, h, category=["IndieWeb"])
assert client.get("/micropub?q=category", headers=h).get_json()["categories"] == ["IndieWeb", "python"]
assert client.get("/micropub?q=category&filter=py", headers=h).get_json()["categories"] == ["python"]
def test_config_lists_queries(self, client, h):
config = client.get("/micropub?q=config", headers=h).get_json()
assert "category" in config["q"] and "media-endpoint" in config
def test_media_scope_alone_can_upload(app, client):
response = client.post("/micropub/media", data={"file": (io.BytesIO(jpeg()), "a.jpg")},
headers=auth(app, "media"), content_type="multipart/form-data")
assert response.status_code == 201