spinuptui 0.27.0 → 1.0.0

package/src/lib/wpCore.ts

@@ -17,7 +17,7 @@
 import type { Server, Site } from "../api/types.ts"
 import { SSH_OPTS, sshPort } from "./dbBackup.ts"
 import { detectWpDirScript } from "./serverClone.ts"
-import { wpCliResolveScript } from "./wpCli.ts"
+import { extractJsonArray, wpCliResolveScript } from "./wpCli.ts"
 import { spawn } from "./spawn.ts"
 
 export interface WpCoreOffer {
@@ -177,24 +177,13 @@ export async function checkWpCore(server: Server, site: Site, sshUser: string |
   const current = lastVersionLine(s.VERSION)
   if (!current) return { ok: false, target: p.target, error: "wp-cli couldn't read the WordPress version on this site." }
 
-  // Belt and braces with --skip-plugins: scan back for the line that parses as
-  // the JSON array, ignoring any other noise (a mu-plugin's notices still load).
+  // Belt and braces with --skip-plugins: a mu-plugin's notices still load, so
+  // pull the JSON array out of any surrounding noise.
   // No match = "Success: WordPress is at the latest version." (plain text).
-  let offers: WpCoreOffer[] = []
-  for (const line of [...(s.UPDATES ?? [])].reverse()) {
-    if (!line.trim().startsWith("[")) continue
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(line.trim())
-    } catch {
-      continue
-    }
-    if (!Array.isArray(parsed)) continue
-    offers = parsed
-      .filter((o) => o && typeof o.version === "string")
-      .map((o) => ({ version: o.version as string, updateType: typeof o.update_type === "string" ? o.update_type : "" }))
-    break
-  }
+  const parsed = extractJsonArray(s.UPDATES) ?? []
+  const offers: WpCoreOffer[] = parsed
+    .filter((o): o is { version: string; update_type?: unknown } => !!o && typeof (o as { version?: unknown }).version === "string")
+    .map((o) => ({ version: o.version, updateType: typeof o.update_type === "string" ? o.update_type : "" }))
 
   const comp = (s.COMPOSER ?? []).join("\n").trim()
   const locked = comp.match(/^locked (.+)$/m)

package/src/lib/wpInventory.ts

@@ -11,7 +11,7 @@
 import type { Server, Site } from "../api/types.ts"
 import { SSH_OPTS, sshPort } from "./dbBackup.ts"
 import { detectWpDirScript } from "./serverClone.ts"
-import { wpCliResolveScript } from "./wpCli.ts"
+import { extractJsonArray, wpCliResolveScript } from "./wpCli.ts"
 import { spawn } from "./spawn.ts"
 
 // One plugin or theme, mirroring `wp {plugin,theme} list` columns.
@@ -68,17 +68,11 @@ function splitSections(out: string): Record<string, string[]> {
   return sections
 }
 
-// wp --format=json emits a single-line JSON array; tolerate blank/garbage by
-// returning [] rather than throwing (a fresh site can legitimately have 0 themes).
-function parseJsonArray(lines: string[] | undefined): RawItem[] {
-  const text = (lines ?? []).join("").trim()
-  if (!text) return []
-  try {
-    const parsed = JSON.parse(text)
-    return Array.isArray(parsed) ? parsed : []
-  } catch {
-    return []
-  }
+// First non-blank line of a section — the likeliest culprit when wp-cli's JSON is
+// missing (a PHP fatal or notice printed in its place).
+function firstNoise(lines: string[] | undefined): string {
+  const line = (lines ?? []).map((l) => l.trim()).find(Boolean) ?? ""
+  return line.length > 160 ? `${line.slice(0, 159)}…` : line
 }
 
 export async function fetchWpInventory(
@@ -147,8 +141,18 @@ export async function fetchWpInventory(
     return { ok: false, target, error: `No WordPress core found under ${root} — is this a WordPress site?` }
   }
   const wpDir = (s.WPDIR?.[0] || root).trim()
-  const plugins = normalize(parseJsonArray(s.PLUGINS))
-  const themes = normalize(parseJsonArray(s.THEMES))
+  // A plugin's PHP notices can print to stdout alongside the JSON (see
+  // extractJsonArray). No JSON at all means wp-cli failed; say so instead of
+  // showing an empty list that reads as "no plugins installed".
+  const rawPlugins = extractJsonArray(s.PLUGINS)
+  const rawThemes = extractJsonArray(s.THEMES)
+  if (!rawPlugins || !rawThemes) {
+    const which = !rawPlugins ? "plugin" : "theme"
+    const noise = firstNoise(!rawPlugins ? s.PLUGINS : s.THEMES)
+    return { ok: false, target, error: `wp-cli didn't return the ${which} list${noise ? `: ${noise}` : "."}` }
+  }
+  const plugins = normalize(rawPlugins as RawItem[])
+  const themes = normalize(rawThemes as RawItem[])
   return { ok: true, target, wpDir, inventory: { plugins, themes } }
 }
 

package/src/ui/App.tsx

@@ -39,6 +39,7 @@ import { WpInventory } from "./views/WpInventory.tsx"
 import { ProviderConnect } from "./views/ProviderConnect.tsx"
 import { DnsRecords } from "./views/DnsRecords.tsx"
 import { KumaSite } from "./views/KumaSite.tsx"
+import { Accounts } from "./views/Accounts.tsx"
 
 const MIN_SPLASH_MS = 1200
 
@@ -49,6 +50,7 @@ export function App() {
   const [splashDone, setSplashDone] = useState(false)
   const [showHelp, setShowHelp] = useState(false)
   const [showExplain, setShowExplain] = useState(false)
+  const [showAccounts, setShowAccounts] = useState(false)
 
   // Enforce a minimum splash duration so the intro is visible even on fast loads.
   useEffect(() => {
@@ -60,6 +62,7 @@ export function App() {
   const overlayActive =
     showHelp ||
     showExplain ||
+    showAccounts ||
     store.releaseNotesInfo !== null ||
     store.healthServer !== null ||
     store.wpInventorySite !== null ||
@@ -119,6 +122,9 @@ export function App() {
     // While a text field is focused, let it consume everything else.
     if (store.inputMode) return
 
+    // The Accounts overlay owns the keyboard while open.
+    if (showAccounts) return
+
     // The release-notes overlay owns the keyboard while open (any key dismisses).
     if (store.releaseNotesInfo) return
 
@@ -194,6 +200,9 @@ export function App() {
     // The site-monitoring (Uptime Kuma) overlay owns the keyboard while open.
     if (store.kumaSite) return
 
+    // A (Shift+a): the Accounts overlay — the header advertises it from every tab.
+    if (key.shift && key.name === "a") return setShowAccounts(true)
+
     switch (key.name) {
       case "q":
         return quit()
@@ -274,6 +283,7 @@ export function App() {
       {store.connectZoneTarget && <ProviderConnect />}
       {store.dnsRecordsTarget && <DnsRecords />}
       {store.kumaSite && <KumaSite />}
+      {showAccounts && <Accounts onClose={() => setShowAccounts(false)} />}
       <ToastStack />
     </box>
   )

package/src/ui/Header.tsx

@@ -6,6 +6,8 @@ import { timeAgo, truncate } from "../lib/format.ts"
 import { Spinner } from "./components.tsx"
 import { APP_NAME, APP_VERSION } from "../version.ts"
 import { isDevMode } from "../dev/devMode.ts"
+import { RL_LOW_WATER, onRateLimitChange, rateLimitSnapshot, type RateLimitSnapshot } from "../api/client.ts"
+import { useEffect, useState } from "react"
 
 const TABS: { route: Route; key: string; label: string }[] = [
   { route: "dashboard", key: "1", label: "Dashboard" },
@@ -26,8 +28,31 @@ const SUBTITLES: Record<Route, string> = {
   events: "Recent deploys, reboots, and operations across your account",
 }
 
+// SpinupWP allows 60 API requests a minute. Show what's left of this minute so
+// the wall is visible before it's hit: dim while there's plenty, amber past
+// three-quarters spent, red once the client has started pacing requests (the
+// point where the app slows down on purpose). Hidden until a response has
+// reported the limit (and in Dev Mode, which never calls the API).
+function ApiHeadroom() {
+  const [rl, setRl] = useState<RateLimitSnapshot | null>(rateLimitSnapshot)
+  useEffect(() => {
+    const refresh = () => setRl(rateLimitSnapshot())
+    const off = onRateLimitChange(refresh)
+    // The window rolls over with no request to announce it; re-read so a spent
+    // budget doesn't sit on screen after it has refilled.
+    const tick = setInterval(refresh, 5_000)
+    return () => {
+      off()
+      clearInterval(tick)
+    }
+  }, [])
+  if (!rl) return null
+  const color = rl.remaining <= RL_LOW_WATER ? theme.bad : rl.remaining <= rl.limit / 4 ? theme.warn : theme.textFaint
+  return <text content={`API ${rl.remaining}/${rl.limit}  `} fg={color} style={{ flexShrink: 0 }} wrapMode="none" />
+}
+
 export function Header() {
-  const { route, servers, sites, loading, lastUpdated, updateInfo, newServerJob, vanityJob, cloneJob, cloneServer, kumaStatus } = useStore()
+  const { route, servers, sites, loading, lastUpdated, updateInfo, newServerJob, vanityJob, cloneJob, cloneServer, kumaStatus, profileLabel } = useStore()
   // Name the domain(s) when there are few enough to fit the header row; fall
   // back to a bare count once there are too many to list safely. Deliberately
   // still just the plain up/down signal (kumaStatus.up) — not expanding what
@@ -114,11 +139,16 @@ export function Header() {
         )}
         {loading && <Spinner interval={100} />}
         <text content={`  ${servers.length} servers · ${sites.length} sites  `} fg={theme.textDim} style={{ flexShrink: 0 }} />
+        <ApiHeadroom />
         <text content={lastUpdated ? `updated ${timeAgo(lastUpdated.toISOString())}` : "loading…"} fg={theme.textFaint} style={{ flexShrink: 0 }} />
       </box>
       <box style={{ flexDirection: "row", height: 1, paddingLeft: 1, paddingRight: 1, alignItems: "center" }}>
         <text content="💡 " fg={theme.accent} style={{ flexShrink: 0 }} />
         <text content={SUBTITLES[route]} fg={theme.textDim} wrapMode="none" style={{ flexGrow: 1, flexShrink: 1 }} />
+        {/* Always visible, so it's never a guess which client's fleet this is. */}
+        <text content="  Account: " fg={theme.textFaint} style={{ flexShrink: 0 }} />
+        <text content={truncate(profileLabel, 32)} fg={theme.text} wrapMode="none" style={{ flexShrink: 0 }} />
+        <text content="  A switch" fg={theme.textFaint} style={{ flexShrink: 0 }} />
       </box>
     </box>
   )

package/src/ui/Help.tsx

@@ -8,7 +8,7 @@ import { theme } from "../lib/theme.ts"
 import { APP_NAME, APP_VERSION, REPO_URL } from "../version.ts"
 import { Sparkle, Spinner } from "./components.tsx"
 import { useStore } from "./store.tsx"
-import { runSelfUpdate, installChannel, PACKAGE_UPDATE_CMD, type UpdateInfo, type SelfUpdateResult } from "../lib/appUpdate.ts"
+import { runSelfUpdate, installChannel, updateCommand, type UpdateInfo, type SelfUpdateResult } from "../lib/appUpdate.ts"
 
 type Section = { title: string; keys: [string, string][] }
 
@@ -18,6 +18,7 @@ const GLOBAL: Section = {
     ["1 … 5", "Switch tabs"],
     ["r", "Refresh from the API"],
     ["/", "Global search"],
+    ["A", "Switch SpinupWP accounts"],
     ["i", "Explain the current screen"],
     ["?", "This help"],
     ["q · Ctrl+C", "Quit · force quit"],
@@ -190,10 +191,10 @@ function AboutColumn({
       {selfUpdate !== "idle" && selfUpdate !== "running" ? (
         <text content={selfUpdate.message} fg={selfUpdate.ok ? theme.good : theme.bad} />
       ) : null}
-      {installChannel() === "package" ? (
+      {installChannel() !== "git" ? (
         <>
           {line("Manual:")}
-          {line(PACKAGE_UPDATE_CMD, theme.text)}
+          {line(updateCommand() ?? "", theme.text)}
         </>
       ) : (
         <>

package/src/ui/accounts.tsx

@@ -0,0 +1,21 @@
+// Account switching lives ABOVE the store: switching remounts <StoreProvider>
+// keyed by the account, which is what guarantees a clean slate — every effect,
+// poller and interval of the outgoing account is torn down by React, and every
+// id-keyed cache (servers, sites, probes, jobs…) starts empty for the new one.
+// See config.ts "Accounts" for how the profiles are stored.
+
+import { createContext, useContext } from "react"
+
+export interface AccountsApi {
+  // Make `id` the active account and remount the app on it. The caller checks
+  // the store's switchBlocker() first — nothing here waits for running work.
+  switchAccount: (id: string) => Promise<void>
+}
+
+export const AccountsContext = createContext<AccountsApi | null>(null)
+
+export function useAccounts(): AccountsApi {
+  const ctx = useContext(AccountsContext)
+  if (!ctx) throw new Error("useAccounts must be used within <AccountsContext.Provider>")
+  return ctx
+}

package/src/ui/store.tsx

@@ -11,7 +11,7 @@ import { SpinupWPClient, ApiError, type ServerService, type SpinupWPClientLike }
 import { isDevMode } from "../dev/devMode.ts"
 import { createMockClient } from "../dev/mockClient.ts"
 import type { Server, Site, Event, ProviderMetadata, CreateServerPayload, CreateSitePayload, AdditionalDomain } from "../api/types.ts"
-import { loadConfig, saveConfig, type ServerProviderRef, type KumaMonitorRef, type UptimeKumaConn } from "../config.ts"
+import { loadConfig, saveConfig, type StoredConfig, type ServerProviderRef, type KumaMonitorRef, type UptimeKumaConn } from "../config.ts"
 import { saveJob, removeJob } from "../lib/jobs.ts"
 import { APP_VERSION } from "../version.ts"
 import { cachedUpdateInfo, refreshUpdateInfo, type UpdateInfo } from "../lib/appUpdate.ts"
@@ -45,7 +45,7 @@ import { withKuma, KumaClient, registerMonitors, registerFingerprintMonitor, reg
 import { deriveFingerprint } from "../lib/siteFingerprint.ts"
 import type { StoredProviders } from "../config.ts"
 import { fetchRebootInfo, grantSiteSshKey, revokeSiteSshKey, verifySudo, ensureSpinupKey, listPersonalKeys, keyBody, type RebootInfo } from "../lib/ssh.ts"
-import { estimateSourceSiteSizes, runStandardWpPull, runBedrockPull, runFilesOnlyPull, verifyClone, verifyFilesClone, preflightBedrockSource, type SudoCtx, type CloneStage, type CloneExecRecord, type VerifyResult as CloneVerifyResult } from "../lib/serverClone.ts"
+import { estimateSourceSiteSizes, runStandardWpPull, runBedrockPull, runFilesOnlyPull, verifyClone, verifyFilesClone, preflightBedrockSource, syncCrontab, type SudoCtx, type CloneStage, type CloneExecRecord, type VerifyResult as CloneVerifyResult } from "../lib/serverClone.ts"
 import { CloneLogger } from "../lib/cloneLog.ts"
 import { syncAdditionalDomains } from "../lib/cloneDomains.ts"
 import { parseRepo, deployKeysSettingsUrl, ghAvailable, ghDeployKeyPresent, ghAddDeployKey, generateDeployKeypair, type RepoHost } from "../lib/gitDeployKey.ts"
@@ -53,9 +53,10 @@ import { keychainAvailable, setSudoPassword, getSudoPassword, deleteSudoPassword
 import { StackCache, siteSignature, type CachedProbe } from "../lib/stackCache.ts"
 import { resolvePhpEolDates, refreshPhpEolDates, isPhpEol as isPhpEolWith, offeredPhpVersions as offeredPhpVersionsWith, type PhpEolDates } from "../lib/phpEol.ts"
 import { resolveUbuntuEolDates, refreshUbuntuEolDates, isUbuntuEol as isUbuntuEolWith, type UbuntuEolDates } from "../lib/ubuntuEol.ts"
-import { planDbBackup, runDbBackup, type DbBackupProgress, type PlanResult } from "../lib/dbBackup.ts"
-import { planDbSync, runDbSync, type DbSyncProgress, type SyncPlanResult } from "../lib/dbSync.ts"
-import { planLocalSetup, runLocalSetup, type LocalSetupProgress, type LocalSetupPlanResult } from "../lib/localSetup.ts"
+import { wpCoreBusy } from "./wpCoreJobs.tsx"
+import { planDbBackup, runDbBackup, isDbBackupInFlight, type DbBackupProgress, type PlanResult } from "../lib/dbBackup.ts"
+import { planDbSync, runDbSync, isDbSyncInFlight, type DbSyncProgress, type SyncPlanResult } from "../lib/dbSync.ts"
+import { planLocalSetup, runLocalSetup, isLocalSetupInFlight, type LocalSetupProgress, type LocalSetupPlanResult } from "../lib/localSetup.ts"
 import { planMediaFallback, type MediaFallbackResult } from "../lib/mediaFallback.ts"
 
 export type Route = "dashboard" | "servers" | "stacks" | "search" | "events"
@@ -267,6 +268,9 @@ export interface CloneSiteState {
   stack: "wp" | "bedrock" | "files" // git repo → bedrock; is_wordpress → wp; else files-only (redirect shells, static/PHP sites)
   gitRepo?: string // source git.repo (Bedrock) — the dest is created as a `git` site of it
   gitBranch?: string // source git.branch
+  deployScript?: string // source git deploy script — the dest's own, and Radicle's build step
+  pushEnabled?: boolean // source push-to-deploy on/off — the dest is created to match
+  pageCache?: boolean // source page cache on/off — the dest is created to match
   gitDeployKey?: { privateKey: string; publicKey: string } // unique per-site key (stamped leaving gitaccess) → create payload
   additionalDomains?: string[] // extra domains served by the site → extra cutover records
   additionalDomainConfigs?: AdditionalDomain[] // full source configs (redirects) — re-created on the dest
@@ -292,6 +296,13 @@ export interface CloneSiteState {
   verify?: CloneVerifyResult // source-vs-clone comparison + HTTP check
   verifyError?: string
   cutover?: CloneCutoverState // slice 6: DNS repoint state for this site's domain
+  cronAdded?: string[] // owner crontab lines carried to the dest (empty = none to carry)
+  cronError?: string // crontab carry-over failed (the clone itself still succeeded)
+  // The source had a deploy script but the dest reads back none — SpinupWP drops a
+  // script set on create, and there's no API to set it after. The verify pane
+  // offers it for copy with a link to the dest's Git settings.
+  deployScriptLost?: boolean
+  pushMismatch?: boolean // the dest's push-to-deploy reads back different from the source's
 }
 // Slice 6: per-site DNS cutover. Each A record among the site's domains (primary +
 // additional_domains) is repointed from the old server IP to the new one. www-style
@@ -754,6 +765,18 @@ interface StoreValue extends DataState {
   enableLocalSync: () => void
   // SpinupWP account slug (from env/config) for building web deep links.
   accountSlug: string | null
+  // The account (profile) this store is mounted for — see config.ts "Accounts".
+  // Switching remounts the whole store, so these never change under a view.
+  profileId: string
+  profileLabel: string
+  setProfileLabel: (label: string) => void // after a rename in the Accounts overlay
+  // The token came from SPINUPWP_ACCESS_TOKEN, which pins the account: switching
+  // would change nothing until it's unset.
+  tokenFromEnv: boolean
+  // What's still running that an account switch would orphan, in words — or
+  // null when it's safe to switch. Only work that writes (to SpinupWP, a server,
+  // DNS, or a local database) counts; reads and probes are simply dropped.
+  switchBlocker: () => string | null
   sitesForServer: (serverId: number) => Site[]
   serverById: (id: number | null | undefined) => Server | undefined
   // Tier-2 stack probes (on-demand SSH), hydrated from disk at startup.
@@ -895,6 +918,9 @@ export function useStore(): StoreValue {
 
 export function StoreProvider({ children }: { children: ReactNode }) {
   const cfgRef = useRef(loadConfig())
+  // Every config write from this store targets the account it was mounted for —
+  // a late write from an async flow can't land in an account switched to since.
+  const saveProfileConfig = (partial: StoredConfig) => saveConfig(partial, cfgRef.current.profileId)
   const clientRef = useRef<SpinupWPClientLike | null>(null)
   if (!clientRef.current) {
     clientRef.current = isDevMode() ? createMockClient() : new SpinupWPClient(cfgRef.current)
@@ -927,7 +953,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
       // Fresh install, or upgrading from a pre-this-feature version — nothing
       // meaningful to announce. Seed silently so future bumps trigger correctly.
       cfgRef.current.lastSeenVersion = APP_VERSION
-      void saveConfig({ lastSeenVersion: APP_VERSION })
+      void saveProfileConfig({ lastSeenVersion: APP_VERSION })
       return
     }
     void fetchReleaseNotes(APP_VERSION).then((notes) => {
@@ -939,7 +965,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
   const dismissReleaseNotes = useCallback(() => {
     setReleaseNotesInfo(null)
     cfgRef.current.lastSeenVersion = APP_VERSION
-    void saveConfig({ lastSeenVersion: APP_VERSION })
+    void saveProfileConfig({ lastSeenVersion: APP_VERSION })
   }, [])
   // On-demand replay (Help overlay's `n`) — bypasses the "seen" gate entirely,
   // since viewing the current version's notes again is always valid regardless
@@ -951,6 +977,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
       if (notes) setReleaseNotesInfo(notes)
     })
   }, [])
+  const [profileLabel, setProfileLabel] = useState(cfgRef.current.profileLabel)
   const [route, setRoute] = useState<Route>("dashboard")
   const [inputMode, setInputMode] = useState(false)
   const [overlayOpen, setOverlayOpen] = useState(false)
@@ -1640,7 +1667,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     const next = { ...prev, [providerKey]: { ...(prev[providerKey] ?? {}), id } }
     cfgRef.current.serverProviders = next
     setServerProviders(next)
-    void saveConfig({ serverProviders: next })
+    void saveProfileConfig({ serverProviders: next })
   }, [])
 
   // Poll a server-create event to completion, mirroring its status into the job
@@ -1734,7 +1761,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     const record: Record<string, LocalLink> = {}
     for (const [id, link] of next) record[String(id)] = link
     cfgRef.current.localSites = record
-    void saveConfig({ localSites: record })
+    void saveProfileConfig({ localSites: record })
   }, [])
 
   const linkSite = useCallback(
@@ -1766,14 +1793,14 @@ export function StoreProvider({ children }: { children: ReactNode }) {
       if (prev.includes(trimmed)) return prev
       const next = [...prev, trimmed]
       cfgRef.current.localRoots = next
-      void saveConfig({ localRoots: next })
+      void saveProfileConfig({ localRoots: next })
       return next
     })
   }, [])
 
   const enableLocalSync = useCallback(() => {
     cfgRef.current.localSync = true
-    void saveConfig({ localSync: true })
+    void saveProfileConfig({ localSync: true })
     setLocalSyncState(true)
   }, [])
 
@@ -1823,7 +1850,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     const record: Record<string, { user: string; keychain?: boolean }> = {}
     for (const [id, u] of users) record[String(id)] = saved.has(id) ? { user: u, keychain: true } : { user: u }
     cfgRef.current.sudoUsers = record
-    void saveConfig({ sudoUsers: record })
+    void saveProfileConfig({ sudoUsers: record })
   }, [])
   const isSudoConnected = useCallback((serverId: number) => sudoConnected.has(serverId), [sudoConnected])
   const sudoSavedFor = useCallback((serverId: number) => sudoSaved.has(serverId), [sudoSaved])
@@ -1920,7 +1947,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
   const setPreferredGrantKeys = useCallback((ids: string[]) => {
     cfgRef.current.preferredGrantKeys = ids
     setPreferredGrantKeysState(ids)
-    void saveConfig({ preferredGrantKeys: ids })
+    void saveProfileConfig({ preferredGrantKeys: ids })
   }, [])
 
   // Persist the granted-keys map (only non-empty entries) to config, write-through.
@@ -1928,7 +1955,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     const rec: Record<string, string[]> = {}
     for (const [id, set] of next) if (set.size) rec[String(id)] = [...set]
     cfgRef.current.grantedKeys = rec
-    void saveConfig({ grantedKeys: rec })
+    void saveProfileConfig({ grantedKeys: rec })
   }, [])
 
   // Record / forget which keys (by body) Spinup has granted on a site.
@@ -1970,7 +1997,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
       else next.delete(apex)
       const rec = Object.fromEntries(next)
       cfgRef.current.zoneAccessNotes = rec
-      void saveConfig({ zoneAccessNotes: rec })
+      void saveProfileConfig({ zoneAccessNotes: rec })
       return next
     })
   }, [])
@@ -2447,7 +2474,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     for (const p of ALL_PROVIDERS) {
       providers[p] = next[p].filter((c) => !c.env).map((c) => ({ id: c.id, label: c.label, creds: c.creds }))
     }
-    void saveConfig({ providers })
+    void saveProfileConfig({ providers })
   }, [])
 
   // Verify a connection and write the result through to the cache.
@@ -2682,7 +2709,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     if (keys[domain] !== key) {
       keys[domain] = key
       cfgRef.current.vanityHealthKeys = keys
-      void saveConfig({ vanityHealthKeys: keys })
+      void saveProfileConfig({ vanityHealthKeys: keys })
     }
     return key
   }, [])
@@ -2696,7 +2723,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     const newKey = crypto.randomUUID().replace(/-/g, "")
     keys[domain] = newKey
     cfgRef.current.vanityHealthKeys = keys
-    void saveConfig({ vanityHealthKeys: keys })
+    void saveProfileConfig({ vanityHealthKeys: keys })
     return { oldKey, newKey }
   }, [])
 
