spinuptui 0.19.0

package/src/lib/stack.ts

@@ -0,0 +1,78 @@
+// Tier-1 site "stack" classification — pure functions over data we already
+// fetch (no SSH, no extra API calls). Signals: `is_wordpress` and
+// `public_folder` on the Site object, validated against the live fleet.
+//
+//   is_wordpress === false      → Non-WP
+//   is_wordpress && "/web/"      → Bedrock
+//   is_wordpress && anything else → Standard WP
+//
+// Important: `public_folder` is the user-set "Public Folder" (the suffix after
+// `~/sites/{domain}/files`), NOT a SpinupWP-enforced stack flag. So this is a
+// heuristic keyed on a convention: webroot `/web/` means Bedrock. The
+// is_wordpress guard matters — a couple of non-WP custom apps also use "/web/",
+// so Bedrock requires WP too. Any other WP webroot (incl. the bare `~/files`
+// default, `/public/`, `/`) is treated as Standard WP. Tier-2 (on-demand SSH
+// probe that inspects the filesystem) is the authoritative correction layer.
+
+import type { Site } from "../api/types.ts"
+import type { ProbeKind } from "./probe.ts"
+import { theme } from "./theme.ts"
+
+export type Stack = "Standard WP" | "Bedrock" | "Non-WP"
+
+// All buckets in display order (kept stable so the Stacks view doesn't reflow).
+export const STACKS: Stack[] = ["Standard WP", "Bedrock", "Non-WP"]
+
+export function classifyStack(site: Site): Stack {
+  if (!site.is_wordpress) return "Non-WP"
+  if (site.public_folder === "/web/") return "Bedrock"
+  return "Standard WP"
+}
+
+// The bucket a site actually belongs in once Tier-2 is considered. A CONCLUSIVE
+// probe (positive identification) overrides the Tier-1 heuristic; an
+// inconclusive ("unknown"), failed, or absent probe falls back to Tier-1. This
+// is how an API-mislabeled site (is_wordpress=false but really WordPress) moves
+// into its true bucket after `d`.
+export function effectiveStack(site: Site, probeKind?: ProbeKind | null): Stack {
+  switch (probeKind) {
+    case "wordpress":
+      return "Standard WP"
+    case "bedrock":
+      return "Bedrock"
+    case "whmcs":
+    case "laravel":
+    case "static":
+      return "Non-WP"
+    default:
+      return classifyStack(site)
+  }
+}
+
+// `onSelection` brightens the colors that read poorly on the focused
+// (bright-green) selection background (green-on-green Bedrock, the faint grey).
+export function stackColor(stack: Stack, onSelection = false): string {
+  switch (stack) {
+    case "Standard WP":
+      return theme.accent // blue
+    case "Bedrock":
+      return onSelection ? theme.text : theme.good // green
+    case "Non-WP":
+      return onSelection ? theme.text : theme.textDim // gray
+  }
+}
+
+// Compact tag for tight one-line list rows.
+export function stackTag(stack: Stack): string {
+  switch (stack) {
+    case "Standard WP":
+      return "wp"
+    case "Bedrock":
+      return "bedrock"
+    case "Non-WP":
+      return "app"
+  }
+}
+
+// PHP version helpers (EOL check, sort key) live in ./phpEol.ts — EOL is
+// computed from real dates vs today, refreshed from endoflife.date.

package/src/lib/stackCache.ts

