mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-16 07:13:29 +00:00
* feat(api): test endpoints for Withings, moodLog, Web Push, Glitchtip, Umami
Five POST /test endpoints modelled on /api/ai/test (apiHandler +
requireAuth/requireAdmin + checkRateLimit 5/60s + annotate() +
sanitised error mapping):
- /api/integrations/withings/test — pings wbsapi.withings.net /measure
with the decrypted user access token
- /api/integrations/moodlog/test — HEAD against the user's decrypted
moodLog URL (5 s timeout, isPublicUrl
SSRF guard)
- /api/notifications/web-push/test — sends "Push test" via web-push to
every PushSubscription, returns only
endpoint host (never full URL)
- /api/monitoring/glitchtip/test — admin-only; sends a stub event via
sendGlitchtipEvent() using the saved
AppSettings.glitchtipDsn
- /api/monitoring/umami/test — admin-only; HTTPS-only GET against
AppSettings.umamiScriptUrl, checks
body for "umami" marker
Each route has a vitest suite covering: happy path, rate-limit denial,
missing config (422), and upstream-401 sanitisation (no sk-/Bearer/full
URL leak).
Co-authored-by: Marc-André Bombeck <noreply@anthropic.com>
* fix(integration-tests): address review findings — singleton key, redirect SSRF, token refresh, scoped push
Multi-agent review caught a regression set on the five integration test
endpoints. Fixes here address every CRITICAL + HIGH finding:
- AppSettings is keyed on `id: "singleton"` everywhere else; the Glitchtip
and Umami test routes were querying `id: "default"` and would silently
return 422 in production. Tests now assert the where argument so the
typo can't sneak back.
- moodLog and Umami fetch with `redirect: "manual"` to neutralise the
redirect-follow SSRF (a public host could 302 to 169.254.169.254 or
RFC1918 ranges); 3xx is now treated as a configuration error.
- Withings test goes through the existing `getValidToken()` helper, so an
expired access token refreshes the same way the real sync does instead
of reporting "credentials rejected" until the next scheduled sync.
- Glitchtip DSN is validated as HTTPS + public host before any outbound
call, and the dispatch is wrapped in a 5 s `Promise.race` deadline.
- Withings dispatch picks up an `AbortController` 5 s deadline; the
Withings API-level `status` field (HTTP 200 + `status !== 0`) is now
categorised separately from the HTTP status (e.g. `status: 401` →
credentials_rejected, `status: 601` → rate_limited).
- moodLog test does an authenticated GET against the actual sync
endpoint instead of a bare HEAD on the configured URL — a HEAD on the
bare URL would return 200 from a generic landing page even when the
API key was invalid.
- Web Push test sends to the most recent subscription only (was: every
registered subscription, so a user with three devices got three buzzes
per click); tests assert findFirst+orderBy so this can't regress.
- Web Push response shape is the same shape on success and upstream
failure (errors land in the meta envelope, not in the visible
response body) — the prior dead-code in the 401 sanitisation test is
gone.
- Every error response now carries an `errorCode` in `meta` (e.g.
`credentials_rejected`, `rate_limited`, `dsn_host_not_public`) so the
upcoming UI can localise via `t("settings.testConnection.errors." + code)`
instead of rendering the server's English fallback.
- Outbound error annotations strip `Bearer <token>` and full URLs
before they reach Wide Events / Loki — push providers in particular
embed the subscription endpoint (which is the routing secret) in
410/404 error messages.
- Umami response read is capped at 256 KB so a hostile public host
cannot stream gigabytes through us; the marker check is tightened to
tracker shapes (`window.umami`, `umami.track`, `"umami"`) so a 404
page that says "Powered by Umami" no longer false-positives.
- `apiError` now optionally carries a `meta` object so error responses
can include the `errorCode` without breaking the existing
`{ data: null, error: <string> }` envelope.
477 tests green.
---------
Co-authored-by: Marc-André Bombeck <noreply@anthropic.com>
104 lines
3.1 KiB
TypeScript
104 lines
3.1 KiB
TypeScript
import type { NextRequest } from "next/server";
|
|
import { apiHandler, requireAuth } from "@/lib/api-handler";
|
|
import { apiSuccess, apiError } from "@/lib/api-response";
|
|
import { checkRateLimit } from "@/lib/rate-limit";
|
|
import { annotate } from "@/lib/logging/context";
|
|
import { prisma } from "@/lib/db";
|
|
import { decrypt } from "@/lib/crypto";
|
|
import { getVapidConfig } from "@/lib/notifications/vapid-config";
|
|
|
|
export const dynamic = "force-dynamic";
|
|
|
|
function hostFromEndpoint(endpoint: string): string {
|
|
try {
|
|
return new URL(endpoint).host;
|
|
} catch {
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
// Strip any URL from a stringified web-push library error. Push providers (FCM,
|
|
// Mozilla autopush, etc.) embed the full subscription endpoint into 410/404
|
|
// error messages — that endpoint token is the routing secret, so it must never
|
|
// land in our Wide Events.
|
|
function redactPushError(text: string): string {
|
|
return text.replace(/https?:\/\/\S+/gi, "[endpoint]");
|
|
}
|
|
|
|
export const POST = apiHandler(async (_request: NextRequest) => {
|
|
const { user } = await requireAuth();
|
|
annotate({ action: { name: "notifications.web-push.test" } });
|
|
|
|
const rl = await checkRateLimit(`web-push-test:${user.id}`, 5, 60_000);
|
|
if (!rl.allowed) {
|
|
return apiError("Too many test requests", 429, {
|
|
errorCode: "rate_limited_self",
|
|
});
|
|
}
|
|
|
|
// Spec: only the most-recent subscription receives the test push. A user
|
|
// with phone + tablet + desktop should not get three buzzes per click.
|
|
const subscription = await prisma.pushSubscription.findFirst({
|
|
where: { userId: user.id },
|
|
orderBy: { createdAt: "desc" },
|
|
});
|
|
|
|
if (!subscription) {
|
|
return apiError("No push subscriptions registered", 422, {
|
|
errorCode: "not_configured",
|
|
});
|
|
}
|
|
|
|
const config = await getVapidConfig();
|
|
if (!config) {
|
|
return apiError("VAPID keys not configured", 422, {
|
|
errorCode: "vapid_not_configured",
|
|
});
|
|
}
|
|
|
|
const webpush = await import("web-push");
|
|
webpush.setVapidDetails(config.subject, config.publicKey, config.privateKey);
|
|
|
|
const pushPayload = JSON.stringify({
|
|
title: "HealthLog",
|
|
body: "This is a test notification from HealthLog",
|
|
tag: "self-test",
|
|
});
|
|
|
|
const host = hostFromEndpoint(subscription.endpoint);
|
|
const start = performance.now();
|
|
|
|
try {
|
|
const p256dh = decrypt(subscription.p256dh);
|
|
const auth = decrypt(subscription.auth);
|
|
|
|
const result = await webpush.sendNotification(
|
|
{ endpoint: subscription.endpoint, keys: { p256dh, auth } },
|
|
pushPayload,
|
|
);
|
|
const latencyMs = Math.round(performance.now() - start);
|
|
|
|
return apiSuccess({
|
|
ok: true,
|
|
sent: 1,
|
|
latencyMs,
|
|
perEndpoint: [{ host, status: result.statusCode ?? 201 }],
|
|
});
|
|
} catch (err: unknown) {
|
|
const status = (err as { statusCode?: number }).statusCode ?? null;
|
|
const message = redactPushError((err as Error).message ?? "").slice(0, 200);
|
|
annotate({
|
|
meta: {
|
|
web_push_test_status: status,
|
|
web_push_test_host: host,
|
|
web_push_test_error: message,
|
|
},
|
|
});
|
|
return apiSuccess({
|
|
ok: false,
|
|
sent: 0,
|
|
perEndpoint: [{ host, status }],
|
|
});
|
|
}
|
|
});
|