spinuptui 1.2.0-alpha.1 → 1.2.0

package/src/lib/offline.ts

@@ -0,0 +1,422 @@
+// Take a server's sites offline, and bring back exactly those sites later.
+//
+// For emergencies like an unpatched PHP remote-code-execution bug: SpinupWP's
+// "disable site" removes the site's nginx server block, so port 80 returns an
+// empty reply, 443 fails the TLS handshake, and no request reaches PHP (checked
+// on a test box with direct-IP and --resolve requests too). Files, database,
+// certificate, the PHP-FPM pool and the site's cron are all left in place.
+//
+// PHP is shared by every site on a server, so the usual unit is the server:
+// one still-enabled site keeps the vulnerable binary reachable. Single sites
+// can go offline too (one exposed site, or one client's site for reasons of its
+// own); they're recorded under their server the same way. What this module
+// disabled is recorded per server in `offline.json` (per account), and bringing
+// a server back only re-enables those sites. A site someone had disabled for
+// another reason stays disabled.
+//
+// Kuma: every monitor registered for the affected sites goes behind one manual
+// maintenance window per server, so taking 30 sites down doesn't page 30 times.
+// Best-effort both ways; Kuma being unreachable never blocks the API work.
+
+import { existsSync, readFileSync } from "node:fs"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import type { AppConfig, KumaMonitorRef } from "../config.ts"
+import { profileDataDir } from "../config.ts"
+import type { Event, Server, Site } from "../api/types.ts"
+import type { SpinupWPClientLike } from "../api/client.ts"
+import { ApiError } from "../api/client.ts"
+import { withKuma } from "./uptimeKuma.ts"
+
+// ---- State ----------------------------------------------------------------
+
+export interface OfflineSite {
+  id: number
+  domain: string
+}
+
+export interface OfflineRecord {
+  serverId: number
+  serverName: string
+  takenAt: string
+  // Only the sites this module disabled; the only ones "online" re-enables.
+  sites: OfflineSite[]
+  kumaMaintenanceId?: number
+}
+
+export interface OfflineState {
+  servers: Record<string, OfflineRecord>
+}
+
+export function offlineStatePath(dir = profileDataDir()): string {
+  return join(dir, "offline.json")
+}
+
+export function loadOfflineState(dir = profileDataDir()): OfflineState {
+  try {
+    const path = offlineStatePath(dir)
+    if (!existsSync(path)) return { servers: {} }
+    const raw = JSON.parse(readFileSync(path, "utf8")) as Partial<OfflineState>
+    return { servers: raw.servers ?? {} }
+  } catch {
+    return { servers: {} }
+  }
+}
+
+// Read-modify-write, so a CLI run and the app working on different servers
+// don't overwrite each other's records.
+async function updateRecord(dir: string, serverId: number, fn: (r: OfflineRecord | undefined) => OfflineRecord | undefined): Promise<void> {
+  const state = loadOfflineState(dir)
+  const next = fn(state.servers[String(serverId)])
+  if (next) state.servers[String(serverId)] = next
+  else delete state.servers[String(serverId)]
+  await mkdir(dir, { recursive: true })
+  await Bun.write(offlineStatePath(dir), JSON.stringify(state, null, 2) + "\n")
+}
+
+// ---- Event waiting ----------------------------------------------------------
+
+const EVENT_DONE = new Set(["deployed", "completed", "finished", "success"])
+const EVENT_FAIL = new Set(["failed", "errored", "error"])
+
+export type EventOutcome = "done" | "failed" | "timeout"
+
+// Wait on many events at once. One `GET /events` page covers the 100 newest,
+// so a whole server (or fleet) costs one request per round instead of one per
+// site; anything that has scrolled off that page is fetched individually. A
+// timeout is reported as a timeout, never a failure: SpinupWP runs a server's
+// events one at a time, so a big server's last site can sit queued a while.
+export async function waitForEvents(
+  client: SpinupWPClientLike,
+  ids: number[],
+  opts: { timeoutMs?: number; pollMs?: number; onSettled?: (id: number, outcome: EventOutcome, event?: Event) => void } = {},
+): Promise<Map<number, EventOutcome>> {
+  const timeoutMs = opts.timeoutMs ?? 15 * 60_000
+  const pollMs = opts.pollMs ?? 4000
+  const out = new Map<number, EventOutcome>()
+  const pending = new Set(ids)
+  const settle = (id: number, outcome: EventOutcome, ev?: Event) => {
+    pending.delete(id)
+    out.set(id, outcome)
+    opts.onSettled?.(id, outcome, ev)
+  }
+  const judge = (ev: Event) => {
+    if (!pending.has(ev.id)) return
+    if (EVENT_FAIL.has(ev.status)) settle(ev.id, "failed", ev)
+    else if (EVENT_DONE.has(ev.status) || ev.finished_at) settle(ev.id, "done", ev)
+  }
+  const deadline = Date.now() + timeoutMs
+  let apiErrs = 0
+  while (pending.size && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, pollMs))
+    try {
+      const recent = await client.listEvents(1)
+      apiErrs = 0
+      const seen = new Set<number>()
+      for (const ev of recent) {
+        seen.add(ev.id)
+        judge(ev)
+      }
+      const oldest = recent.length ? Math.min(...recent.map((e) => e.id)) : Infinity
+      for (const id of [...pending]) {
+        if (seen.has(id) || id >= oldest) continue
+        judge(await client.getEvent(id))
+      }
+    } catch {
+      // A failed read isn't a failed event; give up only on a run of them.
+      if (++apiErrs >= 5) break
+    }
+  }
+  for (const id of pending) settle(id, "timeout")
+  return out
+}
+
+// ---- Kuma -----------------------------------------------------------------
+
+// Every monitor registered for a site: any numeric `*Id` on its ref, by the
+// same convention the alerts toggle uses, so new monitor kinds are covered.
+function monitorIdsFor(ref: KumaMonitorRef | undefined): number[] {
+  if (!ref) return []
+  return Object.entries(ref)
+    .filter((e): e is [string, number] => e[0].endsWith("Id") && typeof e[1] === "number")
+    .map(([, id]) => id)
+}
+
+export type KumaOutcome = "shielded" | "no_monitors" | "not_configured" | "failed" | "skipped"
+
+async function shieldMonitors(cfg: AppConfig, server: Server, domains: string[], existingId?: number): Promise<{ outcome: KumaOutcome; id?: number; error?: string }> {
+  const conn = cfg.uptimeKuma
+  if (!conn) return { outcome: "not_configured" }
+  const ids = [...new Set(domains.flatMap((d) => monitorIdsFor(cfg.kumaMonitors[d])))]
+  if (!ids.length) return { outcome: "no_monitors" }
+  try {
+    const { result } = await withKuma(conn, async (kuma) => {
+      // A re-run after a partial one widens the window it already opened.
+      if (existingId != null) {
+        try {
+          await kuma.setMaintenanceMonitors(existingId, ids)
+          return existingId
+        } catch {
+          // Deleted in Kuma meanwhile; open a fresh one.
+        }
+      }
+      const id = await kuma.addManualMaintenance(`Offline: ${server.name}`, "Sites taken offline from SpinupTUI. Removed automatically when they come back online.")
+      try {
+        await kuma.setMaintenanceMonitors(id, ids)
+      } catch (err) {
+        await kuma.deleteMaintenance(id).catch(() => {})
+        throw err
+      }
+      return id
+    })
+    return { outcome: "shielded", id: result }
+  } catch (err) {
+    return { outcome: "failed", error: (err as Error).message }
+  }
+}
+
+// ---- Server lookup --------------------------------------------------------
+
+export type ServerMatch = { ok: true; server: Server } | { ok: false; query: string; message: string; suggestions: string[] }
+
+// Exact matches only (name, IP or id). A write that takes sites down must
+// never act on a near-miss; a miss lists names that contain the query.
+export function matchServer(servers: Server[], query: string): ServerMatch {
+  const q = query.trim().toLowerCase()
+  const hit = servers.find((s) => s.name.toLowerCase() === q || s.ip_address === q || String(s.id) === q)
+  if (hit) return { ok: true, server: hit }
+  const suggestions = servers.filter((s) => s.name.toLowerCase().includes(q)).map((s) => s.name).slice(0, 8)
+  return { ok: false, query, message: `No server named "${query}".`, suggestions }
+}
+
+// ---- Take offline ---------------------------------------------------------
+
+export interface OfflineServerResult {
+  serverId: number
+  serverName: string
+  // Disabled by this run.
+  disabled: string[]
+  // Already disabled before this run; left alone and not recorded.
+  alreadyOffline: string[]
+  failed: { domain: string; error: string }[]
+  kuma: KumaOutcome
+  kumaError?: string
+}
+
+export interface OfflineOptions {
+  dir?: string
+  onProgress?: (line: string) => void
+  // False in Dev Mode: never talk to a real Kuma.
+  kuma?: boolean
+  timeoutMs?: number
+  pollMs?: number
+}
+
+const errMsg = (err: unknown) => (err instanceof ApiError ? err.message : (err as Error).message)
+
+export async function takeServerOffline(client: SpinupWPClientLike, cfg: AppConfig, server: Server, opts: OfflineOptions = {}): Promise<OfflineServerResult> {
+  const sites = await client.listSites(server.id)
+  const result = emptyOfflineResult(server)
+  result.alreadyOffline = sites.filter((s) => s.disabled_at).map((s) => s.domain)
+  const targets = sites.filter((s) => !s.disabled_at)
+  if (!targets.length) {
+    opts.onProgress?.(`${server.name}: every site is already offline`)
+    return result
+  }
+  return disableSites(client, cfg, server, targets, result, opts)
+}
+
+// One site. The rest of the server stays up, and so does its PHP: this
+// protects that site, not the server.
+export async function takeSiteOffline(client: SpinupWPClientLike, cfg: AppConfig, server: Server, siteId: number, opts: OfflineOptions = {}): Promise<OfflineServerResult> {
+  const site = (await client.listSites(server.id)).find((s) => s.id === siteId)
+  const result = emptyOfflineResult(server)
+  if (!site) throw new Error(`Site ${siteId} is no longer on ${server.name}.`)
+  if (site.disabled_at) {
+    result.alreadyOffline = [site.domain]
+    opts.onProgress?.(`${site.domain}: already offline`)
+    return result
+  }
+  return disableSites(client, cfg, server, [site], result, opts)
+}
+
+function emptyOfflineResult(server: Server): OfflineServerResult {
+  return { serverId: server.id, serverName: server.name, disabled: [], alreadyOffline: [], failed: [], kuma: "skipped" }
+}
+
+async function disableSites(
+  client: SpinupWPClientLike,
+  cfg: AppConfig,
+  server: Server,
+  targets: Site[],
+  result: OfflineServerResult,
+  opts: OfflineOptions,
+): Promise<OfflineServerResult> {
+  const dir = opts.dir ?? profileDataDir(cfg.profileId)
+  const say = opts.onProgress ?? (() => {})
+
+  const existing = loadOfflineState(dir).servers[String(server.id)]
+  if (opts.kuma !== false) {
+    const domains = [...new Set([...(existing?.sites ?? []).map((s) => s.domain), ...targets.map((s) => s.domain)])]
+    const k = await shieldMonitors(cfg, server, domains, existing?.kumaMaintenanceId)
+    result.kuma = k.outcome
+    if (k.error) result.kumaError = k.error
+    if (k.id != null) {
+      await updateRecord(dir, server.id, (r) => ({
+        ...(r ?? { serverId: server.id, serverName: server.name, takenAt: new Date().toISOString(), sites: [] }),
+        kumaMaintenanceId: k.id,
+      }))
+    }
+  }
+
+  // Record each site the moment its disable is accepted, before it finishes:
+  // if this process dies mid-run, "online" still knows to bring it back, and
+  // restoring a site that never went down is a harmless no-op.
+  const events = new Map<number, Site>()
+  for (const site of targets) {
+    try {
+      const { event_id } = await client.disableSite(site.id)
+      events.set(event_id, site)
+      await updateRecord(dir, server.id, (r) => {
+        const rec = r ?? { serverId: server.id, serverName: server.name, takenAt: new Date().toISOString(), sites: [] }
+        if (!rec.sites.some((s) => s.id === site.id)) rec.sites.push({ id: site.id, domain: site.domain })
+        return rec
+      })
+      say(`${site.domain}: going offline…`)
+    } catch (err) {
+      result.failed.push({ domain: site.domain, error: errMsg(err) })
+      say(`${site.domain}: ✕ ${errMsg(err)}`)
+    }
+  }
+
+  await waitForEvents(client, [...events.keys()], {
+    timeoutMs: opts.timeoutMs,
+    pollMs: opts.pollMs,
+    onSettled: (id, outcome, ev) => {
+      const site = events.get(id)!
+      if (outcome === "done") {
+        result.disabled.push(site.domain)
+        say(`${site.domain}: ✓ offline`)
+      } else if (outcome === "failed") {
+        const error = ev?.output?.trim() || "SpinupWP reported the disable as failed."
+        result.failed.push({ domain: site.domain, error })
+        say(`${site.domain}: ✕ ${error}`)
+      } else {
+        result.failed.push({ domain: site.domain, error: "Still queued at SpinupWP when we stopped waiting; it may yet complete. Re-run to check." })
+        say(`${site.domain}: … still queued at SpinupWP`)
+      }
+    },
+  })
+  return result
+}
+
+// ---- Bring back online ----------------------------------------------------
+
+export interface OnlineServerResult {
+  serverId: number
+  serverName: string
+  enabled: string[]
+  // Recorded, but already serving again (enabled by hand, say).
+  alreadyOnline: string[]
+  // Recorded, but deleted from SpinupWP since.
+  gone: string[]
+  failed: { domain: string; error: string }[]
+  // Nothing recorded for this server: this module didn't take it offline.
+  nothingRecorded: boolean
+  // Asked for by id but not taken offline by this module (siteIds only).
+  notRecorded: number[]
+  kumaWindowClosed: boolean
+}
+
+// Bring back what this module took offline on a server: all of it, or only
+// `siteIds` from it.
+export async function bringServerOnline(
+  client: SpinupWPClientLike,
+  cfg: AppConfig,
+  serverId: number,
+  opts: OfflineOptions & { siteIds?: number[] } = {},
+): Promise<OnlineServerResult> {
+  const dir = opts.dir ?? profileDataDir(cfg.profileId)
+  const say = opts.onProgress ?? (() => {})
+  const record = loadOfflineState(dir).servers[String(serverId)]
+  const result: OnlineServerResult = {
+    serverId,
+    serverName: record?.serverName ?? String(serverId),
+    enabled: [],
+    alreadyOnline: [],
+    gone: [],
+    failed: [],
+    nothingRecorded: !record,
+    notRecorded: opts.siteIds?.filter((id) => !record?.sites.some((s) => s.id === id)) ?? [],
+    kumaWindowClosed: false,
+  }
+  if (!record) return result
+  const wanted = opts.siteIds ? record.sites.filter((s) => opts.siteIds!.includes(s.id)) : record.sites
+
+  const live = new Map((await client.listSites(serverId)).map((s) => [s.id, s]))
+  const done = new Set<number>()
+  const events = new Map<number, OfflineSite>()
+  for (const rec of wanted) {
+    const site = live.get(rec.id)
+    if (!site) {
+      result.gone.push(rec.domain)
+      done.add(rec.id)
+      continue
+    }
+    if (!site.disabled_at) {
+      result.alreadyOnline.push(rec.domain)
+      done.add(rec.id)
+      continue
+    }
+    try {
+      const { event_id } = await client.enableSite(rec.id)
+      events.set(event_id, rec)
+      say(`${rec.domain}: coming back online…`)
+    } catch (err) {
+      result.failed.push({ domain: rec.domain, error: errMsg(err) })
+      say(`${rec.domain}: ✕ ${errMsg(err)}`)
+    }
+  }
+
+  await waitForEvents(client, [...events.keys()], {
+    timeoutMs: opts.timeoutMs,
+    pollMs: opts.pollMs,
+    onSettled: (id, outcome, ev) => {
+      const rec = events.get(id)!
+      if (outcome === "done") {
+        result.enabled.push(rec.domain)
+        done.add(rec.id)
+        say(`${rec.domain}: ✓ online`)
+      } else {
+        const error = outcome === "failed" ? ev?.output?.trim() || "SpinupWP reported the enable as failed." : "Still queued at SpinupWP when we stopped waiting. Re-run to check."
+        result.failed.push({ domain: rec.domain, error })
+        say(`${rec.domain}: ✕ ${error}`)
+      }
+    },
+  })
+
+  // Keep whatever didn't come back, so a re-run finishes the job. The Kuma
+  // window shrinks to the sites still offline, and closes once there are none
+  // (or none of them has monitors).
+  let left: OfflineSite[] = []
+  await updateRecord(dir, serverId, (r) => {
+    if (!r) return undefined
+    left = r.sites.filter((s) => !done.has(s.id))
+    return left.length ? { ...r, sites: left } : undefined
+  })
+  if (done.size && record.kumaMaintenanceId != null && cfg.uptimeKuma && opts.kuma !== false) {
+    const id = record.kumaMaintenanceId
+    const stillShielded = [...new Set(left.flatMap((s) => monitorIdsFor(cfg.kumaMonitors[s.domain])))]
+    if (stillShielded.length) {
+      await withKuma(cfg.uptimeKuma, (kuma) => kuma.setMaintenanceMonitors(id, stillShielded)).catch(() => {
+        // The restored sites stay quiet in Kuma until the rest come back.
+      })
+    } else {
+      result.kumaWindowClosed = await withKuma(cfg.uptimeKuma, (kuma) => kuma.deleteMaintenance(id))
+        .then(() => true)
+        .catch(() => false)
+      if (left.length) await updateRecord(dir, serverId, (r) => (r ? { ...r, kumaMaintenanceId: undefined } : r))
+    }
+  }
+  return result
+}