@@ -0,0 +1,113 @@
+// Disk-backed cache for Tier-2 probe results, keyed by site id.
+//
+// Lifecycle (agreed model): hydrate-on-startup, write-on-probe.
+//   - load()  reads stack-cache.json into memory once at startup (no SSH).
+//   - set()   is called after a successful `d` probe; it upserts the entry and
+//             writes the whole file back immediately (write-through), so a probe
+//             survives even if the TUI is killed with q / Ctrl+C.
+// Probing itself is always on-demand and per-site — this cache exists to avoid
+// repeating the slow SSH round-trips across launches, not to save RAM. It's a
+// deliberately small, reusable pattern for other expensive derived data later.
+
+import { join } from "node:path"
+import { existsSync, readFileSync } from "node:fs"
+import { chmod, mkdir } from "node:fs/promises"
+import { configDir } from "../config.ts"
+import type { ProbeResult } from "./probe.ts"
+
+const CACHE_VERSION = 1
+
+export interface CachedProbe {
+  result: ProbeResult
+  detectedAt: number // epoch ms
+  signature: string // invalidation key (see siteSignature)
+}
+
+interface CacheFile {
+  version: number
+  entries: Record<string, CachedProbe> // key: String(site.id)
+}
+
+export function stackCachePath(): string {
+  return join(configDir(), "stack-cache.json")
+}
+
+// A cached probe is considered stale when the site's relevant shape changes.
+// Keying on is_wordpress + public_folder catches the cases that would alter the
+// probe's target paths or expected result.
+export function siteSignature(site: { is_wordpress: boolean; public_folder: string | null }): string {
+  return `${site.is_wordpress}:${site.public_folder ?? ""}`
+}
+
+export class StackCache {
+  private entries = new Map<number, CachedProbe>()
+  // Serializes disk writes so concurrent probes (batch mode) can't tear the
+  // file or drop each other's updates. Each persist() runs after the previous.
+  private writeChain: Promise<void> = Promise.resolve()
+
+  // Read the cache file into memory. Never throws — a missing or corrupt file
+  // simply yields an empty cache.
+  load(): void {
+    try {
+      const path = stackCachePath()
+      if (!existsSync(path)) return
+      const parsed = JSON.parse(readFileSync(path, "utf8")) as CacheFile
+      if (parsed?.version !== CACHE_VERSION || !parsed.entries) return
+      for (const [k, v] of Object.entries(parsed.entries)) {
+        const id = Number(k)
+        if (Number.isFinite(id) && v?.result) this.entries.set(id, v)
+      }
+    } catch {
+      /* ignore corrupt/unreadable cache — start empty */
+    }
+  }
+
+  // Any cached entry (even if stale), for display.
+  get(siteId: number): CachedProbe | undefined {
+    return this.entries.get(siteId)
+  }
+
+  // True when the cached entry exists but no longer matches the site's shape,
+  // so the UI can hint that a re-probe is warranted.
+  isStale(siteId: number, signature: string): boolean {
+    const e = this.entries.get(siteId)
+    return e != null && e.signature !== signature
+  }
+
+  // Upsert a probe result and persist immediately (write-through).
+  async set(siteId: number, result: ProbeResult, signature: string): Promise<void> {
+    this.entries.set(siteId, { result, detectedAt: Date.now(), signature })
+    await this.persist()
+  }
+
+  // A copy of all entries (for rendering aggregates without exposing the map).
+  snapshot(): Map<number, CachedProbe> {
+    return new Map(this.entries)
+  }
+
+  size(): number {
+    return this.entries.size
+  }
+
+  // Queue this write behind any in-flight one. Each write serializes the
+  // current entries map (which already includes all sets so far), so ordering
+  // only needs to prevent overlapping file writes, not preserve per-set diffs.
+  private persist(): Promise<void> {
+    // `.catch` keeps the chain alive if one write fails (cache is best-effort).
+    this.writeChain = this.writeChain.then(() => this.writeFile()).catch(() => {})
+    return this.writeChain
+  }
+
+  private async writeFile(): Promise<void> {
+    await mkdir(configDir(), { recursive: true })
+    const file: CacheFile = { version: CACHE_VERSION, entries: {} }
+    for (const [id, entry] of this.entries) file.entries[String(id)] = entry
+    const path = stackCachePath()
+    await Bun.write(path, JSON.stringify(file, null, 2) + "\n")
+    try {
+      await chmod(path, 0o600)
+    } catch {
+      /* best-effort on filesystems without POSIX perms */
+    }
+  }
+}

