feat: add cron health monitor + fix SectionNav Svelte 5 warning

- monitor.ts: hourly cron checks /api/packages (non-empty) and
  /api/health (healthy); POSTs JSON alert to ALERT_WEBHOOK_URL if set
  (Discord/Slack/any webhook). Logs to Workers dashboard regardless.
- hooks.server.ts: export scheduled handler for Cloudflare cron trigger
- wrangler.toml: add [triggers] crons = ["0 * * * *"] (every hour)
- app.d.ts: add ALERT_WEBHOOK_URL? to Platform.env, add Scheduled type
- SectionNav.svelte: extract sections[0]?.id to const before $state()
  to fix Svelte 5 state_referenced_locally warning

Author: fullstackjam

src/app.d.ts

@@ -15,8 +15,12 @@ declare global {
 				GOOGLE_CLIENT_SECRET: string;
 				JWT_SECRET: string;
 				APP_URL: string;
+				/** Optional. Webhook URL for health alerts (Discord/Slack/etc). */
+				ALERT_WEBHOOK_URL?: string;
 			};
 		}
+		// Cloudflare Workers Cron Trigger handler signature.
+		type Scheduled = (event: { platform: Platform | undefined }) => Promise<void>;
 	}
 }
 

src/hooks.server.ts

@@ -1,4 +1,5 @@
 import type { Handle } from '@sveltejs/kit';
+import { runHealthChecks } from '$lib/server/monitor';
 import { RESERVED_ALIASES } from '$lib/server/validation';
 import { getConfigForHookAlias, getConfigForInstall, getConfigForHookSlug } from '$lib/server/db';
 import { serveInstallByAlias, serveInstallBySlug } from '$lib/server/alias';
@@ -135,3 +136,13 @@ export const handle: Handle = async ({ event, resolve }) => {
 
 	return securedResponse;
 };
+
+// Cloudflare Workers Cron Trigger — runs on the schedule defined in wrangler.toml.
+// Checks critical production signals and sends an alert to ALERT_WEBHOOK_URL if any fail.
+export const scheduled: App.Scheduled = async ({ platform }) => {
+	await runHealthChecks({
+		APP_URL: platform?.env?.APP_URL ?? 'https://openboot.dev',
+		ALERT_WEBHOOK_URL: platform?.env?.ALERT_WEBHOOK_URL,
+	});
+};
+

src/lib/components/SectionNav.svelte

@@ -8,7 +8,8 @@
 
 	let { sections }: { sections: Section[] } = $props();
 
-	let activeId = $state(sections[0]?.id ?? '');
+	const initialId = sections[0]?.id ?? '';
+	let activeId = $state(initialId);
 	let observer: IntersectionObserver | null = null;
 
 	onMount(() => {

src/lib/server/monitor.ts

@@ -0,0 +1,98 @@
+/**
+ * Production health monitoring for Cloudflare Workers cron trigger.
+ *
+ * Checks three critical signals on every run:
+ *   1. /api/packages returns a non-empty array
+ *   2. /api/health returns status "healthy"
+ *   3. DB is reachable (via health endpoint)
+ *
+ * If any check fails, posts a JSON alert to ALERT_WEBHOOK_URL (if set).
+ * Works with Discord, Slack, PagerDuty, or any webhook receiver.
+ */
+
+interface CheckResult {
+	name: string;
+	ok: boolean;
+	detail: string;
+}
+
+interface MonitorEnv {
+	APP_URL: string;
+	ALERT_WEBHOOK_URL?: string;
+}
+
+async function checkPackages(appUrl: string): Promise<CheckResult> {
+	try {
+		const res = await fetch(`${appUrl}/api/packages`, { signal: AbortSignal.timeout(10_000) });
+		if (!res.ok) {
+			return { name: 'packages', ok: false, detail: `HTTP ${res.status}` };
+		}
+		const body = (await res.json()) as { packages?: unknown[] };
+		const count = body?.packages?.length ?? 0;
+		if (count === 0) {
+			return { name: 'packages', ok: false, detail: 'returned empty array' };
+		}
+		return { name: 'packages', ok: true, detail: `${count} packages` };
+	} catch (err) {
+		return { name: 'packages', ok: false, detail: String(err) };
+	}
+}
+
+async function checkHealth(appUrl: string): Promise<CheckResult> {
+	try {
+		const res = await fetch(`${appUrl}/api/health`, { signal: AbortSignal.timeout(10_000) });
+		const body = (await res.json()) as { status?: string; checks?: Record<string, string> };
+		if (body?.status !== 'healthy') {
+			const detail = body?.checks
+				? Object.entries(body.checks)
+						.filter(([, v]) => v !== 'ok')
+						.map(([k, v]) => `${k}=${v}`)
+						.join(', ')
+				: `status=${body?.status}`;
+			return { name: 'health', ok: false, detail: detail || 'degraded' };
+		}
+		return { name: 'health', ok: true, detail: 'healthy' };
+	} catch (err) {
+		return { name: 'health', ok: false, detail: String(err) };
+	}
+}
+
+async function sendAlert(webhookUrl: string, failures: CheckResult[]): Promise<void> {
+	const lines = failures.map((f) => `• **${f.name}**: ${f.detail}`).join('\n');
+	const payload = {
+		// Discord-compatible format; Slack ignores unknown fields
+		content: `🚨 **openboot.dev health alert** — ${failures.length} check(s) failed:\n${lines}`,
+		// Slack-compatible fallback
+		text: `openboot.dev health alert — ${failures.length} check(s) failed:\n${failures.map((f) => `• ${f.name}: ${f.detail}`).join('\n')}`,
+	};
+	await fetch(webhookUrl, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify(payload),
+		signal: AbortSignal.timeout(10_000),
+	});
+}
+
+export async function runHealthChecks(env: MonitorEnv): Promise<void> {
+	const appUrl = env.APP_URL ?? 'https://openboot.dev';
+
+	const results = await Promise.all([checkPackages(appUrl), checkHealth(appUrl)]);
+
+	const failures = results.filter((r) => !r.ok);
+
+	if (failures.length > 0 && env.ALERT_WEBHOOK_URL) {
+		await sendAlert(env.ALERT_WEBHOOK_URL, failures);
+	}
+
+	// Always log — visible in Workers dashboard → Logs
+	for (const r of results) {
+		const icon = r.ok ? '✓' : '✗';
+		console.log(`[monitor] ${icon} ${r.name}: ${r.detail}`);
+	}
+
+	if (failures.length > 0) {
+		// Non-fatal: don't throw, just log. Workers cron retries on exceptions
+		// which could flood alerts. Log and return instead.
+		console.error(`[monitor] ${failures.length} check(s) failed`);
+	}
+}

wrangler.toml

@@ -19,3 +19,7 @@ migrations_dir = "migrations"
 
 [vars]
 APP_URL = "https://openboot.dev"
+# ALERT_WEBHOOK_URL = "https://discord.com/api/webhooks/..."  # set in Cloudflare dashboard (secret)
+
+[triggers]
+crons = ["0 * * * *"]  # every hour