package/src/ui/App.tsx

@@ -19,6 +19,7 @@ import { SiteUpdate } from "./views/SiteUpdate.tsx"
 import { BulkWpUpdate } from "./views/BulkWpUpdate.tsx"
 import { HttpsToggle } from "./views/HttpsToggle.tsx"
 import { PurgeCache } from "./views/PurgeCache.tsx"
+import { SiteOffline } from "./views/SiteOffline.tsx"
 import { ReleaseNotes } from "./views/ReleaseNotes.tsx"
 import { GrantKey } from "./views/GrantKey.tsx"
 import { SudoConnect } from "./views/SudoConnect.tsx"
@@ -40,8 +41,6 @@ import { ProviderConnect } from "./views/ProviderConnect.tsx"
 import { DnsRecords } from "./views/DnsRecords.tsx"
 import { KumaSite } from "./views/KumaSite.tsx"
 import { Accounts } from "./views/Accounts.tsx"
-import { Modules } from "./views/Modules.tsx"
-import { BeaconSetup } from "./views/BeaconSetup.tsx"
 
 const MIN_SPLASH_MS = 1200
 
@@ -72,6 +71,7 @@ export function App() {
     store.bulkWpGroup !== null ||
     store.httpsToggleSite !== null ||
     store.purgeCacheSite !== null ||
+    store.siteOfflineSite !== null ||
     store.grantKeySite !== null ||
     store.sudoConnectServer !== null ||
     store.dbBackupSite !== null ||
@@ -89,8 +89,7 @@ export function App() {
     store.dnsInventoryServer !== null ||
     store.connectZoneTarget !== null ||
     store.dnsRecordsTarget !== null ||
-    store.kumaSite !== null ||
-    store.beaconSetupOpen
+    store.kumaSite !== null
   useEffect(() => {
     store.setOverlayOpen(overlayActive)
   }, [overlayActive, store])
@@ -149,6 +148,9 @@ export function App() {
     // The purge-cache overlay owns the keyboard while open.
     if (store.purgeCacheSite) return
 
+    // The take-site-offline overlay owns the keyboard while open.
+    if (store.siteOfflineSite) return
+
     // The grant-SSH-key overlay owns the keyboard while open.
     if (store.grantKeySite) return
 
@@ -203,9 +205,6 @@ export function App() {
     // The site-monitoring (Uptime Kuma) overlay owns the keyboard while open.
     if (store.kumaSite) return
 
-    // Beacon's guided setup (Modules tab) owns the keyboard while open.
-    if (store.beaconSetupOpen) return
-
     // A (Shift+a): the Accounts overlay — the header advertises it from every tab.
     if (key.shift && key.name === "a") return setShowAccounts(true)
 
@@ -222,8 +221,6 @@ export function App() {
         return store.setRoute("search")
       case "5":
         return store.setRoute("events")
-      case "6":
-        return store.setRoute("modules")
       case "r":
         return void store.refresh()
       case "?":
@@ -263,7 +260,6 @@ export function App() {
         {store.route === "stacks" && <Stacks rows={contentRows} />}
         {store.route === "search" && <Search rows={contentRows} />}
         {store.route === "events" && <Events rows={contentRows} />}
-        {store.route === "modules" && <Modules rows={contentRows} />}
       </box>
       {showHelp && <HelpOverlay onClose={() => setShowHelp(false)} />}
       {showExplain && <ExplainOverlay route={store.route} />}
@@ -274,6 +270,7 @@ export function App() {
       {store.bulkWpGroup && <BulkWpUpdate />}
       {store.httpsToggleSite && <HttpsToggle />}
       {store.purgeCacheSite && <PurgeCache />}
+      {store.siteOfflineSite && <SiteOffline />}
       {store.grantKeySite && <GrantKey />}
       {store.sudoConnectServer && <SudoConnect />}
       {store.dbBackupSite && <DbBackup />}
@@ -292,7 +289,6 @@ export function App() {
       {store.connectZoneTarget && <ProviderConnect />}
       {store.dnsRecordsTarget && <DnsRecords />}
       {store.kumaSite && <KumaSite />}
-      {store.beaconSetupOpen && <BeaconSetup />}
       {showAccounts && <Accounts onClose={() => setShowAccounts(false)} />}
       <ToastStack />
     </box>

package/src/ui/Details.tsx

@@ -110,7 +110,7 @@ export const SERVER_CONTROL: ActionGroup[] = [
   {
     title: "Manage",
     items: [
-      ["a", "Reboot / restart"],
+      ["a", "Restart / offline"],
       ["h", "Health"],
       ["N", "DNS"],
     ],

package/src/ui/Explain.tsx

@@ -27,7 +27,7 @@ const GUIDES: Record<Route, Guide> = {
       ["Recent activity", "The latest deploys and operations"],
     ],
     actions: [
-      ["1–6", "Switch tabs"],
+      ["1–5", "Switch tabs"],
       ["r", "Refresh from the API"],
     ],
   },
@@ -91,23 +91,10 @@ const GUIDES: Record<Route, Guide> = {
     title: "Events",
     summary: "A live feed of deploys, reboots, and operations across your account.",
     actions: [
-      ["1–6", "Switch tabs"],
+      ["1–5", "Switch tabs"],
       ["r", "Refresh"],
     ],
   },
-  modules: {
-    title: "Modules",
-    summary: "Modules are the parts of SpinupTUI that keep working after you close it: paging you, running follow-ups, watching the fleet. Each card says what it does and whether it's set up on this machine.",
-    panes: [
-      ["Modules", "Every module, with its status here: ● set up · ○ not set up · coming soon"],
-      ["Detail", "What the selected module does, its health checks, and what to do next"],
-    ],
-    actions: [
-      ["⏎ / s", "Set up the selected module (Beacon: connect a Telegram bot)"],
-      ["t", "Send a test page through Beacon"],
-      ["1–6", "Switch tabs"],
-    ],
-  },
 }
 
 export function ExplainOverlay({ route }: { route: Route }) {

package/src/ui/Header.tsx

@@ -15,7 +15,6 @@ const TABS: { route: Route; key: string; label: string }[] = [
   { route: "stacks", key: "3", label: "Stacks" },
   { route: "search", key: "4", label: "Search" },
   { route: "events", key: "5", label: "Events" },
-  { route: "modules", key: "6", label: "Modules" },
 ]
 
 // A one-line "what is this view, and what can I do here" subtitle per tab —
@@ -27,7 +26,6 @@ const SUBTITLES: Record<Route, string> = {
   stacks: "Your fleet grouped by app type  ·  d identify an app (SSH)  ·  S find local copies on your disk",
   search: "Jump to any server or site by name  ·  Tab hands focus to the result's actions",
   events: "Recent deploys, reboots, and operations across your account",
-  modules: "What keeps working after you close SpinupTUI  ·  ⏎ set up the selected module",
 }
 
 // SpinupWP allows 60 API requests a minute. Show what's left of this minute so

package/src/ui/Help.tsx

@@ -15,7 +15,7 @@ type Section = { title: string; keys: [string, string][] }
 const GLOBAL: Section = {
   title: "Global",
   keys: [
-    ["1 … 6", "Switch tabs"],
+    ["1 … 5", "Switch tabs"],
     ["r", "Refresh from the API"],
     ["/", "Global search"],
     ["A", "Switch SpinupWP accounts"],
@@ -37,13 +37,14 @@ const NAV: Section = {
     ["s", "SSH into the site"],
     ["h", "Server health (SSH)"],
     ["w", "Open in SpinupWP web app"],
-    ["a", "Server actions (reboot/restart)"],
+    ["a", "Server actions (restart, take offline)"],
     ["c", "Create a new server"],
     ["C", "Clone this server to a new one"],
     ["S", "Connect sudo on the server"],
     ["u", "Update PHP version or WordPress core"],
     ["H", "Enable/disable HTTPS"],
     ["P", "Purge page + object cache"],
+    ["O", "Take a site offline / bring it back"],
     ["K", "Grant SpinupTUI's SSH key (sudo)"],
     ["d", "Identify a site's app (SSH)"],
   ],

package/src/ui/components.tsx

@@ -463,11 +463,12 @@ export function siteGroups(isWordpress: boolean, isVanity: boolean): ActionGroup
   remote.push(["H", "Toggle HTTPS"])
   remote.push(["P", "Purge cache"])
   remote.push(["M", "Monitoring"])
+  remote.push(["O", "Take offline"])
   return [
     { title: "Open", items: [["o", "In browser"], ["w", "In SpinupWP"]] },
     { title: "Remote", items: remote },
     { title: "Local", items: local },
     ...(isVanity ? [{ title: "Vanity", items: [["R", "Refresh"]] as [string, string][] }] : []),
-    { title: "Server", items: [["a", "Reboot / restart"], ["h", "Health"]] },
+    { title: "Server", items: [["a", "Restart / offline"], ["h", "Health"]] },
   ]
 }