NPM stays the source of truth for which domains exist. Overrides here are enrichment only — leave a field blank and it falls back to the NPM name / pattern-match result.
+
+
+
npm hosts
+
+
+
+
domain
pattern
visibility
display name
check path
+
+
loading…
+
+
+
+
manual targets
+
+
+
+
name
url
check path
enabled
+
+
loading…
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+`;
+}
diff --git a/src/checker.ts b/src/checker.ts
index eaeba16..c40d9ea 100644
--- a/src/checker.ts
+++ b/src/checker.ts
@@ -1,4 +1,6 @@
-import { fetchProxyHosts } from './npm.js';
+import { fetchAllProxyHosts, matchesIncludePatterns } from './npm.js';
+import { getAllOverrides, listManualTargets } from './db.js';
+import { computeTargets, type CheckTarget, type RawNpmHost } from './targets.js';
export type CheckStatus = 'up' | 'down' | 'unknown';
@@ -22,7 +24,7 @@ const HOST_REFRESH_MS = 10 * 60_000;
let store: StatusStore = { hosts: [], lastRefreshed: new Date().toISOString() };
let lastHostRefresh = 0;
-let targets: { name: string; url: string }[] = [];
+let rawHosts: RawNpmHost[] = [];
async function checkUrl(url: string): Promise<{ status: CheckStatus; code: number | null; latencyMs: number | null }> {
const controller = new AbortController();
@@ -39,22 +41,33 @@ async function checkUrl(url: string): Promise<{ status: CheckStatus; code: numbe
}
}
-async function refreshHosts(): Promise {
+// Refreshing the NPM host list hits their API and re-authenticates if
+// needed, so it stays on the original 10-minute cadence. Overrides and
+// manual targets are local SQLite reads — cheap enough to re-read on every
+// 60s check tick, so admin changes take effect within one cycle instead of
+// waiting on the NPM refresh.
+async function refreshNpmHosts(): Promise {
try {
- const hosts = await fetchProxyHosts();
- targets = hosts.map(h => ({
- name: h.domain_names[h.domain_names.length - 1],
- url: `https://${h.domain_names[h.domain_names.length - 1]}`,
- }));
+ const hosts = await fetchAllProxyHosts();
+ rawHosts = hosts.map(h => {
+ const domain = h.domain_names[h.domain_names.length - 1];
+ return { domain, matchesPattern: matchesIncludePatterns(domain) };
+ });
lastHostRefresh = Date.now();
- console.log(`[checker] loaded ${targets.length} targets from NPM`);
+ console.log(`[checker] loaded ${rawHosts.length} candidate hosts from NPM`);
} catch (e) {
console.error('[checker] failed to fetch hosts from NPM:', e);
}
}
+function currentTargets(): CheckTarget[] {
+ return computeTargets(rawHosts, getAllOverrides(), listManualTargets());
+}
+
async function runChecks(): Promise {
- if (Date.now() - lastHostRefresh > HOST_REFRESH_MS) await refreshHosts();
+ if (Date.now() - lastHostRefresh > HOST_REFRESH_MS) await refreshNpmHosts();
+
+ const targets = currentTargets();
if (targets.length === 0) return;
const results = await Promise.all(
@@ -70,7 +83,7 @@ async function runChecks(): Promise {
export function getStore(): StatusStore { return store; }
export async function startChecker(): Promise {
- await refreshHosts();
+ await refreshNpmHosts();
await runChecks();
setInterval(runChecks, CHECK_INTERVAL_MS);
}
diff --git a/src/config.ts b/src/config.ts
new file mode 100644
index 0000000..c8e7ea1
--- /dev/null
+++ b/src/config.ts
@@ -0,0 +1,8 @@
+import path from 'node:path';
+
+export const config = {
+ port: parseInt(process.env.PORT ?? '3035', 10),
+ dataDir: process.env.DATA_DIR ?? path.resolve('data'),
+ // Admin UI is disabled entirely if unset — no open-by-default gate.
+ adminPassword: process.env.ADMIN_PASSWORD || null,
+};
diff --git a/src/db.ts b/src/db.ts
new file mode 100644
index 0000000..91c1bde
--- /dev/null
+++ b/src/db.ts
@@ -0,0 +1,169 @@
+import Database from 'better-sqlite3';
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { config } from './config.js';
+
+// 'default' = follow NPM_INCLUDE_PATTERNS as before; 'hidden' / 'shown'
+// force the opposite of whatever the pattern would have decided.
+export type Visibility = 'default' | 'hidden' | 'shown';
+
+export interface HostOverride {
+ domain: string;
+ visibility: Visibility;
+ displayName: string | null;
+ checkPath: string | null;
+ sortOrder: number | null;
+}
+
+export interface ManualTarget {
+ id: string;
+ name: string;
+ url: string;
+ checkPath: string | null;
+ enabled: boolean;
+ sortOrder: number | null;
+ createdAt: number;
+}
+
+fs.mkdirSync(config.dataDir, { recursive: true });
+
+export const db = new Database(path.join(config.dataDir, 'statuspage.db'));
+db.pragma('journal_mode = WAL');
+
+db.exec(`
+ -- NPM stays the source of truth for which domains exist. This table is
+ -- pure enrichment: a row only ever overrides one field at a time in
+ -- practice, and every field falls back to the NPM-derived default when
+ -- null / 'default'.
+ CREATE TABLE IF NOT EXISTS host_overrides (
+ domain TEXT PRIMARY KEY,
+ visibility TEXT NOT NULL DEFAULT 'default', -- 'default' | 'hidden' | 'shown'
+ display_name TEXT,
+ check_path TEXT,
+ sort_order INTEGER
+ );
+
+ CREATE TABLE IF NOT EXISTS manual_targets (
+ id TEXT PRIMARY KEY,
+ name TEXT NOT NULL,
+ url TEXT NOT NULL,
+ check_path TEXT,
+ enabled INTEGER NOT NULL DEFAULT 1,
+ sort_order INTEGER,
+ created_at INTEGER NOT NULL
+ );
+`);
+
+function newId(): string {
+ return randomBytes(9).toString('base64url');
+}
+
+export function getAllOverrides(): Map {
+ const rows = db.prepare(`SELECT * FROM host_overrides`).all() as {
+ domain: string;
+ visibility: Visibility;
+ display_name: string | null;
+ check_path: string | null;
+ sort_order: number | null;
+ }[];
+ const map = new Map();
+ for (const r of rows) {
+ map.set(r.domain, {
+ domain: r.domain,
+ visibility: r.visibility,
+ displayName: r.display_name,
+ checkPath: r.check_path,
+ sortOrder: r.sort_order,
+ });
+ }
+ return map;
+}
+
+export function upsertOverride(
+ domain: string,
+ fields: { visibility?: Visibility; displayName?: string | null; checkPath?: string | null; sortOrder?: number | null },
+): void {
+ const existing = db.prepare(`SELECT * FROM host_overrides WHERE domain = ?`).get(domain) as
+ | { domain: string; visibility: Visibility; display_name: string | null; check_path: string | null; sort_order: number | null }
+ | undefined;
+
+ const next = {
+ visibility: fields.visibility ?? existing?.visibility ?? 'default',
+ display_name: fields.displayName !== undefined ? fields.displayName : (existing?.display_name ?? null),
+ check_path: fields.checkPath !== undefined ? fields.checkPath : (existing?.check_path ?? null),
+ sort_order: fields.sortOrder !== undefined ? fields.sortOrder : (existing?.sort_order ?? null),
+ };
+
+ db.prepare(
+ `INSERT INTO host_overrides (domain, visibility, display_name, check_path, sort_order)
+ VALUES (@domain, @visibility, @display_name, @check_path, @sort_order)
+ ON CONFLICT(domain) DO UPDATE SET
+ visibility = excluded.visibility,
+ display_name = excluded.display_name,
+ check_path = excluded.check_path,
+ sort_order = excluded.sort_order`,
+ ).run({ domain, ...next });
+}
+
+export function deleteOverride(domain: string): void {
+ db.prepare(`DELETE FROM host_overrides WHERE domain = ?`).run(domain);
+}
+
+export function listManualTargets(): ManualTarget[] {
+ const rows = db.prepare(`SELECT * FROM manual_targets ORDER BY created_at ASC`).all() as {
+ id: string;
+ name: string;
+ url: string;
+ check_path: string | null;
+ enabled: number;
+ sort_order: number | null;
+ created_at: number;
+ }[];
+ return rows.map(r => ({
+ id: r.id,
+ name: r.name,
+ url: r.url,
+ checkPath: r.check_path,
+ enabled: r.enabled === 1,
+ sortOrder: r.sort_order,
+ createdAt: r.created_at,
+ }));
+}
+
+export function createManualTarget(fields: { name: string; url: string; checkPath?: string | null; sortOrder?: number | null }): ManualTarget {
+ const id = newId();
+ const createdAt = Math.floor(Date.now() / 1000);
+ db.prepare(
+ `INSERT INTO manual_targets (id, name, url, check_path, enabled, sort_order, created_at)
+ VALUES (?, ?, ?, ?, 1, ?, ?)`,
+ ).run(id, fields.name, fields.url, fields.checkPath ?? null, fields.sortOrder ?? null, createdAt);
+ return { id, name: fields.name, url: fields.url, checkPath: fields.checkPath ?? null, enabled: true, sortOrder: fields.sortOrder ?? null, createdAt };
+}
+
+export function updateManualTarget(
+ id: string,
+ fields: { name?: string; url?: string; checkPath?: string | null; enabled?: boolean; sortOrder?: number | null },
+): boolean {
+ const existing = db.prepare(`SELECT * FROM manual_targets WHERE id = ?`).get(id) as
+ | { id: string; name: string; url: string; check_path: string | null; enabled: number; sort_order: number | null }
+ | undefined;
+ if (!existing) return false;
+
+ const next = {
+ name: fields.name ?? existing.name,
+ url: fields.url ?? existing.url,
+ check_path: fields.checkPath !== undefined ? fields.checkPath : existing.check_path,
+ enabled: fields.enabled !== undefined ? (fields.enabled ? 1 : 0) : existing.enabled,
+ sort_order: fields.sortOrder !== undefined ? fields.sortOrder : existing.sort_order,
+ };
+
+ db.prepare(
+ `UPDATE manual_targets SET name = @name, url = @url, check_path = @check_path, enabled = @enabled, sort_order = @sort_order WHERE id = @id`,
+ ).run({ id, ...next });
+ return true;
+}
+
+export function deleteManualTarget(id: string): void {
+ db.prepare(`DELETE FROM manual_targets WHERE id = ?`).run(id);
+}
diff --git a/src/index.ts b/src/index.ts
index b11a07b..dc0ef48 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,21 +1,34 @@
import express from 'express';
+import { config } from './config.js';
import { startChecker, getStore } from './checker.js';
import { renderPage } from './page.js';
+import { renderAdminPage } from './adminPage.js';
+import { router as adminRouter } from './admin.js';
-const PORT = parseInt(process.env.PORT ?? '3035', 10);
const app = express();
+app.use(express.json());
app.get('/api/status', (_req, res) => {
res.json(getStore());
});
+app.use('/api/admin', adminRouter);
+
+app.get('/admin', (_req, res) => {
+ res.setHeader('Content-Type', 'text/html; charset=utf-8');
+ res.send(renderAdminPage());
+});
+
app.get('/', (_req, res) => {
res.setHeader('Content-Type', 'text/html; charset=utf-8');
res.send(renderPage(getStore()));
});
-app.listen(PORT, () => {
- console.log(`[status] listening on :${PORT}`);
+app.listen(config.port, () => {
+ console.log(`[status] listening on :${config.port}`);
+ if (!config.adminPassword) {
+ console.log('[status] ADMIN_PASSWORD not set — /admin is disabled');
+ }
});
startChecker().catch(e => {
diff --git a/src/npm.ts b/src/npm.ts
index 582e29b..6e22bc1 100644
--- a/src/npm.ts
+++ b/src/npm.ts
@@ -11,7 +11,11 @@ const NPM_SECRET = process.env.NPM_SECRET ?? '';
const rawPatterns = (process.env.NPM_INCLUDE_PATTERNS ?? '\\.goonk\\.se$,\\.dev\\.xplwd\\.com$')
.split(',').map(p => new RegExp(p.trim()));
-const INCLUDE_PATTERNS = rawPatterns;
+export const INCLUDE_PATTERNS = rawPatterns;
+
+export function matchesIncludePatterns(domain: string): boolean {
+ return INCLUDE_PATTERNS.some(p => p.test(domain));
+}
let token: string | null = null;
let tokenExpiry = 0;
@@ -29,14 +33,14 @@ async function getToken(): Promise {
return token;
}
-export async function fetchProxyHosts(): Promise {
+// Every enabled proxy host, regardless of NPM_INCLUDE_PATTERNS — the admin
+// UI needs the full set to let you force-show something the pattern would
+// otherwise exclude. checker.ts applies the pattern (or an override) itself.
+export async function fetchAllProxyHosts(): Promise {
const tok = await getToken();
const res = await fetch(`${NPM_BASE}/api/nginx/proxy-hosts`, {
headers: { Authorization: `Bearer ${tok}` },
});
const all = await res.json() as ProxyHost[];
- return all.filter(h =>
- h.enabled &&
- h.domain_names.some(d => INCLUDE_PATTERNS.some(p => p.test(d)))
- );
+ return all.filter(h => h.enabled);
}
diff --git a/src/targets.ts b/src/targets.ts
new file mode 100644
index 0000000..25f9e1e
--- /dev/null
+++ b/src/targets.ts
@@ -0,0 +1,79 @@
+import type { HostOverride, ManualTarget } from './db.js';
+
+export interface CheckTarget {
+ key: string; // domain for NPM-derived, "manual:" for manual — used for override lookups and stable identity
+ name: string;
+ url: string;
+ source: 'npm' | 'manual';
+}
+
+export interface RawNpmHost {
+ domain: string;
+ matchesPattern: boolean;
+}
+
+/**
+ * Merges NPM-discovered hosts with local overrides and manual targets into
+ * the final check list. Pure function — no I/O — so it's cheap to unit test
+ * and cheap to re-run every check tick (every 60s) even though the NPM host
+ * list itself is only refreshed every 10 minutes.
+ *
+ * NPM is always the source of truth for *which domains exist*; overrides
+ * are strictly additive enrichment. A host with no override row behaves
+ * exactly as it did before this feature existed: included iff it matches
+ * NPM_INCLUDE_PATTERNS, named after its own domain.
+ */
+export function computeTargets(
+ rawHosts: RawNpmHost[],
+ overrides: Map,
+ manualTargets: ManualTarget[],
+): CheckTarget[] {
+ const npmTargets: (CheckTarget & { sortOrder: number | null })[] = [];
+
+ for (const host of rawHosts) {
+ const override = overrides.get(host.domain);
+ const visibility = override?.visibility ?? 'default';
+
+ const visible =
+ visibility === 'hidden' ? false :
+ visibility === 'shown' ? true :
+ host.matchesPattern;
+
+ if (!visible) continue;
+
+ const name = override?.displayName || host.domain;
+ const checkPath = override?.checkPath || '/';
+ npmTargets.push({
+ key: host.domain,
+ name,
+ url: `https://${host.domain}${checkPath}`,
+ source: 'npm',
+ sortOrder: override?.sortOrder ?? null,
+ });
+ }
+
+ const manualTargetsMapped: (CheckTarget & { sortOrder: number | null })[] = manualTargets
+ .filter(t => t.enabled)
+ .map(t => ({
+ key: `manual:${t.id}`,
+ name: t.name,
+ url: t.checkPath ? `${t.url.replace(/\/$/, '')}${t.checkPath}` : t.url,
+ source: 'manual',
+ sortOrder: t.sortOrder,
+ }));
+
+ // Stable sort: explicit sortOrder wins (ascending), unordered entries
+ // keep their relative discovery order and sink after any ordered ones.
+ const combined = [...npmTargets, ...manualTargetsMapped];
+ const withIndex = combined.map((t, i) => ({ t, i }));
+ withIndex.sort((a, b) => {
+ const aHas = a.t.sortOrder != null;
+ const bHas = b.t.sortOrder != null;
+ if (aHas && bHas) return (a.t.sortOrder as number) - (b.t.sortOrder as number);
+ if (aHas) return -1;
+ if (bHas) return 1;
+ return a.i - b.i;
+ });
+
+ return withIndex.map(({ t }) => ({ key: t.key, name: t.name, url: t.url, source: t.source }));
+}