@@ -2705,13 +2732,13 @@ export function StoreProvider({ children }: { children: ReactNode }) {
   const persistKumaAuth = useCallback((conn: UptimeKumaConn, jwt: string) => {
     if (conn.env || jwt === conn.jwt) return
     cfgRef.current.uptimeKuma = { ...conn, jwt }
-    void saveConfig({ uptimeKuma: { ...conn, jwt } })
+    void saveProfileConfig({ uptimeKuma: { ...conn, jwt } })
   }, [])
 
   const persistKumaMonitors = useCallback((domain: string, ref: KumaMonitorRef) => {
     const map = { ...cfgRef.current.kumaMonitors, [domain]: ref }
     cfgRef.current.kumaMonitors = map
-    void saveConfig({ kumaMonitors: map })
+    void saveProfileConfig({ kumaMonitors: map })
   }, [])
 
   // The step machine. Each step performs its work then hands off to the next; it
@@ -3127,7 +3154,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
           if (!login.ok) return { ok: false, error: login.error, tokenRequired: login.tokenRequired }
           const stored = { url, username: conn.username, password: conn.password, jwt: login.jwt }
           cfgRef.current.uptimeKuma = stored
-          void saveConfig({ uptimeKuma: stored })
+          void saveProfileConfig({ uptimeKuma: stored })
           setKumaEpoch((e) => e + 1) // start the status poll loop now
           await kuma.waitForVersion() // `info` can land after the login ack
           return { ok: true, version: kuma.version }
@@ -3556,6 +3583,9 @@ export function StoreProvider({ children }: { children: ReactNode }) {
           stack,
           gitRepo: s.git?.repo ?? undefined,
           gitBranch: s.git?.branch ?? undefined,
+          deployScript: s.git?.deploy_script ?? undefined,
+          pushEnabled: s.git?.push_enabled ?? undefined,
+          pageCache: s.page_cache?.enabled ?? undefined,
           additionalDomains: (s.additional_domains ?? []).map((d) => d.domain),
           additionalDomainConfigs: s.additional_domains ?? [],
           excludeUploads: false,
@@ -3784,7 +3814,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
         // site-creation + auth cycle on a clone that can't succeed. Not a guarantee
         // (see preflightBedrockSource) — the real check is still the one after create.
         if (site.stack === "bedrock") {
-          const pre = await preflightBedrockSource(source, { domain: site.domain, publicFolder: site.publicFolder })
+          const pre = await preflightBedrockSource(source, { domain: site.domain, publicFolder: site.publicFolder, deployScript: site.deployScript }, dest)
           if (!pre.ok) return fail("create", pre.error)
         }
         // create — Bedrock → `git` site (SpinupWP clones the repo); Standard WP →
@@ -3814,14 +3844,18 @@ export function StoreProvider({ children }: { children: ReactNode }) {
                     php_version: site.phpVersion,
                     public_folder: site.publicFolder ?? "/web/",
                     database: { name: dbName, username: dbName, password: dbPw, table_prefix: site.tablePrefix || "wp_" },
-                    // deploy_script is TOP-LEVEL; we send the corrected canonical (the
-                    // source's stored value has a known typo) for future push-to-deploy —
-                    // we composer install over SSH regardless (git/deploy won't run it).
-                    deploy_script: "composer install -o --no-dev",
+                    // deploy_script is TOP-LEVEL; we send the source's own (canonical
+                    // only as the fallback). CAVEAT, verified 2026-09-24: SpinupWP stores
+                    // it, echoes it back, then clears it a minute or two later — so the
+                    // dest's script has to be re-entered in the dashboard. Nothing here
+                    // depends on it: the pull runs composer (and a Radicle source's own
+                    // script) over SSH.
+                    deploy_script: site.deployScript?.trim() || "composer install -o --no-dev",
                     git: {
                       repo: site.gitRepo!,
                       branch: site.gitBranch ?? "main",
-                      push_to_deploy: true,
+                      // Match the source (on when unknown, the long-standing default).
+                      push_to_deploy: site.pushEnabled ?? true,
                       // unique per-site key (gitaccess step) — the server-wide
                       // git_publickey fits only ONE GitHub repo, so it can't be
                       // reused; SpinupWP installs this pair as the site's git identity.
@@ -3846,6 +3880,10 @@ export function StoreProvider({ children }: { children: ReactNode }) {
                       public_folder: site.publicFolder,
                       database: { name: dbName, username: dbName, password: dbPw, table_prefix: site.tablePrefix || "wp_" },
                     }
+            // Match the source's page cache — a deploy script that purges it
+            // (`wp spinupwp cache purge-site`) fails on a site where it's off, and
+            // it can't be switched on through the API after the create.
+            if (site.pageCache != null) payload.page_cache = { enabled: site.pageCache }
             ev = await client.createSite(payload)
             logger?.log({ event: "create-requested", domain: site.domain, eventId: ev?.event_id })
           } catch (err) {
@@ -3911,7 +3949,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
         const onExec = logger ? (e: CloneExecRecord) => logger.log({ event: "exec", ...e }) : undefined
         const res =
           site.stack === "bedrock"
-            ? await runBedrockPull(source, dest, { domain: site.domain, sourceSiteUser: site.siteUser, destSiteUser: site.siteUser, destDbName: dbName, destDbUser: dbName, destDbPassword: dbPw, excludeUploads: site.excludeUploads, publicFolder: site.publicFolder }, onProgress, onExec, onTransfer)
+            ? await runBedrockPull(source, dest, { domain: site.domain, sourceSiteUser: site.siteUser, destSiteUser: site.siteUser, destDbName: dbName, destDbUser: dbName, destDbPassword: dbPw, excludeUploads: site.excludeUploads, publicFolder: site.publicFolder, deployScript: site.deployScript }, onProgress, onExec, onTransfer)
             : site.stack === "files"
               ? await runFilesOnlyPull(source, dest, { domain: site.domain, sourceSiteUser: site.siteUser, destSiteUser: site.siteUser, approxFilesBytes: site.sizeWebBytes }, onProgress, onExec, onTransfer)
               : await runStandardWpPull(source, dest, { domain: site.domain, sourceSiteUser: site.siteUser, destSiteUser: site.siteUser, destDbName: dbName, destDbUser: dbName, destDbPassword: dbPw, publicFolder: site.publicFolder, approxFilesBytes: site.sizeWebBytes }, onProgress, onExec, onTransfer)
@@ -3920,8 +3958,29 @@ export function StoreProvider({ children }: { children: ReactNode }) {
           return fail(stageToStep(stage), res.error ?? "pull failed")
         }
         const { sourceWebrootRel, destWebrootRel } = res as { sourceWebrootRel?: string; destWebrootRel?: string }
-        logger?.log({ event: "site-done", domain: site.domain, sourceWebrootRel, destWebrootRel })
-        set((s) => ({ ...s, step: "done", detail: undefined, error: undefined, failedStep: undefined, sourceWebrootRel, destWebrootRel }))
+        // Owner-added cron jobs (see syncCrontab). Best-effort: a failure is
+        // reported on the site, never fails a clone whose files and DB are in place.
+        set((s) => ({ ...s, detail: "crontab" }))
+        const cron = await syncCrontab(source, dest, { domain: site.domain, sourceSiteUser: site.siteUser, destSiteUser: site.siteUser }, onExec)
+        logger?.log({ event: "crontab", domain: site.domain, ok: cron.ok, added: cron.added, error: cron.error })
+        // Did the dest keep the deploy script we sent on create? (It usually
+        // doesn't — see the create payload.) Re-read rather than assume, so this
+        // goes quiet on its own if SpinupWP fixes it.
+        // Same re-read for push-to-deploy (which does stick, as of 2026-09-24 —
+        // checked anyway, since the create is the only chance to set it).
+        let deployScriptLost = false
+        let pushMismatch = false
+        if (site.gitRepo && destSiteId != null) {
+          try {
+            const destSite = await client.getSite(destSiteId)
+            deployScriptLost = !!site.deployScript?.trim() && !destSite.git?.deploy_script?.trim()
+            pushMismatch = site.pushEnabled != null && destSite.git?.push_enabled !== site.pushEnabled
+          } catch {
+            /* unknown — say nothing rather than guess */
+          }
+        }
+        logger?.log({ event: "site-done", domain: site.domain, sourceWebrootRel, destWebrootRel, deployScriptLost, pushMismatch })
+        set((s) => ({ ...s, step: "done", detail: undefined, error: undefined, failedStep: undefined, sourceWebrootRel, destWebrootRel, cronAdded: cron.added, cronError: cron.ok ? undefined : cron.error, deployScriptLost, pushMismatch }))
       } catch (err) {
         fail(site.step, (err as Error).message)
       }
@@ -4245,6 +4304,29 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     }
   }, [trackServerEvent, trackPhpUpgradeEvent, trackHttpsToggleEvent, driveVanity])
 
