Compare commits
25
Commits
v1.6.0-rc.2
...
v2.6.2
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
a62077ab30 | ||
|
|
fade75fd2d | ||
|
|
0dd59fbc18 | ||
|
|
11e09a0d02 | ||
|
|
565adaeecf | ||
|
|
53d10ed271 | ||
|
|
e8c1b03980 | ||
|
|
0d3a5cd519 | ||
|
|
88088e10e1 | ||
|
|
391bdb9db3 | ||
|
|
c51cf726b0 | ||
|
|
2616ef5060 | ||
|
|
0ae16bd1fc | ||
|
|
cc09098741 | ||
|
|
16925663a3 | ||
|
|
e92c27a84c | ||
|
|
ed63e70c46 | ||
|
|
57b02ad6c7 | ||
|
|
94e8c672df | ||
|
|
011f7cc87d | ||
|
|
f46130569f | ||
|
|
b4e6cf3cc3 | ||
|
|
2d0568d9c2 | ||
|
|
f117913797 | ||
|
|
b84cf23e1a |
No files matched your search
+39
-5
@@ -22,11 +22,24 @@ SITE_DESCRIPTION=My personal IndieWeb site
|
||||
# AUTHENTICATION
|
||||
# =============================================================================
|
||||
|
||||
# Your IndieWeb identity URL (REQUIRED)
|
||||
# This is YOUR personal website URL that you authenticate with
|
||||
# Example: https://yourname.com or https://github.com/yourname
|
||||
# Your identity URL (REQUIRED)
|
||||
# Your personal website. Used as the author h-card source and as the "me"
|
||||
# value in Micropub tokens. It should link to this site's IndieAuth metadata
|
||||
# (see docs/decisions/ADR-064) so Micropub apps can find StarPunk.
|
||||
ADMIN_ME=https://your-website.com
|
||||
|
||||
# Admin login via OpenID Connect (REQUIRED in production)
|
||||
# Register StarPunk as a confidential client with your provider (e.g. Pocket ID)
|
||||
# using the callback URL: <SITE_URL>/auth/callback
|
||||
OIDC_ISSUER=https://id.example.com
|
||||
OIDC_CLIENT_ID=
|
||||
OIDC_CLIENT_SECRET=
|
||||
# The provider's subject ("sub") of the one account allowed to log in.
|
||||
# Pocket ID: the user's ID shown in the admin user list.
|
||||
OIDC_ADMIN_SUB=
|
||||
# Name shown on the login button (default: "single sign-on")
|
||||
OIDC_PROVIDER_NAME=Pocket ID
|
||||
|
||||
# Session secret key (REQUIRED - GENERATE A RANDOM VALUE)
|
||||
# Generate with: python3 -c "import secrets; print(secrets.token_hex(32))"
|
||||
SESSION_SECRET=REPLACE_WITH_RANDOM_SECRET
|
||||
@@ -34,8 +47,29 @@ SESSION_SECRET=REPLACE_WITH_RANDOM_SECRET
|
||||
# Session lifetime in days (default: 30)
|
||||
SESSION_LIFETIME=30
|
||||
|
||||
# IndieLogin service URL (usually don't change this)
|
||||
INDIELOGIN_URL=https://indielogin.com
|
||||
# Lifetime of Micropub access tokens StarPunk issues, in days (default: 90)
|
||||
INDIEAUTH_TOKEN_LIFETIME_DAYS=90
|
||||
|
||||
# =============================================================================
|
||||
# CROSSPOSTING (optional, v2.1.0)
|
||||
# =============================================================================
|
||||
|
||||
# GoToSocial or Mastodon account to copy new notes to. Create an app token
|
||||
# with scopes: write:statuses write:media
|
||||
GOTOSOCIAL_URL=
|
||||
GOTOSOCIAL_ACCESS_TOKEN=
|
||||
# Name shown in the editor and Micropub apps (default: GoToSocial)
|
||||
GOTOSOCIAL_NAME=GoToSocial
|
||||
# public, unlisted, private (default: public)
|
||||
GOTOSOCIAL_VISIBILITY=public
|
||||
|
||||
# Threads account (v2.6.0). A long-lived user token with threads_basic,
|
||||
# threads_content_publish and threads_delete; StarPunk refreshes it daily and
|
||||
# keeps the current one in DATA_PATH/threads_token.json.
|
||||
# How to get one: docs/design/v2.6.0/2026-10-31-threads-crossposting.md
|
||||
THREADS_ACCESS_TOKEN=
|
||||
# Your Threads username (for the Micropub syndicate-to uid)
|
||||
THREADS_USERNAME=
|
||||
|
||||
# =============================================================================
|
||||
# DATA STORAGE
|
||||
|
||||
@@ -1,58 +1,42 @@
|
||||
# Gitea Actions workflow for StarPunk
|
||||
# Builds and pushes container images on version tags
|
||||
|
||||
# Builds and pushes container images on version tags.
|
||||
#
|
||||
# The runner has no Docker daemon (that would give workflows root on the
|
||||
# server). Images are built by the rootless BuildKit container next to it,
|
||||
# reached through its socket.
|
||||
name: Build Container
|
||||
|
||||
on:
|
||||
# Trigger on version tags
|
||||
push:
|
||||
tags:
|
||||
- 'v[0-9]+.[0-9]+.[0-9]+'
|
||||
# Allow manual trigger from Gitea UI
|
||||
workflow_dispatch:
|
||||
|
||||
env:
|
||||
REGISTRY: git.thesatelliteoflove.com
|
||||
BUILDKIT: unix:///run/buildkit/buildkit/buildkitd.sock
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: docker
|
||||
steps:
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
if command -v apk > /dev/null; then
|
||||
apk add --no-cache nodejs npm docker git
|
||||
elif command -v apt-get > /dev/null; then
|
||||
apt-get update && apt-get install -y nodejs npm docker.io git
|
||||
elif command -v yum > /dev/null; then
|
||||
yum install -y nodejs npm docker git
|
||||
fi
|
||||
|
||||
run: apk add --no-cache nodejs git docker-cli docker-cli-buildx
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Set up Docker Buildx
|
||||
uses: docker/setup-buildx-action@v3
|
||||
|
||||
- name: Extract registry URL
|
||||
id: registry
|
||||
run: |
|
||||
# Extract hostname from server URL (remove protocol)
|
||||
REGISTRY_URL=$(echo "${{ github.server_url }}" | sed 's|https://||' | sed 's|http://||')
|
||||
echo "url=${REGISTRY_URL}" >> $GITHUB_OUTPUT
|
||||
|
||||
- name: Login to Gitea Container Registry
|
||||
uses: docker/login-action@v3
|
||||
with:
|
||||
registry: ${{ steps.registry.outputs.url }}
|
||||
username: ${{ github.actor }}
|
||||
password: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
# The automatic Actions token can't log in to the container registry, so
|
||||
# this uses a personal access token with only the write:package scope,
|
||||
# stored as the repository secret REGISTRY_TOKEN.
|
||||
- name: Log in to the Gitea registry
|
||||
run: echo "${{ secrets.REGISTRY_TOKEN }}" | docker login "$REGISTRY" -u "${{ github.repository_owner }}" --password-stdin
|
||||
- name: Use the BuildKit socket
|
||||
run: docker buildx create --name ci --driver remote "$BUILDKIT" --use
|
||||
- name: Build and push
|
||||
uses: docker/build-push-action@v5
|
||||
with:
|
||||
context: .
|
||||
file: ./Containerfile
|
||||
push: true
|
||||
tags: |
|
||||
${{ steps.registry.outputs.url }}/${{ github.repository }}:${{ github.ref_name }}
|
||||
${{ steps.registry.outputs.url }}/${{ github.repository }}:latest
|
||||
cache-from: type=gha
|
||||
cache-to: type=gha,mode=max
|
||||
run: |
|
||||
image="$REGISTRY/$(echo '${{ github.repository }}' | tr '[:upper:]' '[:lower:]')"
|
||||
docker buildx build --push -f Containerfile \
|
||||
-t "$image:${{ github.ref_name }}" -t "$image:latest" .
|
||||
- name: Clean up
|
||||
if: always()
|
||||
run: |
|
||||
docker buildx rm ci || true
|
||||
docker logout "$REGISTRY" || true
|
||||
+177
@@ -7,6 +7,183 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
## [2.6.2] - 2026-11-01
|
||||
|
||||
### Fixed
|
||||
|
||||
- New notes failed their first Threads crosspost with "Invalid Link Attachment" (Meta rejects an explicit link preview for a page it hasn't fetched yet) and only went out on the retry a minute later. StarPunk no longer sends the explicit link preview; Threads still shows one, built from the note's link in the text
|
||||
|
||||
## [2.6.1] - 2026-11-01
|
||||
|
||||
### Fixed
|
||||
|
||||
- Threads crossposts gave up after Meta's publish step returned a one-off `HTTP 400 Fatal`; publish errors are now retried (a retry checks for an existing post first, so nothing is posted twice). Only a bad token or missing permission stops retries
|
||||
- Threads errors now include Meta's error code, subcode, user message and trace id, so the editor shows why a post failed
|
||||
- Wait a moment before the first readiness check on a Threads post, since Meta can report it ready too early
|
||||
|
||||
## [2.6.0] - 2026-11-01
|
||||
|
||||
### Added
|
||||
|
||||
- **Crossposting to Threads** (ADR-069): set `THREADS_ACCESS_TOKEN` (and optionally `THREADS_USERNAME`) to add a Threads target. Text posts get a link preview; 1 image posts as an image, 2–4 as a carousel, with alt text; the note's first tag becomes the post's topic. Shortened to 500 characters. Edits don't follow (the API can't edit); unpublish and delete remove the post. Likes aren't crossposted to Threads; reposts post "🔁 title url" (with the comment, if any)
|
||||
- The Threads token (60-day lifetime) is refreshed automatically once a day and kept in `data/threads_token.json`, so it survives restarts; setting a new token in the config replaces it. Setup steps: `docs/design/v2.6.0/`
|
||||
|
||||
## [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
|
||||
|
||||
- Micropub `name` was ignored, so titles sent by Micropub clients never appeared. It is now stored as the note's `# Heading` first line, which is how StarPunk titles work
|
||||
- Micropub `q=source` returned `/notes/<slug>` links (a 404); it now returns the real permalink `/note/<slug>`
|
||||
- Micropub `q=source` reported every note's first line as its `name`; it now returns `name` only for titled notes, with the heading left out of `content`, matching what was posted
|
||||
- Titled notes showed their title twice: as the page heading and again at the top of the body (and of the home-page summary)
|
||||
|
||||
## [2.3.2] - 2026-10-31
|
||||
|
||||
### Changed
|
||||
|
||||
- Header link reads "Admin" (was "Dashboard") when logged in
|
||||
|
||||
### Fixed
|
||||
|
||||
- Public pages never knew you were logged in (only `/admin` routes checked the session), so the header always said "Log in"
|
||||
|
||||
## [2.3.1] - 2026-10-31
|
||||
|
||||
### Fixed
|
||||
|
||||
- "Log in" is back in the header nav (2.3.0 had moved it to the footer, where it was easy to miss)
|
||||
|
||||
## [2.3.0] - 2026-10-31
|
||||
|
||||
### Changed
|
||||
|
||||
- **Public pages restyled**: compact header with the site name from `SITE_NAME`, serif reading font for notes, one-line metadata (date · #tags · Also on …), dark mode via `prefers-color-scheme`, footer pinned to the bottom, "Log in" moved to the footer
|
||||
- Home and tag pages show short notes in full; titled notes show a summary and "Read more"
|
||||
- Author h-card kept for parsers but visually hidden on this single-author site
|
||||
- Page titles use the note text and `SITE_NAME` instead of the slug and "StarPunk"
|
||||
|
||||
### Fixed
|
||||
|
||||
- Every note's metadata was styled as the page footer (centered, ruled, padded)
|
||||
- Previews cut the note's HTML at 300 characters, which could break markup
|
||||
- Bare URLs in notes are now links
|
||||
|
||||
## [2.2.0] - 2026-10-31
|
||||
|
||||
### Added
|
||||
|
||||
- **Crossposting to Bluesky**, ADR-066
|
||||
- Plain-text note (Markdown stripped) with clickable link and hashtag facets, shortened to 300 characters with the permalink kept
|
||||
- Images (up to 4, shrunk under Bluesky's 1 MB limit) with alt text; notes without images get a link card
|
||||
- Unpublishing, unticking and deleting remove the Bluesky post; edits don't follow (Bluesky has no edits)
|
||||
- Logs in with an app password: `BLUESKY_HANDLE`, `BLUESKY_APP_PASSWORD` (optional `BLUESKY_SERVICE`, default `https://bsky.social`)
|
||||
- Shown in the editor and Micropub `syndicate-to` next to GoToSocial
|
||||
|
||||
## [2.1.0] - 2026-10-31
|
||||
|
||||
### Added
|
||||
|
||||
- **Crossposting to GoToSocial** (or any Mastodon-API server), ADR-065
|
||||
- Full note as Markdown with images (alt text from captions), permalink and hashtags
|
||||
- Edits, unpublishing and deletes follow the note
|
||||
- On by default for new notes; untick in the editor, or send `mp-syndicate-to` from Micropub apps
|
||||
- Micropub `q=syndicate-to` and `q=config` list the target
|
||||
- Editor shows crosspost status, errors and a retry button; note pages link the copy with `u-syndication`
|
||||
- Configure with `GOTOSOCIAL_URL` and `GOTOSOCIAL_ACCESS_TOKEN` (scopes `write:statuses write:media`)
|
||||
- Migration 012: `syndications`
|
||||
|
||||
### Fixed
|
||||
|
||||
- Micropub `Location` header pointed at `/notes/<slug>` (404); now the real permalink
|
||||
- "Delete Note" on the edit page submitted the edit form (nested forms)
|
||||
- Search results linked to `/notes/<slug>` (404); now `/note/<slug>`
|
||||
|
||||
## [2.0.2] - 2026-10-31
|
||||
|
||||
### Fixed
|
||||
|
||||
- Container builds in Gitea Actions log in to the registry with the
|
||||
`REGISTRY_TOKEN` secret (a `write:package` token); the automatic Actions
|
||||
token is refused by the registry. No application changes.
|
||||
|
||||
## [2.0.1] - 2026-10-31
|
||||
|
||||
### Fixed
|
||||
|
||||
- Page links built from the request said `http://` behind an HTTPS reverse proxy
|
||||
(RSS/OPML `<link>`s and microformats `u-url`/`u-uid` permalinks). All absolute
|
||||
URLs in templates now come from `SITE_URL` via `absolute_url_for()`.
|
||||
- Container builds in Gitea Actions: build through the server's rootless BuildKit
|
||||
and log in to the public registry name (the old workflow never succeeded).
|
||||
|
||||
## [2.0.0] - 2026-10-31
|
||||
|
||||
### Changed (breaking)
|
||||
|
||||
- **Admin login uses OpenID Connect** instead of IndieAuth (ADR-064)
|
||||
- Works with Pocket ID or any OIDC provider; authorization code flow with PKCE and nonce
|
||||
- Only the account whose subject matches `OIDC_ADMIN_SUB` can log in
|
||||
- New required settings: `OIDC_ISSUER`, `OIDC_CLIENT_ID`, `OIDC_CLIENT_SECRET`, `OIDC_ADMIN_SUB`
|
||||
- `INDIELOGIN_URL` and `TOKEN_ENDPOINT` are ignored
|
||||
- **Micropub tokens are issued by StarPunk**, not an external IndieAuth server
|
||||
- Your `ADMIN_ME` page must point Micropub apps at StarPunk's
|
||||
`/.well-known/oauth-authorization-server` (or its `/auth/authorize` and `/auth/token`)
|
||||
- Apps authorized through an external server must be authorized again
|
||||
|
||||
### Added
|
||||
|
||||
- Built-in IndieAuth server: metadata, consent screen, token, revocation endpoints
|
||||
- **Connected Apps** admin page (`/admin/tokens`) to review and revoke Micropub tokens
|
||||
- Discovery links (`micropub`, `indieauth-metadata`, `authorization_endpoint`, `token_endpoint`) on every page
|
||||
- Migration 011: `oidc_login_state`, `indieauth_codes`, `indieauth_tokens`
|
||||
|
||||
### Removed
|
||||
|
||||
- IndieAuth endpoint discovery and external token verification (`starpunk/auth_external.py`)
|
||||
|
||||
### Notes
|
||||
|
||||
- Existing notes, media, tags, webmentions, author profile and admin sessions are preserved
|
||||
- v1.6.0 source (webmentions) recovered from the production image; it had not been committed
|
||||
|
||||
## [1.5.0] - 2025-12-17
|
||||
|
||||
### Added
|
||||
|
||||
@@ -27,7 +27,8 @@ StarPunk is designed for a single user who wants to:
|
||||
## Features
|
||||
|
||||
- **File-based storage**: Notes are markdown files, owned by you
|
||||
- **IndieAuth authentication**: Use your own website as identity
|
||||
- **OIDC admin login**: Sign in through your identity provider (e.g. Pocket ID)
|
||||
- **Built-in IndieAuth server**: Approve Micropub apps without a separate auth service
|
||||
- **Micropub support**: Full W3C Micropub specification compliance
|
||||
- **Media attachments**: Upload and display images with your notes
|
||||
- **Microformats2**: Full h-entry, h-card, and h-feed markup for IndieWeb compatibility
|
||||
@@ -62,7 +63,7 @@ uv pip install -r requirements.txt
|
||||
|
||||
# Configure
|
||||
cp .env.example .env
|
||||
# Edit .env and set ADMIN_ME and SESSION_SECRET
|
||||
# Edit .env and set ADMIN_ME, SESSION_SECRET and the OIDC_* values
|
||||
|
||||
# Initialize database
|
||||
mkdir -p data/notes
|
||||
@@ -82,6 +83,8 @@ All configuration is in the `.env` file. Required settings:
|
||||
- `ADMIN_ME` - Your IndieWeb identity URL (e.g., https://yoursite.com)
|
||||
- `SESSION_SECRET` - Random secret key (generate with `python3 -c "import secrets; print(secrets.token_hex(32))"`)
|
||||
- `SITE_URL` - Public URL of your site
|
||||
- `OIDC_ISSUER`, `OIDC_CLIENT_ID`, `OIDC_CLIENT_SECRET` - OIDC client for admin login (callback: `<SITE_URL>/auth/callback`)
|
||||
- `OIDC_ADMIN_SUB` - Subject ID of the one account allowed to log in
|
||||
|
||||
See `.env.example` for all options.
|
||||
|
||||
@@ -110,7 +113,7 @@ starpunk/
|
||||
|
||||
**Via Micropub Client**:
|
||||
1. Configure client with your site URL
|
||||
2. Authenticate via IndieAuth
|
||||
2. Sign in with your OIDC provider
|
||||
3. Publish from any Micropub-compatible app
|
||||
|
||||
### Backing Up Your Data
|
||||
@@ -192,7 +195,6 @@ Built with:
|
||||
- [python-markdown](https://python-markdown.github.io/) - Markdown processing
|
||||
- [feedgen](https://feedgen.kiesow.be/) - RSS generation
|
||||
- [httpx](https://www.python-httpx.org/) - HTTP client
|
||||
- [IndieLogin](https://indielogin.com/) - Authentication service
|
||||
|
||||
## Contributing
|
||||
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
# ADR-064: OIDC Admin Login and Built-in IndieAuth Server
|
||||
|
||||
## Status
|
||||
|
||||
Accepted (v2.0.0, 2026-10-31)
|
||||
|
||||
Supersedes the login parts of ADR-021, ADR-025, ADR-027 and ADR-043, and the
|
||||
external token verification of ADR-030 and ADR-036.
|
||||
|
||||
## Context
|
||||
|
||||
Up to v1.6.0 StarPunk was an IndieAuth *client*. Admin login discovered an
|
||||
authorization endpoint from `ADMIN_ME` and used the authentication-only
|
||||
flow; Micropub verified bearer tokens by calling the token endpoint
|
||||
discovered from `ADMIN_ME`. In practice both pointed at Gondulf, a separate
|
||||
self-hosted IndieAuth server.
|
||||
|
||||
The operator now runs Pocket ID (OIDC, passkeys) for every other
|
||||
self-hosted service and wants StarPunk to use it too. Pocket ID cannot act
|
||||
as an IndieAuth server: IndieAuth clients identify themselves by URL
|
||||
(`client_id` = their homepage) and are not pre-registered, while OIDC
|
||||
clients must be registered with the provider.
|
||||
|
||||
Micropub apps such as Quill and Indigenous only speak IndieAuth, so moving
|
||||
login to OIDC alone would end Micropub posting.
|
||||
|
||||
## Decision
|
||||
|
||||
1. **Admin login uses OIDC** (authorization code flow, PKCE S256, nonce).
|
||||
StarPunk is a confidential client. The ID token's signature (provider
|
||||
JWKS), `iss`, `aud`, `exp` and `nonce` are verified, and only the
|
||||
configured `OIDC_ADMIN_SUB` may log in. A successful login creates the
|
||||
same local session as before, for `ADMIN_ME`.
|
||||
2. **StarPunk becomes its own IndieAuth server** for Micropub clients:
|
||||
`/.well-known/oauth-authorization-server`, `/auth/authorize` (consent
|
||||
screen, admin session required, so approval is protected by OIDC),
|
||||
`/auth/token` and `/auth/revoke`. Only `response_type=code` with PKCE
|
||||
S256 is supported. Tokens are stored as SHA-256 hashes and verified
|
||||
locally by `/micropub` and `/media`.
|
||||
3. **`ADMIN_ME` stays** as the site owner's identity URL: it is the author
|
||||
h-card source and the `me` in issued tokens. That page must advertise
|
||||
StarPunk's IndieAuth metadata (or `authorization_endpoint` /
|
||||
`token_endpoint` links) so Micropub apps discover StarPunk.
|
||||
4. **New tables** (`oidc_login_state`, `indieauth_codes`,
|
||||
`indieauth_tokens`, migration 011). The legacy `auth_state`, `tokens`
|
||||
and `authorization_codes` tables are not reused because migration 004
|
||||
drops the last two after `INITIAL_SCHEMA_SQL` creates them.
|
||||
5. Client `redirect_uri` must share the `client_id` origin, or be published
|
||||
by the client (JSON `redirect_uris` or `rel="redirect_uri"`). The fetch
|
||||
reuses the webmention SSRF guard.
|
||||
|
||||
## Consequences
|
||||
|
||||
- Gondulf is no longer needed and can be retired.
|
||||
- Existing admin sessions stay valid (sessions are keyed by `ADMIN_ME`, which
|
||||
does not change). Notes, media, tags and webmentions are untouched.
|
||||
- Micropub apps must be re-authorized once, since their old tokens were
|
||||
issued by Gondulf. Tokens are visible and revocable at `/admin/tokens`.
|
||||
- Production requires `OIDC_ISSUER`, `OIDC_CLIENT_ID`,
|
||||
`OIDC_CLIENT_SECRET`, `OIDC_ADMIN_SUB`. `INDIELOGIN_URL` and
|
||||
`TOKEN_ENDPOINT` are ignored.
|
||||
- New dependency: `PyJWT[crypto]`.
|
||||
- Major version bump (2.0.0): configuration and endpoint discovery change
|
||||
incompatibly.
|
||||
|
||||
## Alternatives Considered
|
||||
|
||||
- **Keep Gondulf for Micropub only**: two auth systems to run and patch.
|
||||
- **Drop Micropub**: simplest, but loses posting from apps.
|
||||
- **Manually created API tokens**: Quill and most apps require IndieAuth.
|
||||
@@ -0,0 +1,45 @@
|
||||
# ADR-065: Direct Syndication (POSSE) to GoToSocial
|
||||
|
||||
## Status
|
||||
|
||||
Accepted (v2.1.0, 2026-10-31)
|
||||
|
||||
## Context
|
||||
|
||||
StarPunk posts were copied to other networks by Echofeed reading the feed.
|
||||
That gives no control per post, no record of where a post went, and edits
|
||||
and deletes never follow. The operator runs GoToSocial locally and wants
|
||||
StarPunk to post there directly, with Bluesky likely next.
|
||||
|
||||
## Decision
|
||||
|
||||
1. **Publish here, copy out (POSSE).** Each (note, target) has a row in
|
||||
`syndications` (migration 012). Creating, editing, unpublishing or
|
||||
deleting a note marks its rows pending; a background worker reconciles
|
||||
the remote post: create, update (`PUT /api/v1/statuses/:id`) or delete.
|
||||
2. **Defaults.** New notes go to every configured target unless unticked in
|
||||
the editor or a Micropub client sends `mp-syndicate-to` (an explicit
|
||||
list, possibly empty). Existing notes are never backfilled.
|
||||
3. **Content.** The full note as Markdown (`content_type: text/markdown`),
|
||||
then the permalink and the note's tags as hashtags. Longer than the
|
||||
target's limit: shortened at a word boundary with the link kept.
|
||||
Images are uploaded first (the `large` variant) with their captions as
|
||||
alt text.
|
||||
4. **Delivery.** Rows are claimed atomically so the four gunicorn workers'
|
||||
threads never send twice; an `Idempotency-Key` guards retries; a row
|
||||
`version` keeps edits made during a send. Network errors and 5xx/429
|
||||
retry with exponential backoff (8 attempts); other 4xx fail at once.
|
||||
A remote post deleted by hand is posted again on the next edit.
|
||||
5. **Backlinks.** Synced URLs are shown on the note page as `u-syndication`
|
||||
links, and in the editor with status, last error and a retry button.
|
||||
6. **Targets** are config-driven. One kind exists, a Mastodon-API client
|
||||
(`GOTOSOCIAL_URL`, `GOTOSOCIAL_ACCESS_TOKEN`); it also works for
|
||||
Mastodon. A Bluesky target would add a second client behind the same
|
||||
reconcile loop.
|
||||
|
||||
## Consequences
|
||||
|
||||
- Echofeed must stop posting to GoToSocial or posts appear twice.
|
||||
- The token needs only `write:statuses write:media`.
|
||||
- `syndications.note_id` has no foreign key so a hard-deleted note's
|
||||
remote post can still be deleted.
|
||||
@@ -0,0 +1,37 @@
|
||||
# ADR-066: Crossposting to Bluesky
|
||||
|
||||
## Status
|
||||
|
||||
Accepted (v2.2.0, 2026-10-31)
|
||||
|
||||
## Context
|
||||
|
||||
ADR-065 added direct crossposting to GoToSocial. Bluesky was still fed by
|
||||
Echofeed, with the same problems: no per-post control, no record of the
|
||||
copy, deletes never follow.
|
||||
|
||||
## Decision
|
||||
|
||||
1. **Second client, same loop.** `BlueskyClient` sits behind the reconcile
|
||||
loop and `syndications` table from ADR-065, as target id `bluesky`.
|
||||
Clients share a small interface: `create`, `update`, `delete`, `can_edit`.
|
||||
2. **Auth.** An app password (`BLUESKY_HANDLE`, `BLUESKY_APP_PASSWORD`).
|
||||
`createSession` against `BLUESKY_SERVICE` (default `https://bsky.social`);
|
||||
writes go to the PDS named in the returned DID document. Expired access
|
||||
tokens are refreshed, falling back to a new session.
|
||||
3. **Content.** Plain text (Markdown rendered and stripped), then the
|
||||
permalink and hashtags (at most a third of the space), shortened to 300
|
||||
characters at a word boundary. Link and hashtag facets use UTF-8 byte
|
||||
offsets. Images (up to 4) are re-encoded as JPEG if over 1 MB, with alt
|
||||
text and aspect ratio; a note without images gets a link card.
|
||||
4. **Edits don't follow.** Bluesky has no edit; rewriting the record would
|
||||
break likes and replies, and delete-and-repost would lose them. The post
|
||||
stays as first sent. Unpublish, untick and delete remove it.
|
||||
5. **No double posts.** When a create is retried, recent posts are checked
|
||||
for one already linking to the note (a send whose reply was lost).
|
||||
|
||||
## Consequences
|
||||
|
||||
- Echofeed is no longer needed; it must stop posting to Bluesky or posts
|
||||
appear twice.
|
||||
- A post deleted by hand on Bluesky is not re-created.
|
||||
@@ -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).
|
||||
@@ -0,0 +1,57 @@
|
||||
# ADR-069: Crossposting to Threads
|
||||
|
||||
## Status
|
||||
|
||||
Accepted (v2.6.0, 2026-10-31)
|
||||
|
||||
## Context
|
||||
|
||||
ADR-065 and ADR-066 crosspost notes to GoToSocial and Bluesky. Threads
|
||||
(Meta) has a publishing API, so it can be a third target on the same loop.
|
||||
|
||||
## Decision
|
||||
|
||||
1. **Third client, same loop.** `ThreadsClient` is target id `threads`
|
||||
behind the `syndications` table and reconcile loop from ADR-065.
|
||||
2. **Auth.** A long-lived Threads user token (`THREADS_ACCESS_TOKEN`) with
|
||||
`threads_basic`, `threads_content_publish` and `threads_delete`. These
|
||||
tokens expire after 60 days, so StarPunk refreshes the token about once a
|
||||
day (`th_refresh_token`) from the worker loop, even when nothing is being
|
||||
posted. The current token is kept in `DATA_PATH/threads_token.json`
|
||||
(mode 0600) with a hash of the configured token. A different configured
|
||||
token replaces the saved one. A file lock stops gunicorn workers from
|
||||
refreshing at the same time. The file avoids a migration for one value.
|
||||
3. **Posting.** Create a container, poll its status until `FINISHED`, then
|
||||
`threads_publish`. Text-only notes are `TEXT` posts. Threads previews
|
||||
the first link in the text (the permalink) by itself. An explicit
|
||||
`link_attachment` is not sent, because Meta rejects one for a page it
|
||||
hasn't fetched yet ("Invalid Link Attachment", subcode 4279047), which
|
||||
is always the case for a new note (v2.6.2). One image is an `IMAGE` post and 2–4 images are a
|
||||
`CAROUSEL`. Meta fetches images from their public `/media/` URL. Only
|
||||
JPEG and PNG up to 8 MB are allowed, so GIF and WebP images are left off.
|
||||
Alt text goes in `alt_text`.
|
||||
4. **Content.** Plain text (as for Bluesky), then the permalink, shortened
|
||||
to 500 characters. Non-ASCII characters are counted as UTF-8 bytes,
|
||||
because Threads counts emoji that way. Threads allows one tag per post,
|
||||
so the note's first tag is sent as `topic_tag` and no hashtags are added
|
||||
to the text.
|
||||
5. **Edits don't follow.** The API has no way to edit a post. As with
|
||||
Bluesky, the post stays as first sent, and unpublishing, unticking the
|
||||
target or deleting the note removes it.
|
||||
6. **Likes and reposts (ADR-068).** The API can't like or repost outside
|
||||
content, so likes are not crossposted. Reposts are text posts with
|
||||
"🔁 title" and the URL, plus the comment if there is one, and the
|
||||
reposted page as the link preview.
|
||||
7. **No double posts.** A retried create first looks for a recent post that
|
||||
already contains the permalink.
|
||||
|
||||
## Consequences
|
||||
|
||||
- Meta limits accounts to 250 posts and 100 deletes per day. Rate-limit
|
||||
errors (Graph codes 4, 17, 32, 613) are retried.
|
||||
- If StarPunk is down for more than 60 days, the token expires and a new
|
||||
one is needed.
|
||||
- Getting the first token requires a Meta developer app with the Threads
|
||||
use case. See the setup notes in `docs/design/v2.6.0/`.
|
||||
- Notes with more than five links fail on Threads (a Meta limit). The
|
||||
error is shown in the editor.
|
||||
@@ -0,0 +1,56 @@
|
||||
# v2.0.0 Implementation Report: OIDC Login and Built-in IndieAuth Server
|
||||
|
||||
Date: 2026-10-31
|
||||
Decision: ADR-064
|
||||
|
||||
## Summary
|
||||
|
||||
Admin login moved from IndieAuth (via Gondulf) to OIDC (Pocket ID).
|
||||
StarPunk now issues and verifies its own Micropub tokens, so Gondulf is no
|
||||
longer needed. No data migration is required: notes, media, tags,
|
||||
webmentions, the author profile and admin sessions are unchanged.
|
||||
|
||||
## Source recovery
|
||||
|
||||
Production ran `starpunk:v1.6.0-rc.2`, but the v1.6.0 code was never
|
||||
committed (`main` was at v1.5.0). The application code was copied out of
|
||||
the running container's `/app` and committed as `v1.6.0-rc.2` before any
|
||||
v2.0.0 changes. The v1.6.0 tests and docs were not in the image, so ADR-063
|
||||
(webmentions) and the v1.6.0 design folder are still missing.
|
||||
|
||||
## Changes
|
||||
|
||||
| Area | Change |
|
||||
|---|---|
|
||||
| `starpunk/auth.py` | OIDC client: discovery (cached), PKCE S256, nonce, ID token check against the provider JWKS, `OIDC_ADMIN_SUB` check. Session functions unchanged. |
|
||||
| `starpunk/indieauth.py` | New: authorization codes, access tokens (hashed), client `redirect_uri` checks, revocation. |
|
||||
| `starpunk/routes/auth.py` | Login is a single "Sign in with ..." button; callback handles provider errors and `next`. |
|
||||
| `starpunk/routes/indieauth.py` | New: metadata, consent, approve, token, legacy token verify, revoke. |
|
||||
| `starpunk/routes/micropub.py` | Verifies tokens locally. |
|
||||
| `starpunk/routes/admin.py`, `templates/admin/tokens.html` | Connected Apps page with revoke. |
|
||||
| `templates/base.html` | Discovery links built from `SITE_URL` (not the request host, which is `http://` behind the proxy). |
|
||||
| `migrations/011_*.sql` | `oidc_login_state`, `indieauth_codes`, `indieauth_tokens`. |
|
||||
| `starpunk/auth_external.py` | Removed. |
|
||||
|
||||
## Testing
|
||||
|
||||
- New: `tests/test_auth_oidc.py` (real RS256-signed ID tokens: bad audience, issuer,
|
||||
key, expiry, nonce, subject; state reuse; routes) and `tests/test_indieauth.py`
|
||||
(validation, PKCE, single-use codes, consent, full Micropub post with an issued
|
||||
token, revocation, admin page).
|
||||
- `tests/test_auth.py` keeps the session tests; IndieLogin flow tests removed.
|
||||
- Full suite: 905 passed. Remaining failures predate this work and are in the
|
||||
recovered v1.6.0 baseline: seven in `test_media_upload.py` (image
|
||||
validation, HEIC, MPO) and one or two timing-sensitive tests in
|
||||
`test_migration_race_condition.py` that fail on a different test each run.
|
||||
- Migration rehearsed on a copy of the production database: 011 applied,
|
||||
row counts for notes, media, tags, sessions and author profile unchanged.
|
||||
|
||||
## Deployment notes
|
||||
|
||||
- Pocket ID client "StarPunk": confidential, PKCE on, callback
|
||||
`https://starpunk.thesatelliteoflove.com/auth/callback`.
|
||||
- The container needs `id.thesatelliteoflove.com` mapped to Caddy in
|
||||
`extra_hosts` (hairpin NAT does not work from the `lava` network).
|
||||
- `thesatelliteoflove.com` (static file in `/opt/stacks/caddy/site/tsol/`)
|
||||
must advertise StarPunk's IndieAuth endpoints instead of Gondulf's.
|
||||
@@ -0,0 +1,23 @@
|
||||
# v2.3.3: Micropub titles, q=source URL, single title display
|
||||
|
||||
Found while building tuipub, a terminal Micropub client, against StarPunk.
|
||||
|
||||
## Problems
|
||||
|
||||
1. **Micropub `name` dropped.** `handle_create` called `extract_title()` and threw the result away. StarPunk has no title column: `Note.title` is derived from the content's first line, and a `# Heading` first line marks a titled note (Q22). So a `name` sent by a client never showed up.
|
||||
2. **`q=source` URL wrong.** It built `{SITE_URL}notes/{slug}`, but the route is `/note/<slug>`, so the URL was a 404.
|
||||
3. **`q=source` name wrong.** It returned `note.title` for every note. For untitled notes that is just the first line of the content, so clients saw a `name` they never sent.
|
||||
4. **Title shown twice.** `note.html` renders the title as `<h1 class="p-name">` and then the whole content, which includes the `# Heading` again. Home-page previews did the same with the excerpt.
|
||||
|
||||
## Decisions
|
||||
|
||||
- Store `name` as a `# {name}` first line (`micropub.add_title_heading`) rather than adding a title column. This matches how titled notes already work everywhere (pages, feeds, search, admin editor), and needs no migration. If the content already starts with that exact heading, it isn't added twice.
|
||||
- `models.split_title()` is the single definition of "title heading": the first non-blank line starting with `#` (the same rule as the templates' `has_explicit_title`). `q=source` uses it to return `name` + `content` the way they were posted.
|
||||
- `Note.body_html` renders the content without the title heading; `note.html` uses it. `Note.excerpt` also leaves the title out. `Note.html` is unchanged, so feeds and syndication behave as before (feed items carry a separate title anyway).
|
||||
- `extract_title()` no longer derives a fallback title from content: that value was never used.
|
||||
|
||||
## Tests
|
||||
|
||||
- `tests/test_micropub.py`: name stored as heading, no duplicate heading, `q=source` url equals the Location permalink, `name` only for titled notes, round trip.
|
||||
- `tests/test_models.py`: `split_title`, `body_html`, excerpt without title.
|
||||
- Checked end to end with tuipub against a local dev server: titled post → page shows the title once, `q=source` returns `name`, `content` and a working url.
|
||||
@@ -0,0 +1,62 @@
|
||||
# v2.6.0: Crossposting to Threads
|
||||
|
||||
Implements ADR-069.
|
||||
|
||||
## What changed
|
||||
|
||||
- `starpunk/syndication.py`: `ThreadsClient` (target `threads`); media
|
||||
entries now carry their public `url`; `process_due()` calls each client's
|
||||
optional `maintain()` hook, which Threads uses to refresh its token.
|
||||
- `starpunk/config.py`: `THREADS_ACCESS_TOKEN`, `THREADS_USERNAME`,
|
||||
`THREADS_NAME`, `THREADS_MAX_CHARS` (500), `THREADS_MAX_MEDIA` (4).
|
||||
- `tests/test_syndication_threads.py`: a fake Graph API covering text,
|
||||
image and carousel posts; container polling; edits not following; deletes
|
||||
(including posts already deleted by hand); a lost publish reply;
|
||||
permanent and rate-limit errors; and token refresh, persistence and
|
||||
replacement.
|
||||
|
||||
## Configuration
|
||||
|
||||
| Variable | Meaning |
|
||||
|---|---|
|
||||
| `THREADS_ACCESS_TOKEN` | Long-lived Threads user token. Enables the target. |
|
||||
| `THREADS_USERNAME` | Optional. Used for the Micropub `syndicate-to` uid (`https://www.threads.com/@name`) and for fallback links. |
|
||||
| `THREADS_NAME` | Label in the editor (default `Threads`) |
|
||||
|
||||
After the first daily refresh, the working token lives in
|
||||
`DATA_PATH/threads_token.json`. The configured value only seeds it.
|
||||
Changing `THREADS_ACCESS_TOKEN` switches to the new token.
|
||||
|
||||
## Getting a token (one time)
|
||||
|
||||
1. At <https://developers.facebook.com/apps>, create an app with the
|
||||
**Access the Threads API** use case.
|
||||
2. Under the use case's permissions, add `threads_basic`,
|
||||
`threads_content_publish` and `threads_delete`.
|
||||
3. Under **App roles → Roles**, add your Threads account as a Threads
|
||||
tester. Accept the invite in Threads (Settings → Account → Website
|
||||
permissions → Invites). The app can stay in development mode.
|
||||
4. In the use case settings, add `https://<site>/` as a redirect URI. Then
|
||||
open:
|
||||
|
||||
https://threads.net/oauth/authorize?client_id=APP_ID&redirect_uri=https://<site>/&scope=threads_basic,threads_content_publish,threads_delete&response_type=code
|
||||
|
||||
After you approve, the browser lands on `https://<site>/?code=...`. Copy
|
||||
the code (drop a trailing `#_`).
|
||||
5. Exchange the code for a short-lived token, then exchange that for a
|
||||
long-lived one:
|
||||
|
||||
curl -s -X POST https://graph.threads.net/oauth/access_token \
|
||||
-F client_id=APP_ID -F client_secret=APP_SECRET \
|
||||
-F grant_type=authorization_code -F redirect_uri=https://<site>/ -F code=CODE
|
||||
curl -s "https://graph.threads.net/access_token?grant_type=th_exchange_token&client_secret=APP_SECRET&access_token=SHORT_TOKEN"
|
||||
|
||||
6. Set `THREADS_ACCESS_TOKEN` to the long-lived `access_token`.
|
||||
|
||||
The app secret is only needed for these steps. StarPunk doesn't use it.
|
||||
|
||||
## Not done
|
||||
|
||||
- Video, GIF and WebP images (Threads takes video by URL. StarPunk only
|
||||
stores still images, and Threads rejects GIF and WebP).
|
||||
- Edits (no API for them).
|
||||
@@ -0,0 +1,49 @@
|
||||
-- Migration 011: OIDC admin login + built-in IndieAuth server
|
||||
-- Version: 2.0.0
|
||||
-- Per ADR-064: Replace IndieAuth login with OIDC, issue Micropub tokens locally
|
||||
--
|
||||
-- New tables only. The legacy auth_state, tokens and authorization_codes
|
||||
-- tables are left alone: INITIAL_SCHEMA_SQL recreates tokens and
|
||||
-- authorization_codes on every start while migration 004 drops them, so
|
||||
-- nothing new can depend on them.
|
||||
|
||||
-- Pending OIDC logins (state, nonce and PKCE verifier for one round trip)
|
||||
CREATE TABLE IF NOT EXISTS oidc_login_state (
|
||||
state TEXT PRIMARY KEY,
|
||||
nonce TEXT NOT NULL,
|
||||
code_verifier TEXT NOT NULL,
|
||||
next_url TEXT,
|
||||
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
expires_at TIMESTAMP NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_oidc_login_state_expires ON oidc_login_state(expires_at);
|
||||
|
||||
-- Authorization codes issued to IndieAuth (Micropub) clients
|
||||
CREATE TABLE IF NOT EXISTS indieauth_codes (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
code_hash TEXT UNIQUE NOT NULL,
|
||||
client_id TEXT NOT NULL,
|
||||
redirect_uri TEXT NOT NULL,
|
||||
scope TEXT NOT NULL DEFAULT '',
|
||||
code_challenge TEXT NOT NULL,
|
||||
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
expires_at TIMESTAMP NOT NULL,
|
||||
used_at TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_indieauth_codes_expires ON indieauth_codes(expires_at);
|
||||
|
||||
-- Access tokens issued to IndieAuth (Micropub) clients
|
||||
CREATE TABLE IF NOT EXISTS indieauth_tokens (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
token_hash TEXT UNIQUE NOT NULL,
|
||||
client_id TEXT NOT NULL,
|
||||
scope TEXT NOT NULL,
|
||||
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
expires_at TIMESTAMP NOT NULL,
|
||||
last_used_at TIMESTAMP,
|
||||
revoked_at TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_indieauth_tokens_expires ON indieauth_tokens(expires_at);
|
||||
@@ -0,0 +1,29 @@
|
||||
-- Migration 012: Crossposting (POSSE) to syndication targets
|
||||
-- Version: 2.1.0
|
||||
-- Per ADR-065: Direct syndication to GoToSocial / Mastodon-API servers
|
||||
--
|
||||
-- One row per (note, target). The worker reconciles the remote post with the
|
||||
-- note: create, update, or delete as needed. note_id has no foreign key on
|
||||
-- purpose: a row must outlive a hard-deleted note so the remote post can be
|
||||
-- deleted too.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS syndications (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
note_id INTEGER NOT NULL,
|
||||
target TEXT NOT NULL,
|
||||
enabled INTEGER NOT NULL DEFAULT 1,
|
||||
remote_id TEXT,
|
||||
remote_url TEXT,
|
||||
state TEXT NOT NULL DEFAULT 'pending'
|
||||
CHECK (state IN ('pending', 'synced', 'failed')),
|
||||
version INTEGER NOT NULL DEFAULT 1,
|
||||
attempts INTEGER NOT NULL DEFAULT 0,
|
||||
last_error TEXT,
|
||||
next_attempt_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
claimed_until TIMESTAMP,
|
||||
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
UNIQUE (note_id, target)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_syndications_due ON syndications(state, next_attempt_at);
|
||||
@@ -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);
|
||||
@@ -39,3 +39,4 @@ pillow-heif==0.18.*
|
||||
|
||||
# HTML Sanitization (v1.6.0 - Webmention content)
|
||||
nh3==0.2.*
|
||||
PyJWT[crypto]==2.10.*
|
||||
+30
-2
@@ -191,6 +191,10 @@ def create_app(config=None):
|
||||
register_routes(app)
|
||||
|
||||
# Template context processor - Inject author profile (v1.2.0 Phase 2)
|
||||
from starpunk.utils import absolute_url_for
|
||||
|
||||
app.jinja_env.globals["absolute_url_for"] = absolute_url_for
|
||||
|
||||
@app.context_processor
|
||||
def inject_author():
|
||||
"""
|
||||
@@ -276,6 +280,21 @@ def create_app(config=None):
|
||||
"""Add correlation ID to request context for tracing"""
|
||||
add_correlation_id()
|
||||
|
||||
# Know who is logged in on every page, not just /admin (v2.3.2), so
|
||||
# the header can say "Admin" instead of "Log in". Only requests that
|
||||
# carry a session cookie touch the database.
|
||||
from flask import g, request
|
||||
token = request.cookies.get("starpunk_session")
|
||||
if token:
|
||||
from starpunk.auth import verify_session
|
||||
try:
|
||||
info = verify_session(token)
|
||||
except Exception:
|
||||
info = None
|
||||
if info:
|
||||
g.user = info
|
||||
g.me = info["me"]
|
||||
|
||||
# Response middleware - Add webmention Link header (v1.6.0)
|
||||
@app.after_request
|
||||
def add_webmention_headers(response):
|
||||
@@ -332,6 +351,15 @@ def create_app(config=None):
|
||||
if hasattr(app, 'webmention_worker') and app.webmention_worker.is_alive():
|
||||
app.webmention_worker.stop()
|
||||
|
||||
# Start syndication worker when a target is configured (v2.1.0)
|
||||
from starpunk.syndication import SyndicationWorker, targets_configured
|
||||
if targets_configured(app.config) and not app.config.get("TESTING", False):
|
||||
app.syndication_worker = SyndicationWorker(
|
||||
app, poll_interval=app.config["SYNDICATION_POLL_INTERVAL"]
|
||||
)
|
||||
app.syndication_worker.start()
|
||||
app.logger.info("Syndication worker started")
|
||||
|
||||
# Health check endpoint for containers and monitoring
|
||||
@app.route("/health")
|
||||
def health_check():
|
||||
@@ -436,5 +464,5 @@ def create_app(config=None):
|
||||
|
||||
# Package version (Semantic Versioning 2.0.0)
|
||||
# See docs/standards/versioning-strategy.md for details
|
||||
__version__ = "1.6.0"
|
||||
__version_info__ = (1, 6, 0)
|
||||
__version__ = "2.6.2"
|
||||
__version_info__ = (2, 6, 2)
|
||||
+233
-395
@@ -1,20 +1,21 @@
|
||||
"""
|
||||
Authentication module for StarPunk
|
||||
|
||||
Implements IndieLogin authentication for admin access using indielogin.com
|
||||
as a delegated authentication provider. No passwords are stored locally.
|
||||
Admin login uses OpenID Connect (authorization code flow with PKCE) against
|
||||
a configured provider such as Pocket ID. Exactly one OIDC subject
|
||||
(OIDC_ADMIN_SUB) may log in; a successful login creates a local session
|
||||
for the site owner's identity URL (ADMIN_ME). No passwords are stored.
|
||||
|
||||
Security features:
|
||||
- CSRF protection via state tokens
|
||||
- Secure session tokens (cryptographically random)
|
||||
- Token hashing in database (SHA-256)
|
||||
- CSRF protection via single-use state tokens
|
||||
- PKCE (S256) and nonce binding of the ID token to the login attempt
|
||||
- ID token signature, issuer, audience and expiry checks
|
||||
- Session tokens hashed in the database (SHA-256)
|
||||
- HttpOnly, Secure, SameSite cookies
|
||||
- Single-admin authorization
|
||||
- Automatic session cleanup
|
||||
|
||||
Functions:
|
||||
initiate_login: Start IndieLogin authentication flow
|
||||
handle_callback: Process IndieLogin callback
|
||||
initiate_login: Start the OIDC login flow
|
||||
handle_callback: Finish the OIDC login flow and create a session
|
||||
create_session: Create authenticated session
|
||||
verify_session: Check if session is valid
|
||||
destroy_session: Logout and cleanup
|
||||
@@ -24,153 +25,50 @@ Exceptions:
|
||||
AuthError: Base authentication exception
|
||||
InvalidStateError: CSRF state validation failed
|
||||
UnauthorizedError: User not authorized as admin
|
||||
IndieLoginError: External service error
|
||||
OIDCError: Identity provider error
|
||||
"""
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import logging
|
||||
import secrets
|
||||
import time
|
||||
from datetime import datetime, timedelta
|
||||
from functools import wraps
|
||||
from typing import Any, Dict, Optional
|
||||
from typing import Any, Dict, Optional, Tuple
|
||||
from urllib.parse import urlencode
|
||||
|
||||
import httpx
|
||||
import jwt
|
||||
from flask import current_app, g, redirect, request, session, url_for
|
||||
|
||||
from starpunk.auth_external import discover_endpoints, DiscoveryError, normalize_url
|
||||
from starpunk.database import get_db
|
||||
from starpunk.utils import is_valid_url
|
||||
|
||||
# Cached provider metadata: {issuer: (fetched_at, metadata)}
|
||||
_METADATA_CACHE: Dict[str, Tuple[float, dict]] = {}
|
||||
_METADATA_TTL = 3600
|
||||
# One JWKS client per jwks_uri; PyJWKClient caches the keys itself
|
||||
_JWKS_CLIENTS: Dict[str, jwt.PyJWKClient] = {}
|
||||
|
||||
LOGIN_STATE_MINUTES = 10
|
||||
|
||||
|
||||
# Custom exceptions
|
||||
class AuthError(Exception):
|
||||
"""Base exception for authentication errors"""
|
||||
|
||||
pass
|
||||
|
||||
|
||||
class InvalidStateError(AuthError):
|
||||
"""CSRF state validation failed"""
|
||||
|
||||
pass
|
||||
|
||||
|
||||
class UnauthorizedError(AuthError):
|
||||
"""User not authorized as admin"""
|
||||
|
||||
pass
|
||||
|
||||
class OIDCError(AuthError):
|
||||
"""Identity provider error"""
|
||||
|
||||
|
||||
class IndieLoginError(AuthError):
|
||||
"""IndieLogin service error"""
|
||||
|
||||
pass
|
||||
|
||||
|
||||
# Logging helper functions
|
||||
def _redact_token(value: str, show_chars: int = 6) -> str:
|
||||
"""
|
||||
Redact sensitive token for logging
|
||||
|
||||
Shows first N and last 4 characters with asterisks in between.
|
||||
|
||||
Args:
|
||||
value: Token to redact
|
||||
show_chars: Number of characters to show at start (default: 6)
|
||||
|
||||
Returns:
|
||||
Redacted token string like "abc123...********...xyz9"
|
||||
"""
|
||||
if not value or len(value) <= (show_chars + 4):
|
||||
return "***REDACTED***"
|
||||
|
||||
return f"{value[:show_chars]}...{'*' * 8}...{value[-4:]}"
|
||||
|
||||
|
||||
def _log_http_request(method: str, url: str, data: dict, headers: dict = None) -> None:
|
||||
"""
|
||||
Log HTTP request details at DEBUG level
|
||||
|
||||
Automatically redacts sensitive parameters (code, state, authorization)
|
||||
|
||||
Args:
|
||||
method: HTTP method (GET, POST, etc.)
|
||||
url: Request URL
|
||||
data: Request data/parameters
|
||||
headers: Optional request headers
|
||||
"""
|
||||
if not current_app.logger.isEnabledFor(logging.DEBUG):
|
||||
return
|
||||
|
||||
# Redact sensitive data
|
||||
safe_data = data.copy()
|
||||
if "code" in safe_data:
|
||||
safe_data["code"] = _redact_token(safe_data["code"])
|
||||
if "state" in safe_data:
|
||||
safe_data["state"] = _redact_token(safe_data["state"], 8)
|
||||
if "code_verifier" in safe_data:
|
||||
safe_data["code_verifier"] = _redact_token(safe_data["code_verifier"])
|
||||
|
||||
current_app.logger.debug(
|
||||
f"IndieAuth HTTP Request:\n"
|
||||
f" Method: {method}\n"
|
||||
f" URL: {url}\n"
|
||||
f" Data: {safe_data}"
|
||||
)
|
||||
|
||||
if headers:
|
||||
safe_headers = {
|
||||
k: v
|
||||
for k, v in headers.items()
|
||||
if k.lower() not in ["authorization", "cookie"]
|
||||
}
|
||||
current_app.logger.debug(f" Headers: {safe_headers}")
|
||||
|
||||
|
||||
def _log_http_response(status_code: int, headers: dict, body: str) -> None:
|
||||
"""
|
||||
Log HTTP response details at DEBUG level
|
||||
|
||||
Automatically redacts sensitive response data
|
||||
|
||||
Args:
|
||||
status_code: HTTP status code
|
||||
headers: Response headers
|
||||
body: Response body (JSON string or text)
|
||||
"""
|
||||
if not current_app.logger.isEnabledFor(logging.DEBUG):
|
||||
return
|
||||
|
||||
# Parse and redact JSON body if present
|
||||
safe_body = body
|
||||
try:
|
||||
import json
|
||||
|
||||
data = json.loads(body)
|
||||
if "access_token" in data:
|
||||
data["access_token"] = _redact_token(data["access_token"])
|
||||
if "code" in data:
|
||||
data["code"] = _redact_token(data["code"])
|
||||
safe_body = json.dumps(data, indent=2)
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
# Not JSON or parsing failed, log as-is (likely error message)
|
||||
pass
|
||||
|
||||
# Redact sensitive headers
|
||||
safe_headers = {
|
||||
k: v for k, v in headers.items() if k.lower() not in ["set-cookie", "authorization"]
|
||||
}
|
||||
|
||||
current_app.logger.debug(
|
||||
f"IndieAuth HTTP Response:\n"
|
||||
f" Status: {status_code}\n"
|
||||
f" Headers: {safe_headers}\n"
|
||||
f" Body: {safe_body}"
|
||||
)
|
||||
|
||||
|
||||
# Helper functions
|
||||
def _hash_token(token: str) -> str:
|
||||
"""
|
||||
Hash token using SHA-256
|
||||
@@ -185,323 +83,264 @@ def _hash_token(token: str) -> str:
|
||||
|
||||
|
||||
def _generate_state_token() -> str:
|
||||
"""
|
||||
Generate CSRF state token
|
||||
|
||||
Returns:
|
||||
URL-safe random token
|
||||
"""
|
||||
"""Generate a URL-safe random token"""
|
||||
return secrets.token_urlsafe(32)
|
||||
|
||||
|
||||
def _verify_state_token(state: str) -> bool:
|
||||
def _pkce_challenge(verifier: str) -> str:
|
||||
"""S256 PKCE challenge for a verifier (RFC 7636)"""
|
||||
digest = hashlib.sha256(verifier.encode("ascii")).digest()
|
||||
return base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
|
||||
|
||||
|
||||
def _redirect_uri() -> str:
|
||||
"""OIDC redirect URI registered with the provider"""
|
||||
return current_app.config["SITE_URL"].rstrip("/") + "/auth/callback"
|
||||
|
||||
|
||||
def _safe_next_url(next_url: Optional[str]) -> Optional[str]:
|
||||
"""Only allow redirects back to this site after login"""
|
||||
if not next_url:
|
||||
return None
|
||||
site = current_app.config["SITE_URL"].rstrip("/")
|
||||
if next_url.startswith(site + "/"):
|
||||
return next_url
|
||||
if next_url.startswith("/") and not next_url.startswith("//"):
|
||||
return next_url
|
||||
return None
|
||||
|
||||
|
||||
def _cleanup_expired_sessions() -> None:
|
||||
"""Remove expired sessions and pending login state"""
|
||||
db = get_db(current_app)
|
||||
db.execute("DELETE FROM sessions WHERE expires_at <= datetime('now')")
|
||||
db.execute("DELETE FROM oidc_login_state WHERE expires_at <= datetime('now')")
|
||||
db.commit()
|
||||
|
||||
|
||||
def get_oidc_metadata() -> dict:
|
||||
"""
|
||||
Verify and consume CSRF state token.
|
||||
Fetch (and cache) the provider's OpenID configuration
|
||||
|
||||
Raises:
|
||||
OIDCError: Discovery failed or the issuer does not match
|
||||
"""
|
||||
issuer = current_app.config.get("OIDC_ISSUER", "").rstrip("/")
|
||||
if not issuer:
|
||||
raise OIDCError("OIDC_ISSUER is not configured")
|
||||
|
||||
cached = _METADATA_CACHE.get(issuer)
|
||||
if cached and time.time() - cached[0] < _METADATA_TTL:
|
||||
return cached[1]
|
||||
|
||||
url = f"{issuer}/.well-known/openid-configuration"
|
||||
try:
|
||||
response = httpx.get(url, timeout=10.0)
|
||||
response.raise_for_status()
|
||||
metadata = response.json()
|
||||
except (httpx.HTTPError, ValueError) as e:
|
||||
raise OIDCError(f"OIDC discovery failed: {e}")
|
||||
|
||||
if metadata.get("issuer", "").rstrip("/") != issuer:
|
||||
raise OIDCError(
|
||||
f"OIDC issuer mismatch: expected {issuer}, got {metadata.get('issuer')}"
|
||||
)
|
||||
for key in ("authorization_endpoint", "token_endpoint", "jwks_uri"):
|
||||
if not metadata.get(key):
|
||||
raise OIDCError(f"OIDC metadata is missing {key}")
|
||||
|
||||
_METADATA_CACHE[issuer] = (time.time(), metadata)
|
||||
return metadata
|
||||
|
||||
|
||||
def _get_signing_key(metadata: dict, id_token: str):
|
||||
"""Resolve the key that signed an ID token from the provider's JWKS"""
|
||||
jwks_uri = metadata["jwks_uri"]
|
||||
client = _JWKS_CLIENTS.get(jwks_uri)
|
||||
if client is None:
|
||||
client = jwt.PyJWKClient(jwks_uri, timeout=10)
|
||||
_JWKS_CLIENTS[jwks_uri] = client
|
||||
return client.get_signing_key_from_jwt(id_token).key
|
||||
|
||||
|
||||
def _validate_id_token(metadata: dict, id_token: str, nonce: str) -> dict:
|
||||
"""
|
||||
Verify the ID token signature and standard claims (OIDC Core 3.1.3.7)
|
||||
|
||||
Raises:
|
||||
OIDCError: Token is invalid
|
||||
"""
|
||||
algorithms = metadata.get("id_token_signing_alg_values_supported") or ["RS256"]
|
||||
algorithms = [alg for alg in algorithms if alg != "none"]
|
||||
try:
|
||||
key = _get_signing_key(metadata, id_token)
|
||||
claims = jwt.decode(
|
||||
id_token,
|
||||
key,
|
||||
algorithms=algorithms,
|
||||
audience=current_app.config["OIDC_CLIENT_ID"],
|
||||
issuer=metadata["issuer"],
|
||||
options={"require": ["exp", "iat", "sub", "iss", "aud"]},
|
||||
leeway=60,
|
||||
)
|
||||
except jwt.PyJWTError as e:
|
||||
raise OIDCError(f"Invalid ID token: {e}")
|
||||
|
||||
if not nonce or not secrets.compare_digest(str(claims.get("nonce", "")), nonce):
|
||||
raise OIDCError("ID token nonce does not match login request")
|
||||
|
||||
return claims
|
||||
|
||||
|
||||
# Core authentication functions
|
||||
def initiate_login(next_url: Optional[str] = None) -> str:
|
||||
"""
|
||||
Start the OIDC authorization code flow
|
||||
|
||||
Args:
|
||||
state: State token to verify
|
||||
next_url: Where to send the admin after login (same site only)
|
||||
|
||||
Returns:
|
||||
True if valid, False if invalid or expired
|
||||
"""
|
||||
db = get_db(current_app)
|
||||
Redirect URL to the provider's authorization endpoint
|
||||
|
||||
# Check if state exists and not expired
|
||||
result = db.execute(
|
||||
Raises:
|
||||
OIDCError: Provider discovery failed
|
||||
"""
|
||||
metadata = get_oidc_metadata()
|
||||
|
||||
state = _generate_state_token()
|
||||
nonce = secrets.token_urlsafe(32)
|
||||
code_verifier = secrets.token_urlsafe(64)
|
||||
|
||||
db = get_db(current_app)
|
||||
db.execute(
|
||||
"""
|
||||
SELECT 1 FROM auth_state
|
||||
INSERT INTO oidc_login_state (state, nonce, code_verifier, next_url, expires_at)
|
||||
VALUES (?, ?, ?, ?, ?)
|
||||
""",
|
||||
(
|
||||
state,
|
||||
nonce,
|
||||
code_verifier,
|
||||
_safe_next_url(next_url),
|
||||
datetime.utcnow() + timedelta(minutes=LOGIN_STATE_MINUTES),
|
||||
),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
params = {
|
||||
"response_type": "code",
|
||||
"client_id": current_app.config["OIDC_CLIENT_ID"],
|
||||
"redirect_uri": _redirect_uri(),
|
||||
"scope": "openid",
|
||||
"state": state,
|
||||
"nonce": nonce,
|
||||
"code_challenge": _pkce_challenge(code_verifier),
|
||||
"code_challenge_method": "S256",
|
||||
}
|
||||
|
||||
current_app.logger.info("Auth: OIDC login initiated")
|
||||
return f"{metadata['authorization_endpoint']}?{urlencode(params)}"
|
||||
|
||||
|
||||
def _consume_login_state(state: str) -> Optional[dict]:
|
||||
"""Fetch and delete a pending login (single use)"""
|
||||
db = get_db(current_app)
|
||||
row = db.execute(
|
||||
"""
|
||||
SELECT nonce, code_verifier, next_url FROM oidc_login_state
|
||||
WHERE state = ? AND expires_at > datetime('now')
|
||||
""",
|
||||
(state,),
|
||||
).fetchone()
|
||||
|
||||
if not result:
|
||||
return False
|
||||
|
||||
# Delete state (single-use)
|
||||
db.execute("DELETE FROM auth_state WHERE state = ?", (state,))
|
||||
db.execute("DELETE FROM oidc_login_state WHERE state = ?", (state,))
|
||||
db.commit()
|
||||
|
||||
return True
|
||||
return dict(row) if row else None
|
||||
|
||||
|
||||
def _cleanup_expired_sessions() -> None:
|
||||
"""Remove expired sessions and state tokens"""
|
||||
db = get_db(current_app)
|
||||
|
||||
# Delete expired sessions
|
||||
db.execute(
|
||||
"""
|
||||
DELETE FROM sessions
|
||||
WHERE expires_at <= datetime('now')
|
||||
def handle_callback(
|
||||
code: str, state: str, iss: Optional[str] = None
|
||||
) -> Tuple[str, Optional[str]]:
|
||||
"""
|
||||
)
|
||||
|
||||
# Delete expired state tokens
|
||||
db.execute(
|
||||
"""
|
||||
DELETE FROM auth_state
|
||||
WHERE expires_at <= datetime('now')
|
||||
"""
|
||||
)
|
||||
|
||||
db.commit()
|
||||
|
||||
|
||||
# Core authentication functions
|
||||
def initiate_login(me_url: str) -> str:
|
||||
"""
|
||||
Initiate IndieAuth authentication flow with endpoint discovery.
|
||||
|
||||
Per W3C IndieAuth spec, discovers authorization_endpoint from user's
|
||||
profile URL rather than using a hardcoded service.
|
||||
Finish the OIDC flow: exchange the code, verify the ID token, check
|
||||
the subject is the configured admin, and create a session.
|
||||
|
||||
Args:
|
||||
me_url: User's IndieWeb identity URL
|
||||
|
||||
Returns:
|
||||
Redirect URL to discovered authorization endpoint
|
||||
|
||||
Raises:
|
||||
ValueError: Invalid me_url format
|
||||
DiscoveryError: Failed to discover endpoints from profile
|
||||
"""
|
||||
# Validate URL format
|
||||
if not is_valid_url(me_url):
|
||||
raise ValueError(f"Invalid URL format: {me_url}")
|
||||
|
||||
current_app.logger.debug(f"Auth: Validating me URL: {me_url}")
|
||||
|
||||
# Discover authorization endpoint from user's profile URL
|
||||
# Per IndieAuth spec: clients MUST discover endpoints, not hardcode them
|
||||
try:
|
||||
endpoints = discover_endpoints(me_url)
|
||||
except DiscoveryError as e:
|
||||
current_app.logger.error(f"Auth: Endpoint discovery failed for {me_url}: {e}")
|
||||
raise
|
||||
|
||||
auth_endpoint = endpoints.get('authorization_endpoint')
|
||||
if not auth_endpoint:
|
||||
raise DiscoveryError(
|
||||
f"No authorization_endpoint found at {me_url}. "
|
||||
"Ensure your profile has IndieAuth link elements or headers."
|
||||
)
|
||||
|
||||
current_app.logger.info(f"Auth: Discovered authorization_endpoint: {auth_endpoint}")
|
||||
|
||||
# Generate CSRF state token
|
||||
state = _generate_state_token()
|
||||
current_app.logger.debug(f"Auth: Generated state token: {_redact_token(state, 8)}")
|
||||
|
||||
# Store state in database (5-minute expiry)
|
||||
db = get_db(current_app)
|
||||
expires_at = datetime.utcnow() + timedelta(minutes=5)
|
||||
redirect_uri = f"{current_app.config['SITE_URL']}auth/callback"
|
||||
|
||||
db.execute(
|
||||
"""
|
||||
INSERT INTO auth_state (state, expires_at, redirect_uri)
|
||||
VALUES (?, ?, ?)
|
||||
""",
|
||||
(state, expires_at, redirect_uri),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
# Build authorization URL
|
||||
# Per W3C IndieAuth spec: use response_type=id for authentication-only flow
|
||||
# (identity verification without access token). This allows code redemption
|
||||
# at the authorization_endpoint rather than requiring token_endpoint.
|
||||
params = {
|
||||
"me": me_url,
|
||||
"client_id": current_app.config["SITE_URL"],
|
||||
"redirect_uri": redirect_uri,
|
||||
"state": state,
|
||||
"response_type": "id",
|
||||
}
|
||||
|
||||
current_app.logger.debug(
|
||||
f"Auth: Building authorization URL with params:\n"
|
||||
f" me: {me_url}\n"
|
||||
f" client_id: {current_app.config['SITE_URL']}\n"
|
||||
f" redirect_uri: {redirect_uri}\n"
|
||||
f" state: {_redact_token(state, 8)}\n"
|
||||
f" response_type: id (authentication-only flow)"
|
||||
)
|
||||
|
||||
auth_url = f"{auth_endpoint}?{urlencode(params)}"
|
||||
|
||||
current_app.logger.debug(f"Auth: Complete authorization URL: {auth_url}")
|
||||
current_app.logger.info(f"Auth: Authentication initiated for {me_url}")
|
||||
|
||||
return auth_url
|
||||
|
||||
|
||||
def handle_callback(code: str, state: str, iss: Optional[str] = None) -> Optional[str]:
|
||||
"""
|
||||
Handle IndieAuth callback with endpoint discovery.
|
||||
|
||||
Discovers authorization_endpoint from ADMIN_ME profile and exchanges
|
||||
authorization code for identity verification.
|
||||
|
||||
Per IndieAuth spec: Authentication-only flows POST to the authorization
|
||||
endpoint (not token endpoint) and do not include grant_type.
|
||||
|
||||
Args:
|
||||
code: Authorization code from authorization server
|
||||
code: Authorization code from the provider
|
||||
state: CSRF state token
|
||||
iss: Issuer identifier (optional, for security validation)
|
||||
iss: Issuer from the redirect (RFC 9207), checked when present
|
||||
|
||||
Returns:
|
||||
Session token if successful, None otherwise
|
||||
(session_token, next_url)
|
||||
|
||||
Raises:
|
||||
InvalidStateError: State token validation failed
|
||||
UnauthorizedError: User not authorized as admin
|
||||
IndieLoginError: Code exchange failed
|
||||
UnauthorizedError: Subject is not the configured admin
|
||||
OIDCError: Provider or token error
|
||||
"""
|
||||
current_app.logger.debug(f"Auth: Verifying state token: {_redact_token(state, 8)}")
|
||||
|
||||
# Verify state token (CSRF protection)
|
||||
if not _verify_state_token(state):
|
||||
current_app.logger.warning(
|
||||
"Auth: Invalid state token received (possible CSRF or expired token)"
|
||||
)
|
||||
pending = _consume_login_state(state)
|
||||
if not pending:
|
||||
current_app.logger.warning("Auth: Invalid or expired OIDC state")
|
||||
raise InvalidStateError("Invalid or expired state token")
|
||||
|
||||
current_app.logger.debug("Auth: State token valid")
|
||||
metadata = get_oidc_metadata()
|
||||
|
||||
# Discover authorization endpoint from ADMIN_ME profile
|
||||
admin_me = current_app.config.get("ADMIN_ME")
|
||||
if not admin_me:
|
||||
current_app.logger.error("Auth: ADMIN_ME not configured")
|
||||
raise IndieLoginError("ADMIN_ME not configured")
|
||||
if iss and iss.rstrip("/") != metadata["issuer"].rstrip("/"):
|
||||
raise OIDCError(f"Unexpected issuer in callback: {iss}")
|
||||
|
||||
try:
|
||||
endpoints = discover_endpoints(admin_me)
|
||||
except DiscoveryError as e:
|
||||
current_app.logger.error(f"Auth: Endpoint discovery failed: {e}")
|
||||
raise IndieLoginError(f"Failed to discover endpoints: {e}")
|
||||
|
||||
# Use authorization_endpoint for authentication-only flow (identity verification)
|
||||
# Per IndieAuth spec: auth-only flows POST to authorization_endpoint, not token_endpoint
|
||||
auth_endpoint = endpoints.get('authorization_endpoint')
|
||||
if not auth_endpoint:
|
||||
raise IndieLoginError(
|
||||
f"No authorization_endpoint found at {admin_me}. "
|
||||
"Ensure your profile has IndieAuth endpoints configured."
|
||||
)
|
||||
|
||||
current_app.logger.debug(f"Auth: Using authorization_endpoint: {auth_endpoint}")
|
||||
|
||||
# Verify issuer if provided (security check - optional)
|
||||
if iss:
|
||||
current_app.logger.debug(f"Auth: Issuer provided: {iss}")
|
||||
|
||||
# Prepare code verification request
|
||||
# Note: grant_type is NOT included for authentication-only flows per IndieAuth spec
|
||||
token_exchange_data = {
|
||||
"code": code,
|
||||
"client_id": current_app.config["SITE_URL"],
|
||||
"redirect_uri": f"{current_app.config['SITE_URL']}auth/callback",
|
||||
}
|
||||
|
||||
# Log the request
|
||||
_log_http_request(
|
||||
method="POST",
|
||||
url=auth_endpoint,
|
||||
data=token_exchange_data,
|
||||
)
|
||||
|
||||
current_app.logger.debug(
|
||||
"Auth: Sending code verification request to authorization endpoint:\n"
|
||||
" Method: POST\n"
|
||||
" URL: %s\n"
|
||||
" Data: code=%s, client_id=%s, redirect_uri=%s",
|
||||
auth_endpoint,
|
||||
_redact_token(code),
|
||||
token_exchange_data["client_id"],
|
||||
token_exchange_data["redirect_uri"],
|
||||
)
|
||||
|
||||
# Exchange code for identity at authorization endpoint (authentication-only flow)
|
||||
try:
|
||||
response = httpx.post(
|
||||
auth_endpoint,
|
||||
data=token_exchange_data,
|
||||
metadata["token_endpoint"],
|
||||
data={
|
||||
"grant_type": "authorization_code",
|
||||
"code": code,
|
||||
"redirect_uri": _redirect_uri(),
|
||||
"code_verifier": pending["code_verifier"],
|
||||
},
|
||||
auth=(
|
||||
current_app.config["OIDC_CLIENT_ID"],
|
||||
current_app.config["OIDC_CLIENT_SECRET"],
|
||||
),
|
||||
timeout=10.0,
|
||||
)
|
||||
|
||||
current_app.logger.debug(
|
||||
"Auth: Received code verification response:\n"
|
||||
" Status: %d\n"
|
||||
" Headers: %s\n"
|
||||
" Body: %s",
|
||||
response.status_code,
|
||||
{k: v for k, v in dict(response.headers).items()
|
||||
if k.lower() not in ["set-cookie", "authorization"]},
|
||||
_redact_token(response.text) if response.text else "(empty)",
|
||||
)
|
||||
|
||||
_log_http_response(
|
||||
status_code=response.status_code,
|
||||
headers=dict(response.headers),
|
||||
body=response.text,
|
||||
)
|
||||
|
||||
response.raise_for_status()
|
||||
except httpx.RequestError as e:
|
||||
current_app.logger.error(f"Auth: Authorization endpoint request failed: {e}")
|
||||
raise IndieLoginError(f"Failed to verify code: {e}")
|
||||
except httpx.HTTPStatusError as e:
|
||||
raise OIDCError(f"Token request failed: {e}")
|
||||
|
||||
if response.status_code != 200:
|
||||
current_app.logger.error(
|
||||
f"Auth: Authorization endpoint returned error: {e.response.status_code} - {e.response.text}"
|
||||
)
|
||||
raise IndieLoginError(
|
||||
f"Authorization endpoint returned error: {e.response.status_code}"
|
||||
f"Auth: OIDC token endpoint returned {response.status_code}: {response.text[:200]}"
|
||||
)
|
||||
raise OIDCError(f"Token endpoint returned {response.status_code}")
|
||||
|
||||
# Parse response
|
||||
try:
|
||||
data = response.json()
|
||||
except Exception as e:
|
||||
current_app.logger.error(f"Auth: Failed to parse authorization endpoint response: {e}")
|
||||
raise IndieLoginError("Invalid JSON response from authorization endpoint")
|
||||
id_token = response.json().get("id_token")
|
||||
except ValueError:
|
||||
raise OIDCError("Token endpoint returned invalid JSON")
|
||||
if not id_token:
|
||||
raise OIDCError("Token endpoint returned no id_token")
|
||||
|
||||
me = data.get("me")
|
||||
claims = _validate_id_token(metadata, id_token, pending["nonce"])
|
||||
|
||||
admin_sub = current_app.config.get("OIDC_ADMIN_SUB", "")
|
||||
if not admin_sub or not secrets.compare_digest(claims["sub"], admin_sub):
|
||||
current_app.logger.warning(f"Auth: Unauthorized OIDC subject {claims['sub']}")
|
||||
raise UnauthorizedError("This account is not the site admin")
|
||||
|
||||
me = current_app.config.get("ADMIN_ME")
|
||||
if not me:
|
||||
current_app.logger.error("Auth: No identity returned from authorization endpoint")
|
||||
raise IndieLoginError("No identity returned from authorization endpoint")
|
||||
raise OIDCError("ADMIN_ME not configured")
|
||||
|
||||
current_app.logger.debug(f"Auth: Received identity: {me}")
|
||||
|
||||
# Verify this is the admin user
|
||||
current_app.logger.info(f"Auth: Verifying admin authorization for me={me}")
|
||||
|
||||
# Normalize URLs for comparison (handles trailing slashes and case differences)
|
||||
# This is correct per IndieAuth spec - the returned 'me' is the canonical form
|
||||
if normalize_url(me) != normalize_url(admin_me):
|
||||
current_app.logger.warning(
|
||||
f"Auth: Unauthorized login attempt: {me} (expected {admin_me})"
|
||||
)
|
||||
raise UnauthorizedError(f"User {me} is not authorized")
|
||||
|
||||
current_app.logger.debug("Auth: Admin verification passed")
|
||||
|
||||
# Create session
|
||||
session_token = create_session(me)
|
||||
|
||||
# Trigger author profile discovery (v1.2.0 Phase 2)
|
||||
# Per Q14: Never block login, always allow fallback
|
||||
# Refresh the author h-card; never block login on it
|
||||
try:
|
||||
from starpunk.author_discovery import get_author_profile
|
||||
author_profile = get_author_profile(me, refresh=True)
|
||||
current_app.logger.info(f"Author profile refreshed for {me}")
|
||||
|
||||
get_author_profile(me, refresh=True)
|
||||
except Exception as e:
|
||||
current_app.logger.warning(f"Author discovery failed: {e}")
|
||||
# Continue login anyway - never block per Q14
|
||||
|
||||
return session_token
|
||||
return session_token, pending["next_url"]
|
||||
|
||||
|
||||
def create_session(me: str) -> str:
|
||||
@@ -567,7 +406,6 @@ def verify_session(token: str) -> Optional[Dict[str, Any]]:
|
||||
current_app.logger.debug("Auth: No session token provided")
|
||||
return None
|
||||
|
||||
current_app.logger.debug(f"Auth: Verifying session token: {_redact_token(token)}")
|
||||
|
||||
token_hash = _hash_token(token)
|
||||
|
||||
|
||||
@@ -1,614 +0,0 @@
|
||||
"""
|
||||
External IndieAuth Token Verification with Endpoint Discovery
|
||||
|
||||
This module handles verification of bearer tokens issued by external
|
||||
IndieAuth providers. Following the IndieAuth specification, endpoints
|
||||
are discovered dynamically from the user's profile URL, not hardcoded.
|
||||
|
||||
For StarPunk V1 (single-user CMS), we always discover endpoints from
|
||||
ADMIN_ME since only the site owner can post content.
|
||||
|
||||
Key Components:
|
||||
EndpointCache: Simple in-memory cache for discovered endpoints and tokens
|
||||
verify_external_token: Main entry point for token verification
|
||||
discover_endpoints: Discovers IndieAuth endpoints from profile URL
|
||||
|
||||
Configuration (via Flask app.config):
|
||||
ADMIN_ME: Site owner's profile URL (required)
|
||||
DEBUG: Allow HTTP endpoints in debug mode
|
||||
|
||||
ADR: ADR-031 IndieAuth Endpoint Discovery Implementation
|
||||
Date: 2025-11-24
|
||||
Version: v1.0.0-rc.5
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import logging
|
||||
import re
|
||||
import time
|
||||
from typing import Dict, Optional, Any
|
||||
from urllib.parse import urljoin, urlparse
|
||||
|
||||
import httpx
|
||||
from bs4 import BeautifulSoup
|
||||
from flask import current_app
|
||||
|
||||
|
||||
# Timeouts
|
||||
DISCOVERY_TIMEOUT = 5.0 # Profile fetch (cached, so can be slower)
|
||||
VERIFICATION_TIMEOUT = 3.0 # Token verification (every request)
|
||||
|
||||
# Cache TTLs
|
||||
ENDPOINT_CACHE_TTL = 3600 # 1 hour for endpoints
|
||||
TOKEN_CACHE_TTL = 300 # 5 minutes for token verifications
|
||||
|
||||
|
||||
class EndpointCache:
|
||||
"""
|
||||
Simple in-memory cache for endpoint discovery and token verification
|
||||
|
||||
V1 single-user implementation: We only cache one user's endpoints
|
||||
since StarPunk V1 is explicitly single-user (only ADMIN_ME can post).
|
||||
|
||||
When V2 adds multi-user support, this will need refactoring to
|
||||
cache endpoints per profile URL.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
# Endpoint cache (single-user V1)
|
||||
self.endpoints: Optional[Dict[str, str]] = None
|
||||
self.endpoints_expire: float = 0
|
||||
|
||||
# Token verification cache (token_hash -> (info, expiry))
|
||||
self.token_cache: Dict[str, tuple[Dict[str, Any], float]] = {}
|
||||
|
||||
def get_endpoints(self, ignore_expiry: bool = False) -> Optional[Dict[str, str]]:
|
||||
"""
|
||||
Get cached endpoints if still valid
|
||||
|
||||
Args:
|
||||
ignore_expiry: Return cached endpoints even if expired (grace period)
|
||||
|
||||
Returns:
|
||||
Cached endpoints dict or None if not cached or expired
|
||||
"""
|
||||
if self.endpoints is None:
|
||||
return None
|
||||
|
||||
if ignore_expiry or time.time() < self.endpoints_expire:
|
||||
return self.endpoints
|
||||
|
||||
return None
|
||||
|
||||
def set_endpoints(self, endpoints: Dict[str, str], ttl: int = ENDPOINT_CACHE_TTL):
|
||||
"""Cache discovered endpoints"""
|
||||
self.endpoints = endpoints
|
||||
self.endpoints_expire = time.time() + ttl
|
||||
|
||||
def get_token_info(self, token_hash: str) -> Optional[Dict[str, Any]]:
|
||||
"""Get cached token verification if still valid"""
|
||||
if token_hash in self.token_cache:
|
||||
info, expiry = self.token_cache[token_hash]
|
||||
if time.time() < expiry:
|
||||
return info
|
||||
else:
|
||||
# Expired, remove from cache
|
||||
del self.token_cache[token_hash]
|
||||
return None
|
||||
|
||||
def set_token_info(self, token_hash: str, info: Dict[str, Any], ttl: int = TOKEN_CACHE_TTL):
|
||||
"""Cache token verification result"""
|
||||
expiry = time.time() + ttl
|
||||
self.token_cache[token_hash] = (info, expiry)
|
||||
|
||||
|
||||
# Global cache instance (singleton for V1)
|
||||
_cache = EndpointCache()
|
||||
|
||||
|
||||
class DiscoveryError(Exception):
|
||||
"""Raised when endpoint discovery fails"""
|
||||
pass
|
||||
|
||||
|
||||
class TokenVerificationError(Exception):
|
||||
"""Raised when token verification fails"""
|
||||
pass
|
||||
|
||||
|
||||
def verify_external_token(token: str) -> Optional[Dict[str, Any]]:
|
||||
"""
|
||||
Verify bearer token with external IndieAuth provider
|
||||
|
||||
This is the main entry point for token verification. For StarPunk V1
|
||||
(single-user), we always discover endpoints from ADMIN_ME since only
|
||||
the site owner can post content.
|
||||
|
||||
Process:
|
||||
1. Check token verification cache
|
||||
2. Discover endpoints from ADMIN_ME (with caching)
|
||||
3. Verify token with discovered endpoint
|
||||
4. Validate token belongs to ADMIN_ME
|
||||
5. Cache successful verification
|
||||
|
||||
Args:
|
||||
token: Bearer token to verify
|
||||
|
||||
Returns:
|
||||
Dict with token info (me, client_id, scope) if valid
|
||||
None if token is invalid or verification fails
|
||||
|
||||
Token info dict contains:
|
||||
me: User's profile URL
|
||||
client_id: Client application URL
|
||||
scope: Space-separated list of scopes
|
||||
"""
|
||||
admin_me = current_app.config.get("ADMIN_ME")
|
||||
|
||||
if not admin_me:
|
||||
current_app.logger.error(
|
||||
"ADMIN_ME not configured. Cannot verify token ownership."
|
||||
)
|
||||
return None
|
||||
|
||||
# Check token cache first
|
||||
token_hash = _hash_token(token)
|
||||
cached_info = _cache.get_token_info(token_hash)
|
||||
if cached_info:
|
||||
current_app.logger.debug("Token verification cache hit")
|
||||
return cached_info
|
||||
|
||||
# Discover endpoints from ADMIN_ME (V1 single-user assumption)
|
||||
try:
|
||||
endpoints = discover_endpoints(admin_me)
|
||||
except DiscoveryError as e:
|
||||
current_app.logger.error(f"Endpoint discovery failed: {e}")
|
||||
return None
|
||||
|
||||
token_endpoint = endpoints.get('token_endpoint')
|
||||
if not token_endpoint:
|
||||
current_app.logger.error("No token endpoint found in discovery")
|
||||
return None
|
||||
|
||||
# Verify token with discovered endpoint
|
||||
try:
|
||||
token_info = _verify_with_endpoint(token_endpoint, token)
|
||||
except TokenVerificationError as e:
|
||||
current_app.logger.warning(f"Token verification failed: {e}")
|
||||
return None
|
||||
|
||||
# Validate token belongs to admin (single-user security check)
|
||||
token_me = token_info.get('me', '')
|
||||
if normalize_url(token_me) != normalize_url(admin_me):
|
||||
current_app.logger.warning(
|
||||
f"Token 'me' mismatch: {token_me} != {admin_me}"
|
||||
)
|
||||
return None
|
||||
|
||||
# Cache successful verification
|
||||
_cache.set_token_info(token_hash, token_info)
|
||||
|
||||
current_app.logger.debug(f"Token verified successfully for {token_me}")
|
||||
return token_info
|
||||
|
||||
|
||||
def discover_endpoints(profile_url: str) -> Dict[str, str]:
|
||||
"""
|
||||
Discover IndieAuth endpoints from a profile URL
|
||||
|
||||
Implements IndieAuth endpoint discovery per W3C spec:
|
||||
https://www.w3.org/TR/indieauth/#discovery-by-clients
|
||||
|
||||
Discovery priority:
|
||||
1. HTTP Link headers (highest priority)
|
||||
2. HTML link elements
|
||||
|
||||
Args:
|
||||
profile_url: User's profile URL (their IndieWeb identity)
|
||||
|
||||
Returns:
|
||||
Dict with discovered endpoints:
|
||||
{
|
||||
'authorization_endpoint': 'https://...',
|
||||
'token_endpoint': 'https://...'
|
||||
}
|
||||
|
||||
Raises:
|
||||
DiscoveryError: If discovery fails or no endpoints found
|
||||
"""
|
||||
# Check cache first
|
||||
cached_endpoints = _cache.get_endpoints()
|
||||
if cached_endpoints:
|
||||
current_app.logger.debug("Endpoint discovery cache hit")
|
||||
return cached_endpoints
|
||||
|
||||
# Validate profile URL
|
||||
_validate_profile_url(profile_url)
|
||||
|
||||
try:
|
||||
# Fetch profile with discovery
|
||||
endpoints = _fetch_and_parse(profile_url)
|
||||
|
||||
# Cache successful discovery
|
||||
_cache.set_endpoints(endpoints)
|
||||
|
||||
return endpoints
|
||||
|
||||
except Exception as e:
|
||||
# Check cache even if expired (grace period for network failures)
|
||||
cached = _cache.get_endpoints(ignore_expiry=True)
|
||||
if cached:
|
||||
current_app.logger.warning(
|
||||
f"Using expired cache due to discovery failure: {e}"
|
||||
)
|
||||
return cached
|
||||
|
||||
# No cache available, must fail
|
||||
raise DiscoveryError(f"Endpoint discovery failed: {e}")
|
||||
|
||||
|
||||
def _fetch_and_parse(profile_url: str) -> Dict[str, str]:
|
||||
"""
|
||||
Fetch profile URL and parse endpoints from headers and HTML
|
||||
|
||||
Args:
|
||||
profile_url: User's profile URL
|
||||
|
||||
Returns:
|
||||
Dict with discovered endpoints
|
||||
|
||||
Raises:
|
||||
DiscoveryError: If fetch fails or no endpoints found
|
||||
"""
|
||||
try:
|
||||
response = httpx.get(
|
||||
profile_url,
|
||||
timeout=DISCOVERY_TIMEOUT,
|
||||
follow_redirects=True,
|
||||
headers={
|
||||
'Accept': 'text/html,application/xhtml+xml',
|
||||
'User-Agent': f'StarPunk/{current_app.config.get("VERSION", "1.0")}'
|
||||
}
|
||||
)
|
||||
response.raise_for_status()
|
||||
|
||||
except httpx.TimeoutException:
|
||||
raise DiscoveryError(f"Timeout fetching profile: {profile_url}")
|
||||
except httpx.HTTPStatusError as e:
|
||||
raise DiscoveryError(f"HTTP {e.response.status_code} fetching profile")
|
||||
except httpx.RequestError as e:
|
||||
raise DiscoveryError(f"Network error fetching profile: {e}")
|
||||
|
||||
endpoints = {}
|
||||
|
||||
# 1. Parse HTTP Link headers (highest priority)
|
||||
link_header = response.headers.get('Link', '')
|
||||
if link_header:
|
||||
link_endpoints = _parse_link_header(link_header, profile_url)
|
||||
endpoints.update(link_endpoints)
|
||||
|
||||
# 2. Parse HTML link elements
|
||||
content_type = response.headers.get('Content-Type', '')
|
||||
if 'text/html' in content_type or 'application/xhtml+xml' in content_type:
|
||||
try:
|
||||
html_endpoints = _parse_html_links(response.text, profile_url)
|
||||
# Merge: Link headers take priority (so update HTML first)
|
||||
html_endpoints.update(endpoints)
|
||||
endpoints = html_endpoints
|
||||
except Exception as e:
|
||||
current_app.logger.warning(f"HTML parsing failed: {e}")
|
||||
# Continue with Link header endpoints if HTML parsing fails
|
||||
|
||||
# Validate we found at least one endpoint
|
||||
# - authorization_endpoint: Required for authentication-only flows (admin login)
|
||||
# - token_endpoint: Required for Micropub token verification
|
||||
# Having at least one allows the appropriate flow to work
|
||||
if 'token_endpoint' not in endpoints and 'authorization_endpoint' not in endpoints:
|
||||
raise DiscoveryError(
|
||||
f"No IndieAuth endpoints found at {profile_url}. "
|
||||
"Ensure your profile has authorization_endpoint or token_endpoint configured."
|
||||
)
|
||||
|
||||
# Validate endpoint URLs
|
||||
for rel, url in endpoints.items():
|
||||
_validate_endpoint_url(url, rel)
|
||||
|
||||
current_app.logger.info(
|
||||
f"Discovered endpoints from {profile_url}: "
|
||||
f"token={endpoints.get('token_endpoint')}, "
|
||||
f"auth={endpoints.get('authorization_endpoint')}"
|
||||
)
|
||||
|
||||
return endpoints
|
||||
|
||||
|
||||
def _parse_link_header(header: str, base_url: str) -> Dict[str, str]:
|
||||
"""
|
||||
Parse HTTP Link header for IndieAuth endpoints
|
||||
|
||||
Basic RFC 8288 support - handles simple Link headers.
|
||||
Limitations: Only supports quoted rel values, single Link headers.
|
||||
|
||||
Example:
|
||||
Link: <https://auth.example.com/token>; rel="token_endpoint"
|
||||
|
||||
Args:
|
||||
header: Link header value
|
||||
base_url: Base URL for resolving relative URLs
|
||||
|
||||
Returns:
|
||||
Dict with discovered endpoints
|
||||
"""
|
||||
endpoints = {}
|
||||
|
||||
# Pattern: <url>; rel="relation"
|
||||
# Note: Simplified - doesn't handle all RFC 8288 edge cases
|
||||
pattern = r'<([^>]+)>;\s*rel="([^"]+)"'
|
||||
matches = re.findall(pattern, header)
|
||||
|
||||
for url, rel in matches:
|
||||
if rel == 'authorization_endpoint':
|
||||
endpoints['authorization_endpoint'] = urljoin(base_url, url)
|
||||
elif rel == 'token_endpoint':
|
||||
endpoints['token_endpoint'] = urljoin(base_url, url)
|
||||
|
||||
return endpoints
|
||||
|
||||
|
||||
def _parse_html_links(html: str, base_url: str) -> Dict[str, str]:
|
||||
"""
|
||||
Extract IndieAuth endpoints from HTML link elements
|
||||
|
||||
Looks for:
|
||||
<link rel="authorization_endpoint" href="...">
|
||||
<link rel="token_endpoint" href="...">
|
||||
|
||||
Args:
|
||||
html: HTML content
|
||||
base_url: Base URL for resolving relative URLs
|
||||
|
||||
Returns:
|
||||
Dict with discovered endpoints
|
||||
"""
|
||||
endpoints = {}
|
||||
|
||||
try:
|
||||
soup = BeautifulSoup(html, 'html.parser')
|
||||
|
||||
# Find all link elements (check both head and body - be liberal)
|
||||
for link in soup.find_all('link', rel=True):
|
||||
rel = link.get('rel')
|
||||
href = link.get('href')
|
||||
|
||||
if not href:
|
||||
continue
|
||||
|
||||
# rel can be a list or string
|
||||
if isinstance(rel, list):
|
||||
rel = ' '.join(rel)
|
||||
|
||||
# Check for IndieAuth endpoints
|
||||
if 'authorization_endpoint' in rel:
|
||||
endpoints['authorization_endpoint'] = urljoin(base_url, href)
|
||||
elif 'token_endpoint' in rel:
|
||||
endpoints['token_endpoint'] = urljoin(base_url, href)
|
||||
|
||||
except Exception as e:
|
||||
current_app.logger.warning(f"HTML parsing error: {e}")
|
||||
# Return what we found so far
|
||||
|
||||
return endpoints
|
||||
|
||||
|
||||
def _verify_with_endpoint(endpoint: str, token: str) -> Dict[str, Any]:
|
||||
"""
|
||||
Verify token with the discovered token endpoint
|
||||
|
||||
Makes GET request to endpoint with Authorization header.
|
||||
Implements retry logic for network errors only.
|
||||
|
||||
Args:
|
||||
endpoint: Token endpoint URL
|
||||
token: Bearer token to verify
|
||||
|
||||
Returns:
|
||||
Token info dict from endpoint
|
||||
|
||||
Raises:
|
||||
TokenVerificationError: If verification fails
|
||||
"""
|
||||
headers = {
|
||||
'Authorization': f'Bearer {token}',
|
||||
'Accept': 'application/json',
|
||||
}
|
||||
|
||||
max_retries = 3
|
||||
for attempt in range(max_retries):
|
||||
try:
|
||||
response = httpx.get(
|
||||
endpoint,
|
||||
headers=headers,
|
||||
timeout=VERIFICATION_TIMEOUT,
|
||||
follow_redirects=True,
|
||||
)
|
||||
|
||||
# Handle HTTP status codes
|
||||
if response.status_code == 200:
|
||||
token_info = response.json()
|
||||
|
||||
# Validate required fields
|
||||
if 'me' not in token_info:
|
||||
raise TokenVerificationError("Token response missing 'me' field")
|
||||
|
||||
return token_info
|
||||
|
||||
# Client errors - don't retry
|
||||
elif response.status_code in [400, 401, 403, 404]:
|
||||
raise TokenVerificationError(
|
||||
f"Token verification failed: HTTP {response.status_code}"
|
||||
)
|
||||
|
||||
# Server errors - retry
|
||||
elif response.status_code in [500, 502, 503, 504]:
|
||||
if attempt < max_retries - 1:
|
||||
wait_time = 2 ** attempt # Exponential backoff
|
||||
current_app.logger.debug(
|
||||
f"Server error {response.status_code}, retrying in {wait_time}s..."
|
||||
)
|
||||
time.sleep(wait_time)
|
||||
continue
|
||||
else:
|
||||
raise TokenVerificationError(
|
||||
f"Token endpoint error: HTTP {response.status_code}"
|
||||
)
|
||||
|
||||
# Other status codes
|
||||
else:
|
||||
raise TokenVerificationError(
|
||||
f"Unexpected response: HTTP {response.status_code}"
|
||||
)
|
||||
|
||||
except httpx.TimeoutException:
|
||||
if attempt < max_retries - 1:
|
||||
wait_time = 2 ** attempt
|
||||
current_app.logger.debug(f"Timeout, retrying in {wait_time}s...")
|
||||
time.sleep(wait_time)
|
||||
continue
|
||||
else:
|
||||
raise TokenVerificationError("Token verification timeout")
|
||||
|
||||
except httpx.NetworkError as e:
|
||||
if attempt < max_retries - 1:
|
||||
wait_time = 2 ** attempt
|
||||
current_app.logger.debug(f"Network error, retrying in {wait_time}s...")
|
||||
time.sleep(wait_time)
|
||||
continue
|
||||
else:
|
||||
raise TokenVerificationError(f"Network error: {e}")
|
||||
|
||||
except Exception as e:
|
||||
# Don't retry for unexpected errors
|
||||
raise TokenVerificationError(f"Verification failed: {e}")
|
||||
|
||||
# Should never reach here, but just in case
|
||||
raise TokenVerificationError("Maximum retries exceeded")
|
||||
|
||||
|
||||
def _validate_profile_url(url: str) -> None:
|
||||
"""
|
||||
Validate profile URL format and security requirements
|
||||
|
||||
Args:
|
||||
url: Profile URL to validate
|
||||
|
||||
Raises:
|
||||
DiscoveryError: If URL is invalid or insecure
|
||||
"""
|
||||
parsed = urlparse(url)
|
||||
|
||||
# Must be absolute
|
||||
if not parsed.scheme or not parsed.netloc:
|
||||
raise DiscoveryError(f"Invalid profile URL format: {url}")
|
||||
|
||||
# HTTPS required in production
|
||||
if not current_app.debug and parsed.scheme != 'https':
|
||||
raise DiscoveryError(
|
||||
f"HTTPS required for profile URLs in production. Got: {url}"
|
||||
)
|
||||
|
||||
# Allow localhost only in debug mode
|
||||
if not current_app.debug and parsed.hostname in ['localhost', '127.0.0.1', '::1']:
|
||||
raise DiscoveryError(
|
||||
"Localhost URLs not allowed in production"
|
||||
)
|
||||
|
||||
|
||||
def _validate_endpoint_url(url: str, rel: str) -> None:
|
||||
"""
|
||||
Validate discovered endpoint URL
|
||||
|
||||
Args:
|
||||
url: Endpoint URL to validate
|
||||
rel: Endpoint relation (for error messages)
|
||||
|
||||
Raises:
|
||||
DiscoveryError: If URL is invalid or insecure
|
||||
"""
|
||||
parsed = urlparse(url)
|
||||
|
||||
# Must be absolute
|
||||
if not parsed.scheme or not parsed.netloc:
|
||||
raise DiscoveryError(f"Invalid {rel} URL format: {url}")
|
||||
|
||||
# HTTPS required in production
|
||||
if not current_app.debug and parsed.scheme != 'https':
|
||||
raise DiscoveryError(
|
||||
f"HTTPS required for {rel} in production. Got: {url}"
|
||||
)
|
||||
|
||||
# Allow localhost only in debug mode
|
||||
if not current_app.debug and parsed.hostname in ['localhost', '127.0.0.1', '::1']:
|
||||
raise DiscoveryError(
|
||||
f"Localhost not allowed for {rel} in production"
|
||||
)
|
||||
|
||||
|
||||
def normalize_url(url: str) -> str:
|
||||
"""
|
||||
Normalize URL for comparison
|
||||
|
||||
Removes trailing slash and converts to lowercase.
|
||||
Used only for comparison, not for storage.
|
||||
|
||||
Args:
|
||||
url: URL to normalize
|
||||
|
||||
Returns:
|
||||
Normalized URL
|
||||
"""
|
||||
return url.rstrip('/').lower()
|
||||
|
||||
|
||||
def _hash_token(token: str) -> str:
|
||||
"""
|
||||
Hash token for secure caching
|
||||
|
||||
Uses SHA-256 to prevent tokens from appearing in logs
|
||||
and to create fixed-length cache keys.
|
||||
|
||||
Args:
|
||||
token: Bearer token
|
||||
|
||||
Returns:
|
||||
SHA-256 hash of token (hex)
|
||||
"""
|
||||
return hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
|
||||
def check_scope(required_scope: str, token_scope: str) -> bool:
|
||||
"""
|
||||
Check if token has required scope
|
||||
|
||||
Scopes are space-separated in token_scope string.
|
||||
Any scope in the list satisfies the requirement.
|
||||
|
||||
Args:
|
||||
required_scope: Scope needed (e.g., "create")
|
||||
token_scope: Space-separated scope string from token
|
||||
|
||||
Returns:
|
||||
True if token has required scope, False otherwise
|
||||
|
||||
Examples:
|
||||
>>> check_scope("create", "create update")
|
||||
True
|
||||
>>> check_scope("create", "read")
|
||||
False
|
||||
>>> check_scope("create", "")
|
||||
False
|
||||
"""
|
||||
if not token_scope:
|
||||
return False
|
||||
|
||||
scopes = token_scope.split()
|
||||
return required_scope in scopes
|
||||
+44
-17
@@ -35,24 +35,23 @@ def load_config(app, config_override=None):
|
||||
app.config["SESSION_SECRET"] = os.getenv("SESSION_SECRET")
|
||||
app.config["SESSION_LIFETIME"] = int(os.getenv("SESSION_LIFETIME", "30"))
|
||||
|
||||
# DEPRECATED: TOKEN_ENDPOINT no longer used (v1.0.0-rc.5+)
|
||||
# Endpoints are now discovered from ADMIN_ME profile (ADR-031)
|
||||
if 'TOKEN_ENDPOINT' in os.environ:
|
||||
app.logger.warning(
|
||||
"TOKEN_ENDPOINT is deprecated and will be ignored. "
|
||||
"Remove it from your configuration. "
|
||||
"Endpoints are now discovered automatically from your ADMIN_ME profile. "
|
||||
"See docs/migration/fix-hardcoded-endpoints.md for details."
|
||||
)
|
||||
# Admin login via OpenID Connect (v2.0.0, ADR-064)
|
||||
# ADMIN_ME stays the site owner's identity URL (h-card, Micropub "me");
|
||||
# OIDC decides who may log in as that owner.
|
||||
app.config["OIDC_ISSUER"] = os.getenv("OIDC_ISSUER", "").rstrip("/")
|
||||
app.config["OIDC_CLIENT_ID"] = os.getenv("OIDC_CLIENT_ID", "")
|
||||
app.config["OIDC_CLIENT_SECRET"] = os.getenv("OIDC_CLIENT_SECRET", "")
|
||||
app.config["OIDC_ADMIN_SUB"] = os.getenv("OIDC_ADMIN_SUB", "")
|
||||
app.config["OIDC_PROVIDER_NAME"] = os.getenv("OIDC_PROVIDER_NAME", "single sign-on")
|
||||
|
||||
# DEPRECATED: INDIELOGIN_URL no longer used (hotfix 2025-12-17)
|
||||
# Authorization endpoint is now discovered from ADMIN_ME profile per IndieAuth spec
|
||||
if 'INDIELOGIN_URL' in os.environ:
|
||||
app.logger.warning(
|
||||
"INDIELOGIN_URL is deprecated and will be ignored. "
|
||||
"Remove it from your configuration. "
|
||||
"The authorization endpoint is now discovered automatically from your ADMIN_ME profile."
|
||||
)
|
||||
# Micropub access tokens issued by StarPunk's IndieAuth server (v2.0.0)
|
||||
app.config["INDIEAUTH_TOKEN_LIFETIME_DAYS"] = int(
|
||||
os.getenv("INDIEAUTH_TOKEN_LIFETIME_DAYS", "90")
|
||||
)
|
||||
|
||||
for legacy in ("TOKEN_ENDPOINT", "INDIELOGIN_URL"):
|
||||
if legacy in os.environ:
|
||||
app.logger.warning(f"{legacy} is no longer used and will be ignored.")
|
||||
|
||||
# Validate required configuration
|
||||
if not app.config["SESSION_SECRET"]:
|
||||
@@ -125,6 +124,27 @@ def load_config(app, config_override=None):
|
||||
app.config["WEBMENTION_RATE_LIMIT_WINDOW"] = int(os.getenv("WEBMENTION_RATE_LIMIT_WINDOW", "60"))
|
||||
app.config["TRUSTED_PROXY"] = os.getenv("TRUSTED_PROXY", "false").lower() == "true"
|
||||
|
||||
# Crossposting to GoToSocial / Mastodon-API (v2.1.0, ADR-065)
|
||||
# Enabled when both URL and token are set
|
||||
app.config["GOTOSOCIAL_URL"] = os.getenv("GOTOSOCIAL_URL", "")
|
||||
app.config["GOTOSOCIAL_ACCESS_TOKEN"] = os.getenv("GOTOSOCIAL_ACCESS_TOKEN", "")
|
||||
app.config["GOTOSOCIAL_NAME"] = os.getenv("GOTOSOCIAL_NAME", "GoToSocial")
|
||||
app.config["GOTOSOCIAL_VISIBILITY"] = os.getenv("GOTOSOCIAL_VISIBILITY", "public")
|
||||
app.config["GOTOSOCIAL_MAX_CHARS"] = int(os.getenv("GOTOSOCIAL_MAX_CHARS", "5000"))
|
||||
app.config["GOTOSOCIAL_MAX_MEDIA"] = int(os.getenv("GOTOSOCIAL_MAX_MEDIA", "4"))
|
||||
app.config["BLUESKY_HANDLE"] = os.getenv("BLUESKY_HANDLE", "")
|
||||
app.config["BLUESKY_APP_PASSWORD"] = os.getenv("BLUESKY_APP_PASSWORD", "")
|
||||
app.config["BLUESKY_SERVICE"] = os.getenv("BLUESKY_SERVICE", "https://bsky.social")
|
||||
app.config["BLUESKY_NAME"] = os.getenv("BLUESKY_NAME", "Bluesky")
|
||||
app.config["BLUESKY_MAX_CHARS"] = int(os.getenv("BLUESKY_MAX_CHARS", "300"))
|
||||
# Crossposting to Threads (v2.6.0, ADR-069): long-lived token, refreshed automatically
|
||||
app.config["THREADS_ACCESS_TOKEN"] = os.getenv("THREADS_ACCESS_TOKEN", "")
|
||||
app.config["THREADS_USERNAME"] = os.getenv("THREADS_USERNAME", "")
|
||||
app.config["THREADS_NAME"] = os.getenv("THREADS_NAME", "Threads")
|
||||
app.config["THREADS_MAX_CHARS"] = int(os.getenv("THREADS_MAX_CHARS", "500"))
|
||||
app.config["THREADS_MAX_MEDIA"] = int(os.getenv("THREADS_MAX_MEDIA", "4"))
|
||||
app.config["SYNDICATION_POLL_INTERVAL"] = int(os.getenv("SYNDICATION_POLL_INTERVAL", "10"))
|
||||
|
||||
# Apply overrides if provided
|
||||
if config_override:
|
||||
app.config.update(config_override)
|
||||
@@ -246,6 +266,13 @@ def validate_config(app):
|
||||
"Set ADMIN_ME=https://your-site.com in .env"
|
||||
)
|
||||
|
||||
# Production mode: OIDC admin login must be configured
|
||||
# (tests configure OIDC per test, so skip the check there)
|
||||
if not app.config.get("TESTING"):
|
||||
for field in ("OIDC_ISSUER", "OIDC_CLIENT_ID", "OIDC_CLIENT_SECRET", "OIDC_ADMIN_SUB"):
|
||||
if not app.config.get(field):
|
||||
errors.append(f"Production mode requires {field} to be set (see .env.example)")
|
||||
|
||||
# If there are validation errors, fail fast with clear message
|
||||
if errors:
|
||||
error_msg = "\n".join([
|
||||
|
||||
@@ -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">'
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -0,0 +1,342 @@
|
||||
"""
|
||||
Built-in IndieAuth authorization server for StarPunk (v2.0.0, ADR-064)
|
||||
|
||||
Micropub clients (Quill, Indigenous, ...) obtain tokens through IndieAuth.
|
||||
StarPunk issues them itself: the site owner approves a client after logging
|
||||
in with OIDC, and StarPunk hands out an authorization code and then an
|
||||
access token. Tokens are stored hashed and checked locally by /micropub.
|
||||
|
||||
Only the authorization code flow with PKCE (S256) is supported, per the
|
||||
current IndieAuth spec: https://indieauth.spec.indieweb.org/
|
||||
"""
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import secrets
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Any, Dict, List, Optional
|
||||
from urllib.parse import urljoin, urlparse
|
||||
|
||||
import httpx
|
||||
from bs4 import BeautifulSoup
|
||||
from flask import current_app
|
||||
|
||||
from starpunk.database import get_db
|
||||
from starpunk.utils import absolute_url_for
|
||||
|
||||
CODE_LIFETIME_MINUTES = 10
|
||||
SUPPORTED_SCOPES = ["create", "update", "delete", "media", "profile"]
|
||||
|
||||
|
||||
class AuthorizationRequestError(Exception):
|
||||
"""
|
||||
Invalid authorization request
|
||||
|
||||
redirectable=False means the client_id or redirect_uri cannot be trusted,
|
||||
so the error must be shown to the user instead of sent to the client.
|
||||
"""
|
||||
|
||||
def __init__(self, error: str, description: str, redirectable: bool = True):
|
||||
super().__init__(description)
|
||||
self.error = error
|
||||
self.description = description
|
||||
self.redirectable = redirectable
|
||||
|
||||
|
||||
class InvalidGrantError(Exception):
|
||||
"""Authorization code is invalid, expired, used, or does not match"""
|
||||
|
||||
|
||||
def _hash(value: str) -> str:
|
||||
return hashlib.sha256(value.encode()).hexdigest()
|
||||
|
||||
|
||||
def issuer() -> str:
|
||||
"""Issuer identifier (RFC 9207): the site URL with trailing slash"""
|
||||
return current_app.config["SITE_URL"].rstrip("/") + "/"
|
||||
|
||||
|
||||
def admin_me() -> str:
|
||||
"""The single identity StarPunk issues tokens for"""
|
||||
return current_app.config["ADMIN_ME"]
|
||||
|
||||
|
||||
def check_scope(required_scope: str, token_scope: str) -> bool:
|
||||
"""True if required_scope is one of the space-separated token scopes"""
|
||||
return bool(token_scope) and required_scope in token_scope.split()
|
||||
|
||||
|
||||
def _is_http_url(url: str) -> bool:
|
||||
parsed = urlparse(url or "")
|
||||
return parsed.scheme in ("http", "https") and bool(parsed.netloc) and not parsed.fragment
|
||||
|
||||
|
||||
def _same_origin(a: str, b: str) -> bool:
|
||||
pa, pb = urlparse(a), urlparse(b)
|
||||
return (pa.scheme, pa.hostname, pa.port) == (pb.scheme, pb.hostname, pb.port)
|
||||
|
||||
|
||||
def fetch_client_redirect_uris(client_id: str) -> List[str]:
|
||||
"""
|
||||
Fetch the redirect URIs a client publishes at its client_id URL
|
||||
|
||||
Supports a JSON client metadata document ("redirect_uris") and the older
|
||||
HTML/Link header form (rel="redirect_uri"). Returns [] on any failure.
|
||||
"""
|
||||
from starpunk.webmention_ssrf import SSRFBlockedError, validate_url_for_fetch
|
||||
|
||||
try:
|
||||
if not current_app.config.get("DEV_MODE"):
|
||||
validate_url_for_fetch(client_id)
|
||||
response = httpx.get(
|
||||
client_id,
|
||||
timeout=5.0,
|
||||
follow_redirects=True,
|
||||
headers={"Accept": "application/json, text/html;q=0.9"},
|
||||
)
|
||||
except (httpx.HTTPError, SSRFBlockedError, ValueError) as e:
|
||||
current_app.logger.info(f"IndieAuth: could not fetch client {client_id}: {e}")
|
||||
return []
|
||||
|
||||
if response.status_code != 200:
|
||||
return []
|
||||
|
||||
base = str(response.url)
|
||||
uris: List[str] = []
|
||||
|
||||
if "json" in response.headers.get("Content-Type", ""):
|
||||
try:
|
||||
data = response.json()
|
||||
except ValueError:
|
||||
return []
|
||||
if isinstance(data, dict) and isinstance(data.get("redirect_uris"), list):
|
||||
uris.extend(u for u in data["redirect_uris"] if isinstance(u, str))
|
||||
return uris
|
||||
|
||||
link = response.links.get("redirect_uri")
|
||||
if link and link.get("url"):
|
||||
uris.append(urljoin(base, link["url"]))
|
||||
|
||||
soup = BeautifulSoup(response.text[:500_000], "html.parser")
|
||||
for tag in soup.find_all(["link", "a"], href=True):
|
||||
if "redirect_uri" in (tag.get("rel") or []):
|
||||
uris.append(urljoin(base, tag["href"]))
|
||||
return uris
|
||||
|
||||
|
||||
def validate_authorization_request(params: Dict[str, str]) -> Dict[str, Any]:
|
||||
"""
|
||||
Validate an IndieAuth authorization request
|
||||
|
||||
Args:
|
||||
params: Query (or form) parameters from the client
|
||||
|
||||
Returns:
|
||||
Normalized request: client_id, redirect_uri, state, scopes,
|
||||
code_challenge
|
||||
|
||||
Raises:
|
||||
AuthorizationRequestError
|
||||
"""
|
||||
client_id = (params.get("client_id") or "").strip()
|
||||
redirect_uri = (params.get("redirect_uri") or "").strip()
|
||||
|
||||
# client_id / redirect_uri problems are never redirected to the client
|
||||
if not _is_http_url(client_id):
|
||||
raise AuthorizationRequestError(
|
||||
"invalid_request", "client_id must be an http(s) URL", redirectable=False
|
||||
)
|
||||
if not redirect_uri or urlparse(redirect_uri).fragment:
|
||||
raise AuthorizationRequestError(
|
||||
"invalid_request", "redirect_uri is missing or invalid", redirectable=False
|
||||
)
|
||||
if not _same_origin(client_id, redirect_uri):
|
||||
if redirect_uri not in fetch_client_redirect_uris(client_id):
|
||||
raise AuthorizationRequestError(
|
||||
"invalid_request",
|
||||
"redirect_uri is not registered by this client",
|
||||
redirectable=False,
|
||||
)
|
||||
|
||||
if params.get("response_type", "code") != "code":
|
||||
raise AuthorizationRequestError(
|
||||
"unsupported_response_type", "Only response_type=code is supported"
|
||||
)
|
||||
if not params.get("state"):
|
||||
raise AuthorizationRequestError("invalid_request", "state is required")
|
||||
|
||||
code_challenge = params.get("code_challenge") or ""
|
||||
if not code_challenge:
|
||||
raise AuthorizationRequestError("invalid_request", "PKCE code_challenge is required")
|
||||
if params.get("code_challenge_method", "S256") != "S256":
|
||||
raise AuthorizationRequestError(
|
||||
"invalid_request", "Only code_challenge_method=S256 is supported"
|
||||
)
|
||||
|
||||
scopes = [s for s in (params.get("scope") or "").split() if s]
|
||||
|
||||
return {
|
||||
"client_id": client_id,
|
||||
"redirect_uri": redirect_uri,
|
||||
"state": params["state"],
|
||||
"scopes": scopes,
|
||||
"code_challenge": code_challenge,
|
||||
}
|
||||
|
||||
|
||||
def create_authorization_code(
|
||||
client_id: str, redirect_uri: str, scope: str, code_challenge: str
|
||||
) -> str:
|
||||
"""Issue a single-use authorization code (stored hashed)"""
|
||||
code = secrets.token_urlsafe(32)
|
||||
db = get_db(current_app)
|
||||
db.execute("DELETE FROM indieauth_codes WHERE expires_at <= datetime('now')")
|
||||
db.execute(
|
||||
"""
|
||||
INSERT INTO indieauth_codes
|
||||
(code_hash, client_id, redirect_uri, scope, code_challenge, expires_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?)
|
||||
""",
|
||||
(
|
||||
_hash(code),
|
||||
client_id,
|
||||
redirect_uri,
|
||||
scope,
|
||||
code_challenge,
|
||||
datetime.utcnow() + timedelta(minutes=CODE_LIFETIME_MINUTES),
|
||||
),
|
||||
)
|
||||
db.commit()
|
||||
return code
|
||||
|
||||
|
||||
def redeem_authorization_code(
|
||||
code: str, client_id: str, redirect_uri: str, code_verifier: str
|
||||
) -> Dict[str, Any]:
|
||||
"""
|
||||
Redeem an authorization code exactly once
|
||||
|
||||
Returns:
|
||||
{"me": ..., "scope": ..., "client_id": ...}
|
||||
|
||||
Raises:
|
||||
InvalidGrantError
|
||||
"""
|
||||
if not code or not code_verifier:
|
||||
raise InvalidGrantError("code and code_verifier are required")
|
||||
|
||||
db = get_db(current_app)
|
||||
# Atomic single use: only the first redemption flips used_at
|
||||
cursor = db.execute(
|
||||
"""
|
||||
UPDATE indieauth_codes SET used_at = datetime('now')
|
||||
WHERE code_hash = ? AND used_at IS NULL AND expires_at > datetime('now')
|
||||
""",
|
||||
(_hash(code),),
|
||||
)
|
||||
db.commit()
|
||||
if cursor.rowcount != 1:
|
||||
raise InvalidGrantError("Authorization code is invalid, expired or already used")
|
||||
|
||||
row = db.execute(
|
||||
"SELECT client_id, redirect_uri, scope, code_challenge FROM indieauth_codes WHERE code_hash = ?",
|
||||
(_hash(code),),
|
||||
).fetchone()
|
||||
|
||||
if row["client_id"] != client_id or row["redirect_uri"] != redirect_uri:
|
||||
raise InvalidGrantError("client_id or redirect_uri does not match the code")
|
||||
|
||||
digest = hashlib.sha256(code_verifier.encode("ascii", "ignore")).digest()
|
||||
challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
|
||||
if not secrets.compare_digest(challenge, row["code_challenge"]):
|
||||
raise InvalidGrantError("PKCE verification failed")
|
||||
|
||||
return {"me": admin_me(), "scope": row["scope"], "client_id": row["client_id"]}
|
||||
|
||||
|
||||
def create_access_token(client_id: str, scope: str) -> Dict[str, Any]:
|
||||
"""Issue an access token (stored hashed); returns the token response"""
|
||||
token = secrets.token_urlsafe(32)
|
||||
lifetime_days = current_app.config.get("INDIEAUTH_TOKEN_LIFETIME_DAYS", 90)
|
||||
expires_at = datetime.utcnow() + timedelta(days=lifetime_days)
|
||||
|
||||
db = get_db(current_app)
|
||||
db.execute(
|
||||
"""
|
||||
INSERT INTO indieauth_tokens (token_hash, client_id, scope, expires_at)
|
||||
VALUES (?, ?, ?, ?)
|
||||
""",
|
||||
(_hash(token), client_id, scope, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
current_app.logger.info(f"IndieAuth: token issued to {client_id} (scope: {scope})")
|
||||
return {
|
||||
"access_token": token,
|
||||
"token_type": "Bearer",
|
||||
"scope": scope,
|
||||
"me": admin_me(),
|
||||
"expires_in": lifetime_days * 86400,
|
||||
}
|
||||
|
||||
|
||||
def verify_access_token(token: str) -> Optional[Dict[str, Any]]:
|
||||
"""
|
||||
Check a bearer token issued by StarPunk
|
||||
|
||||
Returns:
|
||||
{"me", "client_id", "scope"} if active, otherwise None
|
||||
"""
|
||||
if not token:
|
||||
return None
|
||||
db = get_db(current_app)
|
||||
row = db.execute(
|
||||
"""
|
||||
SELECT id, client_id, scope FROM indieauth_tokens
|
||||
WHERE token_hash = ? AND revoked_at IS NULL AND expires_at > datetime('now')
|
||||
""",
|
||||
(_hash(token),),
|
||||
).fetchone()
|
||||
if not row:
|
||||
return None
|
||||
|
||||
db.execute(
|
||||
"UPDATE indieauth_tokens SET last_used_at = datetime('now') WHERE id = ?",
|
||||
(row["id"],),
|
||||
)
|
||||
db.commit()
|
||||
return {"me": admin_me(), "client_id": row["client_id"], "scope": row["scope"]}
|
||||
|
||||
|
||||
def revoke_access_token(token: str) -> None:
|
||||
"""Revoke a token by value (unknown tokens are ignored, per RFC 7009)"""
|
||||
db = get_db(current_app)
|
||||
db.execute(
|
||||
"UPDATE indieauth_tokens SET revoked_at = datetime('now') WHERE token_hash = ? AND revoked_at IS NULL",
|
||||
(_hash(token or ""),),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
|
||||
def revoke_token_by_id(token_id: int) -> None:
|
||||
"""Revoke a token from the admin UI"""
|
||||
db = get_db(current_app)
|
||||
db.execute(
|
||||
"UPDATE indieauth_tokens SET revoked_at = datetime('now') WHERE id = ? AND revoked_at IS NULL",
|
||||
(token_id,),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
|
||||
def list_active_tokens() -> List[Dict[str, Any]]:
|
||||
"""Tokens that can still be used, newest first"""
|
||||
db = get_db(current_app)
|
||||
rows = db.execute(
|
||||
"""
|
||||
SELECT id, client_id, scope, created_at, expires_at, last_used_at
|
||||
FROM indieauth_tokens
|
||||
WHERE revoked_at IS NULL AND expires_at > datetime('now')
|
||||
ORDER BY created_at DESC
|
||||
"""
|
||||
).fetchall()
|
||||
return [dict(r) for r in rows]
|
||||
@@ -0,0 +1,42 @@
|
||||
"""
|
||||
Markdown extension: turn bare URLs into links (v2.3.0)
|
||||
|
||||
Python-Markdown only links <https://...>; notes often contain pasted URLs.
|
||||
"""
|
||||
|
||||
import re
|
||||
import xml.etree.ElementTree as etree
|
||||
|
||||
from markdown.extensions import Extension
|
||||
from markdown.inlinepatterns import InlineProcessor
|
||||
from markdown.treeprocessors import Treeprocessor
|
||||
from markdown.util import AtomicString
|
||||
|
||||
# Stop at whitespace and brackets; trailing punctuation is not part of the URL
|
||||
BARE_URL_RE = r"(?<![\w/\"'=])https?://[^\s<>()\[\]\"']*[^\s<>()\[\]\"'.,;:!?…]"
|
||||
|
||||
|
||||
class _BareUrl(InlineProcessor):
|
||||
def handleMatch(self, m, data):
|
||||
url = m.group(0)
|
||||
el = etree.Element("a")
|
||||
el.set("href", url)
|
||||
el.text = AtomicString(url)
|
||||
return el, m.start(0), m.end(0)
|
||||
|
||||
|
||||
class _UnnestLinks(Treeprocessor):
|
||||
"""[https://x](https://x) would put a link inside a link; keep the outer one"""
|
||||
|
||||
def run(self, root):
|
||||
for outer in root.iter("a"):
|
||||
for inner in list(outer.iter("a"))[1:]:
|
||||
inner.tag = "span"
|
||||
inner.attrib.clear()
|
||||
|
||||
|
||||
class BareUrlExtension(Extension):
|
||||
def extendMarkdown(self, md):
|
||||
# Below links (160) and <autolinks> (120), so those win
|
||||
md.inlinePatterns.register(_BareUrl(BARE_URL_RE, md), "bare_url", 105)
|
||||
md.treeprocessors.register(_UnnestLinks(md), "unnest_links", 0)
|
||||
+483
-189
@@ -7,9 +7,11 @@ interface for creating posts via external clients.
|
||||
Functions:
|
||||
normalize_properties: Convert form/JSON data to Micropub properties format
|
||||
extract_content: Get content from Micropub properties
|
||||
extract_title: Get or generate title from Micropub properties
|
||||
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
|
||||
|
||||
@@ -28,8 +30,13 @@ from typing import Optional
|
||||
|
||||
from flask import Request, current_app, jsonify
|
||||
|
||||
from starpunk.notes import create_note, get_note, InvalidNoteDataError, NoteNotFoundError
|
||||
from starpunk.auth_external import check_scope
|
||||
from starpunk.models import split_title
|
||||
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
|
||||
|
||||
|
||||
# Custom Exceptions
|
||||
@@ -135,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
|
||||
@@ -188,38 +197,31 @@ def extract_content(properties: dict) -> str:
|
||||
|
||||
def extract_title(properties: dict) -> Optional[str]:
|
||||
"""
|
||||
Extract or generate title from Micropub properties
|
||||
Extract the explicit title (Micropub 'name' property)
|
||||
|
||||
Per ADR-029 mapping rules:
|
||||
1. Use 'name' property if provided
|
||||
2. If no name, extract from content (first line, max 50 chars)
|
||||
StarPunk has no title field: a note's title is a '# Heading' first line
|
||||
(see Note.title), so the caller stores the name as that heading.
|
||||
|
||||
Args:
|
||||
properties: Normalized Micropub properties dict
|
||||
|
||||
Returns:
|
||||
Title string or None
|
||||
Title on a single line, or None if no name was sent
|
||||
"""
|
||||
# Try explicit name property first
|
||||
name = properties.get("name", [""])[0]
|
||||
if name:
|
||||
return name.strip()
|
||||
name = (properties.get("name") or [""])[0]
|
||||
if not isinstance(name, str):
|
||||
return None
|
||||
return " ".join(name.split()) or None
|
||||
|
||||
# Generate from content (first line, max 50 chars)
|
||||
content_list = properties.get("content", [])
|
||||
if content_list:
|
||||
content = content_list[0]
|
||||
# Handle structured content
|
||||
if isinstance(content, dict):
|
||||
content = content.get("text") or content.get("html", "")
|
||||
|
||||
if content:
|
||||
first_line = content.split("\n")[0].strip()
|
||||
if len(first_line) > 50:
|
||||
return first_line[:50] + "..."
|
||||
return first_line
|
||||
|
||||
return None
|
||||
def add_title_heading(content: str, title: Optional[str]) -> str:
|
||||
"""Prefix content with '# title' unless it already starts with that heading"""
|
||||
if not title:
|
||||
return content
|
||||
first_line = content.lstrip().split("\n", 1)[0]
|
||||
if first_line.startswith("#") and first_line.lstrip("#").strip() == title:
|
||||
return content
|
||||
return f"# {title}\n\n{content}"
|
||||
|
||||
|
||||
def extract_tags(properties: dict) -> list[str]:
|
||||
@@ -263,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]]:
|
||||
"""
|
||||
@@ -270,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
|
||||
|
||||
@@ -374,154 +492,330 @@ 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
|
||||
|
||||
# Normalize and extract properties
|
||||
# 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[]"):
|
||||
if key in data:
|
||||
value = data[key]
|
||||
requested_targets = (requested_targets or []) + (
|
||||
value if isinstance(value, list) else [value]
|
||||
)
|
||||
|
||||
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=content,
|
||||
published=True, # Micropub posts are published by default
|
||||
content=add_title_heading(content, title),
|
||||
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)
|
||||
|
||||
# Build permalink URL
|
||||
# Note: SITE_URL is normalized to include trailing slash (for IndieAuth spec compliance)
|
||||
site_url = current_app.config.get("SITE_URL", "http://localhost:5000")
|
||||
permalink = f"{site_url}notes/{note.slug}"
|
||||
# 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))
|
||||
|
||||
# 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_query(args: dict, token_info: dict):
|
||||
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:
|
||||
"""Configured crosspost targets in Micropub syndicate-to form"""
|
||||
from starpunk.syndication import get_targets
|
||||
|
||||
return [{"uid": t.uid, "name": t.name} for t in get_targets().values()]
|
||||
|
||||
|
||||
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 (empty for V1)
|
||||
- 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": [], # No syndication targets in V1
|
||||
"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/notes/{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")
|
||||
if q == "syndicate-to":
|
||||
return jsonify({"syndicate-to": _syndicate_to()}), 200
|
||||
|
||||
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")
|
||||
if q == "category":
|
||||
return jsonify({"categories": _all_categories(args.get("filter") or "")}), 200
|
||||
|
||||
# Convert note to Micropub Microformats2 format
|
||||
# Note: SITE_URL is normalized to include trailing slash (for IndieAuth spec compliance)
|
||||
site_url = current_app.config.get("SITE_URL", "http://localhost:5000")
|
||||
mf2 = {
|
||||
"type": ["h-entry"],
|
||||
"properties": {
|
||||
"content": [note.content],
|
||||
"published": [note.created_at.isoformat()],
|
||||
"url": [f"{site_url}notes/{note.slug}"],
|
||||
},
|
||||
}
|
||||
|
||||
# Add optional properties
|
||||
if note.title:
|
||||
mf2["properties"]["name"] = [note.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":
|
||||
# Return syndication targets (none for V1)
|
||||
return jsonify({"syndicate-to": []}), 200
|
||||
|
||||
else:
|
||||
return error_response("invalid_request", f"Unknown query: {q}")
|
||||
return error_response("invalid_request", f"Unknown query: {q}")
|
||||
+71
-4
@@ -34,13 +34,32 @@ DEFAULT_AUTH_STATE_EXPIRY_MINUTES = 5
|
||||
DEFAULT_TOKEN_EXPIRY_DAYS = 90
|
||||
|
||||
# Constants - Markdown rendering
|
||||
MARKDOWN_EXTENSIONS = ["extra", "codehilite", "nl2br"]
|
||||
from starpunk.markdown_ext import BareUrlExtension
|
||||
|
||||
MARKDOWN_EXTENSIONS = ["extra", "codehilite", "nl2br", BareUrlExtension()]
|
||||
|
||||
# Constants - Content limits
|
||||
MAX_TITLE_LENGTH = 200
|
||||
EXCERPT_LENGTH = 200
|
||||
|
||||
|
||||
def split_title(content: str) -> tuple[Optional[str], str]:
|
||||
"""
|
||||
Split a note's '# Heading' first line (its title, per Q22) off its content
|
||||
|
||||
Returns:
|
||||
(title, remaining content); title is None if the note has no heading
|
||||
"""
|
||||
stripped = content.lstrip()
|
||||
if not stripped.startswith("#"):
|
||||
return None, content
|
||||
first_line, _, rest = stripped.partition("\n")
|
||||
title = first_line.lstrip("#").strip()
|
||||
if not title:
|
||||
return None, content
|
||||
return title, rest.strip()
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Note:
|
||||
"""
|
||||
@@ -115,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
|
||||
)
|
||||
@@ -173,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
|
||||
@@ -242,6 +265,19 @@ class Note:
|
||||
|
||||
return self._cached_html
|
||||
|
||||
@property
|
||||
def body_html(self) -> str:
|
||||
"""
|
||||
Rendered HTML without the title heading
|
||||
|
||||
Pages show a titled note's title as their own heading, so the body
|
||||
leaves it out to avoid showing it twice. Untitled notes: same as html.
|
||||
"""
|
||||
title, body = split_title(self.content)
|
||||
if title is None:
|
||||
return self.html
|
||||
return markdown.markdown(body, extensions=MARKDOWN_EXTENSIONS)
|
||||
|
||||
@property
|
||||
def title(self) -> str:
|
||||
"""
|
||||
@@ -309,10 +345,10 @@ class Note:
|
||||
'This is my note content. It has some interesting points...'
|
||||
"""
|
||||
try:
|
||||
# Get content
|
||||
content = self.content
|
||||
# Leave out the title; previews show it separately
|
||||
_, content = split_title(self.content)
|
||||
|
||||
# Remove markdown heading syntax from first line
|
||||
# Remove markdown heading syntax
|
||||
lines = content.split("\n")
|
||||
cleaned_lines = []
|
||||
for line in lines:
|
||||
@@ -335,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:
|
||||
"""
|
||||
|
||||
+101
-20
@@ -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"])
|
||||
@@ -851,6 +869,13 @@ def update_note(
|
||||
# Reply context fetch failure should not prevent note update
|
||||
current_app.logger.warning(f"Failed to fetch reply context for {in_reply_to}: {e}")
|
||||
|
||||
# Crossposts follow the note (v2.1.0, best-effort)
|
||||
try:
|
||||
from starpunk.syndication import note_changed
|
||||
note_changed(updated_note.id)
|
||||
except Exception as e:
|
||||
current_app.logger.warning(f"Failed to queue syndication update: {e}")
|
||||
|
||||
# 10. RETURN UPDATED NOTE
|
||||
return updated_note
|
||||
|
||||
@@ -1018,5 +1043,61 @@ def delete_note(
|
||||
)
|
||||
# Don't fail - database record already deleted
|
||||
|
||||
# Delete crossposts too (v2.1.0, best-effort)
|
||||
try:
|
||||
from starpunk.syndication import note_changed
|
||||
note_changed(existing_note.id)
|
||||
except Exception as e:
|
||||
current_app.logger.warning(f"Failed to queue syndication delete: {e}")
|
||||
|
||||
# 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)
|
||||
@@ -7,7 +7,7 @@ admin, auth, and (conditionally) dev auth routes.
|
||||
|
||||
from flask import Flask
|
||||
|
||||
from starpunk.routes import admin, auth, micropub, public, search, webmention
|
||||
from starpunk.routes import admin, auth, indieauth, micropub, public, search, webmention
|
||||
|
||||
|
||||
def register_routes(app: Flask) -> None:
|
||||
@@ -29,6 +29,7 @@ def register_routes(app: Flask) -> None:
|
||||
|
||||
# Register auth routes
|
||||
app.register_blueprint(auth.bp)
|
||||
app.register_blueprint(indieauth.bp)
|
||||
|
||||
# Register Micropub routes
|
||||
app.register_blueprint(micropub.bp)
|
||||
|
||||
@@ -97,7 +97,9 @@ def new_note_form():
|
||||
Decorator: @require_auth
|
||||
Template: templates/admin/new.html
|
||||
"""
|
||||
return render_template("admin/new.html")
|
||||
from starpunk.syndication import get_targets
|
||||
|
||||
return render_template("admin/new.html", syndication_targets=get_targets().values())
|
||||
|
||||
|
||||
@bp.route("/new", methods=["POST"])
|
||||
@@ -182,6 +184,11 @@ def create_note_submit():
|
||||
if errors:
|
||||
flash(f"Note created, but some images failed: {'; '.join(errors)}", "warning")
|
||||
|
||||
# Crosspost after media is attached so images go out too (v2.1.0)
|
||||
if "syndication_form" in request.form:
|
||||
from starpunk.syndication import select_targets
|
||||
select_targets(note.id, request.form.getlist("syndicate_to"))
|
||||
|
||||
flash(f"Note created: {note.slug}", "success")
|
||||
return redirect(url_for("admin.dashboard"))
|
||||
|
||||
@@ -223,7 +230,17 @@ def edit_note_form(note_id: int):
|
||||
tags = get_note_tags(note.id)
|
||||
object.__setattr__(note, '_cached_tags', tags)
|
||||
|
||||
return render_template("admin/edit.html", note=note)
|
||||
from starpunk.syndication import get_note_syndications, get_targets
|
||||
|
||||
syndications = get_note_syndications(note.id)
|
||||
enabled = {s["target"] for s in syndications if s["enabled"]}
|
||||
return render_template(
|
||||
"admin/edit.html",
|
||||
note=note,
|
||||
syndication_targets=get_targets().values(),
|
||||
syndications=syndications,
|
||||
syndication_enabled=enabled,
|
||||
)
|
||||
|
||||
|
||||
@bp.route("/edit/<int:note_id>", methods=["POST"])
|
||||
@@ -260,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))
|
||||
|
||||
@@ -274,6 +291,9 @@ def update_note_submit(note_id: int):
|
||||
published=published,
|
||||
tags=tags if tags else None
|
||||
)
|
||||
if "syndication_form" in request.form:
|
||||
from starpunk.syndication import select_targets
|
||||
select_targets(note.id, request.form.getlist("syndicate_to"))
|
||||
flash(f"Note updated: {note.slug}", "success")
|
||||
return redirect(url_for("admin.dashboard"))
|
||||
except ValueError as e:
|
||||
@@ -816,3 +836,36 @@ def webmention_bulk_action():
|
||||
logger.error(f"Error performing bulk action: {e}")
|
||||
flash(f"Error: {e}", "error")
|
||||
return redirect(url_for("admin.webmentions"))
|
||||
|
||||
|
||||
# Connected Micropub apps (v2.0.0)
|
||||
|
||||
@bp.route("/tokens")
|
||||
@require_auth
|
||||
def tokens():
|
||||
"""List active IndieAuth tokens. Template: templates/admin/tokens.html"""
|
||||
from starpunk.indieauth import list_active_tokens
|
||||
|
||||
return render_template("admin/tokens.html", tokens=list_active_tokens(), user_me=g.me)
|
||||
|
||||
|
||||
@bp.route("/tokens/<int:token_id>/revoke", methods=["POST"])
|
||||
@require_auth
|
||||
def revoke_token(token_id):
|
||||
"""Revoke one IndieAuth token"""
|
||||
from starpunk.indieauth import revoke_token_by_id
|
||||
|
||||
revoke_token_by_id(token_id)
|
||||
flash("App access revoked", "success")
|
||||
return redirect(url_for("admin.tokens"))
|
||||
|
||||
|
||||
@bp.route("/syndication/<int:syndication_id>/retry", methods=["POST"])
|
||||
@require_auth
|
||||
def retry_syndication(syndication_id):
|
||||
"""Retry a crosspost now"""
|
||||
from starpunk.syndication import retry
|
||||
|
||||
retry(syndication_id)
|
||||
flash("Crosspost queued", "success")
|
||||
return redirect(request.referrer or url_for("admin.dashboard"))
|
||||
+49
-112
@@ -1,15 +1,14 @@
|
||||
"""
|
||||
Authentication routes for StarPunk
|
||||
|
||||
Handles IndieLogin authentication flow including login form, OAuth callback,
|
||||
logout functionality, and IndieAuth endpoints for Micropub clients.
|
||||
Admin login form, OIDC start/callback, and logout.
|
||||
The IndieAuth server endpoints for Micropub clients live in routes/indieauth.py.
|
||||
"""
|
||||
|
||||
from flask import (
|
||||
Blueprint,
|
||||
current_app,
|
||||
flash,
|
||||
jsonify,
|
||||
redirect,
|
||||
render_template,
|
||||
request,
|
||||
@@ -18,8 +17,9 @@ from flask import (
|
||||
)
|
||||
|
||||
from starpunk.auth import (
|
||||
IndieLoginError,
|
||||
AuthError,
|
||||
InvalidStateError,
|
||||
OIDCError,
|
||||
UnauthorizedError,
|
||||
destroy_session,
|
||||
handle_callback,
|
||||
@@ -27,167 +27,104 @@ from starpunk.auth import (
|
||||
require_auth,
|
||||
verify_session,
|
||||
)
|
||||
from starpunk.auth_external import DiscoveryError
|
||||
|
||||
# Create blueprint
|
||||
bp = Blueprint("auth", __name__, url_prefix="/auth")
|
||||
|
||||
SESSION_COOKIE = "starpunk_session"
|
||||
|
||||
|
||||
@bp.route("/login", methods=["GET"])
|
||||
def login_form():
|
||||
"""
|
||||
Display login form
|
||||
|
||||
If user is already authenticated, redirects to admin dashboard.
|
||||
Otherwise shows login form for IndieLogin authentication.
|
||||
|
||||
Returns:
|
||||
Redirect to dashboard if authenticated, otherwise login template
|
||||
Show the login page, or go to the dashboard if already logged in
|
||||
|
||||
Template: templates/admin/login.html
|
||||
"""
|
||||
# Check if already logged in
|
||||
session_token = request.cookies.get("starpunk_session")
|
||||
session_token = request.cookies.get(SESSION_COOKIE)
|
||||
if session_token and verify_session(session_token):
|
||||
return redirect(url_for("admin.dashboard"))
|
||||
return redirect(session.pop("next", None) or url_for("admin.dashboard"))
|
||||
|
||||
return render_template("admin/login.html")
|
||||
|
||||
|
||||
@bp.route("/login", methods=["POST"])
|
||||
def login_initiate():
|
||||
"""
|
||||
Initiate IndieLogin authentication flow
|
||||
|
||||
Validates the submitted 'me' URL and redirects to IndieLogin.com
|
||||
for authentication.
|
||||
|
||||
Form data:
|
||||
me: User's personal website URL
|
||||
|
||||
Returns:
|
||||
Redirect to IndieLogin.com or back to login form on error
|
||||
|
||||
Raises:
|
||||
Flashes error message and redirects on validation failure
|
||||
"""
|
||||
me_url = request.form.get("me", "").strip()
|
||||
|
||||
if not me_url:
|
||||
flash("Please enter your website URL", "error")
|
||||
return redirect(url_for("auth.login_form"))
|
||||
|
||||
"""Start OIDC login and redirect to the identity provider"""
|
||||
try:
|
||||
# Initiate IndieAuth flow
|
||||
auth_url = initiate_login(me_url)
|
||||
return redirect(auth_url)
|
||||
except ValueError as e:
|
||||
flash(str(e), "error")
|
||||
return redirect(url_for("auth.login_form"))
|
||||
except DiscoveryError as e:
|
||||
current_app.logger.error(f"Endpoint discovery failed for {me_url}: {e}")
|
||||
flash("Unable to verify your profile URL. Please check that it's correct and try again.", "error")
|
||||
return redirect(initiate_login(session.pop("next", None)))
|
||||
except OIDCError as e:
|
||||
current_app.logger.error(f"OIDC login could not start: {e}")
|
||||
flash("The identity provider is unavailable. Please try again later.", "error")
|
||||
return redirect(url_for("auth.login_form"))
|
||||
|
||||
|
||||
@bp.route("/callback")
|
||||
def callback():
|
||||
"""
|
||||
Handle IndieLogin callback
|
||||
|
||||
Processes the OAuth callback from IndieLogin.com, validates the
|
||||
authorization code, state token, and issuer, then creates an
|
||||
authenticated session using PKCE verification.
|
||||
Handle the identity provider's redirect
|
||||
|
||||
Query parameters:
|
||||
code: Authorization code from IndieLogin
|
||||
state: CSRF state token
|
||||
iss: Issuer identifier (should be https://indielogin.com/)
|
||||
|
||||
Returns:
|
||||
Redirect to admin dashboard on success, login form on failure
|
||||
code, state: Authorization response
|
||||
iss: Issuer identifier (RFC 9207)
|
||||
error, error_description: Provider-reported failure
|
||||
|
||||
Sets:
|
||||
session cookie (HttpOnly, Secure, SameSite=Lax, 30 day expiry)
|
||||
session cookie (HttpOnly, Secure, SameSite=Lax)
|
||||
"""
|
||||
if request.args.get("error"):
|
||||
current_app.logger.warning(
|
||||
f"OIDC provider returned error: {request.args.get('error')} "
|
||||
f"{request.args.get('error_description', '')}"
|
||||
)
|
||||
flash("Login was cancelled or refused by the identity provider", "error")
|
||||
return redirect(url_for("auth.login_form"))
|
||||
|
||||
code = request.args.get("code")
|
||||
state = request.args.get("state")
|
||||
iss = request.args.get("iss") # Extract issuer parameter
|
||||
|
||||
if not code or not state:
|
||||
flash("Missing authentication parameters", "error")
|
||||
return redirect(url_for("auth.login_form"))
|
||||
|
||||
try:
|
||||
# Handle callback and create session with PKCE verification
|
||||
session_token = handle_callback(code, state, iss) # Pass issuer
|
||||
|
||||
# Create response with redirect
|
||||
response = redirect(url_for("admin.dashboard"))
|
||||
|
||||
# Set secure session cookie
|
||||
secure = current_app.config.get("SITE_URL", "").startswith("https://")
|
||||
response.set_cookie(
|
||||
"starpunk_session",
|
||||
session_token,
|
||||
httponly=True,
|
||||
secure=secure,
|
||||
samesite="Lax",
|
||||
max_age=30 * 24 * 60 * 60, # 30 days
|
||||
)
|
||||
|
||||
flash("Login successful!", "success")
|
||||
return response
|
||||
|
||||
except InvalidStateError as e:
|
||||
current_app.logger.error(f"Invalid state error: {e}")
|
||||
flash("Authentication failed: Invalid state token (possible CSRF)", "error")
|
||||
session_token, next_url = handle_callback(code, state, request.args.get("iss"))
|
||||
except InvalidStateError:
|
||||
flash("Login expired or was already used. Please try again.", "error")
|
||||
return redirect(url_for("auth.login_form"))
|
||||
|
||||
except UnauthorizedError as e:
|
||||
current_app.logger.error(f"Unauthorized: {e}")
|
||||
except UnauthorizedError:
|
||||
flash("Authentication failed: Not authorized as admin", "error")
|
||||
return redirect(url_for("auth.login_form"))
|
||||
|
||||
except IndieLoginError as e:
|
||||
current_app.logger.error(f"IndieLogin error: {e}")
|
||||
flash(f"Authentication failed: {e}", "error")
|
||||
except AuthError as e:
|
||||
current_app.logger.error(f"OIDC login failed: {e}")
|
||||
flash("Authentication failed. Please try again.", "error")
|
||||
return redirect(url_for("auth.login_form"))
|
||||
|
||||
except Exception as e:
|
||||
current_app.logger.error(f"Unexpected auth error: {e}")
|
||||
flash("Authentication failed: An unexpected error occurred", "error")
|
||||
return redirect(url_for("auth.login_form"))
|
||||
response = redirect(next_url or url_for("admin.dashboard"))
|
||||
response.set_cookie(
|
||||
SESSION_COOKIE,
|
||||
session_token,
|
||||
httponly=True,
|
||||
secure=current_app.config.get("SITE_URL", "").startswith("https://"),
|
||||
samesite="Lax",
|
||||
max_age=current_app.config.get("SESSION_LIFETIME", 30) * 24 * 60 * 60,
|
||||
)
|
||||
if not next_url:
|
||||
flash("Login successful!", "success")
|
||||
return response
|
||||
|
||||
|
||||
@bp.route("/logout", methods=["POST"])
|
||||
@require_auth
|
||||
def logout():
|
||||
"""
|
||||
Logout and destroy session
|
||||
|
||||
Destroys the user's session and clears the session cookie.
|
||||
Requires authentication (user must be logged in to logout).
|
||||
|
||||
Returns:
|
||||
Redirect to homepage with session cookie cleared
|
||||
|
||||
Decorator: @require_auth
|
||||
"""
|
||||
session_token = request.cookies.get("starpunk_session")
|
||||
|
||||
# Destroy session in database
|
||||
"""Destroy the session and clear the cookie"""
|
||||
session_token = request.cookies.get(SESSION_COOKIE)
|
||||
if session_token:
|
||||
try:
|
||||
destroy_session(session_token)
|
||||
except Exception as e:
|
||||
current_app.logger.error(f"Error destroying session: {e}")
|
||||
|
||||
# Clear cookie and redirect
|
||||
response = redirect(url_for("public.index"))
|
||||
response.delete_cookie("starpunk_session")
|
||||
|
||||
response.delete_cookie(SESSION_COOKIE)
|
||||
flash("Logged out successfully", "success")
|
||||
return response
|
||||
|
||||
|
||||
@@ -0,0 +1,228 @@
|
||||
"""
|
||||
IndieAuth server routes for StarPunk (v2.0.0, ADR-064)
|
||||
|
||||
Endpoints:
|
||||
GET /.well-known/oauth-authorization-server Server metadata
|
||||
GET /auth/authorize Consent screen (admin login required)
|
||||
POST /auth/authorize Profile-only code redemption
|
||||
POST /auth/authorize/approve Consent decision
|
||||
POST /auth/token Code -> access token (and legacy revoke)
|
||||
GET /auth/token Legacy token verification
|
||||
POST /auth/revoke Token revocation (RFC 7009)
|
||||
"""
|
||||
|
||||
from urllib.parse import urlencode, urlparse, urlunparse, parse_qsl
|
||||
|
||||
from flask import (
|
||||
Blueprint,
|
||||
current_app,
|
||||
jsonify,
|
||||
redirect,
|
||||
render_template,
|
||||
request,
|
||||
session,
|
||||
url_for,
|
||||
)
|
||||
|
||||
from starpunk.auth import verify_session
|
||||
from starpunk.indieauth import (
|
||||
SUPPORTED_SCOPES,
|
||||
AuthorizationRequestError,
|
||||
InvalidGrantError,
|
||||
create_access_token,
|
||||
create_authorization_code,
|
||||
issuer,
|
||||
redeem_authorization_code,
|
||||
revoke_access_token,
|
||||
validate_authorization_request,
|
||||
verify_access_token,
|
||||
)
|
||||
from starpunk.micropub import extract_bearer_token
|
||||
from starpunk.utils import absolute_url_for
|
||||
|
||||
bp = Blueprint("indieauth", __name__)
|
||||
|
||||
# Parameters carried from the consent screen back to the approve handler
|
||||
_REQUEST_FIELDS = (
|
||||
"response_type",
|
||||
"client_id",
|
||||
"redirect_uri",
|
||||
"state",
|
||||
"code_challenge",
|
||||
"code_challenge_method",
|
||||
"scope",
|
||||
)
|
||||
|
||||
|
||||
def _json(payload: dict, status: int = 200):
|
||||
response = jsonify(payload)
|
||||
response.status_code = status
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
return response
|
||||
|
||||
|
||||
def _oauth_error(error: str, description: str, status: int = 400):
|
||||
return _json({"error": error, "error_description": description}, status)
|
||||
|
||||
|
||||
def _redirect_with(redirect_uri: str, params: dict):
|
||||
"""Append params to redirect_uri, keeping any query it already has"""
|
||||
parts = urlparse(redirect_uri)
|
||||
query = parse_qsl(parts.query, keep_blank_values=True) + list(params.items())
|
||||
return redirect(urlunparse(parts._replace(query=urlencode(query))))
|
||||
|
||||
|
||||
def _admin_session():
|
||||
return verify_session(request.cookies.get("starpunk_session"))
|
||||
|
||||
|
||||
def _request_error_page(error: AuthorizationRequestError):
|
||||
return (
|
||||
render_template("admin/authorize.html", request_error=error.description),
|
||||
400,
|
||||
)
|
||||
|
||||
|
||||
@bp.route("/.well-known/oauth-authorization-server")
|
||||
def metadata():
|
||||
"""IndieAuth server metadata"""
|
||||
return _json(
|
||||
{
|
||||
"issuer": issuer(),
|
||||
"authorization_endpoint": absolute_url_for("indieauth.authorize"),
|
||||
"token_endpoint": absolute_url_for("indieauth.token"),
|
||||
"revocation_endpoint": absolute_url_for("indieauth.revoke"),
|
||||
"revocation_endpoint_auth_methods_supported": ["none"],
|
||||
"scopes_supported": SUPPORTED_SCOPES,
|
||||
"response_types_supported": ["code"],
|
||||
"grant_types_supported": ["authorization_code"],
|
||||
"code_challenge_methods_supported": ["S256"],
|
||||
"authorization_response_iss_parameter_supported": True,
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@bp.route("/auth/authorize", methods=["GET"])
|
||||
def authorize():
|
||||
"""Show the consent screen to the logged-in admin"""
|
||||
try:
|
||||
auth_request = validate_authorization_request(request.args.to_dict())
|
||||
except AuthorizationRequestError as e:
|
||||
if not e.redirectable:
|
||||
return _request_error_page(e)
|
||||
return _redirect_with(
|
||||
request.args["redirect_uri"],
|
||||
{
|
||||
"error": e.error,
|
||||
"error_description": e.description,
|
||||
"state": request.args.get("state", ""),
|
||||
"iss": issuer(),
|
||||
},
|
||||
)
|
||||
|
||||
if not _admin_session():
|
||||
# Come back here after logging in with OIDC
|
||||
session["next"] = request.url
|
||||
return redirect(url_for("auth.login_form"))
|
||||
|
||||
return render_template(
|
||||
"admin/authorize.html",
|
||||
auth_request=auth_request,
|
||||
fields={k: request.args.get(k, "") for k in _REQUEST_FIELDS},
|
||||
me=current_app.config["ADMIN_ME"],
|
||||
)
|
||||
|
||||
|
||||
@bp.route("/auth/authorize/approve", methods=["POST"])
|
||||
def approve():
|
||||
"""Record the admin's consent decision and redirect to the client"""
|
||||
if not _admin_session():
|
||||
return redirect(url_for("auth.login_form"))
|
||||
|
||||
params = {k: request.form.get(k, "") for k in _REQUEST_FIELDS}
|
||||
try:
|
||||
auth_request = validate_authorization_request(params)
|
||||
except AuthorizationRequestError as e:
|
||||
return _request_error_page(e)
|
||||
|
||||
if request.form.get("decision") != "approve":
|
||||
return _redirect_with(
|
||||
auth_request["redirect_uri"],
|
||||
{"error": "access_denied", "state": auth_request["state"], "iss": issuer()},
|
||||
)
|
||||
|
||||
# Only scopes that were both requested and left checked
|
||||
granted = [s for s in auth_request["scopes"] if s in request.form.getlist("scope_granted")]
|
||||
code = create_authorization_code(
|
||||
auth_request["client_id"],
|
||||
auth_request["redirect_uri"],
|
||||
" ".join(granted),
|
||||
auth_request["code_challenge"],
|
||||
)
|
||||
current_app.logger.info(
|
||||
f"IndieAuth: approved {auth_request['client_id']} (scope: {' '.join(granted) or 'none'})"
|
||||
)
|
||||
return _redirect_with(
|
||||
auth_request["redirect_uri"],
|
||||
{"code": code, "state": auth_request["state"], "iss": issuer()},
|
||||
)
|
||||
|
||||
|
||||
def _redeem_from_form():
|
||||
return redeem_authorization_code(
|
||||
request.form.get("code", ""),
|
||||
request.form.get("client_id", ""),
|
||||
request.form.get("redirect_uri", ""),
|
||||
request.form.get("code_verifier", ""),
|
||||
)
|
||||
|
||||
|
||||
@bp.route("/auth/authorize", methods=["POST"])
|
||||
def authorize_redeem():
|
||||
"""Profile-only flow: redeem a code for the user's identity"""
|
||||
if request.form.get("grant_type", "authorization_code") != "authorization_code":
|
||||
return _oauth_error("unsupported_grant_type", "Only authorization_code is supported")
|
||||
try:
|
||||
result = _redeem_from_form()
|
||||
except InvalidGrantError as e:
|
||||
return _oauth_error("invalid_grant", str(e))
|
||||
return _json({"me": result["me"]})
|
||||
|
||||
|
||||
@bp.route("/auth/token", methods=["POST"])
|
||||
def token():
|
||||
"""Exchange an authorization code for an access token"""
|
||||
if request.form.get("action") == "revoke":
|
||||
# Legacy IndieAuth revocation
|
||||
revoke_access_token(request.form.get("token", ""))
|
||||
return _json({})
|
||||
|
||||
if request.form.get("grant_type") != "authorization_code":
|
||||
return _oauth_error("unsupported_grant_type", "Only authorization_code is supported")
|
||||
|
||||
try:
|
||||
result = _redeem_from_form()
|
||||
except InvalidGrantError as e:
|
||||
return _oauth_error("invalid_grant", str(e))
|
||||
|
||||
if not result["scope"]:
|
||||
# Spec: a code issued without scope cannot be used for an access token
|
||||
return _oauth_error("invalid_grant", "No scope was granted; use the authorization endpoint")
|
||||
|
||||
return _json(create_access_token(result["client_id"], result["scope"]))
|
||||
|
||||
|
||||
@bp.route("/auth/token", methods=["GET"])
|
||||
def token_verify():
|
||||
"""Legacy token verification for clients that still call it"""
|
||||
info = verify_access_token(extract_bearer_token(request))
|
||||
if not info:
|
||||
return _oauth_error("unauthorized", "Invalid or expired access token", 401)
|
||||
return _json(info)
|
||||
|
||||
|
||||
@bp.route("/auth/revoke", methods=["POST"])
|
||||
def revoke():
|
||||
"""RFC 7009 token revocation (always 200)"""
|
||||
revoke_access_token(request.form.get("token", ""))
|
||||
return _json({})
|
||||
+22
-21
@@ -17,6 +17,7 @@ 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
|
||||
@@ -26,9 +27,11 @@ from starpunk.micropub import (
|
||||
extract_bearer_token,
|
||||
error_response,
|
||||
handle_create,
|
||||
handle_delete,
|
||||
handle_update,
|
||||
handle_query,
|
||||
)
|
||||
from starpunk.auth_external import verify_external_token, check_scope
|
||||
from starpunk.indieauth import verify_access_token, check_scope
|
||||
|
||||
# Create blueprint
|
||||
bp = Blueprint("micropub", __name__)
|
||||
@@ -48,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
|
||||
@@ -71,14 +74,14 @@ def micropub_endpoint():
|
||||
if not token:
|
||||
return error_response("unauthorized", "No access token provided", 401)
|
||||
|
||||
token_info = verify_external_token(token)
|
||||
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.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:
|
||||
@@ -94,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)
|
||||
|
||||
@@ -121,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
|
||||
@@ -140,15 +140,16 @@ def media_endpoint():
|
||||
if not token:
|
||||
return error_response("unauthorized", "No access token provided", 401)
|
||||
|
||||
token_info = verify_external_token(token)
|
||||
token_info = verify_access_token(token)
|
||||
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
|
||||
)
|
||||
|
||||
|
||||
@@ -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):
|
||||
"""
|
||||
@@ -331,9 +360,15 @@ def note(slug: str):
|
||||
logger = logging.getLogger(__name__)
|
||||
logger.error(f"Error loading webmentions for note {slug}: {e}")
|
||||
|
||||
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",
|
||||
note=note_obj,
|
||||
syndications=syndications,
|
||||
webmentions=webmentions,
|
||||
reply_context=reply_context,
|
||||
**grouped if webmentions else {}
|
||||
@@ -379,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",
|
||||
|
||||
@@ -108,7 +108,7 @@ def api_search():
|
||||
"title": r["title"] or f"Note from {r['created_at'][:10]}",
|
||||
"excerpt": r["snippet"], # Already has <mark> tags
|
||||
"published_at": r["created_at"],
|
||||
"url": f"/notes/{r['slug']}",
|
||||
"url": f"/note/{r['slug']}",
|
||||
}
|
||||
for r in results
|
||||
],
|
||||
@@ -176,7 +176,7 @@ def search_page():
|
||||
"title": r["title"] or f"Note from {r['created_at'][:10]}",
|
||||
"excerpt": Markup(safe_snippet), # Mark as safe since we've escaped it ourselves
|
||||
"published_at": r["created_at"],
|
||||
"url": f"/notes/{r['slug']}",
|
||||
"url": f"/note/{r['slug']}",
|
||||
})
|
||||
results = formatted_results
|
||||
except Exception as e:
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -681,3 +681,15 @@ def parse_iso8601(date_string: str) -> datetime:
|
||||
|
||||
# Parse using fromisoformat
|
||||
return datetime.fromisoformat(date_string)
|
||||
|
||||
|
||||
def absolute_url_for(endpoint: str, **values) -> str:
|
||||
"""
|
||||
Absolute URL for an endpoint, built from SITE_URL
|
||||
|
||||
Use instead of url_for(..., _external=True): behind a reverse proxy the
|
||||
request arrives over plain HTTP, so _external URLs would say http://.
|
||||
"""
|
||||
from flask import current_app, url_for
|
||||
|
||||
return current_app.config["SITE_URL"].rstrip("/") + url_for(endpoint, **values)
|
||||
+96
-25
@@ -1,36 +1,75 @@
|
||||
/* StarPunk CSS - Minimal responsive stylesheet */
|
||||
|
||||
:root {
|
||||
--color-text: #333; --color-text-light: #666; --color-bg: #fff; --color-bg-alt: #f5f5f5;
|
||||
--color-link: #0066cc; --color-link-hover: #004499; --color-border: #ddd;
|
||||
--color-text: #1f2328; --color-text-light: #59636e; --color-bg: #fff; --color-bg-alt: #f4f5f7;
|
||||
--color-link: #0a5cc2; --color-link-hover: #083f85; --color-border: #e3e6ea; --color-accent-soft: #e8f0fb;
|
||||
--color-success: #28a745; --color-error: #dc3545; --color-warning: #ffc107; --color-info: #17a2b8;
|
||||
--font-body: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Arial, sans-serif;
|
||||
--font-mono: 'SF Mono', Monaco, Consolas, 'Courier New', monospace;
|
||||
--font-body: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
|
||||
--font-reading: Charter, 'Bitstream Charter', 'Sitka Text', Cambria, 'Noto Serif', Georgia, serif;
|
||||
--font-mono: ui-monospace, 'SF Mono', Monaco, Consolas, 'Liberation Mono', monospace;
|
||||
--spacing-xs: 0.25rem; --spacing-sm: 0.5rem; --spacing-md: 1rem; --spacing-lg: 2rem; --spacing-xl: 4rem;
|
||||
--max-width: 42rem; --border-radius: 4px;
|
||||
--max-width: 40rem; --border-radius: 6px;
|
||||
}
|
||||
|
||||
@media (prefers-color-scheme: dark) {
|
||||
:root {
|
||||
--color-text: #e4e6e9; --color-text-light: #9aa3ad; --color-bg: #121417; --color-bg-alt: #1c1f24;
|
||||
--color-link: #74b0ff; --color-link-hover: #a8ceff; --color-border: #2b3038; --color-accent-soft: #1a2738;
|
||||
}
|
||||
}
|
||||
|
||||
* { box-sizing: border-box; margin: 0; padding: 0; }
|
||||
body { font-family: var(--font-body); font-size: 1rem; line-height: 1.6; color: var(--color-text); background: var(--color-bg); padding: var(--spacing-md); }
|
||||
body {
|
||||
font-family: var(--font-body); font-size: 1rem; line-height: 1.6; color: var(--color-text); background: var(--color-bg);
|
||||
padding: var(--spacing-md); min-height: 100vh; display: flex; flex-direction: column;
|
||||
-webkit-font-smoothing: antialiased;
|
||||
}
|
||||
|
||||
h1, h2, h3 { margin-bottom: var(--spacing-md); line-height: 1.2; font-weight: 600; }
|
||||
h1 { font-size: 2rem; } h2 { font-size: 1.5rem; } h3 { font-size: 1.25rem; }
|
||||
h1, h2, h3 { margin-bottom: var(--spacing-md); line-height: 1.25; font-weight: 650; letter-spacing: -0.01em; }
|
||||
h1 { font-size: 1.75rem; } h2 { font-size: 1.375rem; } h3 { font-size: 1.125rem; }
|
||||
p { margin-bottom: var(--spacing-md); }
|
||||
a { color: var(--color-link); text-decoration: none; }
|
||||
a:hover { color: var(--color-link-hover); text-decoration: underline; }
|
||||
:focus-visible { outline: 2px solid var(--color-link); outline-offset: 2px; border-radius: 2px; }
|
||||
|
||||
code, pre { font-family: var(--font-mono); background: var(--color-bg-alt); padding: 0.125rem 0.25rem; border-radius: var(--border-radius); font-size: 0.875rem; }
|
||||
code, pre { font-family: var(--font-mono); background: var(--color-bg-alt); padding: 0.125rem 0.3rem; border-radius: var(--border-radius); font-size: 0.875em; }
|
||||
pre { padding: var(--spacing-md); overflow-x: auto; margin-bottom: var(--spacing-md); }
|
||||
pre code { padding: 0; background: none; }
|
||||
|
||||
header, main, footer { max-width: var(--max-width); margin: 0 auto; }
|
||||
header { margin-bottom: var(--spacing-lg); padding-bottom: var(--spacing-md); border-bottom: 2px solid var(--color-border); }
|
||||
header h1 { margin-bottom: var(--spacing-sm); }
|
||||
header h1 a { color: var(--color-text); text-decoration: none; }
|
||||
nav { display: flex; gap: var(--spacing-md); flex-wrap: wrap; }
|
||||
nav a { padding: var(--spacing-sm) var(--spacing-md); border-radius: var(--border-radius); transition: background 0.2s; }
|
||||
nav a:hover { background: var(--color-bg-alt); text-decoration: none; }
|
||||
main { min-height: 60vh; margin-bottom: var(--spacing-lg); }
|
||||
footer { padding-top: var(--spacing-lg); border-top: 1px solid var(--color-border); text-align: center; color: var(--color-text-light); font-size: 0.875rem; }
|
||||
.visually-hidden { position: absolute !important; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); clip-path: inset(50%); white-space: nowrap; }
|
||||
|
||||
/* Page frame */
|
||||
.site-header, main, .site-footer { width: 100%; max-width: var(--max-width); margin-left: auto; margin-right: auto; }
|
||||
main { flex: 1; margin-bottom: var(--spacing-xl); }
|
||||
|
||||
.site-header {
|
||||
display: flex; flex-wrap: wrap; align-items: baseline; justify-content: space-between; gap: var(--spacing-sm) var(--spacing-lg);
|
||||
padding: var(--spacing-md) 0 var(--spacing-md); margin-bottom: var(--spacing-lg); border-bottom: 1px solid var(--color-border);
|
||||
}
|
||||
.site-title { font-size: 1.375rem; font-weight: 700; letter-spacing: -0.02em; color: var(--color-text); }
|
||||
.site-title:hover { color: var(--color-link); text-decoration: none; }
|
||||
.site-nav { display: flex; align-items: center; flex-wrap: wrap; gap: var(--spacing-md); font-size: 0.9375rem; }
|
||||
.site-nav > a { color: var(--color-text-light); }
|
||||
.site-nav > a:hover { color: var(--color-link); text-decoration: none; }
|
||||
.site-search { display: flex; }
|
||||
.site-search input[type="search"] {
|
||||
width: 10rem; padding: 0.3rem 0.6rem; font: inherit; font-size: 0.875rem; color: var(--color-text);
|
||||
background: var(--color-bg-alt); border: 1px solid var(--color-border); border-right: 0; border-radius: var(--border-radius) 0 0 var(--border-radius);
|
||||
}
|
||||
.site-search button {
|
||||
padding: 0.3rem 0.6rem; font: inherit; font-size: 0.875rem; cursor: pointer; color: var(--color-text-light);
|
||||
background: var(--color-bg-alt); border: 1px solid var(--color-border); border-radius: 0 var(--border-radius) var(--border-radius) 0;
|
||||
}
|
||||
.site-search button:hover { color: var(--color-link); }
|
||||
|
||||
.site-footer { padding: var(--spacing-md) 0; border-top: 1px solid var(--color-border); color: var(--color-text-light); font-size: 0.8125rem; }
|
||||
.site-footer p { margin: 0; }
|
||||
.site-footer a { color: var(--color-text-light); text-decoration: underline; text-decoration-color: var(--color-border); }
|
||||
.site-footer a:hover { color: var(--color-link); }
|
||||
|
||||
.page-title { font-size: 1.375rem; margin-bottom: var(--spacing-lg); }
|
||||
.tag-name { color: var(--color-link); }
|
||||
.tag-name::before { content: "#"; }
|
||||
|
||||
.dev-mode-warning { background: var(--color-error); color: white; padding: var(--spacing-md); text-align: center; font-weight: bold; margin: calc(-1 * var(--spacing-md)); margin-bottom: var(--spacing-lg); }
|
||||
|
||||
@@ -40,17 +79,46 @@ footer { padding-top: var(--spacing-lg); border-top: 1px solid var(--color-borde
|
||||
.flash-warning { background: #fff3cd; border-color: var(--color-warning); color: #856404; }
|
||||
.flash-info { background: #d1ecf1; border-color: var(--color-info); color: #0c5460; }
|
||||
|
||||
/* Notes */
|
||||
.h-entry { margin-bottom: var(--spacing-lg); padding-bottom: var(--spacing-lg); border-bottom: 1px solid var(--color-border); }
|
||||
.h-entry:last-child { border-bottom: none; }
|
||||
.note-preview .e-content { margin-bottom: var(--spacing-md); }
|
||||
.note-meta { color: var(--color-text-light); font-size: 0.875rem; }
|
||||
.h-entry > .p-name a { color: var(--color-text); }
|
||||
.h-entry > .p-name a:hover { color: var(--color-link); }
|
||||
.e-content, .p-summary { font-family: var(--font-reading); font-size: 1.125rem; line-height: 1.65; overflow-wrap: anywhere; }
|
||||
.e-content > :last-child, .p-summary > :last-child { margin-bottom: 0; }
|
||||
.e-content a { text-decoration: underline; text-decoration-thickness: 1px; text-underline-offset: 2px; text-decoration-color: color-mix(in srgb, currentColor 40%, transparent); }
|
||||
.e-content a:hover { text-decoration-color: currentColor; }
|
||||
.e-content blockquote { margin: 0 0 var(--spacing-md); padding-left: var(--spacing-md); border-left: 3px solid var(--color-border); color: var(--color-text-light); }
|
||||
.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; }
|
||||
.note-meta a { color: var(--color-text-light); }
|
||||
.note-nav { margin-top: var(--spacing-md); }
|
||||
.note-meta a:hover { color: var(--color-link); }
|
||||
.note-meta > :not(.visually-hidden) + :not(.visually-hidden)::before { content: "·"; margin-right: 0.4rem; color: var(--color-text-light); }
|
||||
.note-tags { display: inline-flex; flex-wrap: wrap; gap: 0 0.4rem; }
|
||||
.note-meta > .note-tags::before { margin-right: 0; }
|
||||
.note-tags .p-category::before { content: "#"; opacity: 0.7; }
|
||||
.h-entry:not(.note-preview) .note-meta { margin-top: var(--spacing-md); }
|
||||
.note-nav { margin-top: var(--spacing-lg); font-size: 0.9375rem; }
|
||||
.empty-state { text-align: center; padding: var(--spacing-xl); color: var(--color-text-light); }
|
||||
|
||||
.form-group { margin-bottom: var(--spacing-md); }
|
||||
label { display: block; margin-bottom: var(--spacing-sm); font-weight: 600; }
|
||||
input[type="text"], input[type="url"], input[type="email"], textarea { width: 100%; padding: var(--spacing-sm); border: 1px solid var(--color-border); border-radius: var(--border-radius); font-family: inherit; font-size: 1rem; }
|
||||
input[type="text"], input[type="url"], input[type="email"], input[type="search"], textarea { color: var(--color-text); background: var(--color-bg); width: 100%; padding: var(--spacing-sm); border: 1px solid var(--color-border); border-radius: var(--border-radius); font-family: inherit; font-size: 1rem; }
|
||||
textarea { font-family: var(--font-mono); resize: vertical; min-height: 10rem; }
|
||||
small { display: block; margin-top: var(--spacing-xs); color: var(--color-text-light); font-size: 0.875rem; }
|
||||
.form-checkbox { display: flex; align-items: center; gap: var(--spacing-sm); }
|
||||
@@ -171,11 +239,14 @@ small { display: block; margin-top: var(--spacing-xs); color: var(--color-text-l
|
||||
}
|
||||
|
||||
@media (min-width: 768px) {
|
||||
body { padding: var(--spacing-lg); }
|
||||
h1 { font-size: 2.5rem; } h2 { font-size: 2rem; } h3 { font-size: 1.5rem; }
|
||||
body { padding: var(--spacing-md) var(--spacing-lg); }
|
||||
h1 { font-size: 2rem; } h2 { font-size: 1.5rem; } h3 { font-size: 1.25rem; }
|
||||
}
|
||||
|
||||
@media (max-width: 767px) {
|
||||
.site-nav { width: 100%; }
|
||||
.site-search { flex: 1; justify-content: flex-end; }
|
||||
.site-search input[type="search"] { width: 100%; max-width: 12rem; }
|
||||
.note-table { font-size: 0.875rem; }
|
||||
.note-table th, .note-table td { padding: var(--spacing-sm); }
|
||||
.note-actions .button { font-size: 0.75rem; padding: 0.25rem 0.5rem; }
|
||||
@@ -426,7 +497,7 @@ small { display: block; margin-top: var(--spacing-xs); color: var(--color-text-l
|
||||
|
||||
.content-preview {
|
||||
padding: var(--spacing-sm);
|
||||
background: white;
|
||||
background: var(--color-bg);
|
||||
border: 1px solid var(--color-border);
|
||||
border-radius: 4px;
|
||||
margin-top: var(--spacing-xs);
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
{% extends "base.html" %}
|
||||
|
||||
{% block title %}Authorize App - StarPunk{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
<div class="login-container authorize">
|
||||
{% if request_error %}
|
||||
<h2>Cannot authorize this app</h2>
|
||||
<p>{{ request_error }}</p>
|
||||
<p><a href="/">Return to homepage</a></p>
|
||||
{% else %}
|
||||
<h2>Authorize app</h2>
|
||||
<p>
|
||||
<strong>{{ auth_request.client_id }}</strong> wants to sign in as
|
||||
<strong>{{ me }}</strong>.
|
||||
</p>
|
||||
<p><small>After approval you will be sent to {{ auth_request.redirect_uri }}</small></p>
|
||||
|
||||
<form action="{{ url_for('indieauth.approve') }}" method="POST" class="login-form">
|
||||
{% for name, value in fields.items() %}
|
||||
<input type="hidden" name="{{ name }}" value="{{ value }}">
|
||||
{% endfor %}
|
||||
|
||||
{% if auth_request.scopes %}
|
||||
<fieldset>
|
||||
<legend>Permissions requested</legend>
|
||||
{% for scope in auth_request.scopes %}
|
||||
<label>
|
||||
<input type="checkbox" name="scope_granted" value="{{ scope }}" checked>
|
||||
{{ scope }}
|
||||
</label><br>
|
||||
{% endfor %}
|
||||
</fieldset>
|
||||
{% else %}
|
||||
<p>This app only wants to confirm your identity. It cannot post.</p>
|
||||
{% endif %}
|
||||
|
||||
<button type="submit" name="decision" value="approve" class="button button-primary">Approve</button>
|
||||
<button type="submit" name="decision" value="deny" class="button button-secondary">Deny</button>
|
||||
</form>
|
||||
{% endif %}
|
||||
</div>
|
||||
{% endblock %}
|
||||
@@ -6,6 +6,7 @@
|
||||
<a href="{{ url_for('admin.dashboard') }}">Dashboard</a>
|
||||
<a href="{{ url_for('admin.new_note_form') }}">New Note</a>
|
||||
<a href="{{ url_for('admin.metrics_dashboard') }}">Metrics</a>
|
||||
<a href="{{ url_for('admin.tokens') }}">Connected Apps</a>
|
||||
<form action="{{ url_for('auth.logout') }}" method="POST" class="logout-form">
|
||||
<button type="submit" class="button button-secondary">Logout</button>
|
||||
</form>
|
||||
|
||||
@@ -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>
|
||||
@@ -52,15 +55,58 @@
|
||||
<label for="published">Published</label>
|
||||
</div>
|
||||
|
||||
{% if syndication_targets %}
|
||||
<input type="hidden" name="syndication_form" value="1">
|
||||
<fieldset class="form-group">
|
||||
<legend>Crosspost</legend>
|
||||
{% for target in syndication_targets %}
|
||||
<div class="form-checkbox">
|
||||
<input type="checkbox" id="syndicate-{{ target.id }}" name="syndicate_to" value="{{ target.id }}"{% if target.id in syndication_enabled %} checked{% endif %}>
|
||||
<label for="syndicate-{{ target.id }}">{{ target.name }}</label>
|
||||
</div>
|
||||
{% endfor %}
|
||||
</fieldset>
|
||||
{% endif %}
|
||||
|
||||
<div class="form-actions">
|
||||
<button type="submit" class="button button-primary">Update Note</button>
|
||||
<a href="{{ url_for('admin.dashboard') }}" class="button button-secondary">Cancel</a>
|
||||
<form action="{{ url_for('admin.delete_note_submit', note_id=note.id) }}" method="POST" class="delete-form" style="display: inline;" onsubmit="return confirm('Are you sure you want to delete this note? This cannot be undone.');">
|
||||
<input type="hidden" name="confirm" value="yes">
|
||||
<button type="submit" class="button button-danger">Delete Note</button>
|
||||
</form>
|
||||
<button type="submit" form="delete-note-form" class="button button-danger">Delete Note</button>
|
||||
</div>
|
||||
</form>
|
||||
|
||||
{# Outside the edit form: nested forms are not allowed in HTML #}
|
||||
<form id="delete-note-form" action="{{ url_for('admin.delete_note_submit', note_id=note.id) }}" method="POST" class="delete-form" onsubmit="return confirm('Are you sure you want to delete this note? This cannot be undone.');">
|
||||
<input type="hidden" name="confirm" value="yes">
|
||||
</form>
|
||||
|
||||
{% if syndications %}
|
||||
<section class="syndication-status">
|
||||
<h3>Crossposts</h3>
|
||||
<ul>
|
||||
{% for s in syndications %}
|
||||
<li>
|
||||
<strong>{{ s.name }}</strong>:
|
||||
{% if s.state == 'synced' and s.remote_url %}
|
||||
<a href="{{ s.remote_url }}" rel="noopener">posted</a>
|
||||
{% elif s.state == 'synced' %}
|
||||
removed
|
||||
{% elif s.state == 'pending' %}
|
||||
pending{% if s.attempts %} (retry {{ s.attempts }}){% endif %}
|
||||
{% else %}
|
||||
failed
|
||||
{% endif %}
|
||||
{% if s.last_error %}<br><small>{{ s.last_error }}</small>{% endif %}
|
||||
{% if s.state != 'synced' %}
|
||||
<form action="{{ url_for('admin.retry_syndication', syndication_id=s.id) }}" method="POST" style="display: inline;">
|
||||
<button type="submit" class="button button-secondary">Retry now</button>
|
||||
</form>
|
||||
{% endif %}
|
||||
</li>
|
||||
{% endfor %}
|
||||
</ul>
|
||||
</section>
|
||||
{% endif %}
|
||||
</div>
|
||||
{% endblock %}
|
||||
|
||||
|
||||
@@ -5,23 +5,10 @@
|
||||
{% block content %}
|
||||
<div class="login-container">
|
||||
<h2>Admin Login</h2>
|
||||
<p>Sign in with your personal website using IndieLogin</p>
|
||||
<p>Sign in with {{ config.OIDC_PROVIDER_NAME }} to manage this site.</p>
|
||||
|
||||
<form action="{{ url_for('auth.login_initiate') }}" method="POST" class="login-form">
|
||||
<div class="form-group">
|
||||
<label for="me">Your Website URL</label>
|
||||
<input
|
||||
type="url"
|
||||
id="me"
|
||||
name="me"
|
||||
placeholder="https://example.com"
|
||||
required
|
||||
autofocus
|
||||
>
|
||||
<small>Enter your website URL (must match admin configuration)</small>
|
||||
</div>
|
||||
|
||||
<button type="submit" class="button button-primary">Sign in with IndieLogin</button>
|
||||
<button type="submit" class="button button-primary">Sign in with {{ config.OIDC_PROVIDER_NAME }}</button>
|
||||
</form>
|
||||
|
||||
{% if config.DEV_MODE %}
|
||||
@@ -33,16 +20,5 @@
|
||||
</a>
|
||||
</div>
|
||||
{% endif %}
|
||||
|
||||
<div class="login-help">
|
||||
<h3>What is IndieLogin?</h3>
|
||||
<p>
|
||||
IndieLogin allows you to sign in using your own website.
|
||||
No password required - just authenticate with your domain.
|
||||
</p>
|
||||
<a href="https://indielogin.com/api" target="_blank" rel="noopener">
|
||||
Learn more about IndieLogin
|
||||
</a>
|
||||
</div>
|
||||
</div>
|
||||
{% endblock %}
|
||||
@@ -65,6 +65,19 @@
|
||||
<label for="published">Publish immediately</label>
|
||||
</div>
|
||||
|
||||
{% if syndication_targets %}
|
||||
<input type="hidden" name="syndication_form" value="1">
|
||||
<fieldset class="form-group">
|
||||
<legend>Crosspost</legend>
|
||||
{% for target in syndication_targets %}
|
||||
<div class="form-checkbox">
|
||||
<input type="checkbox" id="syndicate-{{ target.id }}" name="syndicate_to" value="{{ target.id }}" checked>
|
||||
<label for="syndicate-{{ target.id }}">{{ target.name }}</label>
|
||||
</div>
|
||||
{% endfor %}
|
||||
</fieldset>
|
||||
{% endif %}
|
||||
|
||||
<div class="form-actions">
|
||||
<button type="submit" class="button button-primary">Create Note</button>
|
||||
<a href="{{ url_for('admin.dashboard') }}" class="button button-secondary">Cancel</a>
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
{% extends "admin/base.html" %}
|
||||
|
||||
{% block title %}Connected Apps - StarPunk Admin{% endblock %}
|
||||
|
||||
{% block admin_content %}
|
||||
<div class="tokens-admin">
|
||||
<h2>Connected Apps</h2>
|
||||
<p>Micropub apps you have approved. Revoke any you no longer use.</p>
|
||||
|
||||
{% if tokens %}
|
||||
<table class="note-table">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>App</th>
|
||||
<th>Scope</th>
|
||||
<th>Approved</th>
|
||||
<th>Last used</th>
|
||||
<th>Expires</th>
|
||||
<th></th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{% for t in tokens %}
|
||||
<tr>
|
||||
<td>{{ t.client_id }}</td>
|
||||
<td>{{ t.scope }}</td>
|
||||
<td>{{ t.created_at }}</td>
|
||||
<td>{{ t.last_used_at or "never" }}</td>
|
||||
<td>{{ t.expires_at }}</td>
|
||||
<td>
|
||||
<form method="POST" action="{{ url_for('admin.revoke_token', token_id=t.id) }}">
|
||||
<button type="submit" class="button button-danger"
|
||||
onclick="return confirm('Revoke this app\'s access?')">Revoke</button>
|
||||
</form>
|
||||
</td>
|
||||
</tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
{% else %}
|
||||
<p>No apps connected.</p>
|
||||
{% endif %}
|
||||
</div>
|
||||
{% endblock %}
|
||||
+22
-23
@@ -3,14 +3,19 @@
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>{% block title %}StarPunk{% endblock %}</title>
|
||||
<title>{% block title %}{{ config.SITE_NAME }}{% endblock %}</title>
|
||||
<meta name="color-scheme" content="light dark">
|
||||
<link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
|
||||
<link rel="alternate" type="application/rss+xml" title="{{ config.SITE_NAME }} RSS Feed" href="{{ url_for('public.feed', _external=True) }}">
|
||||
<link rel="alternate" type="application/xml+opml" title="{{ config.SITE_NAME }} Feed Subscription List" href="{{ url_for('public.opml', _external=True) }}">
|
||||
<link rel="alternate" type="application/rss+xml" title="{{ config.SITE_NAME }} RSS Feed" href="{{ absolute_url_for('public.feed') }}">
|
||||
<link rel="alternate" type="application/xml+opml" title="{{ config.SITE_NAME }} Feed Subscription List" href="{{ absolute_url_for('public.opml') }}">
|
||||
|
||||
{# Webmention endpoint (v1.6.0) #}
|
||||
{% if config.WEBMENTION_ENABLED %}
|
||||
<link rel="webmention" href="/webmention">
|
||||
<link rel="micropub" href="{{ absolute_url_for('micropub.micropub_endpoint') }}">
|
||||
<link rel="indieauth-metadata" href="{{ absolute_url_for('indieauth.metadata') }}">
|
||||
<link rel="authorization_endpoint" href="{{ absolute_url_for('indieauth.authorize') }}">
|
||||
<link rel="token_endpoint" href="{{ absolute_url_for('indieauth.token') }}">
|
||||
{% endif %}
|
||||
|
||||
{# rel-me links from discovered author profile (v1.2.0 Phase 2) #}
|
||||
@@ -29,29 +34,21 @@
|
||||
</div>
|
||||
{% endif %}
|
||||
|
||||
<header>
|
||||
<h1><a href="/">StarPunk</a></h1>
|
||||
<nav>
|
||||
<header class="site-header">
|
||||
<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') }}">Dashboard</a>
|
||||
<a href="{{ url_for('admin.dashboard') }}">Admin</a>
|
||||
{% else %}
|
||||
<a href="{{ url_for('auth.login_form') }}">Login</a>
|
||||
<a href="{{ url_for('auth.login_form') }}">Log in</a>
|
||||
{% endif %}
|
||||
<form action="/search" method="get" role="search" style="margin-left: auto; display: flex; gap: var(--spacing-sm);">
|
||||
<input
|
||||
type="search"
|
||||
name="q"
|
||||
placeholder="Search..."
|
||||
aria-label="Search"
|
||||
value="{{ request.args.get('q', '') }}"
|
||||
minlength="2"
|
||||
maxlength="100"
|
||||
required
|
||||
style="width: 200px; padding: var(--spacing-xs) var(--spacing-sm);"
|
||||
>
|
||||
<button type="submit" class="button button-small" style="padding: var(--spacing-xs) var(--spacing-sm);">🔍</button>
|
||||
<form class="site-search" action="/search" method="get" role="search">
|
||||
<input type="search" name="q" placeholder="Search" aria-label="Search"
|
||||
value="{{ request.args.get('q', '') }}" minlength="2" maxlength="100" required>
|
||||
<button type="submit" aria-label="Search">Search</button>
|
||||
</form>
|
||||
</nav>
|
||||
</header>
|
||||
@@ -68,8 +65,10 @@
|
||||
{% block content %}{% endblock %}
|
||||
</main>
|
||||
|
||||
<footer>
|
||||
<p>StarPunk v{{ config.get('VERSION', '0.5.0') }}</p>
|
||||
<footer class="site-footer">
|
||||
<p>
|
||||
Powered by <a href="https://git.thesatelliteoflove.com/phil/StarPunk">StarPunk</a> v{{ config.get('VERSION', '0.5.0') }}
|
||||
</p>
|
||||
</footer>
|
||||
</body>
|
||||
</html>
|
||||
+5
-48
@@ -1,15 +1,15 @@
|
||||
{% extends "base.html" %}
|
||||
{% from "partials/media.html" import display_media %}
|
||||
{% from "partials/note_preview.html" import note_preview %}
|
||||
|
||||
{% block title %}StarPunk - Home{% endblock %}
|
||||
{% block title %}{{ config.SITE_NAME }}{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
<div class="h-feed">
|
||||
{# h-feed required properties per microformats.org/wiki/h-feed #}
|
||||
<h2 class="p-name">{{ config.SITE_NAME or 'Recent Notes' }}</h2>
|
||||
<h1 class="p-name visually-hidden">{{ config.SITE_NAME or 'Recent Notes' }}</h1>
|
||||
|
||||
{# u-url for feed (self-reference) #}
|
||||
<a class="u-url" href="{{ url_for('public.index', _external=True) }}" style="display: none;">Feed URL</a>
|
||||
<a class="u-url" href="{{ absolute_url_for('public.index') }}" style="display: none;">Feed URL</a>
|
||||
|
||||
{# Feed-level author h-card with all properties #}
|
||||
{# Hidden because it's semantic-only markup for parsers, not visual content #}
|
||||
@@ -34,50 +34,7 @@
|
||||
|
||||
{% if notes %}
|
||||
{% for note in notes %}
|
||||
<article class="h-entry note-preview">
|
||||
{# Detect if note has explicit title (starts with # heading) - per Q22 #}
|
||||
{% set has_explicit_title = note.content.strip().startswith('#') %}
|
||||
|
||||
{# p-name only if note has explicit title (per Q22) #}
|
||||
{% if has_explicit_title %}
|
||||
<h3 class="p-name">{{ note.title }}</h3>
|
||||
{% endif %}
|
||||
|
||||
{# Media preview (if available) #}
|
||||
{{ display_media(note.media) }}
|
||||
|
||||
{# e-content: note content (preview) #}
|
||||
<div class="e-content">
|
||||
{{ note.html[:300]|safe }}{% if note.html|length > 300 %}...{% endif %}
|
||||
</div>
|
||||
|
||||
<footer class="note-meta">
|
||||
{# u-url for permalink #}
|
||||
<a class="u-url" href="{{ url_for('public.note', slug=note.slug, _external=True) }}">
|
||||
<time class="dt-published" datetime="{{ note.created_at.isoformat() }}">
|
||||
{{ note.created_at.strftime('%B %d, %Y') }}
|
||||
</time>
|
||||
</a>
|
||||
|
||||
{# Tags in preview #}
|
||||
{% if note.tags %}
|
||||
<span class="note-tags">
|
||||
{% for tag in note.tags %}
|
||||
<a class="p-category" rel="tag" href="{{ url_for('public.tag', tag=tag.name) }}">{{ tag.display_name }}</a>
|
||||
{% endfor %}
|
||||
</span>
|
||||
{% endif %}
|
||||
|
||||
{# Author h-card nested in each h-entry (per Q20) #}
|
||||
{% if author %}
|
||||
<div class="p-author h-card">
|
||||
<a class="p-name u-url" href="{{ author.url or author.me }}">
|
||||
{{ author.name or author.url or author.me }}
|
||||
</a>
|
||||
</div>
|
||||
{% endif %}
|
||||
</footer>
|
||||
</article>
|
||||
{{ note_preview(note, author) }}
|
||||
{% endfor %}
|
||||
{% else %}
|
||||
<p class="empty-state">No notes published yet. Check back soon!</p>
|
||||
|
||||
@@ -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 %}
|
||||
+22
-36
@@ -1,7 +1,8 @@
|
||||
{% extends "base.html" %}
|
||||
{% from "partials/media.html" import display_media %}
|
||||
{% from "partials/reaction.html" import reaction %}
|
||||
|
||||
{% block title %}{{ note.slug }} - StarPunk{% endblock %}
|
||||
{% block title %}{% if note.content.strip().startswith('#') %}{{ note.title }}{% else %}{{ note.excerpt|truncate(60) }}{% endif %} · {{ config.SITE_NAME }}{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
<article class="h-entry">
|
||||
@@ -38,60 +39,45 @@
|
||||
</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) }}
|
||||
|
||||
{# e-content: note content BELOW media (per ADR-057) #}
|
||||
<div class="e-content">
|
||||
{{ note.html|safe }}
|
||||
{{ note.body_html|safe }}
|
||||
</div>
|
||||
|
||||
<footer class="note-meta">
|
||||
{# u-url and u-uid same for notes (per Q23) #}
|
||||
<a class="u-url u-uid" href="{{ url_for('public.note', slug=note.slug, _external=True) }}">
|
||||
<time class="dt-published" datetime="{{ note.created_at.isoformat() }}">
|
||||
{{ note.created_at.strftime('%B %d, %Y at %I:%M %p') }}
|
||||
</time>
|
||||
</a>
|
||||
|
||||
{# dt-updated if note was modified #}
|
||||
<a class="u-url u-uid" href="{{ absolute_url_for('public.note', slug=note.slug) }}"><time class="dt-published" datetime="{{ note.created_at.isoformat() }}">{{ note.created_at.strftime('%B %-d, %Y · %-I:%M %p') }}</time></a>
|
||||
{% if note.updated_at and note.updated_at != note.created_at %}
|
||||
<span class="updated">
|
||||
(Updated: <time class="dt-updated" datetime="{{ note.updated_at.isoformat() }}">{{ note.updated_at.strftime('%B %d, %Y') }}</time>)
|
||||
<span class="updated">Updated <time class="dt-updated" datetime="{{ note.updated_at.isoformat() }}">{{ note.updated_at.strftime('%b %-d, %Y') }}</time></span>
|
||||
{% endif %}
|
||||
{# rel="tag" per microformats2 p-category #}
|
||||
{% if note.tags %}
|
||||
<span class="note-tags">
|
||||
{% for tag in note.tags %}<a class="p-category" rel="tag" href="{{ url_for('public.tag', tag=tag.name) }}">{{ tag.display_name }}</a>{% endfor %}
|
||||
</span>
|
||||
{% endif %}
|
||||
|
||||
{# Tags / Categories #}
|
||||
{# rel="tag" per microformats2 p-category specification #}
|
||||
{% if note.tags %}
|
||||
<div class="note-tags">
|
||||
{% for tag in note.tags %}
|
||||
<a class="p-category" rel="tag" href="{{ url_for('public.tag', tag=tag.name) }}">
|
||||
{{ tag.display_name }}
|
||||
</a>
|
||||
{% endfor %}
|
||||
</div>
|
||||
{% set synced = (syndications or [])|selectattr('remote_url')|list %}
|
||||
{% if synced %}
|
||||
<span class="syndication">Also on {% for s in synced %}<a class="u-syndication" href="{{ s.remote_url }}" rel="syndication">{{ s.name }}</a>{% if not loop.last %}, {% endif %}{% endfor %}</span>
|
||||
{% endif %}
|
||||
|
||||
{# Author h-card (nested within h-entry per Q20) #}
|
||||
{# Author h-card (nested within h-entry per Q20); hidden on a single-author site #}
|
||||
{% if author %}
|
||||
<div class="p-author h-card">
|
||||
{% if author.photo %}
|
||||
<img class="u-photo" src="{{ author.photo }}" alt="{{ author.name or 'Author' }}" width="48" height="48">
|
||||
{% endif %}
|
||||
<a class="p-name u-url" href="{{ author.url or author.me }}">
|
||||
{{ author.name or author.url or author.me }}
|
||||
</a>
|
||||
{% if author.note %}
|
||||
<span class="p-note" style="display: none;">{{ author.note }}</span>
|
||||
{% endif %}
|
||||
</div>
|
||||
<span class="p-author h-card visually-hidden">
|
||||
{% if author.photo %}<img class="u-photo" src="{{ author.photo }}" alt="">{% endif %}
|
||||
<a class="p-name u-url" href="{{ author.url or author.me }}">{{ author.name or author.url or author.me }}</a>
|
||||
{% if author.note %}<span class="p-note">{{ author.note }}</span>{% endif %}
|
||||
</span>
|
||||
{% endif %}
|
||||
</footer>
|
||||
|
||||
<nav class="note-nav">
|
||||
<a href="/">Back to all notes</a>
|
||||
<a href="/">← All notes</a>
|
||||
</nav>
|
||||
|
||||
{# Webmentions section (v1.6.0 Phase 5) - only shown if approved webmentions exist #}
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
{# 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) #}
|
||||
{% set has_explicit_title = note.content.strip().startswith('#') %}
|
||||
{% if has_explicit_title %}
|
||||
<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 %}
|
||||
{# Titled notes are articles: show a summary and link through #}
|
||||
<div class="p-summary">
|
||||
<p>{{ note.excerpt }}</p>
|
||||
</div>
|
||||
<p class="read-more"><a href="{{ absolute_url_for('public.note', slug=note.slug) }}">Read more →</a></p>
|
||||
{% elif note.html %}
|
||||
<div class="e-content">
|
||||
{{ note.html|safe }}
|
||||
</div>
|
||||
{% endif %}
|
||||
|
||||
<footer class="note-meta">
|
||||
<a class="u-url" href="{{ absolute_url_for('public.note', slug=note.slug) }}"><time class="dt-published" datetime="{{ note.created_at.isoformat() }}">{{ note.created_at.strftime('%b %-d, %Y') }}</time></a>
|
||||
{% if note.tags %}
|
||||
<span class="note-tags">
|
||||
{% for tag in note.tags %}<a class="p-category" rel="tag" href="{{ url_for('public.tag', tag=tag.name) }}">{{ tag.display_name }}</a>{% endfor %}
|
||||
</span>
|
||||
{% endif %}
|
||||
{% if author %}
|
||||
{# Single-author site: keep the h-card for parsers, hide it from readers #}
|
||||
<span class="p-author h-card visually-hidden"><a class="p-name u-url" href="{{ author.url or author.me }}">{{ author.name or author.url or author.me }}</a></span>
|
||||
{% endif %}
|
||||
</footer>
|
||||
</article>
|
||||
{% endmacro %}
|
||||
@@ -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 %}
|
||||
@@ -1,6 +1,6 @@
|
||||
{% extends "base.html" %}
|
||||
|
||||
{% block title %}{% if query %}Search: {{ query }}{% else %}Search{% endif %} - StarPunk{% endblock %}
|
||||
{% block title %}{% if query %}Search: {{ query }}{% else %}Search{% endif %} · {{ config.SITE_NAME }}{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
<div class="search-container">
|
||||
|
||||
+5
-48
@@ -1,65 +1,22 @@
|
||||
{% extends "base.html" %}
|
||||
{% from "partials/media.html" import display_media %}
|
||||
{% from "partials/note_preview.html" import note_preview %}
|
||||
|
||||
{% block title %}{{ tag.display_name }} - StarPunk{% endblock %}
|
||||
{% block title %}{{ tag.display_name }} · {{ config.SITE_NAME }}{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
<div class="h-feed">
|
||||
<h1 class="p-name">Notes tagged "{{ tag.display_name }}"</h1>
|
||||
<h1 class="p-name page-title">Notes tagged <span class="tag-name">{{ tag.display_name }}</span></h1>
|
||||
|
||||
{% if notes %}
|
||||
{% for note in notes %}
|
||||
<article class="h-entry note-preview">
|
||||
{# Detect if note has explicit title (starts with # heading) - per Q22 #}
|
||||
{% set has_explicit_title = note.content.strip().startswith('#') %}
|
||||
|
||||
{# p-name only if note has explicit title (per Q22) #}
|
||||
{% if has_explicit_title %}
|
||||
<h3 class="p-name">{{ note.title }}</h3>
|
||||
{% endif %}
|
||||
|
||||
{# Media preview (if available) #}
|
||||
{{ display_media(note.media) }}
|
||||
|
||||
{# e-content: note content (preview) #}
|
||||
<div class="e-content">
|
||||
{{ note.html[:300]|safe }}{% if note.html|length > 300 %}...{% endif %}
|
||||
</div>
|
||||
|
||||
<footer class="note-meta">
|
||||
{# u-url for permalink #}
|
||||
<a class="u-url" href="{{ url_for('public.note', slug=note.slug, _external=True) }}">
|
||||
<time class="dt-published" datetime="{{ note.created_at.isoformat() }}">
|
||||
{{ note.created_at.strftime('%B %d, %Y') }}
|
||||
</time>
|
||||
</a>
|
||||
|
||||
{# Tags in preview #}
|
||||
{% if note.tags %}
|
||||
<span class="note-tags">
|
||||
{% for tag in note.tags %}
|
||||
<a class="p-category" rel="tag" href="{{ url_for('public.tag', tag=tag.name) }}">{{ tag.display_name }}</a>
|
||||
{% endfor %}
|
||||
</span>
|
||||
{% endif %}
|
||||
|
||||
{# Author h-card nested in each h-entry (per Q20) #}
|
||||
{% if author %}
|
||||
<div class="p-author h-card">
|
||||
<a class="p-name u-url" href="{{ author.url or author.me }}">
|
||||
{{ author.name or author.url or author.me }}
|
||||
</a>
|
||||
</div>
|
||||
{% endif %}
|
||||
</footer>
|
||||
</article>
|
||||
{{ note_preview(note, author) }}
|
||||
{% endfor %}
|
||||
{% else %}
|
||||
<p class="empty-state">No notes with this tag.</p>
|
||||
{% endif %}
|
||||
|
||||
<nav class="note-nav">
|
||||
<a href="/">Back to all notes</a>
|
||||
<a href="/">← All notes</a>
|
||||
</nav>
|
||||
</div>
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,48 @@
|
||||
"""
|
||||
Absolute URLs come from SITE_URL, not the request (v2.0.1)
|
||||
|
||||
Behind a reverse proxy the app is reached over plain HTTP, so URLs built
|
||||
from the request said http:// on an https site.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
|
||||
from starpunk import create_app
|
||||
from starpunk.notes import create_note
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app(tmp_path):
|
||||
data = tmp_path / "data"
|
||||
return create_app(
|
||||
{
|
||||
"TESTING": True,
|
||||
"SITE_URL": "https://blog.example.com",
|
||||
"ADMIN_ME": "https://example.com",
|
||||
"SESSION_SECRET": "test-secret",
|
||||
"DATA_PATH": data,
|
||||
"NOTES_PATH": data / "notes",
|
||||
"DATABASE_PATH": data / "starpunk.db",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def test_pages_use_site_url_behind_http_proxy(app):
|
||||
with app.app_context():
|
||||
note = create_note(content="Hello over the proxy", published=True, tags=["proxy"])
|
||||
client = app.test_client()
|
||||
|
||||
pages = ["/", f"/note/{note.slug}", "/tag/proxy"]
|
||||
for path in pages:
|
||||
# The test client makes plain http://localhost requests, like Caddy does
|
||||
response = client.get(path)
|
||||
assert response.status_code == 200, path
|
||||
html = response.data.decode()
|
||||
assert "http://localhost" not in html, path
|
||||
|
||||
home = client.get("/").data.decode()
|
||||
assert 'href="https://blog.example.com/feed"' in home
|
||||
assert 'href="https://blog.example.com/opml.xml"' in home
|
||||
|
||||
note_html = client.get(f"/note/{note.slug}").data.decode()
|
||||
assert f'href="https://blog.example.com/note/{note.slug}"' in note_html
|
||||
@@ -12,21 +12,11 @@ import pytest
|
||||
from flask import g
|
||||
|
||||
from starpunk.auth import (
|
||||
AuthError,
|
||||
IndieLoginError,
|
||||
InvalidStateError,
|
||||
UnauthorizedError,
|
||||
_cleanup_expired_sessions,
|
||||
_generate_state_token,
|
||||
_hash_token,
|
||||
_log_http_request,
|
||||
_log_http_response,
|
||||
_redact_token,
|
||||
_verify_state_token,
|
||||
create_session,
|
||||
destroy_session,
|
||||
handle_callback,
|
||||
initiate_login,
|
||||
require_auth,
|
||||
verify_session,
|
||||
)
|
||||
@@ -104,45 +94,6 @@ class TestHelpers:
|
||||
assert len(set(tokens)) == 10
|
||||
|
||||
|
||||
class TestStateTokenVerification:
|
||||
def test_verify_valid_state_token(self, app, db):
|
||||
"""Test verifying a valid state token"""
|
||||
with app.app_context():
|
||||
state = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.utcnow() + timedelta(minutes=5)
|
||||
|
||||
db.execute(
|
||||
"INSERT INTO auth_state (state, expires_at) VALUES (?, ?)",
|
||||
(state, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
assert _verify_state_token(state) is True
|
||||
|
||||
# Token should be deleted after verification
|
||||
result = db.execute(
|
||||
"SELECT 1 FROM auth_state WHERE state = ?", (state,)
|
||||
).fetchone()
|
||||
assert result is None
|
||||
|
||||
def test_verify_invalid_state_token(self, app):
|
||||
"""Test verifying an invalid state token"""
|
||||
with app.app_context():
|
||||
assert _verify_state_token("invalid-token") is False
|
||||
|
||||
def test_verify_expired_state_token(self, app, db):
|
||||
"""Test verifying an expired state token"""
|
||||
with app.app_context():
|
||||
state = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.utcnow() - timedelta(minutes=5)
|
||||
|
||||
db.execute(
|
||||
"INSERT INTO auth_state (state, expires_at) VALUES (?, ?)",
|
||||
(state, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
assert _verify_state_token(state) is False
|
||||
|
||||
|
||||
class TestCleanup:
|
||||
@@ -170,25 +121,6 @@ class TestCleanup:
|
||||
).fetchone()
|
||||
assert result is None
|
||||
|
||||
def test_cleanup_expired_auth_state(self, app, db):
|
||||
"""Test cleanup of expired auth state"""
|
||||
with app.app_context():
|
||||
state = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.utcnow() - timedelta(minutes=10)
|
||||
|
||||
db.execute(
|
||||
"INSERT INTO auth_state (state, expires_at) VALUES (?, ?)",
|
||||
(state, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
_cleanup_expired_sessions()
|
||||
|
||||
# Expired state should be deleted
|
||||
result = db.execute(
|
||||
"SELECT 1 FROM auth_state WHERE state = ?", (state,)
|
||||
).fetchone()
|
||||
assert result is None
|
||||
|
||||
def test_cleanup_keeps_valid_sessions(self, app, db):
|
||||
"""Test that cleanup keeps valid sessions"""
|
||||
@@ -214,185 +146,8 @@ class TestCleanup:
|
||||
assert result is not None
|
||||
|
||||
|
||||
class TestInitiateLogin:
|
||||
@patch("starpunk.auth.discover_endpoints")
|
||||
def test_initiate_login_success(self, mock_discover, app, db):
|
||||
"""Test successful login initiation"""
|
||||
mock_discover.return_value = {
|
||||
'authorization_endpoint': 'https://auth.example.com/authorize',
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
with app.app_context():
|
||||
me_url = "https://example.com"
|
||||
auth_url = initiate_login(me_url)
|
||||
|
||||
# Changed: Check for discovered endpoint instead of indielogin.com
|
||||
assert "auth.example.com/authorize" in auth_url
|
||||
assert "me=https%3A%2F%2Fexample.com" in auth_url
|
||||
assert "client_id=" in auth_url
|
||||
assert "redirect_uri=" in auth_url
|
||||
assert "state=" in auth_url
|
||||
# Per W3C IndieAuth: response_type=id for authentication-only (identity verification)
|
||||
assert "response_type=id" in auth_url
|
||||
|
||||
# State should be stored in database
|
||||
result = db.execute("SELECT COUNT(*) as count FROM auth_state").fetchone()
|
||||
assert result["count"] > 0
|
||||
|
||||
def test_initiate_login_invalid_url(self, app):
|
||||
"""Test login initiation with invalid URL"""
|
||||
with app.app_context():
|
||||
with pytest.raises(ValueError, match="Invalid URL format"):
|
||||
initiate_login("not-a-url")
|
||||
|
||||
@patch("starpunk.auth.discover_endpoints")
|
||||
def test_initiate_login_stores_state(self, mock_discover, app, db):
|
||||
"""Test that state token is stored"""
|
||||
mock_discover.return_value = {
|
||||
'authorization_endpoint': 'https://auth.example.com/authorize',
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
with app.app_context():
|
||||
me_url = "https://example.com"
|
||||
auth_url = initiate_login(me_url)
|
||||
|
||||
# Extract state from URL
|
||||
state_param = [p for p in auth_url.split("&") if p.startswith("state=")][0]
|
||||
state = state_param.split("=")[1]
|
||||
|
||||
# State should exist in database
|
||||
result = db.execute(
|
||||
"SELECT expires_at FROM auth_state WHERE state = ?", (state,)
|
||||
).fetchone()
|
||||
assert result is not None
|
||||
|
||||
|
||||
class TestHandleCallback:
|
||||
@patch("starpunk.auth.discover_endpoints")
|
||||
@patch("starpunk.auth.httpx.post")
|
||||
def test_handle_callback_success(self, mock_post, mock_discover, app, db, client):
|
||||
"""Test successful callback handling"""
|
||||
mock_discover.return_value = {
|
||||
'authorization_endpoint': 'https://auth.example.com/authorize',
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
with app.test_request_context():
|
||||
# Setup state token
|
||||
state = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.utcnow() + timedelta(minutes=5)
|
||||
db.execute(
|
||||
"INSERT INTO auth_state (state, expires_at) VALUES (?, ?)",
|
||||
(state, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
# Mock authorization endpoint response
|
||||
mock_response = MagicMock()
|
||||
mock_response.json.return_value = {"me": "https://example.com"}
|
||||
mock_post.return_value = mock_response
|
||||
|
||||
# Handle callback
|
||||
code = "test-code"
|
||||
session_token = handle_callback(code, state)
|
||||
|
||||
assert session_token is not None
|
||||
assert isinstance(session_token, str)
|
||||
|
||||
# Session should be created
|
||||
token_hash = _hash_token(session_token)
|
||||
result = db.execute(
|
||||
"SELECT me FROM sessions WHERE session_token_hash = ?", (token_hash,)
|
||||
).fetchone()
|
||||
assert result is not None
|
||||
assert result["me"] == "https://example.com"
|
||||
|
||||
def test_handle_callback_invalid_state(self, app):
|
||||
"""Test callback with invalid state"""
|
||||
with app.app_context():
|
||||
with pytest.raises(InvalidStateError):
|
||||
handle_callback("code", "invalid-state")
|
||||
|
||||
@patch("starpunk.auth.discover_endpoints")
|
||||
@patch("starpunk.auth.httpx.post")
|
||||
def test_handle_callback_unauthorized_user(self, mock_post, mock_discover, app, db):
|
||||
"""Test callback with unauthorized user"""
|
||||
mock_discover.return_value = {
|
||||
'authorization_endpoint': 'https://auth.example.com/authorize',
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
with app.app_context():
|
||||
# Setup state token
|
||||
state = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.utcnow() + timedelta(minutes=5)
|
||||
db.execute(
|
||||
"INSERT INTO auth_state (state, expires_at) VALUES (?, ?)",
|
||||
(state, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
# Mock authorization endpoint response with different user
|
||||
mock_response = MagicMock()
|
||||
mock_response.json.return_value = {"me": "https://attacker.com"}
|
||||
mock_post.return_value = mock_response
|
||||
|
||||
with pytest.raises(UnauthorizedError):
|
||||
handle_callback("code", state)
|
||||
|
||||
@patch("starpunk.auth.discover_endpoints")
|
||||
@patch("starpunk.auth.httpx.post")
|
||||
def test_handle_callback_indielogin_error(self, mock_post, mock_discover, app, db):
|
||||
"""Test callback with authorization endpoint error"""
|
||||
mock_discover.return_value = {
|
||||
'authorization_endpoint': 'https://auth.example.com/authorize',
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
with app.app_context():
|
||||
# Setup state token
|
||||
state = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.utcnow() + timedelta(minutes=5)
|
||||
db.execute(
|
||||
"INSERT INTO auth_state (state, expires_at) VALUES (?, ?)",
|
||||
(state, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
# Mock authorization endpoint error
|
||||
mock_post.side_effect = httpx.RequestError("Connection failed")
|
||||
|
||||
with pytest.raises(IndieLoginError):
|
||||
handle_callback("code", state)
|
||||
|
||||
@patch("starpunk.auth.discover_endpoints")
|
||||
@patch("starpunk.auth.httpx.post")
|
||||
def test_handle_callback_no_identity(self, mock_post, mock_discover, app, db):
|
||||
"""Test callback with no identity in response"""
|
||||
mock_discover.return_value = {
|
||||
'authorization_endpoint': 'https://auth.example.com/authorize',
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
with app.app_context():
|
||||
# Setup state token
|
||||
state = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.utcnow() + timedelta(minutes=5)
|
||||
db.execute(
|
||||
"INSERT INTO auth_state (state, expires_at) VALUES (?, ?)",
|
||||
(state, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
# Mock authorization endpoint response without 'me' field
|
||||
mock_response = MagicMock()
|
||||
mock_response.json.return_value = {}
|
||||
mock_post.return_value = mock_response
|
||||
|
||||
with pytest.raises(IndieLoginError, match="No identity returned"):
|
||||
handle_callback("code", state)
|
||||
|
||||
|
||||
class TestCreateSession:
|
||||
@@ -625,23 +380,6 @@ class TestSecurityFeatures:
|
||||
assert result["session_token_hash"] != session_token
|
||||
assert len(result["session_token_hash"]) == 64 # SHA-256 hex length
|
||||
|
||||
def test_state_tokens_are_single_use(self, app, db):
|
||||
"""Test that state tokens can only be used once"""
|
||||
with app.app_context():
|
||||
state = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.utcnow() + timedelta(minutes=5)
|
||||
|
||||
db.execute(
|
||||
"INSERT INTO auth_state (state, expires_at) VALUES (?, ?)",
|
||||
(state, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
# First verification should succeed
|
||||
assert _verify_state_token(state) is True
|
||||
|
||||
# Second verification should fail (token deleted)
|
||||
assert _verify_state_token(state) is False
|
||||
|
||||
def test_session_expiry(self, app, db, client):
|
||||
"""Test that sessions expire correctly"""
|
||||
@@ -668,273 +406,13 @@ class TestSecurityFeatures:
|
||||
assert delta.total_seconds() <= 86401 # At most 1 day + 1 second
|
||||
|
||||
|
||||
class TestExceptionHierarchy:
|
||||
def test_exception_inheritance(self):
|
||||
"""Test that custom exceptions inherit correctly"""
|
||||
assert issubclass(InvalidStateError, AuthError)
|
||||
assert issubclass(UnauthorizedError, AuthError)
|
||||
assert issubclass(IndieLoginError, AuthError)
|
||||
assert issubclass(AuthError, Exception)
|
||||
|
||||
def test_exception_messages(self):
|
||||
"""Test that exceptions can carry messages"""
|
||||
error = InvalidStateError("Test message")
|
||||
assert str(error) == "Test message"
|
||||
|
||||
error = UnauthorizedError("Unauthorized")
|
||||
assert str(error) == "Unauthorized"
|
||||
|
||||
error = IndieLoginError("Service error")
|
||||
assert str(error) == "Service error"
|
||||
|
||||
|
||||
class TestLoggingHelpers:
|
||||
def test_redact_token_normal(self):
|
||||
"""Test token redaction for normal-length tokens"""
|
||||
token = "abcdefghijklmnopqrstuvwxyz"
|
||||
result = _redact_token(token, 6)
|
||||
assert result == "abcdef...********...wxyz"
|
||||
|
||||
def test_redact_token_short(self):
|
||||
"""Test token redaction for short tokens"""
|
||||
token = "short"
|
||||
result = _redact_token(token, 6)
|
||||
assert result == "***REDACTED***"
|
||||
|
||||
def test_redact_token_empty(self):
|
||||
"""Test token redaction for empty tokens"""
|
||||
result = _redact_token("", 6)
|
||||
assert result == "***REDACTED***"
|
||||
|
||||
result = _redact_token(None, 6)
|
||||
assert result == "***REDACTED***"
|
||||
|
||||
def test_redact_token_custom_length(self):
|
||||
"""Test token redaction with custom show_chars"""
|
||||
token = "abcdefghijklmnopqrstuvwxyz"
|
||||
result = _redact_token(token, 8)
|
||||
assert result == "abcdefgh...********...wxyz"
|
||||
|
||||
def test_log_http_request_redacts_code(self, app, caplog):
|
||||
"""Test that code parameter is redacted in request logs"""
|
||||
import logging
|
||||
|
||||
with app.app_context():
|
||||
# Set DEBUG level for logging
|
||||
app.logger.setLevel(logging.DEBUG)
|
||||
|
||||
with caplog.at_level(logging.DEBUG):
|
||||
_log_http_request(
|
||||
method="POST",
|
||||
url="https://indielogin.com/auth",
|
||||
data={"code": "sensitive_code_12345"},
|
||||
)
|
||||
|
||||
# Should log but with redacted code
|
||||
assert "sensitive_code_12345" not in caplog.text
|
||||
assert "sensit...********...2345" in caplog.text
|
||||
|
||||
def test_log_http_request_redacts_state(self, app, caplog):
|
||||
"""Test that state parameter is redacted in request logs"""
|
||||
import logging
|
||||
|
||||
with app.app_context():
|
||||
app.logger.setLevel(logging.DEBUG)
|
||||
|
||||
with caplog.at_level(logging.DEBUG):
|
||||
_log_http_request(
|
||||
method="POST",
|
||||
url="https://indielogin.com/auth",
|
||||
data={"state": "state_token_123456789"},
|
||||
)
|
||||
|
||||
# Should log but with redacted state (8 chars shown at start)
|
||||
assert "state_token_123456789" not in caplog.text
|
||||
assert "state_to...********...6789" in caplog.text
|
||||
|
||||
def test_log_http_request_not_logged_at_info(self, app, caplog):
|
||||
"""Test that HTTP requests are not logged at INFO level"""
|
||||
import logging
|
||||
|
||||
with app.app_context():
|
||||
app.logger.setLevel(logging.INFO)
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
_log_http_request(
|
||||
method="POST",
|
||||
url="https://indielogin.com/auth",
|
||||
data={"code": "test_code"},
|
||||
)
|
||||
|
||||
# Should not log anything
|
||||
assert "IndieAuth HTTP Request" not in caplog.text
|
||||
|
||||
def test_log_http_response_redacts_tokens(self, app, caplog):
|
||||
"""Test that response tokens are redacted"""
|
||||
import logging
|
||||
|
||||
with app.app_context():
|
||||
app.logger.setLevel(logging.DEBUG)
|
||||
|
||||
with caplog.at_level(logging.DEBUG):
|
||||
_log_http_response(
|
||||
status_code=200,
|
||||
headers={"content-type": "application/json"},
|
||||
body='{"access_token": "secret_token_xyz789"}',
|
||||
)
|
||||
|
||||
# Should log but with redacted token
|
||||
assert "secret_token_xyz789" not in caplog.text
|
||||
assert "secret...********...z789" in caplog.text
|
||||
|
||||
def test_log_http_response_handles_non_json(self, app, caplog):
|
||||
"""Test that non-JSON responses are logged as-is"""
|
||||
import logging
|
||||
|
||||
with app.app_context():
|
||||
app.logger.setLevel(logging.DEBUG)
|
||||
|
||||
with caplog.at_level(logging.DEBUG):
|
||||
_log_http_response(
|
||||
status_code=500, headers={}, body="Internal Server Error"
|
||||
)
|
||||
|
||||
# Should log the plain text body
|
||||
assert "Internal Server Error" in caplog.text
|
||||
|
||||
def test_log_http_response_redacts_sensitive_headers(self, app, caplog):
|
||||
"""Test that sensitive headers are redacted"""
|
||||
import logging
|
||||
|
||||
with app.app_context():
|
||||
app.logger.setLevel(logging.DEBUG)
|
||||
|
||||
with caplog.at_level(logging.DEBUG):
|
||||
_log_http_response(
|
||||
status_code=200,
|
||||
headers={
|
||||
"content-type": "application/json",
|
||||
"set-cookie": "sensitive_cookie",
|
||||
"authorization": "Bearer token",
|
||||
},
|
||||
body='{"me": "https://example.com"}',
|
||||
)
|
||||
|
||||
# Should log content-type but not sensitive headers
|
||||
assert "content-type" in caplog.text
|
||||
assert "set-cookie" not in caplog.text
|
||||
assert "authorization" not in caplog.text
|
||||
assert "sensitive_cookie" not in caplog.text
|
||||
|
||||
|
||||
class TestLoggingIntegration:
|
||||
@patch("starpunk.auth.discover_endpoints")
|
||||
def test_initiate_login_logs_at_debug(self, mock_discover, app, db, caplog):
|
||||
"""Test that initiate_login logs at DEBUG level"""
|
||||
import logging
|
||||
|
||||
mock_discover.return_value = {
|
||||
'authorization_endpoint': 'https://auth.example.com/authorize',
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
with app.app_context():
|
||||
app.logger.setLevel(logging.DEBUG)
|
||||
|
||||
with caplog.at_level(logging.DEBUG):
|
||||
me_url = "https://example.com"
|
||||
initiate_login(me_url)
|
||||
|
||||
# Should see DEBUG logs
|
||||
assert "Validating me URL" in caplog.text
|
||||
assert "Generated state token" in caplog.text
|
||||
assert "Building authorization URL" in caplog.text
|
||||
|
||||
# Should see INFO log
|
||||
assert "Authentication initiated" in caplog.text
|
||||
|
||||
@patch("starpunk.auth.discover_endpoints")
|
||||
def test_initiate_login_info_level(self, mock_discover, app, db, caplog):
|
||||
"""Test that initiate_login only shows milestones at INFO level"""
|
||||
import logging
|
||||
|
||||
mock_discover.return_value = {
|
||||
'authorization_endpoint': 'https://auth.example.com/authorize',
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
with app.app_context():
|
||||
app.logger.setLevel(logging.INFO)
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
me_url = "https://example.com"
|
||||
initiate_login(me_url)
|
||||
|
||||
# Should see INFO milestone
|
||||
assert "Authentication initiated" in caplog.text
|
||||
|
||||
# Should NOT see DEBUG details
|
||||
assert "Validating me URL" not in caplog.text
|
||||
assert "Generated state token" not in caplog.text
|
||||
|
||||
@patch("starpunk.auth.discover_endpoints")
|
||||
@patch("starpunk.auth.httpx.post")
|
||||
def test_handle_callback_logs_http_details(self, mock_post, mock_discover, app, db, client, caplog):
|
||||
"""Test that handle_callback logs HTTP request/response at DEBUG"""
|
||||
import logging
|
||||
|
||||
mock_discover.return_value = {
|
||||
'authorization_endpoint': 'https://auth.example.com/authorize',
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
with app.test_request_context():
|
||||
app.logger.setLevel(logging.DEBUG)
|
||||
|
||||
# Setup state token
|
||||
state = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.utcnow() + timedelta(minutes=5)
|
||||
db.execute(
|
||||
"INSERT INTO auth_state (state, expires_at) VALUES (?, ?)",
|
||||
(state, expires_at),
|
||||
)
|
||||
db.commit()
|
||||
|
||||
# Mock authorization endpoint response
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.headers = {"content-type": "application/json"}
|
||||
mock_response.text = '{"me": "https://example.com"}'
|
||||
mock_response.json.return_value = {"me": "https://example.com"}
|
||||
mock_post.return_value = mock_response
|
||||
|
||||
with caplog.at_level(logging.DEBUG):
|
||||
code = "test_authorization_code"
|
||||
handle_callback(code, state)
|
||||
|
||||
# Should see HTTP request/response logs
|
||||
assert "IndieAuth HTTP Request" in caplog.text
|
||||
assert "IndieAuth HTTP Response" in caplog.text
|
||||
|
||||
# Code should be redacted
|
||||
assert "test_authorization_code" not in caplog.text
|
||||
assert "test_a...********...code" in caplog.text
|
||||
|
||||
def test_create_session_logs_details(self, app, db, client, caplog):
|
||||
"""Test that create_session logs session details at DEBUG"""
|
||||
import logging
|
||||
|
||||
with app.test_request_context():
|
||||
app.logger.setLevel(logging.DEBUG)
|
||||
|
||||
with caplog.at_level(logging.DEBUG):
|
||||
me = "https://example.com"
|
||||
create_session(me)
|
||||
|
||||
# Should see DEBUG logs
|
||||
assert "Session token generated" in caplog.text
|
||||
assert "Session expiry" in caplog.text
|
||||
assert "Request metadata" in caplog.text
|
||||
|
||||
# Should see INFO log
|
||||
assert "Session created" in caplog.text
|
||||
@@ -1,637 +0,0 @@
|
||||
"""
|
||||
Tests for external IndieAuth token verification with endpoint discovery
|
||||
|
||||
Tests cover:
|
||||
- Endpoint discovery from HTTP Link headers
|
||||
- Endpoint discovery from HTML link elements
|
||||
- Token verification with discovered endpoints
|
||||
- Caching behavior for endpoints and tokens
|
||||
- Error handling and edge cases
|
||||
- HTTPS validation
|
||||
- URL normalization
|
||||
|
||||
ADR: ADR-031 IndieAuth Endpoint Discovery Implementation
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import time
|
||||
from unittest.mock import Mock, patch
|
||||
import pytest
|
||||
import httpx
|
||||
|
||||
from starpunk.auth_external import (
|
||||
verify_external_token,
|
||||
discover_endpoints,
|
||||
check_scope,
|
||||
normalize_url,
|
||||
_parse_link_header,
|
||||
_parse_html_links,
|
||||
_cache,
|
||||
DiscoveryError,
|
||||
TokenVerificationError,
|
||||
ENDPOINT_CACHE_TTL,
|
||||
TOKEN_CACHE_TTL,
|
||||
)
|
||||
|
||||
|
||||
# Test Fixtures
|
||||
# -------------
|
||||
|
||||
@pytest.fixture
|
||||
def mock_profile_html():
|
||||
"""HTML profile with IndieAuth link elements"""
|
||||
return """
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<link rel="authorization_endpoint" href="https://auth.example.com/authorize">
|
||||
<link rel="token_endpoint" href="https://auth.example.com/token">
|
||||
<title>Test Profile</title>
|
||||
</head>
|
||||
<body>
|
||||
<h1>Hello World</h1>
|
||||
</body>
|
||||
</html>
|
||||
"""
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_profile_html_relative():
|
||||
"""HTML profile with relative URLs"""
|
||||
return """
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<link rel="authorization_endpoint" href="/auth/authorize">
|
||||
<link rel="token_endpoint" href="/auth/token">
|
||||
</head>
|
||||
<body></body>
|
||||
</html>
|
||||
"""
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_link_headers():
|
||||
"""HTTP Link headers with IndieAuth endpoints"""
|
||||
return (
|
||||
'<https://auth.example.com/authorize>; rel="authorization_endpoint", '
|
||||
'<https://auth.example.com/token>; rel="token_endpoint"'
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_token_response():
|
||||
"""Valid token verification response"""
|
||||
return {
|
||||
'me': 'https://alice.example.com/',
|
||||
'client_id': 'https://app.example.com/',
|
||||
'scope': 'create update',
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def clear_cache():
|
||||
"""Clear cache before each test"""
|
||||
_cache.endpoints = None
|
||||
_cache.endpoints_expire = 0
|
||||
_cache.token_cache.clear()
|
||||
yield
|
||||
# Clear after test too
|
||||
_cache.endpoints = None
|
||||
_cache.endpoints_expire = 0
|
||||
_cache.token_cache.clear()
|
||||
|
||||
|
||||
# Endpoint Discovery Tests
|
||||
# -------------------------
|
||||
|
||||
def test_parse_link_header_both_endpoints(mock_link_headers):
|
||||
"""Parse Link header with both authorization and token endpoints"""
|
||||
endpoints = _parse_link_header(mock_link_headers, 'https://alice.example.com/')
|
||||
|
||||
assert endpoints['authorization_endpoint'] == 'https://auth.example.com/authorize'
|
||||
assert endpoints['token_endpoint'] == 'https://auth.example.com/token'
|
||||
|
||||
|
||||
def test_parse_link_header_single_endpoint():
|
||||
"""Parse Link header with only token endpoint"""
|
||||
header = '<https://auth.example.com/token>; rel="token_endpoint"'
|
||||
endpoints = _parse_link_header(header, 'https://alice.example.com/')
|
||||
|
||||
assert endpoints['token_endpoint'] == 'https://auth.example.com/token'
|
||||
assert 'authorization_endpoint' not in endpoints
|
||||
|
||||
|
||||
def test_parse_link_header_relative_url():
|
||||
"""Parse Link header with relative URL"""
|
||||
header = '</auth/token>; rel="token_endpoint"'
|
||||
endpoints = _parse_link_header(header, 'https://alice.example.com/')
|
||||
|
||||
assert endpoints['token_endpoint'] == 'https://alice.example.com/auth/token'
|
||||
|
||||
|
||||
def test_parse_html_links_both_endpoints(mock_profile_html):
|
||||
"""Parse HTML with both authorization and token endpoints"""
|
||||
endpoints = _parse_html_links(mock_profile_html, 'https://alice.example.com/')
|
||||
|
||||
assert endpoints['authorization_endpoint'] == 'https://auth.example.com/authorize'
|
||||
assert endpoints['token_endpoint'] == 'https://auth.example.com/token'
|
||||
|
||||
|
||||
def test_parse_html_links_relative_urls(mock_profile_html_relative):
|
||||
"""Parse HTML with relative endpoint URLs"""
|
||||
endpoints = _parse_html_links(
|
||||
mock_profile_html_relative,
|
||||
'https://alice.example.com/'
|
||||
)
|
||||
|
||||
assert endpoints['authorization_endpoint'] == 'https://alice.example.com/auth/authorize'
|
||||
assert endpoints['token_endpoint'] == 'https://alice.example.com/auth/token'
|
||||
|
||||
|
||||
def test_parse_html_links_empty():
|
||||
"""Parse HTML with no IndieAuth links"""
|
||||
html = '<html><head></head><body></body></html>'
|
||||
endpoints = _parse_html_links(html, 'https://alice.example.com/')
|
||||
|
||||
assert endpoints == {}
|
||||
|
||||
|
||||
def test_parse_html_links_malformed():
|
||||
"""Parse malformed HTML gracefully"""
|
||||
html = '<html><head><link rel="token_endpoint"' # Missing closing tags
|
||||
endpoints = _parse_html_links(html, 'https://alice.example.com/')
|
||||
|
||||
# Should return empty dict, not crash
|
||||
assert isinstance(endpoints, dict)
|
||||
|
||||
|
||||
def test_parse_html_links_rel_as_list():
|
||||
"""Parse HTML where rel attribute is a list"""
|
||||
html = '''
|
||||
<html><head>
|
||||
<link rel="authorization_endpoint me" href="https://auth.example.com/authorize">
|
||||
</head></html>
|
||||
'''
|
||||
endpoints = _parse_html_links(html, 'https://alice.example.com/')
|
||||
|
||||
assert endpoints['authorization_endpoint'] == 'https://auth.example.com/authorize'
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_from_html(mock_get, app_with_admin_me, mock_profile_html):
|
||||
"""Discover endpoints from HTML link elements"""
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.headers = {'Content-Type': 'text/html'}
|
||||
mock_response.text = mock_profile_html
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
endpoints = discover_endpoints('https://alice.example.com/')
|
||||
|
||||
assert endpoints['token_endpoint'] == 'https://auth.example.com/token'
|
||||
assert endpoints['authorization_endpoint'] == 'https://auth.example.com/authorize'
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_from_link_header(mock_get, app_with_admin_me, mock_link_headers):
|
||||
"""Discover endpoints from HTTP Link headers"""
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.headers = {
|
||||
'Content-Type': 'text/html',
|
||||
'Link': mock_link_headers
|
||||
}
|
||||
mock_response.text = '<html></html>'
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
endpoints = discover_endpoints('https://alice.example.com/')
|
||||
|
||||
assert endpoints['token_endpoint'] == 'https://auth.example.com/token'
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_link_header_priority(mock_get, app_with_admin_me, mock_profile_html, mock_link_headers):
|
||||
"""Link headers take priority over HTML link elements"""
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.headers = {
|
||||
'Content-Type': 'text/html',
|
||||
'Link': '<https://different.example.com/token>; rel="token_endpoint"'
|
||||
}
|
||||
# HTML has different endpoint
|
||||
mock_response.text = mock_profile_html
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
endpoints = discover_endpoints('https://alice.example.com/')
|
||||
|
||||
# Link header should win
|
||||
assert endpoints['token_endpoint'] == 'https://different.example.com/token'
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_no_token_endpoint(mock_get, app_with_admin_me):
|
||||
"""Raise error if no IndieAuth endpoints found"""
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.headers = {'Content-Type': 'text/html'}
|
||||
mock_response.text = '<html><head></head><body></body></html>'
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
with pytest.raises(DiscoveryError) as exc_info:
|
||||
discover_endpoints('https://alice.example.com/')
|
||||
|
||||
assert 'No IndieAuth endpoints found' in str(exc_info.value)
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_http_error(mock_get, app_with_admin_me):
|
||||
"""Handle HTTP errors during discovery"""
|
||||
mock_get.side_effect = httpx.HTTPStatusError(
|
||||
"404 Not Found",
|
||||
request=Mock(),
|
||||
response=Mock(status_code=404)
|
||||
)
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
with pytest.raises(DiscoveryError) as exc_info:
|
||||
discover_endpoints('https://alice.example.com/')
|
||||
|
||||
assert 'HTTP 404' in str(exc_info.value)
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_timeout(mock_get, app_with_admin_me):
|
||||
"""Handle timeout during discovery"""
|
||||
mock_get.side_effect = httpx.TimeoutException("Timeout")
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
with pytest.raises(DiscoveryError) as exc_info:
|
||||
discover_endpoints('https://alice.example.com/')
|
||||
|
||||
assert 'Timeout' in str(exc_info.value)
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_network_error(mock_get, app_with_admin_me):
|
||||
"""Handle network errors during discovery"""
|
||||
mock_get.side_effect = httpx.NetworkError("Connection failed")
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
with pytest.raises(DiscoveryError) as exc_info:
|
||||
discover_endpoints('https://alice.example.com/')
|
||||
|
||||
assert 'Network error' in str(exc_info.value)
|
||||
|
||||
|
||||
# HTTPS Validation Tests
|
||||
# -----------------------
|
||||
|
||||
def test_discover_endpoints_http_not_allowed_production(app_with_admin_me):
|
||||
"""HTTP profile URLs not allowed in production"""
|
||||
with app_with_admin_me.app_context():
|
||||
app_with_admin_me.config['DEBUG'] = False
|
||||
|
||||
with pytest.raises(DiscoveryError) as exc_info:
|
||||
discover_endpoints('http://alice.example.com/')
|
||||
|
||||
assert 'HTTPS required' in str(exc_info.value)
|
||||
|
||||
|
||||
def test_discover_endpoints_http_allowed_debug(app_with_admin_me):
|
||||
"""HTTP profile URLs allowed in debug mode"""
|
||||
with app_with_admin_me.app_context():
|
||||
app_with_admin_me.config['DEBUG'] = True
|
||||
|
||||
# Should validate without raising (mock would be needed for full test)
|
||||
# Just test validation doesn't raise
|
||||
from starpunk.auth_external import _validate_profile_url
|
||||
_validate_profile_url('http://localhost:5000/')
|
||||
|
||||
|
||||
def test_discover_endpoints_localhost_not_allowed_production(app_with_admin_me):
|
||||
"""Localhost URLs not allowed in production"""
|
||||
with app_with_admin_me.app_context():
|
||||
app_with_admin_me.config['DEBUG'] = False
|
||||
|
||||
with pytest.raises(DiscoveryError) as exc_info:
|
||||
discover_endpoints('https://localhost/')
|
||||
|
||||
assert 'Localhost' in str(exc_info.value)
|
||||
|
||||
|
||||
# Caching Tests
|
||||
# -------------
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_caching(mock_get, app_with_admin_me, mock_profile_html):
|
||||
"""Discovered endpoints are cached"""
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.headers = {'Content-Type': 'text/html'}
|
||||
mock_response.text = mock_profile_html
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
# First call - should fetch
|
||||
endpoints1 = discover_endpoints('https://alice.example.com/')
|
||||
|
||||
# Second call - should use cache
|
||||
endpoints2 = discover_endpoints('https://alice.example.com/')
|
||||
|
||||
# Should only call httpx.get once
|
||||
assert mock_get.call_count == 1
|
||||
assert endpoints1 == endpoints2
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_cache_expiry(mock_get, app_with_admin_me, mock_profile_html):
|
||||
"""Endpoint cache expires after TTL"""
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.headers = {'Content-Type': 'text/html'}
|
||||
mock_response.text = mock_profile_html
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
# First call
|
||||
discover_endpoints('https://alice.example.com/')
|
||||
|
||||
# Expire cache manually
|
||||
_cache.endpoints_expire = time.time() - 1
|
||||
|
||||
# Second call should fetch again
|
||||
discover_endpoints('https://alice.example.com/')
|
||||
|
||||
assert mock_get.call_count == 2
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_discover_endpoints_grace_period(mock_get, app_with_admin_me, mock_profile_html):
|
||||
"""Use expired cache on network failure (grace period)"""
|
||||
# First call succeeds
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.headers = {'Content-Type': 'text/html'}
|
||||
mock_response.text = mock_profile_html
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
endpoints1 = discover_endpoints('https://alice.example.com/')
|
||||
|
||||
# Expire cache
|
||||
_cache.endpoints_expire = time.time() - 1
|
||||
|
||||
# Second call fails, but should use expired cache
|
||||
mock_get.side_effect = httpx.NetworkError("Connection failed")
|
||||
|
||||
endpoints2 = discover_endpoints('https://alice.example.com/')
|
||||
|
||||
# Should return cached endpoints despite network failure
|
||||
assert endpoints1 == endpoints2
|
||||
|
||||
|
||||
# Token Verification Tests
|
||||
# -------------------------
|
||||
|
||||
@patch('starpunk.auth_external.discover_endpoints')
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_verify_external_token_success(mock_get, mock_discover, app_with_admin_me, mock_token_response):
|
||||
"""Successfully verify token with discovered endpoint"""
|
||||
# Mock discovery
|
||||
mock_discover.return_value = {
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
# Mock token verification
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = mock_token_response
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
token_info = verify_external_token('test-token-123')
|
||||
|
||||
assert token_info is not None
|
||||
assert token_info['me'] == 'https://alice.example.com/'
|
||||
assert token_info['scope'] == 'create update'
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.discover_endpoints')
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_verify_external_token_wrong_me(mock_get, mock_discover, app_with_admin_me):
|
||||
"""Reject token for different user"""
|
||||
mock_discover.return_value = {
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
# Token for wrong user
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {
|
||||
'me': 'https://bob.example.com/', # Not ADMIN_ME
|
||||
'scope': 'create',
|
||||
}
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
token_info = verify_external_token('test-token-123')
|
||||
|
||||
# Should reject
|
||||
assert token_info is None
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.discover_endpoints')
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_verify_external_token_401(mock_get, mock_discover, app_with_admin_me):
|
||||
"""Handle 401 Unauthorized from token endpoint"""
|
||||
mock_discover.return_value = {
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 401
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
token_info = verify_external_token('invalid-token')
|
||||
|
||||
assert token_info is None
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.discover_endpoints')
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_verify_external_token_missing_me(mock_get, mock_discover, app_with_admin_me):
|
||||
"""Reject token response missing 'me' field"""
|
||||
mock_discover.return_value = {
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {
|
||||
'scope': 'create',
|
||||
# Missing 'me' field
|
||||
}
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
token_info = verify_external_token('test-token')
|
||||
|
||||
assert token_info is None
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.discover_endpoints')
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_verify_external_token_retry_on_500(mock_get, mock_discover, app_with_admin_me, mock_token_response):
|
||||
"""Retry token verification on 500 server error"""
|
||||
mock_discover.return_value = {
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
# First call: 500 error
|
||||
error_response = Mock()
|
||||
error_response.status_code = 500
|
||||
|
||||
# Second call: success
|
||||
success_response = Mock()
|
||||
success_response.status_code = 200
|
||||
success_response.json.return_value = mock_token_response
|
||||
|
||||
mock_get.side_effect = [error_response, success_response]
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
with patch('time.sleep'): # Skip sleep delay
|
||||
token_info = verify_external_token('test-token')
|
||||
|
||||
assert token_info is not None
|
||||
assert mock_get.call_count == 2
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.discover_endpoints')
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_verify_external_token_no_retry_on_403(mock_get, mock_discover, app_with_admin_me):
|
||||
"""Don't retry on 403 Forbidden (client error)"""
|
||||
mock_discover.return_value = {
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 403
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
token_info = verify_external_token('test-token')
|
||||
|
||||
assert token_info is None
|
||||
# Should only call once (no retries)
|
||||
assert mock_get.call_count == 1
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.discover_endpoints')
|
||||
@patch('starpunk.auth_external.httpx.get')
|
||||
def test_verify_external_token_caching(mock_get, mock_discover, app_with_admin_me, mock_token_response):
|
||||
"""Token verifications are cached"""
|
||||
mock_discover.return_value = {
|
||||
'token_endpoint': 'https://auth.example.com/token'
|
||||
}
|
||||
|
||||
mock_response = Mock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = mock_token_response
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with app_with_admin_me.app_context():
|
||||
# First call
|
||||
token_info1 = verify_external_token('test-token')
|
||||
|
||||
# Second call should use cache
|
||||
token_info2 = verify_external_token('test-token')
|
||||
|
||||
assert token_info1 == token_info2
|
||||
# Should only verify once
|
||||
assert mock_get.call_count == 1
|
||||
|
||||
|
||||
@patch('starpunk.auth_external.discover_endpoints')
|
||||
def test_verify_external_token_no_admin_me(mock_discover, app):
|
||||
"""Fail if ADMIN_ME not configured"""
|
||||
with app.app_context():
|
||||
# app fixture has no ADMIN_ME
|
||||
token_info = verify_external_token('test-token')
|
||||
|
||||
assert token_info is None
|
||||
# Should not even attempt discovery
|
||||
mock_discover.assert_not_called()
|
||||
|
||||
|
||||
# URL Normalization Tests
|
||||
# ------------------------
|
||||
|
||||
def test_normalize_url_removes_trailing_slash():
|
||||
"""Normalize URL removes trailing slash"""
|
||||
assert normalize_url('https://example.com/') == 'https://example.com'
|
||||
assert normalize_url('https://example.com') == 'https://example.com'
|
||||
|
||||
|
||||
def test_normalize_url_lowercase():
|
||||
"""Normalize URL converts to lowercase"""
|
||||
assert normalize_url('https://Example.COM/') == 'https://example.com'
|
||||
assert normalize_url('HTTPS://EXAMPLE.COM') == 'https://example.com'
|
||||
|
||||
|
||||
def test_normalize_url_path_preserved():
|
||||
"""Normalize URL preserves path"""
|
||||
assert normalize_url('https://example.com/path/') == 'https://example.com/path'
|
||||
assert normalize_url('https://Example.com/Path') == 'https://example.com/path'
|
||||
|
||||
|
||||
# Scope Checking Tests
|
||||
# ---------------------
|
||||
|
||||
def test_check_scope_present():
|
||||
"""Check scope returns True when scope is present"""
|
||||
assert check_scope('create', 'create update delete') is True
|
||||
assert check_scope('create', 'create') is True
|
||||
|
||||
|
||||
def test_check_scope_missing():
|
||||
"""Check scope returns False when scope is missing"""
|
||||
assert check_scope('create', 'update delete') is False
|
||||
assert check_scope('create', '') is False
|
||||
assert check_scope('create', 'created') is False # Partial match
|
||||
|
||||
|
||||
def test_check_scope_empty():
|
||||
"""Check scope handles empty scope string"""
|
||||
assert check_scope('create', '') is False
|
||||
assert check_scope('create', None) is False
|
||||
|
||||
|
||||
# Fixtures
|
||||
# --------
|
||||
|
||||
@pytest.fixture
|
||||
def app():
|
||||
"""Create test Flask app without ADMIN_ME"""
|
||||
from flask import Flask
|
||||
app = Flask(__name__)
|
||||
app.config['TESTING'] = True
|
||||
app.config['DEBUG'] = False
|
||||
return app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app_with_admin_me():
|
||||
"""Create test Flask app with ADMIN_ME configured"""
|
||||
from flask import Flask
|
||||
app = Flask(__name__)
|
||||
app.config['TESTING'] = True
|
||||
app.config['DEBUG'] = False
|
||||
app.config['ADMIN_ME'] = 'https://alice.example.com/'
|
||||
app.config['VERSION'] = '1.0.0-test'
|
||||
return app
|
||||
@@ -0,0 +1,243 @@
|
||||
"""
|
||||
Tests for OIDC admin login (starpunk/auth.py, v2.0.0)
|
||||
"""
|
||||
|
||||
import time
|
||||
from unittest.mock import MagicMock, patch
|
||||
from urllib.parse import parse_qs, urlparse
|
||||
|
||||
import jwt
|
||||
import pytest
|
||||
from cryptography.hazmat.primitives.asymmetric import rsa
|
||||
|
||||
from starpunk import auth
|
||||
from starpunk.auth import (
|
||||
InvalidStateError,
|
||||
OIDCError,
|
||||
UnauthorizedError,
|
||||
_pkce_challenge,
|
||||
handle_callback,
|
||||
initiate_login,
|
||||
verify_session,
|
||||
)
|
||||
|
||||
ISSUER = "https://id.example.com"
|
||||
CLIENT_ID = "starpunk-client"
|
||||
ADMIN_SUB = "admin-sub-123"
|
||||
|
||||
METADATA = {
|
||||
"issuer": ISSUER,
|
||||
"authorization_endpoint": f"{ISSUER}/authorize",
|
||||
"token_endpoint": f"{ISSUER}/api/oidc/token",
|
||||
"jwks_uri": f"{ISSUER}/.well-known/jwks.json",
|
||||
"id_token_signing_alg_values_supported": ["RS256"],
|
||||
}
|
||||
|
||||
PRIVATE_KEY = rsa.generate_private_key(public_exponent=65537, key_size=2048)
|
||||
OTHER_KEY = rsa.generate_private_key(public_exponent=65537, key_size=2048)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app(tmp_path):
|
||||
from starpunk import create_app
|
||||
|
||||
data = tmp_path / "data"
|
||||
return create_app(
|
||||
{
|
||||
"TESTING": True,
|
||||
"SITE_URL": "https://blog.example.com",
|
||||
"ADMIN_ME": "https://example.com",
|
||||
"SESSION_SECRET": "test-secret",
|
||||
"DATA_PATH": data,
|
||||
"NOTES_PATH": data / "notes",
|
||||
"DATABASE_PATH": data / "starpunk.db",
|
||||
"OIDC_ISSUER": ISSUER,
|
||||
"OIDC_CLIENT_ID": CLIENT_ID,
|
||||
"OIDC_CLIENT_SECRET": "secret",
|
||||
"OIDC_ADMIN_SUB": ADMIN_SUB,
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def provider():
|
||||
"""Fake identity provider: discovery, JWKS key and token endpoint"""
|
||||
auth._METADATA_CACHE.clear()
|
||||
metadata_response = MagicMock(status_code=200)
|
||||
metadata_response.json.return_value = METADATA
|
||||
metadata_response.raise_for_status.return_value = None
|
||||
with patch("starpunk.auth.httpx.get", return_value=metadata_response) as get, patch(
|
||||
"starpunk.auth._get_signing_key", return_value=PRIVATE_KEY.public_key()
|
||||
), patch("starpunk.auth.httpx.post") as post, patch(
|
||||
"starpunk.author_discovery.get_author_profile"
|
||||
):
|
||||
yield {"get": get, "post": post}
|
||||
|
||||
|
||||
def make_id_token(nonce, sub=ADMIN_SUB, aud=CLIENT_ID, iss=ISSUER, key=PRIVATE_KEY, exp_in=300):
|
||||
now = int(time.time())
|
||||
claims = {"iss": iss, "aud": aud, "sub": sub, "iat": now, "exp": now + exp_in, "nonce": nonce}
|
||||
return jwt.encode(claims, key, algorithm="RS256")
|
||||
|
||||
|
||||
def start_login(app, next_url=None):
|
||||
"""Run initiate_login and return (state, nonce) from the stored row"""
|
||||
with app.test_request_context():
|
||||
url = initiate_login(next_url)
|
||||
query = parse_qs(urlparse(url).query)
|
||||
return query["state"][0], query["nonce"][0], query
|
||||
|
||||
|
||||
def token_response(provider, id_token, status=200):
|
||||
response = MagicMock(status_code=status, text="")
|
||||
response.json.return_value = {"id_token": id_token, "access_token": "x"}
|
||||
provider["post"].return_value = response
|
||||
|
||||
|
||||
class TestInitiateLogin:
|
||||
def test_redirects_to_provider_with_pkce(self, app):
|
||||
with app.test_request_context():
|
||||
url = initiate_login()
|
||||
parsed = urlparse(url)
|
||||
query = parse_qs(parsed.query)
|
||||
assert f"{parsed.scheme}://{parsed.netloc}{parsed.path}" == METADATA["authorization_endpoint"]
|
||||
assert query["client_id"] == [CLIENT_ID]
|
||||
assert query["redirect_uri"] == ["https://blog.example.com/auth/callback"]
|
||||
assert query["response_type"] == ["code"]
|
||||
assert query["scope"] == ["openid"]
|
||||
assert query["code_challenge_method"] == ["S256"]
|
||||
assert query["state"][0] and query["nonce"][0]
|
||||
|
||||
def test_stores_verifier_matching_challenge(self, app):
|
||||
state, _, query = start_login(app)
|
||||
from starpunk.database import get_db
|
||||
|
||||
with app.app_context():
|
||||
row = get_db(app).execute(
|
||||
"SELECT code_verifier FROM oidc_login_state WHERE state = ?", (state,)
|
||||
).fetchone()
|
||||
assert _pkce_challenge(row["code_verifier"]) == query["code_challenge"][0]
|
||||
|
||||
def test_rejects_offsite_next_url(self, app):
|
||||
state, _, _ = start_login(app, "https://evil.example/steal")
|
||||
from starpunk.database import get_db
|
||||
|
||||
with app.app_context():
|
||||
row = get_db(app).execute(
|
||||
"SELECT next_url FROM oidc_login_state WHERE state = ?", (state,)
|
||||
).fetchone()
|
||||
assert row["next_url"] is None
|
||||
|
||||
def test_issuer_mismatch_fails(self, app, provider):
|
||||
provider["get"].return_value.json.return_value = {**METADATA, "issuer": "https://other"}
|
||||
with app.test_request_context(), pytest.raises(OIDCError):
|
||||
initiate_login()
|
||||
|
||||
|
||||
class TestHandleCallback:
|
||||
def test_success_creates_admin_session(self, app, provider):
|
||||
state, nonce, _ = start_login(app, "/admin/new")
|
||||
token_response(provider, make_id_token(nonce))
|
||||
|
||||
with app.test_request_context():
|
||||
session_token, next_url = handle_callback("code", state, ISSUER)
|
||||
assert verify_session(session_token)["me"] == "https://example.com"
|
||||
assert next_url == "/admin/new"
|
||||
|
||||
sent = provider["post"].call_args
|
||||
assert sent.kwargs["data"]["grant_type"] == "authorization_code"
|
||||
assert sent.kwargs["data"]["code_verifier"]
|
||||
assert sent.kwargs["auth"] == (CLIENT_ID, "secret")
|
||||
|
||||
def test_state_is_single_use(self, app, provider):
|
||||
state, nonce, _ = start_login(app)
|
||||
token_response(provider, make_id_token(nonce))
|
||||
with app.test_request_context():
|
||||
handle_callback("code", state)
|
||||
with pytest.raises(InvalidStateError):
|
||||
handle_callback("code", state)
|
||||
|
||||
def test_unknown_state(self, app):
|
||||
with app.test_request_context(), pytest.raises(InvalidStateError):
|
||||
handle_callback("code", "nope")
|
||||
|
||||
def test_wrong_subject_is_unauthorized(self, app, provider):
|
||||
state, nonce, _ = start_login(app)
|
||||
token_response(provider, make_id_token(nonce, sub="someone-else"))
|
||||
with app.test_request_context(), pytest.raises(UnauthorizedError):
|
||||
handle_callback("code", state)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"kwargs",
|
||||
[
|
||||
{"aud": "another-client"},
|
||||
{"iss": "https://evil.example"},
|
||||
{"key": OTHER_KEY},
|
||||
{"exp_in": -3600},
|
||||
],
|
||||
)
|
||||
def test_invalid_id_token_rejected(self, app, provider, kwargs):
|
||||
state, nonce, _ = start_login(app)
|
||||
token_response(provider, make_id_token(nonce, **kwargs))
|
||||
with app.test_request_context(), pytest.raises(OIDCError):
|
||||
handle_callback("code", state)
|
||||
|
||||
def test_nonce_mismatch_rejected(self, app, provider):
|
||||
state, _, _ = start_login(app)
|
||||
token_response(provider, make_id_token("wrong-nonce"))
|
||||
with app.test_request_context(), pytest.raises(OIDCError):
|
||||
handle_callback("code", state)
|
||||
|
||||
def test_callback_issuer_mismatch_rejected(self, app, provider):
|
||||
state, nonce, _ = start_login(app)
|
||||
token_response(provider, make_id_token(nonce))
|
||||
with app.test_request_context(), pytest.raises(OIDCError):
|
||||
handle_callback("code", state, "https://evil.example")
|
||||
|
||||
def test_token_endpoint_error(self, app, provider):
|
||||
state, _, _ = start_login(app)
|
||||
token_response(provider, None, status=400)
|
||||
with app.test_request_context(), pytest.raises(OIDCError):
|
||||
handle_callback("code", state)
|
||||
|
||||
|
||||
class TestRoutes:
|
||||
def test_login_page_shows_sso_button(self, app):
|
||||
response = app.test_client().get("/auth/login")
|
||||
assert response.status_code == 200
|
||||
assert b"Sign in with" in response.data
|
||||
assert b'name="me"' not in response.data
|
||||
|
||||
def test_login_post_redirects_to_provider(self, app):
|
||||
response = app.test_client().post("/auth/login")
|
||||
assert response.status_code == 302
|
||||
assert response.headers["Location"].startswith(METADATA["authorization_endpoint"])
|
||||
|
||||
def test_callback_sets_cookie_and_returns_to_next(self, app, provider):
|
||||
client = app.test_client()
|
||||
with client.session_transaction() as s:
|
||||
s["next"] = "https://blog.example.com/admin/tokens"
|
||||
login = client.post("/auth/login")
|
||||
query = parse_qs(urlparse(login.headers["Location"]).query)
|
||||
token_response(provider, make_id_token(query["nonce"][0]))
|
||||
|
||||
response = client.get(f"/auth/callback?code=abc&state={query['state'][0]}&iss={ISSUER}")
|
||||
assert response.status_code == 302
|
||||
assert response.headers["Location"] == "https://blog.example.com/admin/tokens"
|
||||
cookie = response.headers["Set-Cookie"]
|
||||
assert "starpunk_session=" in cookie and "HttpOnly" in cookie and "Secure" in cookie
|
||||
|
||||
def test_callback_wrong_user_gets_no_cookie(self, app, provider):
|
||||
client = app.test_client()
|
||||
login = client.post("/auth/login")
|
||||
query = parse_qs(urlparse(login.headers["Location"]).query)
|
||||
token_response(provider, make_id_token(query["nonce"][0], sub="intruder"))
|
||||
|
||||
response = client.get(f"/auth/callback?code=abc&state={query['state'][0]}")
|
||||
assert response.headers["Location"].endswith("/auth/login")
|
||||
assert "starpunk_session" not in response.headers.get("Set-Cookie", "")
|
||||
|
||||
def test_callback_provider_error(self, app):
|
||||
response = app.test_client().get("/auth/callback?error=access_denied")
|
||||
assert response.status_code == 302
|
||||
assert response.headers["Location"].endswith("/auth/login")
|
||||
@@ -0,0 +1,329 @@
|
||||
"""
|
||||
Tests for the built-in IndieAuth server (starpunk/indieauth.py, v2.0.0)
|
||||
"""
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import secrets
|
||||
from unittest.mock import MagicMock, patch
|
||||
from urllib.parse import parse_qs, urlencode, urlparse
|
||||
|
||||
import pytest
|
||||
|
||||
from starpunk.auth import create_session
|
||||
from starpunk.indieauth import (
|
||||
AuthorizationRequestError,
|
||||
InvalidGrantError,
|
||||
check_scope,
|
||||
create_access_token,
|
||||
create_authorization_code,
|
||||
fetch_client_redirect_uris,
|
||||
redeem_authorization_code,
|
||||
validate_authorization_request,
|
||||
verify_access_token,
|
||||
)
|
||||
|
||||
CLIENT_ID = "https://quill.example/"
|
||||
REDIRECT_URI = "https://quill.example/auth/callback"
|
||||
|
||||
|
||||
def challenge_for(verifier):
|
||||
digest = hashlib.sha256(verifier.encode()).digest()
|
||||
return base64.urlsafe_b64encode(digest).rstrip(b"=").decode()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app(tmp_path):
|
||||
from starpunk import create_app
|
||||
|
||||
data = tmp_path / "data"
|
||||
return create_app(
|
||||
{
|
||||
"TESTING": True,
|
||||
"SITE_URL": "https://blog.example.com",
|
||||
"ADMIN_ME": "https://example.com",
|
||||
"SESSION_SECRET": "test-secret",
|
||||
"DATA_PATH": data,
|
||||
"NOTES_PATH": data / "notes",
|
||||
"DATABASE_PATH": data / "starpunk.db",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(app):
|
||||
return app.test_client()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def admin_client(app):
|
||||
"""Test client with a valid admin session cookie"""
|
||||
client = app.test_client()
|
||||
with app.test_request_context():
|
||||
token = create_session("https://example.com")
|
||||
client.set_cookie("starpunk_session", token)
|
||||
return client
|
||||
|
||||
|
||||
def auth_params(verifier="v" * 50, **overrides):
|
||||
params = {
|
||||
"response_type": "code",
|
||||
"client_id": CLIENT_ID,
|
||||
"redirect_uri": REDIRECT_URI,
|
||||
"state": "client-state",
|
||||
"code_challenge": challenge_for(verifier),
|
||||
"code_challenge_method": "S256",
|
||||
"scope": "create media",
|
||||
}
|
||||
params.update(overrides)
|
||||
return params
|
||||
|
||||
|
||||
def approve(admin_client, granted=("create", "media"), **overrides):
|
||||
form = auth_params(**overrides)
|
||||
form["decision"] = "approve"
|
||||
form["scope_granted"] = list(granted)
|
||||
response = admin_client.post("/auth/authorize/approve", data=form)
|
||||
assert response.status_code == 302
|
||||
return parse_qs(urlparse(response.headers["Location"]).query)
|
||||
|
||||
|
||||
class TestValidation:
|
||||
def test_valid_request(self, app):
|
||||
with app.test_request_context():
|
||||
result = validate_authorization_request(auth_params())
|
||||
assert result["scopes"] == ["create", "media"]
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"overrides",
|
||||
[{"client_id": "not-a-url"}, {"redirect_uri": ""}, {"client_id": "ftp://x.example/"}],
|
||||
)
|
||||
def test_untrusted_client_errors_are_not_redirected(self, app, overrides):
|
||||
with app.test_request_context(), pytest.raises(AuthorizationRequestError) as e:
|
||||
validate_authorization_request(auth_params(**overrides))
|
||||
assert e.value.redirectable is False
|
||||
|
||||
def test_missing_pkce_is_redirectable_error(self, app):
|
||||
with app.test_request_context(), pytest.raises(AuthorizationRequestError) as e:
|
||||
validate_authorization_request(auth_params(code_challenge=""))
|
||||
assert e.value.redirectable is True
|
||||
|
||||
def test_plain_pkce_rejected(self, app):
|
||||
with app.test_request_context(), pytest.raises(AuthorizationRequestError):
|
||||
validate_authorization_request(auth_params(code_challenge_method="plain"))
|
||||
|
||||
def test_cross_origin_redirect_needs_client_registration(self, app):
|
||||
params = auth_params(redirect_uri="https://evil.example/cb")
|
||||
with app.test_request_context(), patch(
|
||||
"starpunk.indieauth.fetch_client_redirect_uris", return_value=[]
|
||||
), pytest.raises(AuthorizationRequestError) as e:
|
||||
validate_authorization_request(params)
|
||||
assert e.value.redirectable is False
|
||||
|
||||
def test_cross_origin_redirect_allowed_when_published(self, app):
|
||||
params = auth_params(redirect_uri="app://callback")
|
||||
with app.test_request_context(), patch(
|
||||
"starpunk.indieauth.fetch_client_redirect_uris", return_value=["app://callback"]
|
||||
):
|
||||
assert validate_authorization_request(params)["redirect_uri"] == "app://callback"
|
||||
|
||||
|
||||
class TestClientMetadata:
|
||||
def _response(self, content_type, body, links=None):
|
||||
response = MagicMock(status_code=200, text=body, url="https://quill.example/")
|
||||
response.headers = {"Content-Type": content_type}
|
||||
response.links = links or {}
|
||||
response.json.return_value = __import__("json").loads(body) if "json" in content_type else None
|
||||
return response
|
||||
|
||||
def test_json_metadata(self, app):
|
||||
body = '{"client_id": "https://quill.example/", "redirect_uris": ["app://cb"]}'
|
||||
with app.test_request_context(), patch(
|
||||
"starpunk.webmention_ssrf.validate_url_for_fetch"
|
||||
), patch("starpunk.indieauth.httpx.get", return_value=self._response("application/json", body)):
|
||||
assert fetch_client_redirect_uris(CLIENT_ID) == ["app://cb"]
|
||||
|
||||
def test_html_link(self, app):
|
||||
body = '<html><head><link rel="redirect_uri" href="/cb"></head></html>'
|
||||
with app.test_request_context(), patch(
|
||||
"starpunk.webmention_ssrf.validate_url_for_fetch"
|
||||
), patch("starpunk.indieauth.httpx.get", return_value=self._response("text/html", body)):
|
||||
assert fetch_client_redirect_uris(CLIENT_ID) == ["https://quill.example/cb"]
|
||||
|
||||
|
||||
class TestCodesAndTokens:
|
||||
def test_full_exchange(self, app):
|
||||
verifier = secrets.token_urlsafe(50)
|
||||
with app.test_request_context():
|
||||
code = create_authorization_code(CLIENT_ID, REDIRECT_URI, "create", challenge_for(verifier))
|
||||
result = redeem_authorization_code(code, CLIENT_ID, REDIRECT_URI, verifier)
|
||||
assert result == {"me": "https://example.com", "scope": "create", "client_id": CLIENT_ID}
|
||||
|
||||
token = create_access_token(CLIENT_ID, "create")
|
||||
info = verify_access_token(token["access_token"])
|
||||
assert info["me"] == "https://example.com"
|
||||
assert info["scope"] == "create"
|
||||
|
||||
def test_code_single_use(self, app):
|
||||
verifier = "v" * 50
|
||||
with app.test_request_context():
|
||||
code = create_authorization_code(CLIENT_ID, REDIRECT_URI, "create", challenge_for(verifier))
|
||||
redeem_authorization_code(code, CLIENT_ID, REDIRECT_URI, verifier)
|
||||
with pytest.raises(InvalidGrantError):
|
||||
redeem_authorization_code(code, CLIENT_ID, REDIRECT_URI, verifier)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"client_id,redirect_uri,verifier",
|
||||
[
|
||||
("https://other.example/", REDIRECT_URI, "v" * 50),
|
||||
(CLIENT_ID, "https://quill.example/other", "v" * 50),
|
||||
(CLIENT_ID, REDIRECT_URI, "wrong-verifier"),
|
||||
],
|
||||
)
|
||||
def test_code_mismatch_rejected(self, app, client_id, redirect_uri, verifier):
|
||||
with app.test_request_context():
|
||||
code = create_authorization_code(CLIENT_ID, REDIRECT_URI, "create", challenge_for("v" * 50))
|
||||
with pytest.raises(InvalidGrantError):
|
||||
redeem_authorization_code(code, client_id, redirect_uri, verifier)
|
||||
|
||||
def test_token_stored_hashed(self, app):
|
||||
from starpunk.database import get_db
|
||||
|
||||
with app.test_request_context():
|
||||
token = create_access_token(CLIENT_ID, "create")["access_token"]
|
||||
rows = get_db(app).execute("SELECT token_hash FROM indieauth_tokens").fetchall()
|
||||
assert token not in [r["token_hash"] for r in rows]
|
||||
|
||||
def test_unknown_token(self, app):
|
||||
with app.test_request_context():
|
||||
assert verify_access_token("nope") is None
|
||||
assert verify_access_token("") is None
|
||||
|
||||
def test_check_scope(self):
|
||||
assert check_scope("create", "create media")
|
||||
assert not check_scope("create", "media")
|
||||
assert not check_scope("create", "")
|
||||
|
||||
|
||||
class TestEndpoints:
|
||||
def test_metadata(self, client):
|
||||
data = client.get("/.well-known/oauth-authorization-server").get_json()
|
||||
assert data["issuer"] == "https://blog.example.com/"
|
||||
assert data["authorization_endpoint"] == "https://blog.example.com/auth/authorize"
|
||||
assert data["token_endpoint"] == "https://blog.example.com/auth/token"
|
||||
assert data["code_challenge_methods_supported"] == ["S256"]
|
||||
|
||||
def test_discovery_links_on_homepage(self, client):
|
||||
html = client.get("/").data.decode()
|
||||
assert 'rel="indieauth-metadata"' in html
|
||||
assert 'rel="micropub"' in html
|
||||
|
||||
def test_authorize_requires_login(self, client):
|
||||
response = client.get("/auth/authorize?" + urlencode(auth_params()))
|
||||
assert response.status_code == 302
|
||||
assert response.headers["Location"].endswith("/auth/login")
|
||||
with client.session_transaction() as s:
|
||||
assert "/auth/authorize?" in s["next"]
|
||||
|
||||
def test_authorize_shows_consent(self, admin_client):
|
||||
response = admin_client.get("/auth/authorize?" + urlencode(auth_params()))
|
||||
assert response.status_code == 200
|
||||
assert b"quill.example" in response.data
|
||||
assert b'value="create"' in response.data
|
||||
|
||||
def test_authorize_bad_client_shows_error_page(self, admin_client):
|
||||
response = admin_client.get("/auth/authorize?" + urlencode(auth_params(client_id="nope")))
|
||||
assert response.status_code == 400
|
||||
|
||||
def test_approve_requires_login(self, client):
|
||||
response = client.post("/auth/authorize/approve", data={**auth_params(), "decision": "approve"})
|
||||
assert response.headers["Location"].endswith("/auth/login")
|
||||
|
||||
def test_deny(self, admin_client):
|
||||
form = {**auth_params(), "decision": "deny"}
|
||||
query = parse_qs(urlparse(admin_client.post("/auth/authorize/approve", data=form).headers["Location"]).query)
|
||||
assert query["error"] == ["access_denied"]
|
||||
assert query["state"] == ["client-state"]
|
||||
|
||||
def test_full_micropub_flow(self, admin_client, client):
|
||||
verifier = "v" * 50
|
||||
query = approve(admin_client, granted=["create"])
|
||||
assert query["state"] == ["client-state"]
|
||||
assert query["iss"] == ["https://blog.example.com/"]
|
||||
|
||||
response = client.post(
|
||||
"/auth/token",
|
||||
data={
|
||||
"grant_type": "authorization_code",
|
||||
"code": query["code"][0],
|
||||
"client_id": CLIENT_ID,
|
||||
"redirect_uri": REDIRECT_URI,
|
||||
"code_verifier": verifier,
|
||||
},
|
||||
)
|
||||
assert response.status_code == 200
|
||||
assert response.headers["Cache-Control"] == "no-store"
|
||||
body = response.get_json()
|
||||
assert body["me"] == "https://example.com"
|
||||
assert body["scope"] == "create" # media was unchecked
|
||||
|
||||
token = body["access_token"]
|
||||
micropub = client.post(
|
||||
"/micropub",
|
||||
data={"h": "entry", "content": "Posted through the built-in IndieAuth server"},
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
)
|
||||
assert micropub.status_code == 201
|
||||
|
||||
verify = client.get("/auth/token", headers={"Authorization": f"Bearer {token}"})
|
||||
assert verify.get_json()["client_id"] == CLIENT_ID
|
||||
|
||||
client.post("/auth/revoke", data={"token": token})
|
||||
again = client.post(
|
||||
"/micropub",
|
||||
data={"h": "entry", "content": "should fail"},
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
)
|
||||
assert again.status_code == 401
|
||||
|
||||
def test_profile_only_code_cannot_get_token(self, admin_client, client):
|
||||
query = approve(admin_client, granted=[], scope="")
|
||||
form = {
|
||||
"grant_type": "authorization_code",
|
||||
"code": query["code"][0],
|
||||
"client_id": CLIENT_ID,
|
||||
"redirect_uri": REDIRECT_URI,
|
||||
"code_verifier": "v" * 50,
|
||||
}
|
||||
assert client.post("/auth/token", data=form).get_json()["error"] == "invalid_grant"
|
||||
|
||||
def test_profile_only_redemption(self, admin_client, client):
|
||||
query = approve(admin_client, granted=[], scope="")
|
||||
response = client.post(
|
||||
"/auth/authorize",
|
||||
data={
|
||||
"grant_type": "authorization_code",
|
||||
"code": query["code"][0],
|
||||
"client_id": CLIENT_ID,
|
||||
"redirect_uri": REDIRECT_URI,
|
||||
"code_verifier": "v" * 50,
|
||||
},
|
||||
)
|
||||
assert response.get_json() == {"me": "https://example.com"}
|
||||
|
||||
def test_unsupported_grant(self, client):
|
||||
assert client.post("/auth/token", data={"grant_type": "password"}).status_code == 400
|
||||
|
||||
def test_admin_can_list_and_revoke(self, app, admin_client):
|
||||
with app.test_request_context():
|
||||
token = create_access_token(CLIENT_ID, "create")["access_token"]
|
||||
page = admin_client.get("/admin/tokens")
|
||||
assert page.status_code == 200 and b"quill.example" in page.data
|
||||
|
||||
from starpunk.database import get_db
|
||||
|
||||
with app.app_context():
|
||||
token_id = get_db(app).execute("SELECT id FROM indieauth_tokens").fetchone()["id"]
|
||||
admin_client.post(f"/admin/tokens/{token_id}/revoke")
|
||||
with app.test_request_context():
|
||||
assert verify_access_token(token) is None
|
||||
@@ -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("🔁")
|
||||
+89
-41
@@ -69,7 +69,7 @@ def test_micropub_no_token(client):
|
||||
|
||||
def test_micropub_invalid_token(client, mock_invalid_token):
|
||||
"""Test Micropub endpoint rejects invalid tokens"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_invalid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_invalid_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
data={'h': 'entry', 'content': 'Test post'},
|
||||
@@ -84,7 +84,7 @@ def test_micropub_invalid_token(client, mock_invalid_token):
|
||||
|
||||
def test_micropub_insufficient_scope(client, mock_read_only_token):
|
||||
"""Test Micropub endpoint rejects token without create scope"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_read_only_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_read_only_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
data={'h': 'entry', 'content': 'Test post'},
|
||||
@@ -101,7 +101,7 @@ def test_micropub_insufficient_scope(client, mock_read_only_token):
|
||||
|
||||
def test_micropub_create_note_form(client, app, mock_valid_token):
|
||||
"""Test creating a note via form-encoded request"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
data={
|
||||
@@ -126,7 +126,7 @@ def test_micropub_create_note_form(client, app, mock_valid_token):
|
||||
|
||||
def test_micropub_create_note_json(client, app, mock_valid_token):
|
||||
"""Test creating a note via JSON request"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
json={
|
||||
@@ -150,7 +150,7 @@ def test_micropub_create_note_json(client, app, mock_valid_token):
|
||||
|
||||
def test_micropub_create_with_name(client, app, mock_valid_token):
|
||||
"""Test creating a note with a title (name property)"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
json={
|
||||
@@ -167,10 +167,38 @@ def test_micropub_create_with_name(client, app, mock_valid_token):
|
||||
assert response.status_code == 201
|
||||
assert 'Location' in response.headers
|
||||
|
||||
# StarPunk titles are a '# Heading' first line, so name must land there
|
||||
slug = response.headers['Location'].rstrip('/').split('/')[-1]
|
||||
with app.app_context():
|
||||
note = get_note(slug)
|
||||
assert note.content == '# My Test Title\n\nContent goes here'
|
||||
assert note.title == 'My Test Title'
|
||||
|
||||
|
||||
def test_micropub_create_with_name_already_heading(client, app, mock_valid_token):
|
||||
"""A name that matches the content's heading is not added twice"""
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
json={
|
||||
'type': ['h-entry'],
|
||||
'properties': {
|
||||
'name': ['Same Title'],
|
||||
'content': ['# Same Title\n\nBody']
|
||||
}
|
||||
},
|
||||
headers={'Authorization': 'Bearer valid_token'}
|
||||
)
|
||||
|
||||
assert response.status_code == 201
|
||||
slug = response.headers['Location'].rstrip('/').split('/')[-1]
|
||||
with app.app_context():
|
||||
assert get_note(slug).content == '# Same Title\n\nBody'
|
||||
|
||||
|
||||
def test_micropub_create_with_categories(client, app, mock_valid_token):
|
||||
"""Test creating a note with tags (category property)"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
json={
|
||||
@@ -190,7 +218,7 @@ def test_micropub_create_with_categories(client, app, mock_valid_token):
|
||||
|
||||
def test_micropub_create_with_custom_slug_form(client, app, mock_valid_token):
|
||||
"""Test creating a note with custom slug via form-encoded request"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
data={
|
||||
@@ -206,7 +234,7 @@ def test_micropub_create_with_custom_slug_form(client, app, mock_valid_token):
|
||||
|
||||
# Verify the custom slug was used
|
||||
location = response.headers['Location']
|
||||
assert location.endswith('/notes/my-custom-slug')
|
||||
assert location.endswith('/note/my-custom-slug')
|
||||
|
||||
# Verify note exists with the custom slug
|
||||
with app.app_context():
|
||||
@@ -218,7 +246,7 @@ def test_micropub_create_with_custom_slug_form(client, app, mock_valid_token):
|
||||
|
||||
def test_micropub_create_with_custom_slug_json(client, app, mock_valid_token):
|
||||
"""Test creating a note with custom slug via JSON request"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
json={
|
||||
@@ -236,7 +264,7 @@ def test_micropub_create_with_custom_slug_json(client, app, mock_valid_token):
|
||||
|
||||
# Verify the custom slug was used
|
||||
location = response.headers['Location']
|
||||
assert location.endswith('/notes/json-custom-slug')
|
||||
assert location.endswith('/note/json-custom-slug')
|
||||
|
||||
# Verify note exists with the custom slug
|
||||
with app.app_context():
|
||||
@@ -251,7 +279,7 @@ def test_micropub_create_with_custom_slug_json(client, app, mock_valid_token):
|
||||
|
||||
def test_micropub_query_config(client, mock_valid_token):
|
||||
"""Test q=config endpoint"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
response = client.get(
|
||||
'/micropub?q=config',
|
||||
headers={'Authorization': 'Bearer valid_token'}
|
||||
@@ -266,7 +294,7 @@ def test_micropub_query_config(client, mock_valid_token):
|
||||
|
||||
def test_micropub_query_source(client, mock_valid_token):
|
||||
"""Test q=source endpoint"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
# First create a note
|
||||
create_response = client.post(
|
||||
'/micropub',
|
||||
@@ -290,6 +318,38 @@ def test_micropub_query_source(client, mock_valid_token):
|
||||
data = response.get_json()
|
||||
assert 'properties' in data
|
||||
assert data['properties']['content'][0] == 'Source test'
|
||||
# url must be the real permalink (was /notes/<slug>, a 404)
|
||||
assert data['properties']['url'] == [location]
|
||||
# A note without a heading has no name
|
||||
assert 'name' not in data['properties']
|
||||
|
||||
|
||||
def test_micropub_query_source_with_name(client, mock_valid_token):
|
||||
"""q=source returns name and content the way they were posted"""
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
create_response = client.post(
|
||||
'/micropub',
|
||||
json={
|
||||
'type': ['h-entry'],
|
||||
'properties': {
|
||||
'name': ['Round Trip'],
|
||||
'content': ['Body text']
|
||||
}
|
||||
},
|
||||
headers={'Authorization': 'Bearer valid_token'}
|
||||
)
|
||||
location = create_response.headers['Location']
|
||||
|
||||
response = client.get(
|
||||
f'/micropub?q=source&url={location}',
|
||||
headers={'Authorization': 'Bearer valid_token'}
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
properties = response.get_json()['properties']
|
||||
assert properties['name'] == ['Round Trip']
|
||||
assert properties['content'] == ['Body text']
|
||||
assert properties['url'] == [location]
|
||||
|
||||
|
||||
# Error Handling Tests
|
||||
@@ -297,7 +357,7 @@ def test_micropub_query_source(client, mock_valid_token):
|
||||
|
||||
def test_micropub_missing_content(client, mock_valid_token):
|
||||
"""Test creating note without content fails"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
with patch('starpunk.routes.micropub.verify_access_token', mock_valid_token):
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
json={
|
||||
@@ -312,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"""
|
||||
with patch('starpunk.routes.micropub.verify_external_token', mock_valid_token):
|
||||
# Test update
|
||||
response = client.post(
|
||||
'/micropub',
|
||||
json={
|
||||
'action': 'update',
|
||||
'url': 'https://example.com/note/123'
|
||||
},
|
||||
headers={'Authorization': 'Bearer valid_token'}
|
||||
)
|
||||
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):
|
||||
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']
|
||||
@@ -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
|
||||
+38
-1
@@ -11,7 +11,7 @@ Organized by model:
|
||||
import pytest
|
||||
from datetime import datetime, timedelta
|
||||
from pathlib import Path
|
||||
from starpunk.models import Note, Session, Token, AuthState
|
||||
from starpunk.models import Note, Session, Token, AuthState, split_title
|
||||
from starpunk.utils import calculate_content_hash
|
||||
|
||||
|
||||
@@ -245,6 +245,43 @@ class TestNoteModel:
|
||||
|
||||
assert note.excerpt == "my-note"
|
||||
|
||||
def _note_with(self, tmp_path, content):
|
||||
note_file = tmp_path / "notes" / "2024" / "11" / "test.md"
|
||||
note_file.parent.mkdir(parents=True, exist_ok=True)
|
||||
note_file.write_text(content)
|
||||
return Note(
|
||||
id=1,
|
||||
slug="test",
|
||||
file_path="notes/2024/11/test.md",
|
||||
published=True,
|
||||
created_at=datetime.utcnow(),
|
||||
updated_at=datetime.utcnow(),
|
||||
_data_dir=tmp_path,
|
||||
)
|
||||
|
||||
def test_split_title(self):
|
||||
"""A '# Heading' first line is split off as the title"""
|
||||
assert split_title("# My Title\n\nBody") == ("My Title", "Body")
|
||||
assert split_title("\n## Sub\nBody") == ("Sub", "Body")
|
||||
assert split_title("No heading\n# later") == (None, "No heading\n# later")
|
||||
assert split_title("#\nBody") == (None, "#\nBody")
|
||||
|
||||
def test_body_html_leaves_out_title(self, tmp_path):
|
||||
"""Pages show the title themselves, so the body must not repeat it"""
|
||||
note = self._note_with(tmp_path, "# My Title\n\nBody text.")
|
||||
assert "My Title" not in note.body_html
|
||||
assert "<p>Body text.</p>" in note.body_html
|
||||
assert "<h1>My Title</h1>" in note.html # html is unchanged
|
||||
|
||||
def test_body_html_untitled_matches_html(self, tmp_path):
|
||||
note = self._note_with(tmp_path, "Plain note.")
|
||||
assert note.body_html == note.html
|
||||
|
||||
def test_excerpt_leaves_out_title(self, tmp_path):
|
||||
"""Previews show the title above the excerpt, so it is not repeated"""
|
||||
note = self._note_with(tmp_path, "# Title\n\nShort content.")
|
||||
assert note.excerpt == "Short content."
|
||||
|
||||
def test_permalink(self):
|
||||
"""Test permalink generation"""
|
||||
note = Note(
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
"""Public page markup from the v2.3.0 style pass"""
|
||||
|
||||
import markdown
|
||||
import pytest
|
||||
|
||||
from starpunk import create_app
|
||||
from starpunk.models import MARKDOWN_EXTENSIONS
|
||||
from starpunk.notes import create_note
|
||||
|
||||
|
||||
def md(text):
|
||||
return markdown.markdown(text, extensions=MARKDOWN_EXTENSIONS)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text, expected", [
|
||||
("see https://sqlite.org/x.html.", '<a href="https://sqlite.org/x.html">https://sqlite.org/x.html</a>.'),
|
||||
("(https://a.example/p)", '(<a href="https://a.example/p">https://a.example/p</a>)'),
|
||||
("[label](https://a.example)", '<a href="https://a.example">label</a>'),
|
||||
("`https://code.example`", "<code>https://code.example</code>"),
|
||||
])
|
||||
def test_bare_urls_are_linked(text, expected):
|
||||
assert expected in md(text)
|
||||
|
||||
|
||||
def test_url_as_link_label_is_not_nested():
|
||||
assert md("[https://b.example](https://b.example)").count("<a ") == 1
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app(tmp_path):
|
||||
data = tmp_path / "data"
|
||||
return create_app({
|
||||
"TESTING": True, "SITE_URL": "https://blog.example.com", "SITE_NAME": "My Notes",
|
||||
"ADMIN_ME": "https://example.com", "SESSION_SECRET": "x",
|
||||
"DATA_PATH": data, "NOTES_PATH": data / "notes", "DATABASE_PATH": data / "starpunk.db",
|
||||
})
|
||||
|
||||
|
||||
def test_home_shows_full_notes_and_site_name(app):
|
||||
long_text = "word " * 120 + "THE-END"
|
||||
with app.app_context():
|
||||
create_note(content=long_text, published=True, tags=["thoughts"])
|
||||
html = app.test_client().get("/").data.decode()
|
||||
assert "THE-END" in html # not cut at 300 characters
|
||||
assert '<a class="site-title" href="/">My Notes</a>' in html
|
||||
assert 'class="p-category" rel="tag"' in html
|
||||
# Notes' metadata is not styled as the page footer
|
||||
assert html.count('<footer class="site-footer">') == 1
|
||||
assert '<footer class="note-meta">' in html
|
||||
nav = html.split('class="site-nav"', 1)[1].split("</nav>", 1)[0]
|
||||
assert 'href="/auth/login"' in nav # login is in the top bar
|
||||
|
||||
|
||||
def test_note_page_meta_line(app):
|
||||
with app.app_context():
|
||||
note = create_note(content="Hello", published=True)
|
||||
html = app.test_client().get(f"/note/{note.slug}").data.decode()
|
||||
assert "<title>Hello · My Notes</title>" in html
|
||||
assert 'class="u-url u-uid"' in html
|
||||
|
||||
|
||||
def test_nav_shows_admin_when_logged_in(app):
|
||||
from starpunk.auth import create_session
|
||||
client = app.test_client()
|
||||
with app.test_request_context():
|
||||
client.set_cookie("starpunk_session", create_session("https://example.com"))
|
||||
nav = client.get("/").data.decode().split('class="site-nav"', 1)[1].split("</nav>", 1)[0]
|
||||
assert ">Admin</a>" in nav
|
||||
assert "/auth/login" not in nav
|
||||
@@ -274,7 +274,8 @@ class TestVersionDisplay:
|
||||
"""Test version number appears in footer"""
|
||||
response = client.get("/")
|
||||
assert response.status_code == 200
|
||||
assert b"0.5.0" in response.data or b"StarPunk v" in response.data
|
||||
from starpunk import __version__
|
||||
assert f"v{__version__}".encode() in response.data
|
||||
|
||||
|
||||
# OAuth metadata endpoint tests removed in Phase 1 of IndieAuth server removal
|
||||
|
||||
@@ -220,8 +220,8 @@ def test_search_api_generates_correct_urls(client, test_notes):
|
||||
|
||||
if data["count"] > 0:
|
||||
result = data["results"][0]
|
||||
assert result["url"].startswith("/notes/")
|
||||
assert result["url"] == f"/notes/{result['slug']}"
|
||||
assert result["url"].startswith("/note/")
|
||||
assert result["url"] == f"/note/{result['slug']}"
|
||||
|
||||
|
||||
def test_search_api_provides_fallback_title(client, app):
|
||||
|
||||
@@ -185,8 +185,8 @@ def test_search_page_links_to_notes(client, test_notes):
|
||||
response = client.get("/search?q=test")
|
||||
assert response.status_code == 200
|
||||
|
||||
# Should contain links to /notes/
|
||||
assert b'href="/notes/' in response.data
|
||||
# Should contain links to /note/
|
||||
assert b'href="/note/' in response.data
|
||||
|
||||
|
||||
def test_search_form_validation(client):
|
||||
|
||||
@@ -0,0 +1,349 @@
|
||||
"""
|
||||
Tests for crossposting to GoToSocial (starpunk/syndication.py, v2.1.0)
|
||||
|
||||
A fake Mastodon-API server (httpx.MockTransport) records what StarPunk sends.
|
||||
"""
|
||||
|
||||
import io
|
||||
import json
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from PIL import Image
|
||||
|
||||
from starpunk import create_app, syndication
|
||||
from starpunk.auth import create_session
|
||||
from starpunk.indieauth import create_access_token
|
||||
from starpunk.notes import create_note, delete_note, update_note
|
||||
from starpunk.syndication import (
|
||||
MastodonClient,
|
||||
compose_text,
|
||||
get_note_syndications,
|
||||
note_changed,
|
||||
process_due,
|
||||
select_targets,
|
||||
)
|
||||
|
||||
GTS = "https://social.example.com"
|
||||
|
||||
|
||||
class FakeServer:
|
||||
def __init__(self):
|
||||
self.statuses = {}
|
||||
self.calls = []
|
||||
self.media = 0
|
||||
self.fail_next = None # status code to return once
|
||||
|
||||
def __call__(self, request: httpx.Request) -> httpx.Response:
|
||||
self.calls.append((request.method, request.url.path))
|
||||
assert request.headers["Authorization"] == "Bearer secret-token"
|
||||
if self.fail_next:
|
||||
code, self.fail_next = self.fail_next, None
|
||||
return httpx.Response(code, json={"error": "nope"})
|
||||
path = request.url.path
|
||||
if path == "/api/v2/media":
|
||||
self.media += 1
|
||||
return httpx.Response(200, json={"id": f"m{self.media}"})
|
||||
if path == "/api/v1/statuses" and request.method == "POST":
|
||||
body = json.loads(request.content)
|
||||
sid = str(len(self.statuses) + 1)
|
||||
self.statuses[sid] = body
|
||||
return httpx.Response(200, json={"id": sid, "url": f"{GTS}/@phil/statuses/{sid}"})
|
||||
if path.startswith("/api/v1/statuses/"):
|
||||
sid = path.rsplit("/", 1)[1]
|
||||
if sid not in self.statuses:
|
||||
return httpx.Response(404, json={"error": "not found"})
|
||||
if request.method == "PUT":
|
||||
self.statuses[sid] = json.loads(request.content)
|
||||
return httpx.Response(200, json={"id": sid, "url": f"{GTS}/@phil/statuses/{sid}"})
|
||||
if request.method == "DELETE":
|
||||
del self.statuses[sid]
|
||||
return httpx.Response(200, json={"id": sid})
|
||||
return httpx.Response(500)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def server():
|
||||
return FakeServer()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app(tmp_path, server):
|
||||
data = tmp_path / "data"
|
||||
app = create_app(
|
||||
{
|
||||
"TESTING": True,
|
||||
"SITE_URL": "https://blog.example.com",
|
||||
"ADMIN_ME": "https://example.com",
|
||||
"SESSION_SECRET": "test-secret",
|
||||
"DATA_PATH": data,
|
||||
"NOTES_PATH": data / "notes",
|
||||
"DATABASE_PATH": data / "starpunk.db",
|
||||
"GOTOSOCIAL_URL": GTS,
|
||||
"GOTOSOCIAL_ACCESS_TOKEN": "secret-token",
|
||||
}
|
||||
)
|
||||
syndication._client_cache[GTS] = MastodonClient(
|
||||
GTS, "secret-token", http=httpx.Client(transport=httpx.MockTransport(server))
|
||||
)
|
||||
yield app
|
||||
syndication._client_cache.clear()
|
||||
|
||||
|
||||
def rows(app, note_id):
|
||||
with app.app_context():
|
||||
return get_note_syndications(note_id)
|
||||
|
||||
|
||||
def publish(app, content="Hello fediverse", tags=None, targets=("gotosocial",)):
|
||||
with app.test_request_context():
|
||||
note = create_note(content=content, published=True, tags=tags)
|
||||
select_targets(note.id, list(targets))
|
||||
process_due()
|
||||
return note
|
||||
|
||||
|
||||
class TestCompose:
|
||||
def test_full_note_with_link_and_hashtags(self, app):
|
||||
with app.app_context():
|
||||
note = create_note(content="# Title\n\nSome *markdown*", published=True)
|
||||
text = compose_text(note, "https://blog.example.com/note/x", ["IndieWeb", "Self Hosting"], 5000)
|
||||
assert text == "# Title\n\nSome *markdown*\n\nhttps://blog.example.com/note/x\n\n#IndieWeb #SelfHosting"
|
||||
|
||||
def test_long_note_is_shortened_but_keeps_link(self, app):
|
||||
with app.app_context():
|
||||
note = create_note(content="word " * 2000, published=True)
|
||||
text = compose_text(note, "https://blog.example.com/note/x", [], 500)
|
||||
assert len(text) <= 500
|
||||
assert text.endswith("https://blog.example.com/note/x")
|
||||
assert "…" in text
|
||||
|
||||
|
||||
class TestLifecycle:
|
||||
def test_publish_creates_status(self, app, server):
|
||||
note = publish(app, tags=["Test"])
|
||||
(row,) = rows(app, note.id)
|
||||
assert row["state"] == "synced"
|
||||
assert row["remote_url"] == f"{GTS}/@phil/statuses/1"
|
||||
body = server.statuses["1"]
|
||||
assert body["content_type"] == "text/markdown"
|
||||
assert body["visibility"] == "public"
|
||||
assert f"https://blog.example.com/note/{note.slug}" in body["status"]
|
||||
assert "#Test" in body["status"]
|
||||
|
||||
def test_edit_updates_status(self, app, server):
|
||||
note = publish(app)
|
||||
with app.test_request_context():
|
||||
update_note(id=note.id, content="Edited text")
|
||||
process_due()
|
||||
assert server.statuses["1"]["status"].startswith("Edited text")
|
||||
assert ("PUT", "/api/v1/statuses/1") in server.calls
|
||||
|
||||
def test_delete_deletes_status(self, app, server):
|
||||
note = publish(app)
|
||||
with app.test_request_context():
|
||||
delete_note(id=note.id)
|
||||
process_due()
|
||||
assert server.statuses == {}
|
||||
(row,) = rows(app, note.id)
|
||||
assert row["remote_id"] is None and row["state"] == "synced"
|
||||
|
||||
def test_hard_delete_deletes_status(self, app, server):
|
||||
note = publish(app)
|
||||
with app.test_request_context():
|
||||
delete_note(id=note.id, soft=False)
|
||||
process_due()
|
||||
assert server.statuses == {}
|
||||
|
||||
def test_unpublish_then_republish(self, app, server):
|
||||
note = publish(app)
|
||||
with app.test_request_context():
|
||||
update_note(id=note.id, published=False)
|
||||
process_due()
|
||||
assert server.statuses == {}
|
||||
update_note(id=note.id, published=True)
|
||||
process_due()
|
||||
assert len(server.statuses) == 1
|
||||
|
||||
def test_opt_out_sends_nothing(self, app, server):
|
||||
note = publish(app, targets=())
|
||||
assert server.calls == []
|
||||
assert rows(app, note.id) == []
|
||||
|
||||
def test_unticking_later_deletes_status(self, app, server):
|
||||
note = publish(app)
|
||||
with app.test_request_context():
|
||||
select_targets(note.id, [])
|
||||
process_due()
|
||||
assert server.statuses == {}
|
||||
|
||||
def test_drafts_are_not_sent(self, app, server):
|
||||
with app.test_request_context():
|
||||
note = create_note(content="draft", published=False)
|
||||
select_targets(note.id, ["gotosocial"])
|
||||
process_due()
|
||||
assert server.statuses == {}
|
||||
|
||||
def test_remote_deleted_by_hand_is_reposted_on_edit(self, app, server):
|
||||
note = publish(app)
|
||||
server.statuses.clear()
|
||||
with app.test_request_context():
|
||||
note_changed(note.id)
|
||||
process_due()
|
||||
assert len(server.statuses) == 1
|
||||
|
||||
def test_edit_during_send_is_not_lost(self, app, server):
|
||||
with app.test_request_context():
|
||||
note = create_note(content="v1", published=True)
|
||||
select_targets(note.id, ["gotosocial"])
|
||||
# Simulate an edit arriving while the first send is in flight
|
||||
original = syndication._reconcile
|
||||
|
||||
def edit_mid_send(row, target):
|
||||
result = original(row, target)
|
||||
update_note(id=note.id, content="v2")
|
||||
return result
|
||||
|
||||
syndication._reconcile = edit_mid_send
|
||||
try:
|
||||
process_due()
|
||||
finally:
|
||||
syndication._reconcile = original
|
||||
assert rows(app, note.id)[0]["state"] == "pending"
|
||||
process_due()
|
||||
assert server.statuses["1"]["status"].startswith("v2")
|
||||
|
||||
|
||||
class TestFailures:
|
||||
def test_server_error_retries_later(self, app, server):
|
||||
server.fail_next = 503
|
||||
note = publish(app)
|
||||
(row,) = rows(app, note.id)
|
||||
assert row["state"] == "pending"
|
||||
assert row["attempts"] == 1
|
||||
assert "503" in row["last_error"]
|
||||
|
||||
def test_client_error_fails_permanently(self, app, server):
|
||||
server.fail_next = 422
|
||||
note = publish(app)
|
||||
(row,) = rows(app, note.id)
|
||||
assert row["state"] == "failed"
|
||||
|
||||
def test_retry_button(self, app, server):
|
||||
server.fail_next = 422
|
||||
note = publish(app)
|
||||
(row,) = rows(app, note.id)
|
||||
client = app.test_client()
|
||||
with app.test_request_context():
|
||||
client.set_cookie("starpunk_session", create_session("https://example.com"))
|
||||
client.post(f"/admin/syndication/{row['id']}/retry")
|
||||
with app.test_request_context():
|
||||
process_due()
|
||||
assert rows(app, note.id)[0]["state"] == "synced"
|
||||
|
||||
def test_no_targets_configured_does_nothing(self, tmp_path):
|
||||
data = tmp_path / "d"
|
||||
app = create_app({
|
||||
"TESTING": True, "SITE_URL": "https://b.example", "ADMIN_ME": "https://e.example",
|
||||
"SESSION_SECRET": "x", "DATA_PATH": data, "NOTES_PATH": data / "notes",
|
||||
"DATABASE_PATH": data / "s.db",
|
||||
})
|
||||
with app.test_request_context():
|
||||
note = create_note(content="x", published=True)
|
||||
select_targets(note.id, ["gotosocial"])
|
||||
assert process_due() == 0
|
||||
assert get_note_syndications(note.id) == []
|
||||
|
||||
|
||||
class TestMedia:
|
||||
def test_images_are_uploaded_with_alt_text(self, app, server):
|
||||
from starpunk.media import attach_media_to_note, save_media
|
||||
|
||||
buf = io.BytesIO()
|
||||
Image.new("RGB", (800, 600), "red").save(buf, format="JPEG")
|
||||
with app.test_request_context():
|
||||
note = create_note(content="With a picture", published=True)
|
||||
media = save_media(buf.getvalue(), "red.jpg")
|
||||
attach_media_to_note(note.id, [media["id"]], ["A red square"])
|
||||
select_targets(note.id, ["gotosocial"])
|
||||
process_due()
|
||||
assert ("POST", "/api/v2/media") in server.calls
|
||||
assert server.statuses["1"]["media_ids"] == ["m1"]
|
||||
|
||||
|
||||
class TestEntryPoints:
|
||||
@pytest.fixture
|
||||
def admin(self, app):
|
||||
client = app.test_client()
|
||||
with app.test_request_context():
|
||||
client.set_cookie("starpunk_session", create_session("https://example.com"))
|
||||
return client
|
||||
|
||||
def test_new_note_form_ticks_target_by_default(self, admin):
|
||||
html = admin.get("/admin/new").data.decode()
|
||||
assert 'name="syndicate_to" value="gotosocial" checked' in html
|
||||
|
||||
def test_admin_create_queues(self, app, admin):
|
||||
admin.post("/admin/new", data={
|
||||
"content": "From the editor", "published": "on",
|
||||
"syndication_form": "1", "syndicate_to": "gotosocial",
|
||||
})
|
||||
with app.app_context():
|
||||
from starpunk.database import get_db
|
||||
assert get_db(app).execute("SELECT COUNT(*) FROM syndications").fetchone()[0] == 1
|
||||
|
||||
def test_admin_create_opt_out(self, app, admin):
|
||||
admin.post("/admin/new", data={"content": "Not this one", "published": "on", "syndication_form": "1"})
|
||||
with app.app_context():
|
||||
from starpunk.database import get_db
|
||||
assert get_db(app).execute("SELECT COUNT(*) FROM syndications").fetchone()[0] == 0
|
||||
|
||||
def _token(self, app):
|
||||
with app.test_request_context():
|
||||
return create_access_token("https://quill.example/", "create")["access_token"]
|
||||
|
||||
def test_micropub_lists_target(self, app):
|
||||
token = self._token(app)
|
||||
data = app.test_client().get(
|
||||
"/micropub?q=syndicate-to", headers={"Authorization": f"Bearer {token}"}
|
||||
).get_json()
|
||||
assert data["syndicate-to"] == [{"uid": f"{GTS}/", "name": "GoToSocial"}]
|
||||
|
||||
def test_micropub_default_is_all_targets(self, app):
|
||||
token = self._token(app)
|
||||
response = app.test_client().post(
|
||||
"/micropub", data={"h": "entry", "content": "via quill"},
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
)
|
||||
assert response.status_code == 201
|
||||
assert "/note/" in response.headers["Location"]
|
||||
assert response.headers["Location"].startswith("https://blog.example.com/note/")
|
||||
with app.app_context():
|
||||
from starpunk.database import get_db
|
||||
assert get_db(app).execute("SELECT COUNT(*) FROM syndications").fetchone()[0] == 1
|
||||
|
||||
def test_micropub_explicit_empty_choice(self, app):
|
||||
token = self._token(app)
|
||||
app.test_client().post(
|
||||
"/micropub", json={"type": ["h-entry"], "properties": {"content": ["no crosspost"]},
|
||||
"mp-syndicate-to": []},
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
)
|
||||
with app.app_context():
|
||||
from starpunk.database import get_db
|
||||
assert get_db(app).execute("SELECT COUNT(*) FROM syndications").fetchone()[0] == 0
|
||||
|
||||
def test_note_page_links_to_crosspost(self, app, server):
|
||||
note = publish(app)
|
||||
html = app.test_client().get(f"/note/{note.slug}").data.decode()
|
||||
assert f'class="u-syndication" href="{GTS}/@phil/statuses/1"' in html
|
||||
|
||||
def test_edit_page_shows_status_and_separate_delete_form(self, app, admin, server):
|
||||
note = publish(app)
|
||||
html = admin.get(f"/admin/edit/{note.id}").data.decode()
|
||||
assert 'value="gotosocial" checked' in html
|
||||
assert f"{GTS}/@phil/statuses/1" in html
|
||||
# Delete button belongs to its own form, not the edit form
|
||||
assert 'form="delete-note-form"' in html
|
||||
edit_form = html.split('class="note-form"', 1)[1].split("</form>", 1)[0]
|
||||
assert "<form" not in edit_form
|
||||
@@ -0,0 +1,274 @@
|
||||
"""
|
||||
Tests for crossposting to Bluesky (starpunk/syndication.py, v2.2.0)
|
||||
|
||||
A fake PDS (httpx.MockTransport) records what StarPunk sends.
|
||||
"""
|
||||
|
||||
import io
|
||||
import json
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from PIL import Image
|
||||
|
||||
from starpunk import create_app, syndication
|
||||
from starpunk.notes import create_note, delete_note, update_note
|
||||
from starpunk.syndication import (
|
||||
BlueskyClient,
|
||||
bluesky_facets,
|
||||
get_note_syndications,
|
||||
plain_text,
|
||||
process_due,
|
||||
select_targets,
|
||||
)
|
||||
|
||||
SERVICE = "https://bsky.example"
|
||||
PDS = "https://pds.example"
|
||||
DID = "did:plc:abc123"
|
||||
|
||||
|
||||
class FakePDS:
|
||||
def __init__(self):
|
||||
self.records = {}
|
||||
self.blobs = []
|
||||
self.calls = []
|
||||
self.logins = 0
|
||||
self.expire_next = False
|
||||
self.lose_next_reply = False
|
||||
self.fail_next = None
|
||||
|
||||
def _json(self, code, body):
|
||||
return httpx.Response(code, json=body)
|
||||
|
||||
def __call__(self, request: httpx.Request) -> httpx.Response:
|
||||
nsid = request.url.path.removeprefix("/xrpc/")
|
||||
self.calls.append((request.url.host, nsid))
|
||||
if nsid == "com.atproto.server.createSession":
|
||||
body = json.loads(request.content)
|
||||
if body["password"] != "app-pass":
|
||||
return self._json(401, {"error": "AuthenticationRequired"})
|
||||
self.logins += 1
|
||||
return self._json(200, {
|
||||
"did": DID, "handle": "phil.example", "accessJwt": f"access{self.logins}",
|
||||
"refreshJwt": "refresh",
|
||||
"didDoc": {"service": [{"id": "#atproto_pds", "serviceEndpoint": PDS}]},
|
||||
})
|
||||
if nsid == "com.atproto.server.refreshSession":
|
||||
self.logins += 1
|
||||
return self._json(200, {"did": DID, "handle": "phil.example",
|
||||
"accessJwt": f"access{self.logins}", "refreshJwt": "refresh"})
|
||||
assert request.url.host == "pds.example"
|
||||
if request.headers.get("Authorization") != f"Bearer access{self.logins}" or self.expire_next:
|
||||
self.expire_next = False
|
||||
return self._json(400, {"error": "ExpiredToken"})
|
||||
if self.fail_next:
|
||||
code, self.fail_next = self.fail_next, None
|
||||
return self._json(code, {"error": "Nope"})
|
||||
if nsid == "com.atproto.repo.uploadBlob":
|
||||
self.blobs.append(len(request.content))
|
||||
assert len(request.content) <= 1_000_000
|
||||
return self._json(200, {"blob": {"$type": "blob", "ref": {"$link": f"b{len(self.blobs)}"},
|
||||
"mimeType": request.headers["Content-Type"],
|
||||
"size": len(request.content)}})
|
||||
if nsid == "com.atproto.repo.createRecord":
|
||||
body = json.loads(request.content)
|
||||
uri = f"at://{DID}/app.bsky.feed.post/r{len(self.records) + 1}"
|
||||
self.records[uri] = body["record"]
|
||||
if self.lose_next_reply:
|
||||
self.lose_next_reply = False
|
||||
raise httpx.ReadTimeout("lost reply")
|
||||
return self._json(200, {"uri": uri, "cid": "c"})
|
||||
if nsid == "com.atproto.repo.listRecords":
|
||||
return self._json(200, {"records": [{"uri": u, "value": v} for u, v in self.records.items()]})
|
||||
if nsid == "com.atproto.repo.deleteRecord":
|
||||
body = json.loads(request.content)
|
||||
self.records.pop(f"at://{body['repo']}/{body['collection']}/{body['rkey']}", None)
|
||||
return self._json(200, {})
|
||||
return self._json(500, {"error": "unknown"})
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def pds():
|
||||
return FakePDS()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app(tmp_path, pds):
|
||||
data = tmp_path / "data"
|
||||
app = create_app({
|
||||
"TESTING": True,
|
||||
"SITE_URL": "https://blog.example.com",
|
||||
"ADMIN_ME": "https://example.com",
|
||||
"SESSION_SECRET": "test-secret",
|
||||
"DATA_PATH": data,
|
||||
"NOTES_PATH": data / "notes",
|
||||
"DATABASE_PATH": data / "starpunk.db",
|
||||
"BLUESKY_HANDLE": "phil.example",
|
||||
"BLUESKY_APP_PASSWORD": "app-pass",
|
||||
"BLUESKY_SERVICE": SERVICE,
|
||||
})
|
||||
syndication._client_cache[f"bluesky:{SERVICE}:phil.example"] = BlueskyClient(
|
||||
SERVICE, "phil.example", "app-pass", http=httpx.Client(transport=httpx.MockTransport(pds))
|
||||
)
|
||||
yield app
|
||||
syndication._client_cache.clear()
|
||||
|
||||
|
||||
def publish(app, content="Hello Bluesky", tags=None):
|
||||
with app.test_request_context():
|
||||
note = create_note(content=content, published=True, tags=tags)
|
||||
select_targets(note.id, ["bluesky"])
|
||||
process_due()
|
||||
return note
|
||||
|
||||
|
||||
def only_record(pds):
|
||||
(record,) = pds.records.values()
|
||||
return record
|
||||
|
||||
|
||||
def row(app, note):
|
||||
with app.app_context():
|
||||
(r,) = get_note_syndications(note.id)
|
||||
return r
|
||||
|
||||
|
||||
class TestText:
|
||||
def test_markdown_becomes_plain_text(self):
|
||||
md = "# Title\n\nSome *emphasis* and a [link](https://x.example).\n\n- one\n- two\n\n"
|
||||
assert plain_text(md) == "Title\n\nSome emphasis and a link.\n\n• one\n• two"
|
||||
|
||||
def test_facets_use_utf8_byte_offsets(self):
|
||||
text = "Café ☕ https://blog.example.com/note/x #IndieWeb"
|
||||
link, tag = bluesky_facets(text)
|
||||
raw = text.encode()
|
||||
assert raw[link["index"]["byteStart"]:link["index"]["byteEnd"]] == b"https://blog.example.com/note/x"
|
||||
assert raw[tag["index"]["byteStart"]:tag["index"]["byteEnd"]] == b"#IndieWeb"
|
||||
assert tag["features"][0]["tag"] == "IndieWeb"
|
||||
|
||||
def test_fragment_in_url_is_not_a_tag(self):
|
||||
facets = bluesky_facets("see https://x.example/page#section and #42 too")
|
||||
assert [f["features"][0]["$type"] for f in facets] == ["app.bsky.richtext.facet#link"]
|
||||
|
||||
|
||||
class TestLifecycle:
|
||||
def test_publish_posts_with_link_card(self, app, pds):
|
||||
note = publish(app, content="Hello **Bluesky**", tags=["IndieWeb"])
|
||||
record = only_record(pds)
|
||||
permalink = f"https://blog.example.com/note/{note.slug}"
|
||||
assert record["text"] == f"Hello Bluesky\n\n{permalink}\n\n#IndieWeb"
|
||||
assert record["embed"]["external"]["uri"] == permalink
|
||||
kinds = {f["features"][0]["$type"] for f in record["facets"]}
|
||||
assert kinds == {"app.bsky.richtext.facet#link", "app.bsky.richtext.facet#tag"}
|
||||
r = row(app, note)
|
||||
assert r["state"] == "synced"
|
||||
assert r["remote_id"] == f"at://{DID}/app.bsky.feed.post/r1"
|
||||
assert r["remote_url"] == "https://bsky.app/profile/phil.example/post/r1"
|
||||
|
||||
def test_long_note_fits_300(self, app, pds):
|
||||
note = publish(app, content="word " * 500)
|
||||
text = only_record(pds)["text"]
|
||||
assert len(text) <= 300
|
||||
assert text.endswith(f"https://blog.example.com/note/{note.slug}")
|
||||
|
||||
def test_edit_leaves_post_alone(self, app, pds):
|
||||
note = publish(app, content="first")
|
||||
with app.test_request_context():
|
||||
update_note(id=note.id, content="second")
|
||||
process_due()
|
||||
assert only_record(pds)["text"].startswith("first")
|
||||
assert row(app, note)["state"] == "synced"
|
||||
|
||||
def test_delete_and_unpublish_remove_post(self, app, pds):
|
||||
note = publish(app)
|
||||
with app.test_request_context():
|
||||
update_note(id=note.id, published=False)
|
||||
process_due()
|
||||
assert pds.records == {}
|
||||
update_note(id=note.id, published=True)
|
||||
process_due()
|
||||
assert len(pds.records) == 1
|
||||
delete_note(id=note.id)
|
||||
process_due()
|
||||
assert pds.records == {}
|
||||
|
||||
|
||||
class TestSession:
|
||||
def test_logs_in_once_and_uses_pds(self, app, pds):
|
||||
publish(app, content="one")
|
||||
publish(app, content="two")
|
||||
assert pds.logins == 1
|
||||
assert ("bsky.example", "com.atproto.server.createSession") in pds.calls
|
||||
assert ("pds.example", "com.atproto.repo.createRecord") in pds.calls
|
||||
|
||||
def test_expired_token_is_refreshed(self, app, pds):
|
||||
publish(app, content="one")
|
||||
pds.expire_next = True
|
||||
publish(app, content="two")
|
||||
assert len(pds.records) == 2
|
||||
assert ("bsky.example", "com.atproto.server.refreshSession") in pds.calls
|
||||
|
||||
def test_bad_password_fails_permanently(self, app, pds):
|
||||
syndication._client_cache[f"bluesky:{SERVICE}:phil.example"].password = "wrong"
|
||||
note = publish(app)
|
||||
r = row(app, note)
|
||||
assert r["state"] == "failed" and "401" in r["last_error"]
|
||||
|
||||
def test_lost_reply_does_not_double_post(self, app, pds):
|
||||
pds.lose_next_reply = True
|
||||
note = publish(app)
|
||||
assert row(app, note)["state"] == "pending"
|
||||
with app.test_request_context():
|
||||
from starpunk.syndication import retry
|
||||
retry(row(app, note)["id"])
|
||||
# retry() resets attempts; simulate the scheduled retry instead
|
||||
from starpunk.database import get_db
|
||||
get_db(app).execute("UPDATE syndications SET attempts = 1")
|
||||
get_db(app).commit()
|
||||
process_due()
|
||||
assert len(pds.records) == 1
|
||||
assert row(app, note)["state"] == "synced"
|
||||
|
||||
def test_server_error_retries(self, app, pds):
|
||||
publish(app, content="warm up") # log in first
|
||||
pds.fail_next = 502
|
||||
note = publish(app, content="later")
|
||||
assert row(app, note)["state"] == "pending"
|
||||
|
||||
|
||||
class TestMedia:
|
||||
def test_large_image_is_shrunk_with_alt_and_aspect_ratio(self, app, pds):
|
||||
from starpunk.media import attach_media_to_note, save_media
|
||||
import os
|
||||
|
||||
img = Image.frombytes("RGB", (2400, 1800), os.urandom(2400 * 1800 * 3))
|
||||
buf = io.BytesIO()
|
||||
img.save(buf, format="PNG")
|
||||
assert buf.tell() > 1_000_000
|
||||
with app.test_request_context():
|
||||
note = create_note(content="noisy", published=True)
|
||||
media = save_media(buf.getvalue(), "noise.png")
|
||||
attach_media_to_note(note.id, [media["id"]], ["Static"])
|
||||
select_targets(note.id, ["bluesky"])
|
||||
process_due()
|
||||
record = only_record(pds)
|
||||
(image,) = record["embed"]["images"]
|
||||
assert record["embed"]["$type"] == "app.bsky.embed.images"
|
||||
assert image["alt"] == "Static"
|
||||
assert image["aspectRatio"]["width"] > 0
|
||||
|
||||
|
||||
def test_both_targets_listed_for_micropub(tmp_path):
|
||||
data = tmp_path / "d"
|
||||
app = create_app({
|
||||
"TESTING": True, "SITE_URL": "https://b.example", "ADMIN_ME": "https://e.example",
|
||||
"SESSION_SECRET": "x", "DATA_PATH": data, "NOTES_PATH": data / "notes",
|
||||
"DATABASE_PATH": data / "s.db",
|
||||
"GOTOSOCIAL_URL": "https://social.example", "GOTOSOCIAL_ACCESS_TOKEN": "t",
|
||||
"BLUESKY_HANDLE": "phil.example", "BLUESKY_APP_PASSWORD": "p",
|
||||
})
|
||||
with app.app_context():
|
||||
from starpunk.syndication import get_targets, resolve_targets
|
||||
assert set(get_targets()) == {"gotosocial", "bluesky"}
|
||||
assert resolve_targets(["https://bsky.app/profile/phil.example"]) == ["bluesky"]
|
||||
syndication._client_cache.clear()
|
||||
@@ -0,0 +1,402 @@
|
||||
"""
|
||||
Tests for crossposting to Threads (starpunk/syndication.py, v2.6.0)
|
||||
|
||||
A fake Graph API (httpx.MockTransport) records what StarPunk sends.
|
||||
"""
|
||||
|
||||
import io
|
||||
import json
|
||||
import time
|
||||
from urllib.parse import parse_qsl
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from PIL import Image
|
||||
|
||||
from starpunk import create_app, syndication
|
||||
from starpunk.notes import create_note, delete_note, update_note
|
||||
from starpunk.syndication import (
|
||||
THREADS_REFRESH_EVERY,
|
||||
ThreadsClient,
|
||||
get_note_syndications,
|
||||
process_due,
|
||||
select_targets,
|
||||
threads_length,
|
||||
threads_topic,
|
||||
)
|
||||
|
||||
API = "https://graph.threads.example/v1.0"
|
||||
UID = "1789"
|
||||
|
||||
|
||||
class FakeThreads:
|
||||
def __init__(self):
|
||||
self.containers = {}
|
||||
self.posts = {}
|
||||
self.calls = []
|
||||
self.token = "tok1"
|
||||
self.refreshes = 0
|
||||
self.refresh_fails = False
|
||||
self.pending_polls = 0
|
||||
self.lose_next_publish = False
|
||||
self.fail_next = None
|
||||
self.fail_next_publish = False
|
||||
|
||||
def _json(self, code, body):
|
||||
return httpx.Response(code, json=body)
|
||||
|
||||
def _error(self, code, message, err_code, subcode=None):
|
||||
error = {"message": message, "type": "OAuthException", "code": err_code}
|
||||
if subcode:
|
||||
error["error_subcode"] = subcode
|
||||
return self._json(code, {"error": error})
|
||||
|
||||
def __call__(self, request: httpx.Request) -> httpx.Response:
|
||||
params = dict(request.url.params)
|
||||
if request.content:
|
||||
params.update(parse_qsl(request.content.decode()))
|
||||
path = request.url.path
|
||||
self.calls.append((request.method, path, params))
|
||||
|
||||
if path == "/refresh_access_token":
|
||||
assert params["grant_type"] == "th_refresh_token"
|
||||
if self.refresh_fails or params.get("access_token") != self.token:
|
||||
return self._error(400, "token too new", 190)
|
||||
self.refreshes += 1
|
||||
self.token = f"tok{self.refreshes + 1}"
|
||||
return self._json(200, {"access_token": self.token, "token_type": "bearer",
|
||||
"expires_in": 5184000})
|
||||
|
||||
if params.get("access_token") != self.token:
|
||||
return self._error(400, "Invalid OAuth access token", 190)
|
||||
if self.fail_next:
|
||||
code, err, self.fail_next = *self.fail_next, None
|
||||
return self._error(code, "nope", err)
|
||||
|
||||
path = path.removeprefix("/v1.0/")
|
||||
if path == "me":
|
||||
return self._json(200, {"id": UID, "username": "phil"})
|
||||
if path == f"{UID}/threads" and request.method == "POST":
|
||||
cid = f"c{len(self.containers) + 1}"
|
||||
self.containers[cid] = params
|
||||
return self._json(200, {"id": cid})
|
||||
if path == f"{UID}/threads" and request.method == "GET":
|
||||
return self._json(200, {"data": [
|
||||
{"id": pid, "text": p["text"], "permalink": f"https://www.threads.com/@phil/post/{pid}"}
|
||||
for pid, p in self.posts.items()]})
|
||||
if path == f"{UID}/threads_publish" and self.fail_next_publish:
|
||||
self.fail_next_publish = False
|
||||
return self._error(400, "Fatal", 24, 4279009)
|
||||
if path == f"{UID}/threads_publish":
|
||||
container = self.containers[params["creation_id"]]
|
||||
pid = f"p{len(self.posts) + 1}"
|
||||
self.posts[pid] = container
|
||||
if self.lose_next_publish:
|
||||
self.lose_next_publish = False
|
||||
raise httpx.ReadTimeout("lost reply")
|
||||
return self._json(200, {"id": pid})
|
||||
if path in self.containers and request.method == "GET":
|
||||
if self.pending_polls:
|
||||
self.pending_polls -= 1
|
||||
return self._json(200, {"status": "IN_PROGRESS"})
|
||||
return self._json(200, {"status": "FINISHED"})
|
||||
if path in self.posts and request.method == "GET":
|
||||
return self._json(200, {"id": path, "permalink": f"https://www.threads.com/@phil/post/{path}"})
|
||||
if request.method == "DELETE":
|
||||
if self.posts.pop(path, None) is None:
|
||||
return self._error(400, "Object does not exist", 100, 33)
|
||||
return self._json(200, {"success": True, "deleted_id": path})
|
||||
return self._json(500, {"error": {"message": "unknown", "code": 2}})
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def api():
|
||||
return FakeThreads()
|
||||
|
||||
|
||||
def make_client(app, api, token="tok1"):
|
||||
return ThreadsClient(token, app.config["DATA_PATH"] / "threads_token.json", api=API,
|
||||
http=httpx.Client(transport=httpx.MockTransport(api)), sleep=lambda s: None)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app(tmp_path, api):
|
||||
data = tmp_path / "data"
|
||||
app = create_app({
|
||||
"TESTING": True,
|
||||
"SITE_URL": "https://blog.example.com",
|
||||
"ADMIN_ME": "https://example.com",
|
||||
"SESSION_SECRET": "test-secret",
|
||||
"DATA_PATH": data,
|
||||
"NOTES_PATH": data / "notes",
|
||||
"DATABASE_PATH": data / "starpunk.db",
|
||||
"THREADS_ACCESS_TOKEN": "tok1",
|
||||
"THREADS_USERNAME": "phil",
|
||||
})
|
||||
syndication._client_cache["threads"] = make_client(app, api)
|
||||
yield app
|
||||
syndication._client_cache.clear()
|
||||
|
||||
|
||||
def publish(app, content="Hello Threads", tags=None):
|
||||
with app.test_request_context():
|
||||
note = create_note(content=content, published=True, tags=tags)
|
||||
select_targets(note.id, ["threads"])
|
||||
process_due()
|
||||
return note
|
||||
|
||||
|
||||
def only_post(api):
|
||||
(post,) = api.posts.values()
|
||||
return post
|
||||
|
||||
|
||||
def row(app, note):
|
||||
with app.app_context():
|
||||
(r,) = get_note_syndications(note.id)
|
||||
return r
|
||||
|
||||
|
||||
def image_bytes(fmt="JPEG", size=(800, 600)):
|
||||
buf = io.BytesIO()
|
||||
Image.new("RGB", size, (200, 30, 30)).save(buf, format=fmt)
|
||||
return buf.getvalue()
|
||||
|
||||
|
||||
class TestText:
|
||||
def test_emoji_count_as_bytes(self):
|
||||
assert threads_length("abc") == 3
|
||||
assert threads_length("☕") == 3
|
||||
|
||||
def test_topic_is_first_usable_tag(self):
|
||||
assert threads_topic(["...", "Indie.Web & Co", "x"]) == "IndieWeb Co"
|
||||
assert threads_topic([]) == ""
|
||||
|
||||
|
||||
class TestLifecycle:
|
||||
def test_publish_text_post(self, app, api):
|
||||
note = publish(app, content="Hello **Threads**", tags=["IndieWeb", "Second"])
|
||||
post = only_post(api)
|
||||
permalink = f"https://blog.example.com/note/{note.slug}"
|
||||
assert post["media_type"] == "TEXT"
|
||||
assert post["text"] == f"Hello Threads\n\n{permalink}"
|
||||
assert "link_attachment" not in post # Threads previews the first link itself
|
||||
assert post["topic_tag"] == "IndieWeb"
|
||||
r = row(app, note)
|
||||
assert r["state"] == "synced"
|
||||
assert r["remote_id"] == "p1"
|
||||
assert r["remote_url"] == "https://www.threads.com/@phil/post/p1"
|
||||
|
||||
def test_long_note_fits_500(self, app, api):
|
||||
note = publish(app, content="☕ word " * 300)
|
||||
text = only_post(api)["text"]
|
||||
assert threads_length(text) <= 500
|
||||
assert text.endswith(f"https://blog.example.com/note/{note.slug}")
|
||||
|
||||
def test_waits_for_container(self, app, api):
|
||||
api.pending_polls = 2
|
||||
note = publish(app)
|
||||
assert row(app, note)["state"] == "synced"
|
||||
|
||||
def test_edit_leaves_post_alone(self, app, api):
|
||||
note = publish(app, content="first")
|
||||
with app.test_request_context():
|
||||
update_note(id=note.id, content="second")
|
||||
process_due()
|
||||
assert only_post(api)["text"].startswith("first")
|
||||
assert row(app, note)["state"] == "synced"
|
||||
|
||||
def test_delete_and_unpublish_remove_post(self, app, api):
|
||||
note = publish(app)
|
||||
with app.test_request_context():
|
||||
update_note(id=note.id, published=False)
|
||||
process_due()
|
||||
assert api.posts == {}
|
||||
update_note(id=note.id, published=True)
|
||||
process_due()
|
||||
assert len(api.posts) == 1
|
||||
delete_note(id=note.id)
|
||||
process_due()
|
||||
assert api.posts == {}
|
||||
|
||||
def test_post_deleted_on_threads_is_fine(self, app, api):
|
||||
note = publish(app)
|
||||
api.posts.clear()
|
||||
with app.test_request_context():
|
||||
delete_note(id=note.id)
|
||||
process_due()
|
||||
assert row(app, note)["state"] == "synced"
|
||||
|
||||
|
||||
class TestErrors:
|
||||
def test_lost_reply_does_not_double_post(self, app, api):
|
||||
api.lose_next_publish = True
|
||||
note = publish(app)
|
||||
assert row(app, note)["state"] == "pending"
|
||||
with app.test_request_context():
|
||||
from starpunk.database import get_db
|
||||
get_db(app).execute("UPDATE syndications SET next_attempt_at = datetime('now')")
|
||||
get_db(app).commit()
|
||||
process_due()
|
||||
assert len(api.posts) == 1
|
||||
assert row(app, note)["state"] == "synced"
|
||||
|
||||
def test_publish_fatal_is_retried(self, app, api):
|
||||
api.fail_next_publish = True
|
||||
note = publish(app)
|
||||
r = row(app, note)
|
||||
assert r["state"] == "pending" and "Fatal" in r["last_error"] and "subcode 4279009" in r["last_error"]
|
||||
with app.test_request_context():
|
||||
from starpunk.database import get_db
|
||||
get_db(app).execute("UPDATE syndications SET next_attempt_at = datetime('now')")
|
||||
get_db(app).commit()
|
||||
process_due()
|
||||
assert len(api.posts) == 1
|
||||
assert row(app, note)["state"] == "synced"
|
||||
|
||||
def test_bad_token_fails_permanently(self, app, api):
|
||||
api.token = "other"
|
||||
note = publish(app)
|
||||
r = row(app, note)
|
||||
assert r["state"] == "failed" and "Invalid OAuth" in r["last_error"]
|
||||
assert "tok1" not in r["last_error"]
|
||||
|
||||
def test_rate_limit_retries(self, app, api):
|
||||
publish(app, content="warm up")
|
||||
api.fail_next = (400, 4) # Graph "application request limit reached"
|
||||
note = publish(app, content="later")
|
||||
assert row(app, note)["state"] == "pending"
|
||||
|
||||
|
||||
class TestMedia:
|
||||
def _note_with(self, app, images):
|
||||
from starpunk.media import attach_media_to_note, save_media
|
||||
with app.test_request_context():
|
||||
note = create_note(content="pics", published=True)
|
||||
ids = [save_media(data, name)["id"] for data, name in images]
|
||||
attach_media_to_note(note.id, ids, [f"alt {i}" for i in range(len(ids))])
|
||||
select_targets(note.id, ["threads"])
|
||||
process_due()
|
||||
return note
|
||||
|
||||
def test_single_image(self, app, api):
|
||||
self._note_with(app, [(image_bytes(), "a.jpg")])
|
||||
post = only_post(api)
|
||||
assert post["media_type"] == "IMAGE"
|
||||
assert post["image_url"].startswith("https://blog.example.com/media/")
|
||||
assert post["alt_text"] == "alt 0"
|
||||
assert "link_attachment" not in post
|
||||
|
||||
def test_carousel(self, app, api):
|
||||
self._note_with(app, [(image_bytes(), "a.jpg"), (image_bytes("PNG"), "b.png")])
|
||||
post = only_post(api)
|
||||
assert post["media_type"] == "CAROUSEL"
|
||||
children = [api.containers[c] for c in post["children"].split(",")]
|
||||
assert [c["is_carousel_item"] for c in children] == ["true", "true"]
|
||||
assert [c["alt_text"] for c in children] == ["alt 0", "alt 1"]
|
||||
|
||||
def test_unsupported_format_is_left_off(self, app, api):
|
||||
self._note_with(app, [(image_bytes("WEBP"), "a.webp")])
|
||||
assert only_post(api)["media_type"] == "TEXT"
|
||||
|
||||
|
||||
class TestToken:
|
||||
def test_refreshes_daily_and_saves(self, app, api):
|
||||
client = syndication._client_cache["threads"]
|
||||
with app.app_context():
|
||||
client.maintain()
|
||||
assert api.refreshes == 1
|
||||
client.maintain() # same day: nothing
|
||||
assert api.refreshes == 1
|
||||
saved = json.loads((app.config["DATA_PATH"] / "threads_token.json").read_text())
|
||||
assert saved["token"] == "tok2"
|
||||
# A restart picks up the saved token
|
||||
assert make_client(app, api)._token == "tok2"
|
||||
publish(app)
|
||||
assert len(api.posts) == 1
|
||||
|
||||
def test_other_worker_refresh_is_reused(self, app, api):
|
||||
first, second = make_client(app, api), make_client(app, api)
|
||||
with app.app_context():
|
||||
first.maintain()
|
||||
second.maintain()
|
||||
assert api.refreshes == 1
|
||||
assert second._token == "tok2"
|
||||
|
||||
def test_refresh_due_after_a_day(self, app, api, monkeypatch):
|
||||
client = syndication._client_cache["threads"]
|
||||
with app.app_context():
|
||||
client.maintain()
|
||||
later = time.time() + THREADS_REFRESH_EVERY + 1
|
||||
monkeypatch.setattr(syndication.time, "time", lambda: later)
|
||||
client.maintain()
|
||||
assert api.refreshes == 2
|
||||
|
||||
def test_failed_refresh_keeps_token(self, app, api):
|
||||
api.refresh_fails = True
|
||||
client = syndication._client_cache["threads"]
|
||||
with app.app_context():
|
||||
client.maintain()
|
||||
assert client._token == "tok1"
|
||||
publish(app)
|
||||
assert len(api.posts) == 1
|
||||
|
||||
def test_new_config_token_replaces_saved_one(self, app, api):
|
||||
with app.app_context():
|
||||
syndication._client_cache["threads"].maintain()
|
||||
api.token = "fresh"
|
||||
assert make_client(app, api, token="fresh")._token == "fresh"
|
||||
|
||||
def test_worker_runs_upkeep(self, app, api):
|
||||
with app.app_context():
|
||||
process_due()
|
||||
assert api.refreshes == 1
|
||||
|
||||
|
||||
def test_all_targets_listed_for_micropub(tmp_path):
|
||||
data = tmp_path / "d"
|
||||
app = create_app({
|
||||
"TESTING": True, "SITE_URL": "https://b.example", "ADMIN_ME": "https://e.example",
|
||||
"SESSION_SECRET": "x", "DATA_PATH": data, "NOTES_PATH": data / "notes",
|
||||
"DATABASE_PATH": data / "s.db",
|
||||
"GOTOSOCIAL_URL": "https://social.example", "GOTOSOCIAL_ACCESS_TOKEN": "t",
|
||||
"BLUESKY_HANDLE": "phil.example", "BLUESKY_APP_PASSWORD": "p",
|
||||
"THREADS_ACCESS_TOKEN": "x", "THREADS_USERNAME": "@phil",
|
||||
})
|
||||
with app.app_context():
|
||||
from starpunk.syndication import get_targets, resolve_targets
|
||||
assert set(get_targets()) == {"gotosocial", "bluesky", "threads"}
|
||||
assert resolve_targets(["https://www.threads.com/@phil"]) == ["threads"]
|
||||
syndication._client_cache.clear()
|
||||
|
||||
|
||||
class TestLikesReposts:
|
||||
PAGE = "https://other.example/post/1"
|
||||
|
||||
def _post(self, app, monkeypatch, content="", **kind):
|
||||
monkeypatch.setattr("starpunk.reply_context.fetch_reply_context", lambda *a, **k: None)
|
||||
with app.test_request_context():
|
||||
note = create_note(content=content, published=True, **kind)
|
||||
select_targets(note.id, ["threads"])
|
||||
process_due()
|
||||
return note
|
||||
|
||||
def test_like_is_not_crossposted(self, app, api, monkeypatch):
|
||||
note = self._post(app, monkeypatch, like_of=self.PAGE)
|
||||
assert api.posts == {}
|
||||
r = row(app, note)
|
||||
assert r["state"] == "synced" and r["remote_id"] is None
|
||||
|
||||
def test_repost_posts_link(self, app, api, monkeypatch):
|
||||
self._post(app, monkeypatch, repost_of=self.PAGE)
|
||||
post = only_post(api)
|
||||
assert post["text"].startswith("🔁") and self.PAGE in post["text"]
|
||||
assert "link_attachment" not in post
|
||||
|
||||
def test_repost_with_comment_keeps_comment(self, app, api, monkeypatch):
|
||||
note = self._post(app, monkeypatch, content="So **true**", repost_of=self.PAGE)
|
||||
assert only_post(api)["text"].startswith("So true")
|
||||
with app.test_request_context():
|
||||
delete_note(id=note.id)
|
||||
process_due()
|
||||
assert api.posts == {}
|
||||
@@ -212,11 +212,12 @@ class TestAdminTemplates:
|
||||
assert response.status_code == 200
|
||||
assert b"<form" in response.data
|
||||
|
||||
def test_login_has_me_input(self, client):
|
||||
"""Test login form has 'me' URL input"""
|
||||
def test_login_has_sso_button(self, client):
|
||||
"""Test login form offers OIDC sign-in, not a URL field (v2.0.0)"""
|
||||
response = client.get("/auth/login")
|
||||
assert response.status_code == 200
|
||||
assert b'name="me"' in response.data or b'id="me"' in response.data
|
||||
assert b"Sign in with" in response.data
|
||||
assert b'name="me"' not in response.data
|
||||
|
||||
def test_login_has_submit_button(self, client):
|
||||
"""Test login form has submit button"""
|
||||
|
||||
Reference in new issue
Block a user