Build Housecarl 0.1.0: the nftables firewall manager

Zones, address sets (IPv4 and IPv6 mixed, dynamic sets with timeouts) and
services, ordered rules in the early, input, forward and output chains,
port forwards with hairpin NAT and IPv6 pinholes, source NAT, redirects,
and switchable built-ins (loopback, conntrack, ICMPv6, antispoofing, MSS
clamping, DHCPv6 client, flowtable). Every change is validated, checked
with nft -c and applied in one transaction to Housecarl's own table,
inet housecarl; changes made over the network roll back unless
confirmed, and the confirmed ruleset is loaded at boot by
housecarl-ruleset.service. An empty configuration applies nothing.

Also: hit counters and the drop log (nflog), 'hc import' of an existing
nftables ruleset and 'hc takeover', the hc CLI, the REST API and the web
UI, users, scoped tokens (sets:write:NAME), the audit log, the web UI's
certificate through Jarl, Debian packages, docs, unit tests with real
nft 1.1.3, and an e2e test with real traffic (71 checks).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/web/static/assets/api.js

@@ -0,0 +1,88 @@
+// API client and shared application state.
+import { toast } from "./ui.js";
+
+export const state = {
+  me: null, // whoami response
+  csrf: "",
+  catalog: null,
+};
+
+export class APIError extends Error {
+  constructor(status, body) {
+    const e = (body && body.error) || {};
+    super(e.message || ("HTTP " + status));
+    this.status = status;
+    this.code = e.code || "";
+    this.details = e;
+  }
+}
+
+let onUnauthorized = () => {};
+export function setUnauthorizedHandler(fn) { onUnauthorized = fn; }
+
+// onChange is told about every applied change (the probation banner).
+let onChange = () => {};
+export function setChangeHandler(fn) { onChange = fn; }
+
+// api calls the REST API. opts: {body, query}.
+export async function api(method, path, opts = {}) {
+  const headers = { "Accept": "application/json" };
+  let body;
+  if (opts.body !== undefined) {
+    headers["Content-Type"] = "application/json";
+    body = JSON.stringify(opts.body);
+  }
+  if (method !== "GET" && state.csrf) headers["X-CSRF-Token"] = state.csrf;
+  let url = "/api/v1" + path;
+  if (opts.query) {
+    const q = new URLSearchParams();
+    for (const [k, v] of Object.entries(opts.query)) if (v !== undefined && v !== null && v !== "") q.set(k, v);
+    const s = q.toString();
+    if (s) url += (url.includes("?") ? "&" : "?") + s;
+  }
+  const resp = await fetch(url, { method, headers, body, credentials: "same-origin" });
+  if (resp.status === 204) return null;
+  const ct = resp.headers.get("Content-Type") || "";
+  const data = ct.includes("application/json") ? await resp.json() : await resp.text();
+  if (!resp.ok) {
+    if (resp.status === 401 && !path.startsWith("/auth/login")) onUnauthorized();
+    throw new APIError(resp.status, data);
+  }
+  return data;
+}
+
+export const get = (path, query) => api("GET", path, { query });
+
+// change sends a configuration change and reports it: a toast with the
+// history entry (to undo it from History) and one per new warning. It
+// returns the response.
+export async function change(method, path, body, opts = {}) {
+  const r = await api(method, path, { body, query: opts.query });
+  if (!opts.quiet) report(r);
+  return r;
+}
+
+export function report(r) {
+  if (!r) return;
+  if (r.dry_run) toast("Checked by Housecarl and nftables: nothing was changed");
+  else if (r.applied && r.confirm_by) toast("Applied on probation (history #" + r.history_id + "): confirm it in the banner", "warn", 6000);
+  else if (r.applied) toast("Applied and saved (history #" + r.history_id + ")");
+  else if (!(r.changes || []).length) toast("Nothing to change");
+  for (const w of r.warnings || []) toast(w.message + (w.object ? " (" + w.object + ")" : ""), "warn", 10000);
+  if (r.applied) onChange();
+}
+
+// can reports whether the user may read (or write) a resource.
+export function can(resource, write) {
+  const me = state.me;
+  if (!me) return false;
+  if (me.admin) return true;
+  const perms = me.permissions || [];
+  return perms.includes(resource + ":write") || (!write && perms.includes(resource + ":read"));
+}
+
+// catalog returns the option catalog (cached).
+export async function catalog() {
+  if (!state.catalog) state.catalog = await get("/catalog");
+  return state.catalog;
+}