+  const switchBlocker = (): string | null => {
+    const count = <T,>(m: Map<unknown, T>, busy: (p: T) => boolean) => [...m.values()].filter(busy).length
+    const running: [number, string][] = [
+      [count(phpUpgrades, isUpgradeInFlight), "PHP upgrade"],
+      [count(httpsToggles, isHttpsToggleInFlight), "HTTPS change"],
+      [count(purgeCacheProgress, isPurgeCacheInFlight), "cache purge"],
+      [count(serverOps, isServerOpInFlight), "server reboot/restart"],
+      [count(keyGrants, isKeyGrantInFlight), "SSH key grant"],
+      [count(dbBackups, isDbBackupInFlight), "database backup"],
+      [count(dbSyncs, isDbSyncInFlight), "database sync"],
+      [count(localSetups, isLocalSetupInFlight), "local copy setup"],
+      [count(recordWrites, isRecordWriteInFlight), "DNS change"],
+      [count(kumaOps, (o) => o.status === "running"), "monitoring change"],
+      [isNewServerInFlight(newServerJob) ? 1 : 0, "server build"],
+      [isVanityInFlight(vanityJob) ? 1 : 0, "vanity-site build"],
+      // A clone still being planned hasn't touched anything yet — only a launched one counts.
+      [isCloneInFlight(cloneJob) && cloneJob!.step !== "plan" && cloneJob!.step !== "server" ? 1 : 0, "server clone"],
+      [wpCoreBusy() ? 1 : 0, "WordPress update"],
+    ]
+    const busy = running.filter(([n]) => n > 0).map(([n, what]) => (n > 1 ? `${n} ${what}s` : `a ${what}`))
+    return busy.length ? `Still running: ${busy.join(", ")}. Switch accounts once ${busy.length > 1 ? "they finish" : "it finishes"}.` : null
+  }
+
   const value: StoreValue = {
     servers,
     sites,
@@ -4437,6 +4519,11 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     setEnableLocalSyncSite,
     enableLocalSync,
     accountSlug: cfgRef.current.accountSlug,
+    profileId: cfgRef.current.profileId,
+    profileLabel,
+    setProfileLabel,
+    tokenFromEnv: cfgRef.current.tokenSource === "env",
+    switchBlocker,
     sitesForServer,
     serverById,
     probes,