package/src/lib/theme.ts

@@ -0,0 +1,54 @@
+// Centralized color palette + status helpers. Tweaking these restyles the whole app.
+// SpinupWP's brand green anchors the theme.
+
+export const theme = {
+  brand: "#00d18f", // SpinupWP green
+  brandDim: "#0a8f64",
+  accent: "#5ec8ff", // sky blue for highlights/links
+  text: "#e6edf3",
+  textDim: "#8b949e",
+  textFaint: "#586069",
+  bg: "#0d1117",
+  bgAlt: "#161b22",
+  bgPanel: "#11161d",
+  border: "#30363d",
+  borderActive: "#00d18f",
+  selectedBg: "#1f6f53",
+  good: "#3fb950",
+  warn: "#d29922",
+  update: "#ffd23f", // bright gold — "new version available" nudge; brighter/cleaner than warn-amber so it reads as "new", not "caution"
+  bad: "#f85149",
+  info: "#5ec8ff",
+  purple: "#bc8cff",
+} as const
+
+// Map an arbitrary status/connection string to a semantic color.
+export function statusColor(status: string | null | undefined): string {
+  const s = (status ?? "").toLowerCase()
+  if (["connected", "deployed", "provisioned", "completed", "active", "success"].includes(s)) {
+    return theme.good
+  }
+  if (["connecting", "provisioning", "deploying", "queued", "running", "pending", "in_progress"].includes(s)) {
+    return theme.warn
+  }
+  if (["disconnected", "failed", "errored", "error", "offline"].includes(s)) {
+    return theme.bad
+  }
+  return theme.textDim
+}
+
+// A small colored dot used throughout the UI to denote status at a glance.
+export function statusDot(status: string | null | undefined): string {
+  const s = (status ?? "").toLowerCase()
+  if (["connected", "deployed", "provisioned", "completed", "active", "success"].includes(s)) return "●"
+  if (["connecting", "provisioning", "deploying", "queued", "running", "pending", "in_progress"].includes(s)) return "◐"
+  if (["disconnected", "failed", "errored", "error", "offline"].includes(s)) return "✕"
+  return "○"
+}
+
+// Color a disk-usage percentage: green < 70, amber < 90, red otherwise.
+export function diskColor(pct: number): string {
+  if (pct < 70) return theme.good
+  if (pct < 90) return theme.warn
+  return theme.bad
+}

package/src/lib/ubuntuEol.ts

