Merge branch 'feat/v2.18.0-admin-cleanup' for v2.18.0 release
Build Container / build (push) Successful in 9m36s

This commit is contained in:
Phil committed 2026-11-12 13:06:48 -07:00
commit bda7adc449
13 files changed
+399 -37

No files matched your search

+21
View File
@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased]
## [2.18.0] - 2026-11-12
A tidier admin area.
### Added
- **Log page** (`/admin/log`): everything that is failing right now, newest
first. Each entry shows when it happened, what failed (crosspost, response
check, outgoing webmention, reply-context fetch, WebSub delivery,
notifications, refused silo credentials), a link to the affected post and
the error message, with Retry / Check now where that applies. It reads the
error columns the workers already keep, so an entry goes away once the
next attempt succeeds. The admin nav shows the error count.
- **Settings page** (`/admin/settings`) for site-wide settings. Notification
status and the test button live here now.
- Webmentions, Log and Settings links in the admin nav.
### Changed
- The Webmentions page no longer has the Back to Dashboard button or the
Notifications section, and links to the Log instead of counting response
check errors.
## [2.17.1] - 2026-11-12
### Fixed
@@ -139,8 +139,8 @@ again with the new content. `_fail()` does the same.
a Threads container in `ERROR`/`EXPIRED`, and Graph API auth/permission
errors (codes 10, 190, 200).
- Other errors retry after `min(30 s × 2^attempts, 6 h)`. After 8 attempts
the row becomes `failed`. The error is shown on the edit page with a
Retry button. When a row finally fails, the owner also gets a `problems`
the row becomes `failed`. The error is shown on the edit page and on the
admin Log page (v2.18.0), both with a Retry button. When a row finally fails, the owner also gets a `problems`
notification (ADR-074).
- `RemoteGone` (404, or Graph error 100/33) during an update means the copy
was deleted remotely, so a new one is created. During a delete it counts as
@@ -273,7 +273,7 @@ reposts) that are due, each under a lease (`backfeed_claimed_until`):
(`site_state.backfeed_backfill_last`). Start and finish times are in
`site_state`.
- **Refused credentials.** A 401/403 (or Graph auth error) puts the target
in `backfeed.denied` until restart; the admin Webmentions page says which
in `backfeed.denied` until restart; the admin Log page says which
scopes are needed, and a `problems` notification is sent. Crossposting
is unaffected.
+2 -2
View File
@@ -468,5 +468,5 @@ def create_app(config=None):
# Package version (Semantic Versioning 2.0.0)
# See docs/standards/versioning-strategy.md for details
__version__ = "2.17.1"
__version_info__ = (2, 17, 1)
__version__ = "2.18.0"
__version_info__ = (2, 18, 0)
+127
View File
@@ -0,0 +1,127 @@
"""
Error log for the admin Log page (v2.18.0)
Collects what is failing right now from the tables that already record it:
crossposts, response checks (backfeed), outgoing webmentions, reply-context
fetches, WebSub deliveries and notifications. Nothing new is stored. An entry
disappears once the next attempt succeeds, so the page lists only problems
that still need attention.
Each entry is a dict:
when -- timestamp text (UTC) or "" when unknown
area -- short label, e.g. "Crosspost to Bluesky"
note -- the affected Note, or None for site-wide problems
detail -- extra context (a URL or "retrying"), may be ""
error -- the recorded error message
action -- optional (endpoint, id, label) for a retry button
"""
from flask import current_app
from starpunk.database import get_db
SILOS = {"gotosocial": "GoToSocial", "bluesky": "Bluesky", "threads": "Threads"}
def _silo(target: str) -> str:
return SILOS.get(target, target)
def _notes(ids) -> dict:
"""Load the affected notes once each (deleted notes come back as None)"""
from starpunk.notes import get_note
return {i: get_note(id=i) for i in set(ids) if i is not None}
def entries() -> list:
"""Every current error, newest first; site-wide problems come first"""
from starpunk import backfeed, notifications
db = get_db(current_app)
rows = []
for r in db.execute(
"SELECT id, note_id, target, state, last_error, updated_at FROM syndications "
"WHERE last_error IS NOT NULL AND state != 'synced'"
):
rows.append({
"when": r["updated_at"], "area": f"Crosspost to {_silo(r['target'])}",
"note_id": r["note_id"], "detail": "retrying" if r["state"] == "pending" else "",
"error": r["last_error"],
"action": ("admin.retry_syndication", r["id"], "Retry"),
})
for r in db.execute(
"SELECT id, note_id, target, backfeed_error, backfeed_checked_at, remote_url FROM syndications "
"WHERE backfeed_error IS NOT NULL"
):
rows.append({
"when": r["backfeed_checked_at"], "area": f"Response check on {_silo(r['target'])}",
"note_id": r["note_id"], "detail": r["remote_url"] or "", "error": r["backfeed_error"],
"action": ("admin.check_syndication_responses", r["id"], "Check now"),
})
for r in db.execute(
"SELECT source_note_id, target_url, status, last_error, COALESCE(started_at, created_at) AS at "
"FROM webmention_queue WHERE last_error IS NOT NULL AND status IN ('pending', 'failed')"
):
rows.append({
"when": r["at"], "area": "Webmention sent", "note_id": r["source_note_id"],
"detail": r["target_url"] + (" (retrying)" if r["status"] == "pending" else ""),
"error": r["last_error"], "action": None,
})
for r in db.execute(
"SELECT n.id AS note_id, rc.url, rc.fetch_error, rc.fetched_at, rc.created_at "
"FROM reply_contexts rc JOIN notes n ON n.in_reply_to = rc.url "
"WHERE rc.fetch_status = 'error' AND n.deleted_at IS NULL"
):
rows.append({
"when": r["fetched_at"] or r["created_at"], "area": "Reply context fetch",
"note_id": r["note_id"], "detail": r["url"], "error": r["fetch_error"] or "fetch failed",
"action": None,
})
for r in db.execute(
"SELECT topic, callback, last_error, COALESCE(last_success_at, verified_at, created_at) AS at "
"FROM websub_subscriptions WHERE last_error IS NOT NULL"
):
rows.append({
"when": r["at"], "area": "WebSub delivery", "note_id": None,
"detail": f"{r['topic']} → {r['callback']}", "error": r["last_error"], "action": None,
})
rows.sort(key=lambda e: str(e["when"] or ""), reverse=True)
site = []
for silo, message in backfeed.denied.items():
site.append({"when": "", "area": f"Response checks on {_silo(silo)}", "note_id": None,
"detail": "paused", "error": message, "action": None})
notify_error = notifications.last_error(db)
if notify_error:
when, _, message = notify_error.partition(" UTC ")
site.append({"when": when if message else "", "area": "Notifications", "note_id": None,
"detail": "", "error": message or notify_error, "action": None})
entries = site + rows
notes = _notes(e["note_id"] for e in entries)
for e in entries:
e["note"] = notes.get(e.pop("note_id"))
return entries
def count() -> int:
"""Cheap total for the admin nav badge"""
from starpunk import backfeed, notifications
db = get_db(current_app)
total = db.execute(
"SELECT (SELECT COUNT(*) FROM syndications WHERE last_error IS NOT NULL AND state != 'synced')"
" + (SELECT COUNT(*) FROM syndications WHERE backfeed_error IS NOT NULL)"
" + (SELECT COUNT(*) FROM webmention_queue WHERE last_error IS NOT NULL AND status IN ('pending', 'failed'))"
" + (SELECT COUNT(*) FROM reply_contexts rc JOIN notes n ON n.in_reply_to = rc.url"
" WHERE rc.fetch_status = 'error' AND n.deleted_at IS NULL)"
" + (SELECT COUNT(*) FROM websub_subscriptions WHERE last_error IS NOT NULL)"
).fetchone()[0]
return total + len(backfeed.denied) + (1 if notifications.last_error(db) else 0)
+32 -3
View File
@@ -25,6 +25,20 @@ from starpunk.notes import (
bp = Blueprint("admin", __name__, url_prefix="/admin")
@bp.context_processor
def _admin_nav():
"""Error count for the Log link in the admin nav (v2.18.0)"""
if not getattr(g, "me", None):
return {}
from starpunk import error_log
try:
return {"error_count": error_log.count()}
except Exception as e: # never break an admin page over the badge
logger.warning(f"Could not count errors for the admin nav: {e}")
return {"error_count": 0}
@bp.route("/")
@require_auth
def dashboard():
@@ -530,7 +544,6 @@ def webmentions():
status_filter=status_filter,
origin_filter=origin_filter,
backfeed=backfeed.status(),
notify=_notify_status(),
page=page,
total_pages=total_pages,
user_me=g.me
@@ -698,7 +711,7 @@ def revoke_token(token_id):
def _notify_status() -> dict:
"""Notification settings and last error for the Webmentions page (v2.14.0)"""
"""Notification settings and last error for the Settings page (v2.14.0)"""
from starpunk import notifications
from starpunk.database import get_db
@@ -711,6 +724,22 @@ def _notify_status() -> dict:
}
@bp.route("/settings")
@require_auth
def settings():
"""Site settings: notifications (v2.18.0). Template: templates/admin/settings.html"""
return render_template("admin/settings.html", notify=_notify_status(), user_me=g.me)
@bp.route("/log")
@require_auth
def error_log():
"""Current errors with the affected note (v2.18.0). Template: templates/admin/log.html"""
from starpunk import error_log as log
return render_template("admin/log.html", entries=log.entries(), user_me=g.me)
@bp.route("/notifications/test", methods=["POST"])
@require_auth
def notifications_test():
@@ -722,7 +751,7 @@ def notifications_test():
notifications._record(current_app.config["DATABASE_PATH"], ok, error)
flash("Test notification sent" if ok else f"Test notification failed: {error or 'unknown error'}",
"success" if ok else "error")
return redirect(url_for("admin.webmentions"))
return redirect(url_for("admin.settings"))
@bp.route("/backfeed/backfill", methods=["POST"])
+7
View File
@@ -465,6 +465,13 @@ small { display: block; margin-top: var(--spacing-xs); color: var(--color-text-l
.badge-like { background: #FECACA; color: #991B1B; }
.badge-repost { background: #D1FAE5; color: #065F46; }
.badge-bookmark { background: #FEF3C7; color: #92400E; }
.badge-error { background: var(--color-error); color: #fff; }
/* Admin Log (v2.18.0) */
.log-table td { vertical-align: top; }
.log-table .button { white-space: nowrap; }
.log-error code { white-space: pre-wrap; overflow-wrap: anywhere; font-size: 0.85rem; }
.backfeed-status { margin-bottom: var(--spacing-lg); }
.badge-mention { background: #E5E7EB; color: #374151; }
.status-badge {
+3
View File
@@ -8,7 +8,10 @@
<nav class="admin-nav">
<a href="{{ url_for('admin.dashboard') }}">Dashboard</a>
<a href="{{ url_for('admin.new_note_form') }}">New Note</a>
{% if config.WEBMENTION_ENABLED %}<a href="{{ url_for('admin.webmentions') }}">Webmentions</a>{% endif %}
<a href="{{ url_for('admin.error_log') }}">Log{% if error_count %} <span class="badge badge-error">{{ error_count }}</span>{% endif %}</a>
<a href="{{ url_for('admin.tokens') }}">Connected Apps</a>
<a href="{{ url_for('admin.settings') }}">Settings</a>
<form action="{{ url_for('auth.logout') }}" method="POST" class="logout-form"><input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
<button type="submit" class="button button-secondary">Logout</button>
</form>
+57
View File
@@ -0,0 +1,57 @@
{% extends "admin/base.html" %}
{% block title %}Log - StarPunk Admin{% endblock %}
{% block admin_content %}
<div class="log-admin">
<h2>Log</h2>
<p class="text-muted">What is failing right now. An entry goes away once the next attempt succeeds.</p>
{% if entries %}
<div class="table-scroll">
<table class="note-table log-table">
<thead>
<tr>
<th>When (UTC)</th>
<th>What</th>
<th>Post</th>
<th>Error</th>
<th></th>
</tr>
</thead>
<tbody>
{% for e in entries %}
<tr>
<td class="note-date">{{ e.when or '' }}</td>
<td>
{{ e.area }}
{% if e.detail %}<br><small class="note-slug">{% if e.detail.startswith('http') %}<a href="{{ e.detail.split(' ')[0] }}" target="_blank" rel="noopener">{{ e.detail|truncate(60) }}</a>{% else %}{{ e.detail|truncate(80) }}{% endif %}</small>{% endif %}
</td>
<td>
{% if e.note %}
<a href="{{ url_for('admin.edit_note_form', note_id=e.note.id) }}">{{ (e.note.title or e.note.content or e.note.slug)|truncate(60) }}</a>
{% if e.note.published %}<br><small><a href="{{ e.note.url }}" target="_blank">View</a></small>{% endif %}
{% else %}
<span class="text-muted">Site-wide</span>
{% endif %}
</td>
<td class="log-error"><code>{{ e.error }}</code></td>
<td>
{% if e.action %}
<form method="POST" action="{{ url_for(e.action[0], syndication_id=e.action[1]) }}"><input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
<button type="submit" class="button button-small">{{ e.action[2] }}</button>
</form>
{% endif %}
</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% else %}
<div class="empty-state">
<p>No errors. Crossposts, response checks, webmentions, WebSub and notifications are all working.</p>
</div>
{% endif %}
</div>
{% endblock %}
+23
View File
@@ -0,0 +1,23 @@
{% extends "admin/base.html" %}
{% block title %}Settings - StarPunk Admin{% endblock %}
{% block admin_content %}
<div class="settings-admin">
<h2>Settings</h2>
{# Notifications (v2.14.0, ADR-074; moved here in v2.18.0) #}
<section class="notify-status">
<h3>Notifications</h3>
{% if notify.enabled %}
<p>Sending {{ notify.events|join(', ') }} to {{ notify.services|join(', ') }} at {{ notify.priority }} priority.</p>
{% if notify.last_error %}<p class="flash flash-error">Last send failed: {{ notify.last_error }}</p>{% endif %}
<form method="POST" action="{{ url_for('admin.notifications_test') }}"><input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
<button type="submit" class="button">Send test notification</button>
</form>
{% else %}
<p>Off. Set <code>NOTIFY_URLS</code> to one or more Apprise URLs to be notified of new responses.</p>
{% endif %}
</section>
</div>
{% endblock %}
+1 -26
View File
@@ -6,35 +6,10 @@
<div class="webmentions-admin">
<h2>Webmentions</h2>
<div class="dashboard-actions">
<a href="{{ url_for('admin.dashboard') }}" class="button">
Back to Dashboard
</a>
</div>
{# Notifications (v2.14.0, ADR-074) #}
{% if notify %}
<section class="notify-status">
<h3>Notifications</h3>
{% if notify.enabled %}
<p>Sending {{ notify.events|join(', ') }} to {{ notify.services|join(', ') }} at {{ notify.priority }} priority.</p>
{% if notify.last_error %}<p class="flash flash-error">Last send failed: {{ notify.last_error }}</p>{% endif %}
<form method="POST" action="{{ url_for('admin.notifications_test') }}"><input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
<button type="submit" class="button">Send test notification</button>
</form>
{% else %}
<p>Off. Set <code>NOTIFY_URLS</code> to one or more Apprise URLs to be notified of new responses.</p>
{% endif %}
</section>
{% endif %}
{# Backfeed (v2.13.0, ADR-073) #}
{% if backfeed and backfeed.enabled %}
<section class="backfeed-status">
<h3>Backfeed</h3>
{% for silo, message in backfeed.denied.items() %}
<p class="flash flash-error">{{ silo }}: {{ message }}</p>
{% endfor %}
{% if backfeed.remaining %}
<p>Backfill started {{ backfeed.started }} UTC: {{ backfeed.remaining }} crosspost(s) left to check.</p>
{% elif backfeed.finished %}
@@ -42,7 +17,7 @@
{% else %}
<p>No backfill has been run. It checks every crosspost once for responses, however old the note.</p>
{% endif %}
{% if backfeed.errors %}<p>{{ backfeed.errors }} crosspost(s) had an error at their last check (see each note's edit page).</p>{% endif %}
{% if backfeed.errors or backfeed.denied %}<p><a href="{{ url_for('admin.error_log') }}">Response checks have errors: see the Log.</a></p>{% endif %}
<form method="POST" action="{{ url_for('admin.backfeed_backfill') }}"><input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
<button type="submit" class="button"{% if backfeed.remaining %} disabled{% endif %}>Backfill responses</button>
</form>
+119
View File
@@ -0,0 +1,119 @@
"""Admin Log and Settings pages (v2.18.0)"""
import pytest
from starpunk import backfeed, create_app, error_log
from starpunk.auth import create_session
from starpunk.database import get_db
from starpunk.notes import create_note
SITE = "https://blog.example.com"
@pytest.fixture
def app(tmp_path):
app = create_app({
"TESTING": True, "SITE_URL": SITE, "ADMIN_ME": "https://example.com",
"DATABASE_PATH": tmp_path / "starpunk.db", "DATA_PATH": tmp_path,
"NOTES_PATH": tmp_path / "notes", "SESSION_SECRET": "test", "CSRF_ENABLED": False,
"BACKGROUND_WORKERS_ENABLED": False, "WEBMENTION_ENABLED": True,
})
backfeed.denied.clear()
yield app
backfeed.denied.clear()
@pytest.fixture
def browser(app):
with app.test_request_context():
token = create_session("https://example.com")
client = app.test_client()
client.set_cookie("starpunk_session", token)
return client
def _failures(app):
"""One of each kind of error, on two notes"""
with app.app_context():
broken = create_note(content="A crosspost that broke", published=True)
reply = create_note(content="Replying", published=True)
db = get_db(app)
db.execute("UPDATE notes SET in_reply_to = 'https://gone.example/post' WHERE id = ?", (reply.id,))
db.execute("INSERT INTO syndications (note_id, target, state, last_error, updated_at) "
"VALUES (?, 'bluesky', 'failed', 'HTTP 400: post too long', '2026-11-12 10:00:00')",
(broken.id,))
db.execute("INSERT INTO syndications (note_id, target, state, remote_url, backfeed_error, "
"backfeed_checked_at) VALUES (?, 'gotosocial', 'synced', 'https://social.example/1', "
"'HTTP 404 from GoToSocial', '2026-11-12 11:00:00')", (broken.id,))
db.execute("INSERT INTO webmention_queue (source_url, target_url, source_note_id, status, last_error) "
"VALUES (?, 'https://other.example/a', ?, 'failed', 'Endpoint returned 500')",
(f"{SITE}/note/{reply.slug}", reply.id))
db.execute("INSERT INTO reply_contexts (url, fetch_status, fetch_error) "
"VALUES ('https://gone.example/post', 'error', 'HTTP 410 Gone')")
db.execute("INSERT INTO syndications (note_id, target, state, last_error) "
"VALUES (?, 'threads', 'synced', 'old error, since fixed')", (reply.id,))
db.commit()
return broken, reply
def test_log_lists_each_error_with_its_post(app, browser):
broken, reply = _failures(app)
backfeed.denied["threads"] = "Needs a Threads token with threads_manage_replies"
page = browser.get("/admin/log").get_data(as_text=True)
for text in ("Crosspost to Bluesky", "HTTP 400: post too long", "Retry",
"Response check on GoToSocial", "HTTP 404 from GoToSocial", "Check now",
"Webmention sent", "https://other.example/a", "Endpoint returned 500",
"Reply context fetch", "HTTP 410 Gone",
"Response checks on Threads", "Needs a Threads token", "Site-wide"):
assert text in page, text
assert f"/admin/edit/{broken.id}" in page and f"/admin/edit/{reply.id}" in page
assert "old error, since fixed" not in page, "synced crossposts aren't errors"
assert 'class="badge badge-error">5<' in page
with app.app_context():
assert error_log.count() == 5
areas = [e["area"] for e in error_log.entries()]
assert areas[0] == "Response checks on Threads", "site-wide problems first"
assert areas.index("Response check on GoToSocial") < areas.index("Crosspost to Bluesky"), "newest first"
def test_log_retry_clears_the_crosspost_error(app, browser):
broken, _ = _failures(app)
with app.app_context():
sid = get_db(app).execute("SELECT id FROM syndications WHERE target = 'bluesky'").fetchone()[0]
browser.post(f"/admin/syndication/{sid}/retry")
assert "HTTP 400: post too long" not in browser.get("/admin/log").get_data(as_text=True)
def test_empty_log_and_no_badge(browser):
page = browser.get("/admin/log").get_data(as_text=True)
assert "No errors." in page and "badge-error" not in page
def test_notification_error_is_logged(app, browser):
with app.app_context():
get_db(app).execute("INSERT INTO site_state (key, value) VALUES "
"('notify_last_error', '2026-11-12 09:00:00 UTC gotify: 401 Unauthorized')")
get_db(app).commit()
page = browser.get("/admin/log").get_data(as_text=True)
assert "Notifications" in page and "gotify: 401 Unauthorized" in page and "2026-11-12 09:00:00" in page
def test_webmentions_page_is_decluttered(browser):
page = browser.get("/admin/webmentions").get_data(as_text=True)
assert "Back to Dashboard" not in page
assert "Send test notification" not in page and "<h3>Notifications</h3>" not in page
def test_nav_and_settings_page(browser):
page = browser.get("/admin/settings").get_data(as_text=True)
assert "<h3>Notifications</h3>" in page and "NOTIFY_URLS" in page
for link in ("/admin/webmentions", "/admin/log", "/admin/settings", "/admin/tokens"):
assert f'href="{link}"' in page, link
def test_pages_require_login(app):
client = app.test_client()
for path in ("/admin/log", "/admin/settings"):
assert client.get(path).status_code == 302
+2 -1
View File
@@ -543,7 +543,8 @@ def test_admin_backfill_and_check_now(app, client):
assert s["backfeed_next_at"]
backfeed.denied["gotosocial"] = "Needs a GoToSocial token with read:statuses"
assert "Needs a GoToSocial token" in browser.get("/admin/webmentions?origin=gotosocial").get_data(as_text=True)
assert "Needs a GoToSocial token" in browser.get("/admin/log").get_data(as_text=True)
assert "Response checks have errors" in browser.get("/admin/webmentions").get_data(as_text=True)
def test_threads_avatar_kept_while_its_copy_exists(app, client, web):
+2 -2
View File
@@ -209,10 +209,10 @@ def test_admin_status_and_test_button(app, sent):
token = create_session("https://example.com")
browser = app.test_client()
browser.set_cookie("starpunk_session", token)
page = browser.get("/admin/webmentions").get_data(as_text=True)
page = browser.get("/admin/settings").get_data(as_text=True)
assert "Sending like, mention, problems, reply to gotifys, ntfys at high priority" in page
page = browser.post("/admin/notifications/test", follow_redirects=True).get_data(as_text=True)
assert "Test notification sent" in page and sent[-1]["title"] == "StarPunk test notification"
assert "Test notification sent" in page and "<h2>Settings</h2>" in page and sent[-1]["title"] == "StarPunk test notification"
# --- Real Apprise -------------------------------------------------------------------------------------