spinuptui 0.19.0

package/src/config.ts

@@ -0,0 +1,309 @@
+// Configuration resolution + persistence.
+//
+// Token resolution order (first match wins):
+//   1. SPINUPWP_ACCESS_TOKEN environment variable (Bun auto-loads ./.env)
+//   2. ~/.config/spinupwp-tui/config.json  (written by the onboarding wizard)
+//
+// This lets the original author keep a project-local .env while letting other
+// users configure the tool globally after a `bun install -g`.
+
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { mkdir, chmod } from "node:fs/promises"
+import { existsSync, readFileSync } from "node:fs"
+import type { LocalLink } from "./lib/local.ts"
+import { ALL_PROVIDERS, type Connection, type ConnProvider } from "./lib/providers.ts"
+
+export const DEFAULT_BASE_URL = "https://api.spinupwp.app/v1"
+
+export interface AppConfig {
+  token: string
+  baseUrl: string
+  tokenSource: "env" | "file" | "none"
+  // Optional override for the SSH user used by the server health view. When unset,
+  // the health view derives the user from a site on the server (its `site_user`).
+  sshUser: string | null
+  // SpinupWP account/team slug (e.g. "wenmark-digital-solutions"), used to build
+  // deep links into the SpinupWP web app. The API doesn't expose it, so it's
+  // configured. When unset, deep links fall back to the dashboard root.
+  accountSlug: string | null
+  // macOS terminal app to open for local working copies (e.g. "iTerm", "Warp").
+  // When unset, inferred from $TERM_PROGRAM, falling back to Terminal.
+  terminalApp: string | null
+  // Opt-in for the production→local DB sync (`p`). Off by default because it
+  // OVERWRITES the local database and assumes a working local WP dev environment
+  // (WP-CLI + a local DB). The read-only DB backup (`d`) needs neither and stays
+  // available without this. Set "localSync": true in config to enable.
+  localSync: boolean
+  // Directories to (eventually) scan for local working copies. Reserved for the
+  // Phase 2 auto-discovery pass; unused by Phase 1's manual linking.
+  localRoots: string[]
+  // Local working-copy links, keyed by SpinupWP site id (as a string, since
+  // JSON object keys are strings). See lib/local.ts for the link shape.
+  localSites: Record<string, LocalLink>
+  // DNS provider connections (Phase 2 access detection), keyed by provider, merged
+  // from the stored config and the environment. Env-sourced connections carry
+  // `env: true` and are read-only in the UI. Secrets live here (file is chmod 600).
+  providerConnections: Record<ConnProvider, Connection[]>
+  // SpinupWP server-provider connections, keyed by provider name
+  // (digitalocean | vultr | linode | hetzner). The API exposes no endpoint to
+  // list these, so — like accountSlug — the id is configured. Required to create
+  // a server on that provider (POST /servers needs server_provider[id]). Find the
+  // id in SpinupWP → Account Settings → Server Providers.
+  serverProviders: Record<string, ServerProviderRef>
+  // In-flight resumable jobs, keyed by job id. Hydrated at startup so a build
+  // (e.g. a server provision) keeps its tracker across a quit/relaunch.
+  jobs: Record<string, StoredJob>
+  // Per-server sudo user for privileged writes-over-SSH (e.g. dropping Spinup's
+  // machine key into a site user's authorized_keys), keyed by server id (string,
+  // since JSON object keys are strings). Only the username is stored — the sudo
+  // PASSWORD is held in-memory for the session and (opt-in, macOS) the Keychain,
+  // never config.json. `keychain: true` flags that a password is saved in Keychain.
+  sudoUsers: Record<string, { user: string; keychain?: boolean }>
+  // The public keys (by key body, the base64 second field) the user last chose to
+  // grant. Pre-selected in the grant-key picker so they don't re-pick every time.
+  preferredGrantKeys: string[]
+  // Keys Spinup has granted, keyed by site id (string) → key bodies. Drives the
+  // "has Spinup's key" row badge and informs revoke. Optimistic (a record of what
+  // Spinup wrote, not a live probe); revoke removes entries.
+  grantedKeys: Record<string, string[]>
+  // Per-zone access-note OVERRIDES only, keyed by zone apex. A provider's
+  // `defaultAccessNote` (e.g. GoDaddy's "Delegate Access") is the assumed normal
+  // case and is never stored here — only the exceptions (e.g. "Integracon", a
+  // third-party IT contact) are, so this stays empty for the common case.
+  zoneAccessNotes: Record<string, string>
+  // Uptime Kuma connection (optional). Creds live here like provider creds (file
+  // is chmod 600); `jwt` is captured after the first successful login so later
+  // sessions use loginByToken (survives 2FA accounts, skips re-sending the
+  // password). Env overrides: SPINUP_KUMA_URL / _USERNAME / _PASSWORD.
+  uptimeKuma: UptimeKumaConn | null
+  // Kuma monitors Spinup has registered, keyed by site domain. `pushToken` is the
+  // token baked into the server-side cron; ids let later features pause/verify.
+  kumaMonitors: Record<string, KumaMonitorRef>
+  // Per-vanity-site health keys, keyed by domain — the `key` the seeded page's
+  // ?format=json mode requires (baked in at seed time). Kept here so re-seeds
+  // reuse the same key (monitor URLs stay stable) and so monitor-registration
+  // features can build the JSON URL later. Letters/digits only.
+  vanityHealthKeys: Record<string, string>
+  // The last app version the user actually saw the Release Notes overlay for
+  // (or, on a fresh install / pre-this-feature upgrade, silently seeded to the
+  // running version with no notes shown — nothing meaningful to announce). A
+  // mismatch against the running version is what triggers the overlay.
+  lastSeenVersion: string | null
+}
+
+export interface ServerProviderRef {
+  id: number
+  databaseProviderId?: number
+}
+
+export interface UptimeKumaConn {
+  url: string
+  username: string
+  password: string
+  jwt?: string
+  env?: boolean // creds came from the environment — read-only in the UI
+}
+
+// CONVENTION: every numeric field ending in `Id` is a Kuma monitor id belonging
+// to this site, and the alert wiring (`n` in the monitoring overlay) attaches/
+// detaches notification providers across ALL of them by that naming rule — a
+// new monitor kind only needs a `fooId?: number` field here to be included.
+// Don't add a numeric `*Id` field that isn't a monitor id.
+export interface KumaMonitorRef {
+  healthId?: number // HTTP monitor on /?healthz
+  pushId?: number // push monitor fed by the server-side load cron
+  pushToken?: string
+  redisId?: number // "{server} redis" push monitor fed by the cron's redis-cli ping (vanity/server domains)
+  redisToken?: string
+  fingerprintId?: number // keyword monitor asserting the front page serves its own template
+  // What fingerprint calibration derived (lib/siteFingerprint.ts) — shown in the
+  // overlay and kept so a recalibration can explain what it's replacing.
+  // `interval` is the check window in seconds.
+  fingerprint?: { keyword: string; kind: string; detail: string; interval: number; derivedAt: string }
+}
+
+// A long-running, fire-and-forget job persisted across restarts so the app can
+// resume tracking it (see docs/2026-06-24_clone-to-server-spec.md "Resumable
+// jobs"). `eventId` is the resume key — the SpinupWP event we re-attach a poller
+// to on startup. `inputs` is the kind-specific payload needed to continue/retry
+// (e.g. { hostname } for a server create). Only in-flight jobs are persisted;
+// they're removed once terminal.
+export interface StoredJob {
+  id: string
+  kind: string
+  status: string
+  step?: string
+  failedStep?: string
+  error?: string
+  startedAt: number
+  eventId?: number
+  inputs?: unknown
+}
+
+// Stored connection (no `provider`/`env` discriminators — added on load).
+export interface StoredConnection {
+  id: string
+  label: string
+  creds: Record<string, string>
+}
+export type StoredProviders = Partial<Record<ConnProvider, StoredConnection[]>>
+
+// Read a connection's creds, migrating the pre-registry shape (credentials stored
+// as inline fields) to the `creds` bag. The migrated bag is rewritten to disk on
+// the next saveConfig (add/remove a connection).
+function migrateCreds(provider: ConnProvider, c: Record<string, unknown>): Record<string, string> {
+  if (c.creds && typeof c.creds === "object") return c.creds as Record<string, string>
+  if (provider === "aws") {
+    return {
+      accessKeyId: String(c.accessKeyId ?? ""),
+      secretAccessKey: String(c.secretAccessKey ?? ""),
+      region: String(c.region ?? ""),
+    }
+  }
+  if (provider === "cloudflare") return { token: String(c.token ?? "") }
+  if (provider === "godaddy") return { apiKey: String(c.apiKey ?? ""), apiSecret: String(c.apiSecret ?? "") }
+  return {}
+}
+
+export interface StoredConfig {
+  token?: string
+  baseUrl?: string
+  sshUser?: string
+  accountSlug?: string
+  terminalApp?: string
+  localRoots?: string[]
+  localSites?: Record<string, LocalLink>
+  localSync?: boolean
+  providers?: StoredProviders
+  serverProviders?: Record<string, ServerProviderRef>
+  jobs?: Record<string, StoredJob>
+  sudoUsers?: Record<string, { user: string; keychain?: boolean }>
+  preferredGrantKeys?: string[]
+  grantedKeys?: Record<string, string[]>
+  zoneAccessNotes?: Record<string, string>
+  vanityHealthKeys?: Record<string, string>
+  uptimeKuma?: UptimeKumaConn
+  kumaMonitors?: Record<string, KumaMonitorRef>
+  lastSeenVersion?: string
+}
+
+export function configDir(): string {
+  const xdg = process.env.XDG_CONFIG_HOME
+  return xdg ? join(xdg, "spinupwp-tui") : join(homedir(), ".config", "spinupwp-tui")
+}
+
+export function configPath(): string {
+  return join(configDir(), "config.json")
+}
+
+// Where Spinup's dedicated machine keypair (spinup-tui[.pub]) lives. Generated
+// lazily on first privileged use (see lib/ssh.ts ensureSpinupKey).
+export function keysDir(): string {
+  return join(configDir(), "keys")
+}
+
+function readStoredConfig(): StoredConfig {
+  try {
+    const path = configPath()
+    if (!existsSync(path)) return {}
+    return JSON.parse(readFileSync(path, "utf8")) as StoredConfig
+  } catch {
+    return {}
+  }
+}
+
+// Resolve the active config from env + stored file. Never throws.
+export function loadConfig(): AppConfig {
+  const stored = readStoredConfig()
+  const envToken = process.env.SPINUPWP_ACCESS_TOKEN?.trim()
+  const fileToken = stored.token?.trim()
+
+  const token = envToken || fileToken || ""
+  const tokenSource: AppConfig["tokenSource"] = envToken ? "env" : fileToken ? "file" : "none"
+
+  // Provider connections: stored ones first (per provider), with env-derived ones
+  // prepended as read-only "env" connections (consistent with the env token above).
+  const sp = stored.providers ?? {}
+  const providerConnections = {} as Record<ConnProvider, Connection[]>
+  for (const provider of ALL_PROVIDERS) {
+    providerConnections[provider] = (sp[provider] ?? []).map((c) => ({
+      id: c.id,
+      provider,
+      label: c.label,
+      creds: migrateCreds(provider, c as unknown as Record<string, unknown>),
+    }))
+  }
+  const cfEnv = process.env.CLOUDFLARE_API_TOKEN?.trim()
+  if (cfEnv) providerConnections.cloudflare.unshift({ id: "cloudflare-env", provider: "cloudflare", label: "env", creds: { token: cfEnv }, env: true })
+  const awsKey = process.env.AWS_ACCESS_KEY_ID?.trim()
+  const awsSecret = process.env.AWS_SECRET_ACCESS_KEY?.trim()
+  if (awsKey && awsSecret) {
+    providerConnections.aws.unshift({
+      id: "aws-env",
+      provider: "aws",
+      label: "env",
+      creds: { accessKeyId: awsKey, secretAccessKey: awsSecret, region: process.env.AWS_REGION?.trim() || "" },
+      env: true,
+    })
+  }
+  const gdKey = process.env.GODADDY_API_KEY?.trim()
+  const gdSecret = process.env.GODADDY_API_SECRET?.trim()
+  if (gdKey && gdSecret) {
+    providerConnections.godaddy.unshift({ id: "godaddy-env", provider: "godaddy", label: "env", creds: { apiKey: gdKey, apiSecret: gdSecret }, env: true })
+  }
+
+  return {
+    token,
+    baseUrl: (stored.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, ""),
+    tokenSource,
+    sshUser: process.env.SPINUPWP_SSH_USER?.trim() || stored.sshUser?.trim() || null,
+    accountSlug: process.env.SPINUPWP_ACCOUNT_SLUG?.trim() || stored.accountSlug?.trim() || null,
+    terminalApp: process.env.SPINUPWP_TERMINAL_APP?.trim() || stored.terminalApp?.trim() || null,
+    localSync: ((): boolean => {
+      // Env overrides the file when present; otherwise the stored flag (default off).
+      const env = process.env.SPINUPWP_LOCAL_SYNC?.trim()
+      if (env != null && env !== "") return /^(1|true|yes|on)$/i.test(env)
+      return stored.localSync === true
+    })(),
+    localRoots: stored.localRoots ?? [],
+    localSites: stored.localSites ?? {},
+    providerConnections,
+    serverProviders: stored.serverProviders ?? {},
+    jobs: stored.jobs ?? {},
+    sudoUsers: stored.sudoUsers ?? {},
+    preferredGrantKeys: stored.preferredGrantKeys ?? [],
+    grantedKeys: stored.grantedKeys ?? {},
+    zoneAccessNotes: stored.zoneAccessNotes ?? {},
+    vanityHealthKeys: stored.vanityHealthKeys ?? {},
+    uptimeKuma: ((): UptimeKumaConn | null => {
+      const url = process.env.SPINUP_KUMA_URL?.trim()
+      const username = process.env.SPINUP_KUMA_USERNAME?.trim()
+      const password = process.env.SPINUP_KUMA_PASSWORD?.trim()
+      if (url && username && password) return { url: url.replace(/\/+$/, ""), username, password, env: true }
+      return stored.uptimeKuma ?? null
+    })(),
+    kumaMonitors: stored.kumaMonitors ?? {},
+    lastSeenVersion: stored.lastSeenVersion?.trim() || null,
+  }
+}
+
+export function hasToken(): boolean {
+  return loadConfig().token.length > 0
+}
+
+// Persist a token (and optional base URL) to the config file. Used by onboarding.
+export async function saveConfig(partial: StoredConfig): Promise<void> {
+  const dir = configDir()
+  await mkdir(dir, { recursive: true })
+  const current = readStoredConfig()
+  const next: StoredConfig = { ...current, ...partial }
+  const path = configPath()
+  await Bun.write(path, JSON.stringify(next, null, 2) + "\n")
+  // The file holds an API token — restrict it to the owner.
+  try {
+    await chmod(path, 0o600)
+  } catch {
+    // Best-effort (e.g. on filesystems without POSIX perms).
+  }
+}