@@ -0,0 +1,124 @@
+// Ubuntu end-of-life data for the OS a SpinupWP server runs on, computed from
+// real EOL *dates* vs the current date — same approach as php-eol (phpEol.ts).
+//
+// Hybrid sourcing:
+//   1. An embedded table of Canonical's published LTS dates is the offline
+//      default, so flagging is correct with no network.
+//   2. At startup we refresh from endoflife.date (cached to disk), which keeps
+//      the data current and adds releases published after this build.
+//
+// A version with no known date is NOT flagged — we don't guess. SpinupWP only
+// provisions Ubuntu LTS releases, so only those are tracked.
+
+import { join } from "node:path"
+import { existsSync, readFileSync } from "node:fs"
+import { mkdir } from "node:fs/promises"
+import { configDir } from "../config.ts"
+
+// Map of "YY.MM" → standard security-support EOL date (ISO). Source:
+// Canonical's published LTS schedule. Refreshed at runtime from endoflife.date.
+export const EMBEDDED_UBUNTU_EOL: Record<string, string> = {
+  "16.04": "2021-04-30",
+  "18.04": "2023-05-31",
+  "20.04": "2025-04-30",
+  "22.04": "2027-04-30",
+  "24.04": "2029-04-30",
+}
+
+// Refresh from the network at most this often.
+const REFRESH_AFTER_MS = 7 * 24 * 60 * 60 * 1000
+const FETCH_TIMEOUT_MS = 6000
+const ENDPOINT = "https://endoflife.date/api/ubuntu.json"
+
+export type UbuntuEolDates = Record<string, string>
+
+interface CacheFile {
+  fetchedAt: number
+  dates: UbuntuEolDates
+}
+
+export function ubuntuEolCachePath(): string {
+  return join(configDir(), "ubuntu-eol.json")
+}
+
+// Normalize "20.04.6" / "20.04" → "20.04" (the key Canonical schedules by).
+function releaseKey(version: string): string | null {
+  const parts = version.split(".")
+  if (parts.length < 2) return null
+  const year = Number.parseInt(parts[0] ?? "", 10)
+  const month = parts[1] ?? ""
+  if (!Number.isFinite(year) || !/^\d{2}$/.test(month)) return null
+  return `${parts[0]}.${month}`
+}
+
+// True when `version`'s known EOL date is before `asOf`. Unknown → not flagged.
+export function isUbuntuEol(version: string | null | undefined, dates: UbuntuEolDates, asOf: Date = new Date()): boolean {
+  if (!version) return false
+  const key = releaseKey(version)
+  if (!key) return false
+  const eol = dates[key]
+  if (!eol) return false
+  const t = Date.parse(eol)
+  return Number.isFinite(t) && t < asOf.getTime()
+}
+
+function loadCache(): CacheFile | null {
+  try {
+    const path = ubuntuEolCachePath()
+    if (!existsSync(path)) return null
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as CacheFile
+    if (!parsed?.dates || typeof parsed.fetchedAt !== "number") return null
+    return parsed
+  } catch {
+    return null
+  }
+}
+
+// The dates to use right now: embedded defaults overlaid with cached fetch data.
+export function resolveUbuntuEolDates(): UbuntuEolDates {
+  return { ...EMBEDDED_UBUNTU_EOL, ...(loadCache()?.dates ?? {}) }
+}
+
+function cacheIsFresh(): boolean {
+  const c = loadCache()
+  return c != null && Date.now() - c.fetchedAt < REFRESH_AFTER_MS
+}
+
+// Fetch the live Ubuntu release schedule from endoflife.date. Returns null on
+// any failure (offline, timeout, bad shape) so callers fall back to
+// embedded/cached data.
+async function fetchUbuntuEolDates(): Promise<UbuntuEolDates | null> {
+  try {
+    const res = await fetch(ENDPOINT, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    })
+    if (!res.ok) return null
+    const cycles = (await res.json()) as { cycle?: string; eol?: string | boolean }[]
+    if (!Array.isArray(cycles)) return null
+    const dates: UbuntuEolDates = {}
+    for (const c of cycles) {
+      if (typeof c.cycle === "string" && typeof c.eol === "string") dates[c.cycle] = c.eol
+    }
+    return Object.keys(dates).length > 0 ? dates : null
+  } catch {
+    return null
+  }
+}
+
+// Refresh the cache if stale; returns the freshly merged dates when it updated,
+// or null when nothing changed (cache still fresh, or the fetch failed). Never
+// throws — Ubuntu-EOL data is best-effort decoration.
+export async function refreshUbuntuEolDates(): Promise<UbuntuEolDates | null> {
+  if (cacheIsFresh()) return null
+  const fetched = await fetchUbuntuEolDates()
+  if (!fetched) return null
+  try {
+    await mkdir(configDir(), { recursive: true })
+    const file: CacheFile = { fetchedAt: Date.now(), dates: fetched }
+    await Bun.write(ubuntuEolCachePath(), JSON.stringify(file, null, 2) + "\n")
+  } catch {
+    /* best-effort cache write */
+  }
+  return { ...EMBEDDED_UBUNTU_EOL, ...fetched }
+}