import { csvCell } from './csv.js';
import {
  html, useState, useEffect, useCallback, useRef,
} from './vendor/htm-preact.js';
import { t } from './i18n.js';
import { ask } from './ask.js';
import * as platform from './platform.js';
import { Icon } from './icon.js';
import { HUB, session, hubFetch } from './hub-client.js';

// ── Node management (D5) ────────────────────────────────────────────────────
//
// Electron-only: talks to the local node daemon via its loopback HTTP API
// (platform.node.op), not over MNP/WebRTC. The MNP protocol types remain
// for potential future browser-side use.

// true / false from a node that has read its roster, null from one that has
// not yet (it publishes the roster only once it has signed in to the hub) --
// which is not the same as having no operator.
export function pairedFrom(result) {
  const v = result && result.operator_paired;
  return v === true || v === false ? v : null;
}

// Why this machine's node cannot serve the signed-in account, if it cannot:
// 'other_account' when it is set up for another account or hub, 'other_node'
// when the account is linked to another node's key. Signing in links this
// node (main.js ensureNode) but never over either, since that would cut off
// the user's other machine or someone else's node; both left a node reading
// "Running" that the hub refused in a loop, with nothing here saying why
// (found on a real install, 2026-10-10). Worked out from the node and the hub
// each time the page looks, not kept from sign-in: a link made or removed on
// the Profile page or on the other machine changes the answer.
export function nodeLinkProblem(info, linkedKey, username, hub) {
  if (!info || !username) return null;
  const sameHub = (a, b) => String(a || '').replace(/\/+$/, '') === String(b || '').replace(/\/+$/, '');
  if ((info.username && info.username !== username)
      || (info.hub_url && hub && !sameHub(info.hub_url, hub))) return 'other_account';
  if (linkedKey && info.pk_node_ed25519 && linkedKey !== info.pk_node_ed25519) return 'other_node';
  return null;
}

function NodeLinkBanner({ info, token, username, onLinked }) {
  const [linkedKey, setLinkedKey] = useState(null);
  const [busy, setBusy] = useState(false);
  const [err, setErr] = useState('');
  const nodeKey = info && info.pk_node_ed25519;

  useEffect(() => {
    if (!username || !token) return;
    let cancelled = false;
    hubFetch(`/v1/users/${encodeURIComponent(username)}/pubkeys`, { token })
      .then((k) => { if (!cancelled) setLinkedKey((k && k.pk_node_ed25519) || null); })
      .catch(() => {});
    return () => { cancelled = true; };
  }, [username, token, nodeKey]);

  const problem = nodeLinkProblem(info, linkedKey, username, HUB);
  if (!problem) return null;

  // Another node's key: this node's replaces it on the account, and a node
  // waiting for its account signs in on its next attempt. Not node:start,
  // which leaves a node that answers "running" alone, and one can (signed in
  // before the account was linked elsewhere). Another account: node:start
  // switches it, after asking, restarts it and links it.
  const takeOver = async () => {
    if (problem === 'other_node' && !await ask(t('node.link_here_confirm'))) return;
    setBusy(true);
    setErr('');
    try {
      if (problem === 'other_node') {
        await hubFetch('/v1/users/me/node_key', {
          method: 'PUT', token, body: { pk_node_ed25519: nodeKey },
        });
      } else {
        await platform.node.start({ hubUrl: HUB, username, token, takeOver: true });
      }
      setLinkedKey(nodeKey);
      if (onLinked) onLinked();
    } catch (e) {
      setErr(platform.bridgeMessage(e));
    } finally {
      setBusy(false);
    }
  };

  return html`
    <div class="node-pair-banner node-link-banner">
      <p>${problem === 'other_node'
        ? t('node.link_other_node')
        : t('node.link_other_account', { account: `${info.username} @ ${info.hub_url}` })}</p>
      <button class="btn btn-primary btn-small" disabled=${busy} onClick=${takeOver}>
        ${busy ? t('node.link_linking')
          : problem === 'other_node' ? t('node.link_here') : t('node.link_take_over')}</button>
      ${err && html`<p class="error-msg">${err}</p>`}
    </div>`;
}