package/src/dev/devMode.ts

@@ -0,0 +1,7 @@
+// Dev Mode: run Spinup entirely against an in-memory fixture fleet instead of the
+// real SpinupWP API — no token, no network, nothing that can touch a live account.
+// For demos, screenshots, and UI work. See src/dev/fixtures.ts + mockClient.ts.
+
+export function isDevMode(): boolean {
+  return /^(1|true|yes|on)$/i.test(process.env.SPINUP_DEV_MODE?.trim() ?? "")
+}

package/src/dev/fixtures.ts

@@ -0,0 +1,238 @@
+// Example fleet for Dev Mode (SPINUP_DEV_MODE=1) — a small, deliberately varied set
+// of servers/sites/events so every view has something interesting to show: an EOL
+// Ubuntu server, EOL PHP versions, a Bedrock site, a non-WP app, an empty server, a
+// disabled-HTTPS site, and a mix of disk usage / update counts. All domains are
+// example.com/.org/.net — never a real client's.
+//
+// freshFixtures() returns a deep clone so MockSpinupWPClient can mutate its own copy
+// freely without leaking state across StoreProvider remounts.
+
+import type { Event, Server, Site } from "../api/types.ts"
+
+const GB = 1024 * 1024 * 1024
+
+const SERVERS: Server[] = [
+  {
+    id: 101,
+    name: "web1.example.com",
+    provider_name: "digitalocean",
+    ubuntu_version: "24.04",
+    ip_address: "203.0.113.11",
+    ssh_port: 22,
+    timezone: "UTC",
+    region: "nyc3",
+    size: "s-2vcpu-4gb",
+    disk_space: { total: 80 * GB, available: 61 * GB, used: 19 * GB, updated_at: "2026-07-01T08:00:00Z" },
+    database: null,
+    connection_status: "connected",
+    reboot_required: false,
+    upgrade_required: false,
+    created_at: "2024-11-02T10:15:00Z",
+    status: "active",
+  },
+  {
+    id: 102,
+    name: "web2.example.com",
+    provider_name: "vultr",
+    ubuntu_version: "22.04",
+    ip_address: "203.0.113.12",
+    ssh_port: 22,
+    timezone: "UTC",
+    region: "ewr",
+    size: "vc2-2c-4gb",
+    disk_space: { total: 60 * GB, available: 55 * GB, used: 5 * GB, updated_at: "2026-07-01T08:00:00Z" },
+    database: null,
+    connection_status: "connected",
+    reboot_required: true,
+    upgrade_required: false,
+    created_at: "2026-06-20T14:00:00Z",
+    status: "active",
+  },
+  {
+    id: 103,
+    name: "web3.example.org",
+    provider_name: "hetzner",
+    ubuntu_version: "20.04",
+    ip_address: "203.0.113.13",
+    ssh_port: 22,
+    timezone: "UTC",
+    region: "nbg1",
+    size: "cx31",
+    disk_space: { total: 40 * GB, available: 7 * GB, used: 33 * GB, updated_at: "2026-07-01T08:00:00Z" },
+    database: null,
+    connection_status: "connected",
+    reboot_required: false,
+    upgrade_required: true,
+    created_at: "2022-03-14T09:30:00Z",
+    status: "active",
+  },
+  {
+    id: 104,
+    name: "web9.example.org",
+    provider_name: "linode",
+    ubuntu_version: "24.04",
+    ip_address: "203.0.113.19",
+    ssh_port: 22,
+    timezone: "UTC",
+    region: "us-east",
+    size: "g6-standard-2",
+    disk_space: { total: 80 * GB, available: 68 * GB, used: 12 * GB, updated_at: "2026-07-01T08:00:00Z" },
+    database: null,
+    connection_status: "connected",
+    reboot_required: false,
+    upgrade_required: false,
+    created_at: "2025-01-08T16:45:00Z",
+    status: "active",
+  },
+]
+
+const SITES: Site[] = [
+  {
+    id: 1001,
+    server_id: 101,
+    domain: "example.com",
+    additional_domains: [{ id: 1, domain: "www.example.com", created_at: "2024-11-02T10:20:00Z" }],
+    site_user: "example",
+    php_version: "8.3",
+    public_folder: "/",
+    is_wordpress: true,
+    page_cache: { enabled: true },
+    https: { enabled: true },
+    database: { id: 1, user_id: 1, table_prefix: "wp_" },
+    backups: { files: true, database: true, retention_period: 14, next_run_time: "2026-07-03T03:00:00Z" },
+    wp_core_update: false,
+    wp_theme_updates: 1,
+    wp_plugin_updates: 3,
+    created_at: "2024-11-02T10:20:00Z",
+    status: "active",
+  },
+  {
+    id: 1002,
+    server_id: 101,
+    domain: "shop.example.com",
+    site_user: "shop",
+    php_version: "8.3",
+    public_folder: "/web/",
+    is_wordpress: true,
+    page_cache: { enabled: true },
+    https: { enabled: true },
+    database: { id: 2, user_id: 2, table_prefix: "wp_" },
+    backups: { files: true, database: true, retention_period: 14, next_run_time: "2026-07-03T03:00:00Z" },
+    git: {
+      repo: "git@github.com:example/shop-bedrock.git",
+      branch: "main",
+      deploy_script: "composer install -o --no-dev",
+      push_enabled: true,
+      deployment_url: null,
+    },
+    wp_core_update: false,
+    wp_theme_updates: 0,
+    wp_plugin_updates: 0,
+    created_at: "2025-02-18T13:00:00Z",
+    status: "active",
+  },
+  {
+    id: 1003,
+    server_id: 101,
+    domain: "blog.example.com",
+    site_user: "blog",
+    php_version: "8.1",
+    public_folder: "/",
+    is_wordpress: true,
+    page_cache: { enabled: false },
+    https: { enabled: true },
+    database: { id: 3, user_id: 3, table_prefix: "wp_" },
+    backups: { files: true, database: true, retention_period: 7, next_run_time: "2026-07-03T03:00:00Z" },
+    wp_core_update: true,
+    wp_theme_updates: 2,
+    wp_plugin_updates: 5,
+    created_at: "2023-08-05T11:00:00Z",
+    status: "active",
+  },
+  {
+    id: 1004,
+    server_id: 103,
+    domain: "app.example.org",
+    site_user: "app",
+    php_version: "8.2",
+    public_folder: "/public/",
+    is_wordpress: false,
+    https: { enabled: true },
+    created_at: "2022-04-01T09:00:00Z",
+    status: "active",
+  },
+  {
+    id: 1005,
+    server_id: 104,
+    domain: "web9.example.org",
+    site_user: "web9",
+    php_version: "8.3",
+    public_folder: "/",
+    is_wordpress: false,
+    https: { enabled: true },
+    created_at: "2025-01-08T17:00:00Z",
+    status: "active",
+  },
+  {
+    id: 1006,
+    server_id: 103,
+    domain: "docs.example.org",
+    site_user: "docs",
+    php_version: "7.4",
+    public_folder: "/",
+    is_wordpress: true,
+    page_cache: { enabled: false },
+    https: { enabled: false },
+    database: { id: 4, user_id: 4, table_prefix: "wp_" },
+    backups: { files: false, database: false },
+    wp_core_update: true,
+    wp_theme_updates: 0,
+    wp_plugin_updates: 8,
+    created_at: "2022-06-11T15:20:00Z",
+    status: "active",
+  },
+]
+
+const EVENTS: Event[] = [
+  {
+    id: 9001,
+    initiated_by: "dev-mode",
+    server_id: 101,
+    name: "site.php_version.updated",
+    status: "deployed",
+    output: "PHP updated to 8.3 for shop.example.com",
+    created_at: "2026-06-30T09:00:00Z",
+    started_at: "2026-06-30T09:00:05Z",
+    finished_at: "2026-06-30T09:00:42Z",
+  },
+  {
+    id: 9002,
+    initiated_by: "dev-mode",
+    server_id: 101,
+    name: "site.cache.purged",
+    status: "deployed",
+    output: "Page cache and object cache purged for example.com",
+    created_at: "2026-06-29T16:12:00Z",
+    started_at: "2026-06-29T16:12:01Z",
+    finished_at: "2026-06-29T16:12:09Z",
+  },
+  {
+    id: 9003,
+    initiated_by: "dev-mode",
+    server_id: 103,
+    name: "server.rebooted",
+    status: "deployed",
+    output: "Server rebooted successfully",
+    created_at: "2026-06-27T04:00:00Z",
+    started_at: "2026-06-27T04:00:02Z",
+    finished_at: "2026-06-27T04:01:15Z",
+  },
+]
+
+function clone<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T
+}
+
+export function freshFixtures(): { servers: Server[]; sites: Site[]; events: Event[] } {
+  return { servers: clone(SERVERS), sites: clone(SITES), events: clone(EVENTS) }
+}