function NodeServicePanel({ onChanged, token, username }) {
  const [info, setInfo] = useState(null);
  const [busy, setBusy] = useState('');
  // Two errors, not one: the status poll below cleared the message of an
  // action that had just been refused, within five seconds and often before
  // it was read (found switching startup mode on a real Store install).
  const [pollErr, setPollErr] = useState('');
  const [actErr, setActErr] = useState('');
  const err = actErr || pollErr;

  const refresh = useCallback(async () => {
    try {
      const r = await platform.node.service.status();
      setInfo(r);
      setPollErr('');
    } catch (e) {
      setPollErr(platform.bridgeMessage(e));
    }
  }, []);

  useEffect(() => {
    if (!platform.node.service.available) return;
    refresh();
    const timer = setInterval(refresh, 5000);
    return () => clearInterval(timer);
  }, [refresh]);

  const act = useCallback(async (name, fn) => {
    setBusy(name);
    setActErr('');
    try {
      await fn();
      await refresh();
      if (onChanged) onChanged();
    } catch (e) {
      setActErr(platform.bridgeMessage(e));
    } finally {
      setBusy('');
    }
  }, [refresh, onChanged]);

  // "off" / "signin" / "service" -- derived from the status payload, no new
  // backend field needed: mode/autostart already distinguish all three.
  const startupMode = (i) => {
    if (!i) return 'off';
    if (i.mode === 'service') return i.mode;
    return i.autostart ? 'signin' : 'off';
  };

  // Switching mode itself — the installer's own radio page only runs once,
  // at install time, so this is the only way back in if service mode was
  // declined there, or out if it is no longer wanted. One elevation, task +
  // firewall together, same script the installer runs.
  //
  // The two mechanisms are mutually exclusive by construction here: never
  // both installed at once, which would start the daemon twice (once at
  // boot via the Scheduled Task, again at sign-in via the Startup .vbs).
  // Always remove whichever one is currently active before installing the
  // target, so every transition -- not just the two that used to be
  // separate toggles -- keeps that invariant.
  const changeStartupMode = useCallback((target) => {
    const current = startupMode(info);
    if (target === current) return;
    act('startupMode', async () => {
      if (current === 'service') await platform.node.serviceMode.remove();
      else if (current === 'signin') await platform.node.autostart.remove();
      if (target === 'service') await platform.node.serviceMode.install();
      else if (target === 'signin') await platform.node.autostart.install();
    });
  }, [act, info]);

  // The Start button below passes {hubUrl, username, token} to node:start,
  // same as create-group-page.js's own startNode() -- node:start only links
  // an unlinked node key to the hub account when given credentials to link
  // it with (main.js's linkNodeKeyAndAwaitRunning). Without them, a node that
  // is not linked yet (a fresh install, or one whose hub-side link was lost)
  // just polls for up to 105s and fails with "could not link", pointing at a
  // "Link Node" control that lives on Settings, not here. Reproduced live
  // 2026-09-14: a fresh non-service install's own Start button hung and
  // failed this way, the exact same account and key that had just linked
  // fine through the Create Group wizard.
  if (!platform.node.service.available) return null;
  if (!info || info.supported === false) {
    return html`<div class="node-service">
      <span class="spinner"></span>${' '}${t('node.service_checking')}
    </div>`;
  }

  const KNOWN_STATES = ['active', 'inactive', 'failed', 'activating', 'deactivating'];
  const stateKey = KNOWN_STATES.includes(info.activeState) ? info.activeState : 'unknown';
  const running = info.activeState === 'active' || info.activeState === 'activating';
  // A node process that does not answer ('unknown': on its way up or down, or
  // stuck) is still one to stop -- only "nothing there" takes Stop away.
  const stoppable = info.activeState !== 'inactive';
  const dot = info.activeState === 'active' ? 'online'
    : info.activeState === 'failed' ? 'offline' : 'unknown';
  const label = info.installed ? t('node.service_state_' + stateKey)
                                : t('node.service_not_installed');

  // Own row, below the status/actions card rather than a further item
  // crammed into its flex-wrap line -- that (plus two independent toggles
  // for what is really one choice) is what made this a mess before.
  const showStartupRow = (platform.node.autostart.available
    || platform.node.serviceMode.available) && typeof info.mode === 'string';

  return html`
    <div>
      <div class="node-service">
        <div class="node-service-status">
          <span class="presence presence-${dot}" title="${label}" aria-label="${label}"></span>
          <span>${label}</span>
        </div>
        ${err && html`<div class="error-msg">${err}</div>`}
        <div class="node-service-actions">
          <button class="btn btn-small btn-secondary" disabled=${!!busy || running}
            onClick=${() => act('start', () => platform.node.start({ hubUrl: HUB, username, token }))}>
            ${busy === 'start' ? t('node.service_starting') : t('node.service_start')}</button>
          ${info.installed && html`
            <button class="btn btn-small btn-secondary" disabled=${!!busy || !stoppable}
              onClick=${() => act('stop', () => platform.node.service.stop())}>
              ${busy === 'stop' ? t('node.service_stopping') : t('node.service_stop')}</button>
            <button class="btn btn-small btn-secondary" disabled=${!!busy}
              onClick=${() => act('restart', () => platform.node.service.restart())}>
              ${busy === 'restart' ? t('node.service_restarting') : t('node.service_restart')}</button>
          `}
        </div>
        ${info.mode === 'service' && html`
          <p class="node-hint">${t('node.service_mode_hint')}</p>
        `}
      </div>
      ${showStartupRow && html`
        <div class="settings-row">
          <span class="settings-label">${t('node.startup_mode_label')}</span>
          <select class="settings-select" disabled=${!!busy}
            value=${startupMode(info)}
            onChange=${(e) => changeStartupMode(e.target.value)}>
            <option value="off">${t('node.startup_mode_off')}</option>
            <option value="signin">${t('node.startup_mode_signin')}</option>
            <option value="service" disabled=${!info.canElevate}>
              ${t('node.startup_mode_service')}</option>
          </select>
        </div>
        ${busy === 'startupMode' && html`
          <p class="settings-hint">${t('node.startup_mode_updating')}</p>`}
        ${!info.canElevate && html`
          <p class="settings-hint">${t(info.store
            ? 'node.startup_mode_service_store_hint'
            : 'node.startup_mode_service_unavailable_hint')}</p>`}
      `}
    </div>`;
}

async function nodeOp(name, args) {
  return platform.node.op(name, args);
}

// Hand a generated file to the user: native Save As on the desktop, a blob
// download link everywhere else. Small text only (CSV export) — not the
// large-file download path in file-utils.js.
async function saveCsv(filename, text) {
  const bytes = new TextEncoder().encode(text);
  try {
    const target = await platform.nativeSave(filename, { auto: false });
    if (target && target.writable) {
      if (target.open) await target.open();
      await target.writable.write(bytes);
      await target.writable.close();
      return;
    }
  } catch { /* fall through to the blob path */ }
  const url = URL.createObjectURL(new Blob([bytes], { type: 'text/csv' }));
  const a = document.createElement('a');
  a.href = url;
  a.download = filename;
  document.body.appendChild(a);
  a.click();
  document.body.removeChild(a);
  URL.revokeObjectURL(url);
}

export function NodePage({ groups, token, username }) {
  const [status, setStatus] = useState('idle');
  const [error, setError] = useState('');
  const [nodeGroups, setNodeGroups] = useState([]);
  const [busy, setBusy] = useState(false);
  const [actionMsg, setActionMsg] = useState('');
  const [roster, setRoster] = useState(null);
  const [rosterGroup, setRosterGroup] = useState('');
  const [denylist, setDenylist] = useState(null);
  const [showDenylist, setShowDenylist] = useState(false);
  const [nodeSettings, setNodeSettings] = useState(null);
  const [editSettings, setEditSettings] = useState(null);
  const [savingSettings, setSavingSettings] = useState(false);
  const [editStun, setEditStun] = useState(null);
  const [savingStun, setSavingStun] = useState(false);
  const [stunInput, setStunInput] = useState('');
  const [editIce, setEditIce] = useState(null);
  const [savingIce, setSavingIce] = useState(false);
  const [iceInput, setIceInput] = useState('');
  const [operatorPaired, setOperatorPaired] = useState(null);
  const [pairBusy, setPairBusy] = useState(false);
  const [pairStatus, setPairStatus] = useState('');
  const [nodeInfo, setNodeInfo] = useState(null);
  const [peers, setPeers] = useState(null);
  const [audit, setAudit] = useState(null);
  const [auditEvent, setAuditEvent] = useState('');
  const [auditPageSize, setAuditPageSize] = useState(100);
  const [auditPage, setAuditPage] = useState(0);
  const [auditHasMore, setAuditHasMore] = useState(false);
  const [auditExporting, setAuditExporting] = useState(false);
  const [cacheCount, setCacheCount] = useState(null);
  const [nodeRoster, setNodeRoster] = useState(null);
  const [unlinkBusy, setUnlinkBusy] = useState(false);
  const [tab, setTab] = useState('overview');
  const [keyCopied, setKeyCopied] = useState(false);

  const fetchStatus = useCallback(async () => {
    setStatus('connecting');
    setError('');
    try {
      const detection = await platform.node.detect();
      if (!detection.detected) {
        setError(t('node.offline'));
        setStatus('error');
        return;
      }
      const result = await nodeOp('groups');
      setNodeGroups(result.groups || []);
      setOperatorPaired(pairedFrom(result));
      setNodeSettings(result.settings || null);
      try { setNodeInfo(await nodeOp('status')); } catch {}
      setStatus('connected');
    } catch (err) {
      setError(platform.bridgeMessage(err));
      setStatus('error');
    }
  }, []);

  useEffect(() => { fetchStatus(); }, [fetchStatus]);

  useEffect(() => {
    if (nodeSettings && !editSettings) setEditSettings({ ...nodeSettings });
    if (nodeSettings && !editStun) setEditStun([...(nodeSettings.stun_servers || [])]);
    if (nodeSettings && !editIce) setEditIce([...(nodeSettings.ice_interfaces || [])]);
  }, [nodeSettings]);

  const refresh = useCallback(async () => {
    try {
      const result = await nodeOp('groups');
      setNodeGroups(result.groups || []);
      setOperatorPaired(pairedFrom(result));
      setNodeSettings(result.settings || null);
      try { setNodeInfo(await nodeOp('status')); } catch {}
    } catch {}
  }, []);

  const copyNodeKey = useCallback(async () => {
    const pk = nodeInfo && nodeInfo.pk_node_ed25519;
    if (!pk) return;
    try {
      await navigator.clipboard.writeText(pk);
      setKeyCopied(true);
      setTimeout(() => setKeyCopied(false), 2000);
    } catch { /* clipboard blocked -- the key is on screen to copy by hand */ }
  }, [nodeInfo]);

  const addRoot = useCallback(async (groupId) => {
    const chosen = await platform.rootPicker.choose();
    if (!chosen) return;
    setBusy(true);
    setActionMsg('');
    try {
      await nodeOp('addRoot', { groupId, path: chosen.path });
      await nodeOp('reload');
      await refresh();
      setActionMsg(t('node.root_added'));
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, [refresh]);

  const removeRoot = useCallback(async (groupId, rootName) => {
    if (!await ask(t('node.root_remove_confirm', { name: rootName }))) return;
    setBusy(true);
    setActionMsg('');
    try {
      await nodeOp('removeRoot', { groupId, rootName });
      await nodeOp('reload');
      await refresh();
      setActionMsg(t('node.root_removed'));
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, [refresh]);

  const loadRoster = useCallback(async (groupId) => {
    setBusy(true);
    try {
      const result = await nodeOp('roster', { groupId });
      setRoster(result);
      setRosterGroup(groupId);
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, []);

  const unpinMember = useCallback(async (userId) => {
    if (!await ask(t('node.unpin_confirm', { name: userId }))) return;
    setBusy(true);
    setActionMsg('');
    try {
      await nodeOp('unpinMember', { userId });
      setActionMsg(t('node.unpin_done'));
      if (rosterGroup) await loadRoster(rosterGroup);
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, [rosterGroup, loadRoster]);

  const rotateGek = useCallback(async (groupId) => {
    setBusy(true);
    setActionMsg('');
    try {
      await nodeOp('initGek', { groupId, rotate: true });
      setActionMsg(t('node.gek_rotated'));
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, []);

  const loadDenylist = useCallback(async () => {
    setBusy(true);
    try {
      const result = await nodeOp('denylist');
      setDenylist(result);
      setShowDenylist(true);
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, []);

  const clearDenylist = useCallback(async (subject) => {
    // Asked natively by the app (node:op): it re-admits whoever it kept out.
    setBusy(true);
    setActionMsg('');
    try {
      await nodeOp('clearDenylist', { subject });
      setActionMsg(t('node.denylist_cleared'));
      await loadDenylist();
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, [loadDenylist]);

  const detachGroup = useCallback(async (name) => {
    if (!await ask(t('node.detach_confirm', { name }))) return;
    setBusy(true);
    setActionMsg('');
    try {
      await nodeOp('detachGroup', { name });
      await nodeOp('reload');
      setActionMsg(t('node.detached'));
      await refresh();
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, [refresh]);

  const reloadConfig = useCallback(async () => {
    setBusy(true);
    setActionMsg('');
    try {
      await nodeOp('reload');
      setActionMsg(t('node.reloaded'));
      await refresh();
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, [refresh]);

  const saveSettings = useCallback(async () => {
    if (!editSettings) return;
    setSavingSettings(true);
    setActionMsg('');
    try {
      await nodeOp('setNodeSettings', { settings: editSettings });
      setNodeSettings({ ...editSettings });
      setActionMsg(t('node.settings_saved'));
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setSavingSettings(false);
    }
  }, [editSettings]);

  const saveStun = useCallback(async () => {
    if (!editStun) return;
    setSavingStun(true);
    setActionMsg('');
    try {
      await nodeOp('setNodeSettings', { settings: { stun_servers: editStun } });
      setNodeSettings(s => s ? { ...s, stun_servers: [...editStun] } : s);
      setActionMsg(t('node.stun_saved'));
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setSavingStun(false);
    }
  }, [editStun]);

  const addStunServer = useCallback(() => {
    const url = stunInput.trim();
    if (!url) return;
    if (!url.startsWith('stun:')) {
      setActionMsg(t('node.stun_invalid'));
      return;
    }
    if (editStun && editStun.includes(url)) {
      setActionMsg(t('node.stun_duplicate'));
      return;
    }
    setEditStun(s => [...(s || []), url]);
    setStunInput('');
    setActionMsg('');
  }, [stunInput, editStun]);

  const removeStunServer = useCallback((idx) => {
    setEditStun(s => s.filter((_, i) => i !== idx));
  }, []);

  const moveStunServer = useCallback((idx, dir) => {
    setEditStun(s => {
      const a = [...s];
      const target = idx + dir;
      if (target < 0 || target >= a.length) return a;
      [a[idx], a[target]] = [a[target], a[idx]];
      return a;
    });
  }, []);

  const resetStunDefaults = useCallback(() => {
    // Keep in step with meshbay_node.config.DEFAULT_STUN_SERVERS.
    setEditStun([
      'stun:stun.l.google.com:19302',
      'stun:stun1.l.google.com:19302',
      'stun:stun.cloudflare.com:3478',
    ]);
    setActionMsg('');
  }, []);

  const saveIce = useCallback(async () => {
    if (!editIce) return;
    setSavingIce(true);
    setActionMsg('');
    try {
      await nodeOp('setNodeSettings', { settings: { ice_interfaces: editIce } });
      setNodeSettings(s => s ? { ...s, ice_interfaces: [...editIce] } : s);
      setActionMsg(t('node.ice_saved'));
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setSavingIce(false);
    }
  }, [editIce]);

  const addIceInterface = useCallback(() => {
    const name = iceInput.trim();
    if (!name) return;
    if (editIce && editIce.includes(name)) {
      setActionMsg(t('node.ice_duplicate'));
      return;
    }
    setEditIce(s => [...(s || []), name]);
    setIceInput('');
    setActionMsg('');
  }, [iceInput, editIce]);

  const removeIceInterface = useCallback((idx) => {
    setEditIce(s => s.filter((_, i) => i !== idx));
  }, []);

  const resetIceAuto = useCallback(() => {
    setEditIce([]);
    setActionMsg('');
  }, []);

  const doPairOperator = useCallback(async () => {
    setPairBusy(true);
    setPairStatus('');
    try {
      // An operator code is redeemed over MNP, with the account's identity in
      // a group -- this page has no transport. It used to store the code where
      // nothing read it and say "Paired successfully", and the banner came back
      // on the next refresh. Queued the way the Create Group wizard queues it:
      // the next group of this node to open redeems it.
      const result = await nodeOp('pairOperator');
      if (result && result.code) {
        await platform.node.setPairingCode(result.code);
        session.pendingJoinCode = result.code;
      }
      setPairStatus('pending');
    } catch (err) {
      setPairStatus(platform.bridgeMessage(err));
    } finally {
      setPairBusy(false);
    }
  }, [refresh]);

  const loadPeers = useCallback(async () => {
    setBusy(true);
    try {
      const r = await nodeOp('peers');
      setPeers(r.peers || []);
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, []);

  const loadAudit = useCallback(async () => {
    setBusy(true);
    try {
      const offset = auditPage * auditPageSize;
      const r = await nodeOp('audit', { limit: auditPageSize, offset,
                                        event: auditEvent || undefined });
      setAudit(r.entries || []);
      setAuditHasMore(!!r.has_more);
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, [auditEvent, auditPage, auditPageSize]);

  const exportAuditCsv = useCallback(async () => {
    setAuditExporting(true);
    setActionMsg('');
    try {
      // Every entry that matches the current event filter, not just one page.
      // Walk the log newest-first in blocks; de-dupe by id so an event written
      // mid-export (which shifts rows to a higher offset) cannot duplicate one.
      const PAGE = 1000;
      const MAX_PAGES = 1000;          // 1M-row stop, so a bug cannot spin forever
      const seen = new Set();
      const rows = [];
      for (let page = 0; page < MAX_PAGES; page++) {
        const r = await nodeOp('audit', { limit: PAGE, offset: page * PAGE,
                                          event: auditEvent || undefined });
        const batch = r.entries || [];
        for (const e of batch) {
          if (!seen.has(e.id)) { seen.add(e.id); rows.push(e); }
        }
        if (!r.has_more || batch.length === 0) break;
      }

      const cols = ['timestamp', 'event', 'user', 'user_id', 'ip',
        'group', 'group_id', 'detail'];
      const lines = [cols.join(',')];
      for (const e of rows) {
        lines.push([
          new Date(e.timestamp * 1000).toISOString(),
          e.event, e.username || '', e.user_id || '', e.ip || '',
          e.group_name || '', e.group_id || '', e.detail || '',
        ].map(csvCell).join(','));
      }
      const csv = lines.join('\r\n') + '\r\n';
      const stamp = new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-');
      await saveCsv(`node-audit-${stamp}.csv`, csv);
      setActionMsg(t('node.audit_exported', { n: rows.length }));
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setAuditExporting(false);
    }
  }, [auditEvent]);

  const loadCache = useCallback(async () => {
    setBusy(true);
    try {
      const r = await nodeOp('indexCache');
      setCacheCount(r.count ?? 0);
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, []);

  const pruneCache = useCallback(async () => {
    setBusy(true);
    setActionMsg('');
    try {
      const r = await nodeOp('pruneIndexCache');
      setCacheCount(r.kept ?? null);
      setActionMsg(t('node.maintenance_pruned', { n: r.removed ?? 0 }));
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, []);

  const loadNodeRoster = useCallback(async () => {
    setBusy(true);
    try {
      const r = await nodeOp('roster');
      setNodeRoster(r);
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, []);

  const unpinNodeMember = useCallback(async (userId) => {
    if (!await ask(t('node.unpin_confirm', { name: userId }))) return;
    setBusy(true);
    setActionMsg('');
    try {
      await nodeOp('unpinMember', { userId });
      setActionMsg(t('node.unpin_done'));
      await loadNodeRoster();
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setBusy(false);
    }
  }, [loadNodeRoster]);

  const unlinkNode = useCallback(async () => {
    if (!await ask(t('node.unlink_confirm'))) return;
    setUnlinkBusy(true);
    setActionMsg('');
    try {
      await nodeOp('unlink');
      setActionMsg(t('node.unlink_done'));
      await refresh();
    } catch (err) {
      setActionMsg(platform.bridgeMessage(err));
    } finally {
      setUnlinkBusy(false);
    }
  }, [refresh]);

  // Each read-only tab loads itself on open — no Load button.
  useEffect(() => {
    if (status !== 'connected') return;
    if (tab === 'overview') loadCache();
    else if (tab === 'roster') loadNodeRoster();
    else if (tab === 'peers') loadPeers();
  }, [tab, status, loadCache, loadNodeRoster, loadPeers]);

  // Audit reloads on tab open and whenever the filter or page changes
  // (loadAudit's identity tracks auditEvent / auditPage / auditPageSize).
  useEffect(() => {
    if (status === 'connected' && tab === 'audit') loadAudit();
  }, [tab, status, loadAudit]);

  if (status === 'idle' || status === 'connecting') {
    return html`<div class="page-content">
      <h2>${t('node.title')}</h2>
      <${NodeServicePanel} onChanged=${fetchStatus} token=${token} username=${username} />
      <p class="page-message"><span class="spinner"></span>${' '}${t('status.connecting')}</p>
    </div>`;
  }
  if (status === 'error') {
    return html`<div class="page-content">
      <h2>${t('node.title')}</h2>
      <${NodeServicePanel} onChanged=${fetchStatus} token=${token} username=${username} />
      <p class="error-msg">${error}</p>
      <button class="btn btn-primary" onClick=${fetchStatus}>
        ${t('node.retry')}</button>
    </div>`;
  }

  return html`
    <div class="page-content node-page">
      <div class="node-header">
        <h2>${t('node.title')}</h2>
        <button class="btn btn-small btn-secondary" disabled=${busy}
          onClick=${reloadConfig}>
          ${t('node.reload')}</button>
      </div>
      <${NodeServicePanel} onChanged=${fetchStatus} token=${token} username=${username} />
      <${NodeLinkBanner} info=${nodeInfo} token=${token} username=${username}
        onLinked=${fetchStatus} />
      ${actionMsg && html`<div class="node-message">${actionMsg}</div>`}
      ${operatorPaired === false && nodeGroups.length > 0 && html`
        <div class="node-pair-banner">
          <p>${t('node.pair_needed')}</p>
          <button class="btn btn-primary btn-small"
            disabled=${pairBusy}
            onClick=${doPairOperator}>
            ${pairBusy ? t('node.settings_saving') : t('node.pair_button')}</button>
          ${pairStatus === 'pending'
            ? html`<p class="success-msg">${t('node.pair_pending')}</p>`
            : pairStatus ? html`<p class="error-msg">${pairStatus}</p>` : null}
        </div>
      `}
      <div class="admin-tabs">
        ${['overview', 'groups', 'roster', 'peers', 'audit', 'settings'].map(k => html`
          <button key=${k} class="admin-tab ${tab === k ? 'active' : ''}"
            onClick=${() => setTab(k)}>${t('node.tab_' + k)}</button>
        `)}
      </div>

      ${tab === 'overview' && nodeInfo && html`
        <div class="node-group">
          <span class="settings-heading">${t('node.overview')}</span>
          <table class="node-table">
            <tbody>
              <tr><td>${t('node.overview_version')}</td><td>${nodeInfo.version || '—'}</td></tr>
              <tr><td>${t('node.overview_node_id')}</td>
                  <td><code>${nodeInfo.endpoint_hint || '—'}</code></td></tr>
              <tr><td>${t('node.overview_node_key')}</td>
                  <td>
                    <code class="node-key">${nodeInfo.pk_node_ed25519 || '—'}</code>
                    ${nodeInfo.pk_node_ed25519 && html`
                      <button class="btn btn-small btn-secondary" onClick=${copyNodeKey}>
                        ${keyCopied ? t('node.overview_node_key_copied')
                                    : t('node.overview_node_key_copy')}
                      </button>`}
                  </td></tr>
              <tr><td>${t('node.overview_quic_port')}</td><td>${nodeInfo.quic_port || '—'}</td></tr>
              <tr><td>${t('node.overview_hub')}</td><td>${nodeInfo.hub_url || '—'}</td></tr>
            </tbody>
          </table>
        </div>
      `}

      ${tab === 'groups' && (() => {
        const hubIds = new Set((groups || []).map(g => g.id));
        return nodeGroups.map(g => {
          const stale = !hubIds.has(g.id);
          return html`
        <div class="node-group ${stale ? 'node-group-stale' : ''}" key=${g.id}>
          <div class="node-group-header">
            <h3>${g.name}${stale ? html` <span class="node-warn">${t('node.stale')}</span>` : ''}</h3>
            <div class="node-group-stats">
              <span>${t('node.files', { n: g.file_count })}</span>
              <span>${t('node.peers', { n: g.peers })}</span>
              ${!g.has_gek && html`
                <span class="node-warn">${t('node.no_gek')}</span>`}
            </div>
          </div>
          <div class="node-roots">
            <div class="node-roots-header">
              <span class="settings-heading">${t('node.roots')}</span>
            </div>
            ${(g.roots || []).map(r => html`
              <div class="node-root ${!r.available ? 'node-root-unavailable' : ''}"
                   key=${r.name}>
                <div class="node-root-info">
                  <span class="node-root-name">
                    <${Icon} name="folder" />
                    ${r.name}
                  </span>
                  ${r.writable && html`
                    <span class="node-root-badge">${t('node.root_rw')}</span>`}
                  ${r.removable && html`
                    <span class="node-root-badge">${t('node.removable')}</span>`}
                  ${r.ejected ? html`
                    <span class="node-root-badge node-root-badge-warn">
                      ${t('group.root_ejected')}</span>`
                  : !r.available && html`
                    <span class="node-root-badge node-root-badge-warn">
                      ${t('node.unavailable')}</span>`}
                </div>
                ${/* Removing a writable root is allowed now — several can be
                      writable, and a group with none is a valid read-only
                      group. The last root is still the one that cannot go. */''}
                ${(g.roots || []).length > 1 && html`
                  <button class="btn btn-small btn-danger"
                    disabled=${busy} onClick=${() => removeRoot(g.id, r.name)}>
                    ${t('node.remove_root')}</button>`}
              </div>
            `)}
            <button class="btn btn-small btn-secondary"
              disabled=${busy} onClick=${() => addRoot(g.id)}>
              <${Icon} name="folder-plus" /> ${t('node.add_root')}
            </button>
          </div>

          <div class="node-section">
            <span class="settings-heading">${t('node.gek')}</span>
            ${g.has_gek ? (g.visibility !== 'public' ? html`
              <button class="btn btn-small btn-secondary" disabled=${busy}
                onClick=${() => rotateGek(g.id)}>
                ${t('node.gek_rotate')}</button>
            ` : html`<p class="node-hint">${t('node.gek_public_hint')}</p>`) : html`
              <p class="node-hint">${t('node.gek_init_hint')}</p>
            `}
          </div>

          <div class="node-section">
            <div class="node-section-header">
              <span class="settings-heading">${t('node.roster')}</span>
              <button class="btn btn-small btn-secondary" disabled=${busy}
                onClick=${() => loadRoster(g.id)}>
                ${t('node.roster_load')}</button>
            </div>
            ${roster && rosterGroup === g.id && html`
              <div class="node-roster">
                ${(roster.members || []).length === 0 ? html`
                  <p class="node-hint">${t('node.roster_empty')}</p>
                ` : html`
                  <table class="node-table">
                    <thead><tr>
                      <th>${t('node.roster_user')}</th>
                      <th>${t('node.roster_role')}</th>
                      <th>${t('node.roster_status')}</th>
                      <th>${t('node.roster_via')}</th>
                      <th></th>
                    </tr></thead>
                    <tbody>
                      ${(roster.members || []).map(m => html`
                        <tr key=${m.user_id}>
                          <td>${m.username || m.user_id.slice(0, 12)}</td>
                          <td>${m.role}</td>
                          <td>${m.status}</td>
                          <td>${m.pinned_via || ''}</td>
                          <td>${m.pk_ed25519 && html`
                            <button class="btn btn-small btn-danger"
                              disabled=${busy}
                              onClick=${() => unpinMember(m.user_id)}>
                              ${t('node.unpin')}</button>
                          `}</td>
                        </tr>
                      `)}
                    </tbody>
                  </table>
                `}
                ${(roster.invites || []).length > 0 && html`
                  <p class="node-hint">${t('node.roster_invites',
                    { n: roster.invites.length })}</p>
                `}
              </div>
            `}
          </div>

          ${stale && html`
            <div class="node-section">
              <button class="btn btn-small btn-danger" disabled=${busy}
                onClick=${() => detachGroup(g.name)}>
                ${t('node.detach_group')}</button>
            </div>
          `}
        </div>
      `;
        });
      })()}

      ${tab === 'roster' && html`
      <div class="node-group">
        <span class="settings-heading">${t('node.node_roster')}</span>
        <p class="node-hint">${t('node.node_roster_hint')}</p>
        ${!nodeRoster ? html`
          <p class="node-hint">${t('node.loading')}</p>
        ` : (nodeRoster.members || []).length === 0 ? html`
          <p class="node-hint">${t('node.roster_empty')}</p>
        ` : html`
          <div class="node-table-scroll">
            <table class="node-table">
              <thead><tr>
                <th>${t('node.roster_user')}</th>
                <th>${t('node.roster_role')}</th>
                <th>${t('node.roster_status')}</th>
                <th>${t('node.roster_scope')}</th>
                <th>${t('node.roster_via')}</th>
                <th></th>
              </tr></thead>
              <tbody>
                ${(nodeRoster.members || []).map(m => html`
                  <tr key=${m.user_id + ':' + (m.group_id || '')}>
                    <td>${m.username || m.user_id.slice(0, 12)}</td>
                    <td>${m.role}</td>
                    <td>${m.status}</td>
                    <td>${m.group_id ? m.group_id.slice(0, 8) : t('node.roster_scope_node')}</td>
                    <td>${m.pinned_via || ''}</td>
                    <td>${m.pk_ed25519 && html`
                      <button class="btn btn-small btn-danger" disabled=${busy}
                        onClick=${() => unpinNodeMember(m.user_id)}>
                        ${t('node.unpin')}</button>
                    `}</td>
                  </tr>
                `)}
              </tbody>
            </table>
          </div>
        `}
      </div>
      `}

      ${tab === 'peers' && html`
      <div class="node-group">
        <span class="settings-heading">${t('node.peers_title')}</span>
        ${!peers ? html`
          <p class="node-hint">${t('node.loading')}</p>
        ` : peers.length === 0 ? html`
          <p class="node-hint">${t('node.peers_empty')}</p>
        ` : html`
          <div class="node-table-scroll">
            <table class="node-table">
              <thead><tr>
                <th>${t('node.peers_user')}</th>
                <th>${t('node.peers_ip')}</th>
                <th>${t('node.peers_group')}</th>
                <th>${t('node.peers_state')}</th>
              </tr></thead>
              <tbody>
                ${peers.map(p => html`
                  <tr key=${p.peer_id}>
                    <td>${p.username || (p.user_id || '').slice(0, 12) || '—'}</td>
                    <td>${p.remote_ip || '—'}</td>
                    <td>${p.group_name || (p.group_id ? p.group_id.slice(0, 8) : '—')}</td>
                    <td>${p.state || '—'}</td>
                  </tr>
                `)}
              </tbody>
            </table>
          </div>
        `}
      </div>
      `}

      ${tab === 'audit' && html`
      <div class="node-group">
        <div class="node-section-header">
          <span class="settings-heading">${t('node.audit_title')}</span>
          <button class="btn btn-small btn-secondary"
            disabled=${auditExporting || busy}
            onClick=${exportAuditCsv}>
            ${auditExporting ? t('node.audit_exporting') : t('node.audit_export')}</button>
        </div>
        <div class="stun-add-row">
          <select value=${auditEvent}
            onChange=${e => { setAuditEvent(e.target.value); setAuditPage(0); }}>
            <option value="">${t('node.audit_all_events')}</option>
            <option value="handshake">handshake</option>
            <option value="file_download">file_download</option>
            <option value="file_upload">file_upload</option>
            <option value="file_delete">file_delete</option>
            <option value="stream_video">stream_video</option>
            <option value="chat_message">chat_message</option>
            <option value="disconnect">disconnect</option>
            <option value="auth_failed">auth_failed</option>
          </select>
          <select value=${String(auditPageSize)}
            onChange=${e => { setAuditPageSize(parseInt(e.target.value) || 100); setAuditPage(0); }}>
            <option value="50">50</option>
            <option value="100">100</option>
            <option value="200">200</option>
            <option value="500">500</option>
          </select>
        </div>
        ${!audit ? html`
          <p class="node-hint">${t('node.loading')}</p>
        ` : audit.length === 0 ? html`
          <p class="node-hint">${t('node.audit_empty')}</p>
        ` : html`
          <div class="node-table-scroll">
            <table class="node-table node-table-audit">
              <thead><tr>
                <th>${t('node.audit_time')}</th>
                <th>${t('node.audit_event')}</th>
                <th>${t('node.audit_user')}</th>
                <th>${t('node.audit_ip')}</th>
                <th>${t('node.audit_group')}</th>
                <th>${t('node.audit_detail')}</th>
              </tr></thead>
              <tbody>
                ${audit.map(e => html`
                  <tr key=${e.id}>
                    <td>${new Date(e.timestamp * 1000).toLocaleString()}</td>
                    <td>${e.event}</td>
                    <td>${e.username || (e.user_id || '').slice(0, 8)}</td>
                    <td>${e.ip || '—'}</td>
                    <td>${e.group_name || (e.group_id ? e.group_id.slice(0, 8) : '—')}</td>
                    <td>${e.detail || ''}</td>
                  </tr>
                `)}
              </tbody>
            </table>
          </div>
        `}
        ${audit && html`
          <div class="node-audit-pager">
            <button class="btn btn-small btn-secondary"
              disabled=${busy || auditPage === 0}
              onClick=${() => setAuditPage(p => Math.max(0, p - 1))}>
              ${t('node.audit_prev')}</button>
            <span class="node-hint">${t('node.audit_page', { n: auditPage + 1 })}</span>
            <button class="btn btn-small btn-secondary"
              disabled=${busy || !auditHasMore}
              onClick=${() => setAuditPage(p => p + 1)}>
              ${t('node.audit_next')}</button>
          </div>
        `}
      </div>
      `}

      ${tab === 'overview' && html`
      <div class="node-group">
        <span class="settings-heading">${t('node.maintenance')}</span>
        ${cacheCount === null ? html`
          <p class="node-hint">${t('node.loading')}</p>
        ` : html`
          <p class="node-hint">${t('node.maintenance_cache', { n: cacheCount })}</p>
          <button class="btn btn-small btn-secondary" disabled=${busy}
            onClick=${pruneCache}>${t('node.maintenance_prune')}</button>
        `}
      </div>
      `}

      ${tab === 'settings' && editSettings && html`
        <div class="node-group">
          <span class="settings-heading">${t('node.settings')}</span>
          <p class="node-hint">${t('node.settings_edit_hint')}</p>
          <div class="node-settings-grid">
            <label class="node-setting">
              <span class="node-setting-label">${t('node.setting_invite_ttl')}</span>
              <div class="node-setting-input">
                <input type="number" min="1" value=${editSettings.invite_ttl_hours}
                  onInput=${e => setEditSettings(s => ({...s, invite_ttl_hours: parseInt(e.target.value) || 1}))} />
                <span class="node-setting-unit">${t('node.setting_unit_hours')}</span>
              </div>
            </label>
            <label class="node-setting">
              <span class="node-setting-label">${t('node.setting_pair_ttl')}</span>
              <div class="node-setting-input">
                <input type="number" min="1" value=${editSettings.pair_ttl_hours}
                  onInput=${e => setEditSettings(s => ({...s, pair_ttl_hours: parseInt(e.target.value) || 1}))} />
                <span class="node-setting-unit">${t('node.setting_unit_hours')}</span>
              </div>
            </label>
            <label class="node-setting">
              <span class="node-setting-label">${t('node.setting_device_ttl')}</span>
              <div class="node-setting-input">
                <input type="number" min="1" value=${editSettings.device_request_ttl_minutes}
                  onInput=${e => setEditSettings(s => ({...s, device_request_ttl_minutes: parseInt(e.target.value) || 1}))} />
                <span class="node-setting-unit">${t('node.setting_unit_minutes')}</span>
              </div>
            </label>
            <label class="node-setting">
              <span class="node-setting-label">${t('node.setting_max_streams')}</span>
              <div class="node-setting-input">
                <input type="number" min="1" value=${editSettings.max_concurrent_streams}
                  onInput=${e => setEditSettings(s => ({...s, max_concurrent_streams: parseInt(e.target.value) || 1}))} />
              </div>
            </label>
            <label class="node-setting">
              <span class="node-setting-label">${t('node.setting_max_downloads')}</span>
              <div class="node-setting-input">
                <input type="number" min="1" value=${editSettings.max_concurrent_downloads}
                  onInput=${e => setEditSettings(s => ({...s, max_concurrent_downloads: parseInt(e.target.value) || 1}))} />
              </div>
            </label>
            <label class="node-setting">
              <span class="node-setting-label">${t('node.setting_max_uploads')}</span>
              <div class="node-setting-input">
                <input type="number" min="1" value=${editSettings.max_concurrent_uploads}
                  onInput=${e => setEditSettings(s => ({...s, max_concurrent_uploads: parseInt(e.target.value) || 1}))} />
              </div>
            </label>
            <label class="node-setting">
              <span class="node-setting-label">${t('node.setting_max_upload')}</span>
              <div class="node-setting-input">
                <input type="number" min="0.1" step="0.5" value=${editSettings.max_upload_gb}
                  onInput=${e => setEditSettings(s => ({...s, max_upload_gb: parseFloat(e.target.value) || 0.1}))} />
                <span class="node-setting-unit">${t('node.setting_unit_gb')}</span>
              </div>
            </label>
            <label class="node-setting">
              <span class="node-setting-label">${t('node.setting_transcode')}</span>
              <div class="node-setting-input">
                <input type="checkbox" checked=${editSettings.transcode_incompatible_video}
                  onChange=${e => setEditSettings(s => ({...s, transcode_incompatible_video: e.target.checked}))} />
              </div>
            </label>
          </div>
          <div class="node-settings-actions">
            <button class="btn btn-primary btn-small" disabled=${savingSettings || busy}
              onClick=${saveSettings}>
              ${savingSettings ? t('node.settings_saving') : t('node.settings_save')}</button>
          </div>
        </div>
      `}

      ${tab === 'settings' && editStun && html`
        <div class="node-group">
          <span class="settings-heading">${t('node.stun_servers')}</span>
          <p class="node-hint">${t('node.stun_hint')}</p>
          ${editStun.length === 0 ? html`
            <p class="node-hint">${t('node.stun_empty')}</p>
          ` : html`
            <div class="stun-server-list">
              ${editStun.map((url, idx) => html`
                <div class="stun-server-entry" key=${url + idx}>
                  <span class="stun-server-url">${url}</span>
                  <div class="stun-server-actions">
                    <button class="btn btn-small btn-icon" disabled=${idx === 0}
                      onClick=${() => moveStunServer(idx, -1)}
                      title=${t('node.stun_move_up')}>▲</button>
                    <button class="btn btn-small btn-icon" disabled=${idx === editStun.length - 1}
                      onClick=${() => moveStunServer(idx, 1)}
                      title=${t('node.stun_move_down')}>▼</button>
                    <button class="btn btn-small btn-danger btn-icon"
                      onClick=${() => removeStunServer(idx)}
                      title=${t('node.stun_remove')}>✕</button>
                  </div>
                </div>
              `)}
            </div>
          `}
          <div class="stun-add-row">
            <input type="text" placeholder=${t('node.stun_add_placeholder')}
              value=${stunInput}
              onInput=${e => setStunInput(e.target.value)}
              onKeyDown=${e => { if (e.key === 'Enter') addStunServer(); }} />
            <button class="btn btn-small btn-secondary" onClick=${addStunServer}>
              ${t('node.stun_add')}</button>
          </div>
          <div class="node-settings-actions">
            <button class="btn btn-primary btn-small" disabled=${savingStun || busy}
              onClick=${saveStun}>
              ${savingStun ? t('node.stun_saving') : t('node.stun_save')}</button>
            <button class="btn btn-small btn-secondary" disabled=${savingStun || busy}
              onClick=${resetStunDefaults}>
              ${t('node.stun_reset')}</button>
          </div>
        </div>
      `}

      ${tab === 'settings' && editIce && html`
        <div class="node-group">
          <span class="settings-heading">${t('node.ice_interfaces')}</span>
          <p class="node-hint">${editIce.length === 0
            ? t('node.ice_auto_hint')
            : t('node.ice_manual_hint')}</p>
          ${editIce.length > 0 && html`
            <div class="stun-server-list">
              ${editIce.map((name, idx) => html`
                <div class="stun-server-entry" key=${name + idx}>
                  <span class="stun-server-url">${name}</span>
                  <div class="stun-server-actions">
                    <button class="btn btn-small btn-danger btn-icon"
                      onClick=${() => removeIceInterface(idx)}
                      title=${t('node.ice_remove')}>✕</button>
                  </div>
                </div>
              `)}
            </div>
          `}
          <div class="stun-add-row">
            <input type="text" placeholder=${t('node.ice_add_placeholder')}
              value=${iceInput}
              onInput=${e => setIceInput(e.target.value)}
              onKeyDown=${e => { if (e.key === 'Enter') addIceInterface(); }} />
            <button class="btn btn-small btn-secondary" onClick=${addIceInterface}>
              ${t('node.ice_add')}</button>
          </div>
          <div class="node-settings-actions">
            <button class="btn btn-primary btn-small" disabled=${savingIce || busy}
              onClick=${saveIce}>
              ${savingIce ? t('node.ice_saving') : t('node.ice_save')}</button>
            ${editIce.length > 0 && html`
              <button class="btn btn-small btn-secondary" disabled=${savingIce || busy}
                onClick=${resetIceAuto}>
                ${t('node.ice_reset_auto')}</button>
            `}
          </div>
        </div>
      `}

      ${tab === 'settings' && html`
      <div class="node-group">
        <div class="node-section-header">
          <span class="settings-heading">${t('node.denylist')}</span>
          <button class="btn btn-small btn-secondary" disabled=${busy}
            onClick=${loadDenylist}>
            ${t('node.denylist_load')}</button>
        </div>
        ${showDenylist && denylist && html`
          <div class="node-denylist">
            ${denylist.count === 0 ? html`
              <p class="node-hint">${t('node.denylist_empty')}</p>
            ` : html`
              <p class="node-hint">${t('node.denylist_count',
                { n: denylist.count })}</p>
              ${(denylist.users || []).map(u => html`
                <div class="node-deny-entry" key=${'u:' + u}>
                  <span>user: ${u}</span>
                  <button class="btn btn-small btn-danger" disabled=${busy}
                    onClick=${() => clearDenylist(u)}>
                    ${t('node.denylist_remove')}</button>
                </div>
              `)}
              ${(denylist.groups || []).map(g => html`
                <div class="node-deny-entry" key=${'g:' + g}>
                  <span>group: ${g}</span>
                  <button class="btn btn-small btn-danger" disabled=${busy}
                    onClick=${() => clearDenylist(g)}>
                    ${t('node.denylist_remove')}</button>
                </div>
              `)}
              ${(denylist.jtis || []).map(j => html`
                <div class="node-deny-entry" key=${'j:' + j}>
                  <span>token: ${j.slice(0, 16)}</span>
                  <button class="btn btn-small btn-danger" disabled=${busy}
                    onClick=${() => clearDenylist(j)}>
                    ${t('node.denylist_remove')}</button>
                </div>
              `)}
              <button class="btn btn-small btn-danger" disabled=${busy}
                onClick=${() => clearDenylist('')}>
                ${t('node.denylist_clear_all')}</button>
            `}
          </div>
        `}
      </div>
      `}

      ${tab === 'settings' && nodeInfo && nodeInfo.status !== 'waiting_for_node_key' && html`
        <div class="node-group node-group-danger">
          <span class="settings-heading">${t('node.unlink_title')}</span>
          <p class="node-hint">${t('node.unlink_hint')}</p>
          <button class="btn btn-small btn-danger" disabled=${unlinkBusy || busy}
            onClick=${unlinkNode}>${t('node.unlink_button')}</button>
        </div>
      `}
    </div>
  `;
}