spinuptui 0.28.0 → 1.1.0

package/src/ui/store.tsx

@@ -10,7 +10,7 @@ import { toast } from "./toast.ts"
 import { SpinupWPClient, ApiError, type ServerService, type SpinupWPClientLike } from "../api/client.ts"
 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 type { Server, Site, Event, ProviderMetadata, CreateServerPayload, CreateSitePayload, AdditionalDomain, UpdateSiteGitPayload } from "../api/types.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"
@@ -45,8 +45,9 @@ 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 { carrySiteSettings, type SettingsCarryResult } from "../lib/cloneSettings.ts"
 import { syncAdditionalDomains } from "../lib/cloneDomains.ts"
 import { parseRepo, deployKeysSettingsUrl, ghAvailable, ghDeployKeyPresent, ghAddDeployKey, generateDeployKeypair, type RepoHost } from "../lib/gitDeployKey.ts"
 import { keychainAvailable, setSudoPassword, getSudoPassword, deleteSudoPassword } from "../lib/keychain.ts"
@@ -268,6 +269,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
@@ -293,6 +297,17 @@ 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)
+  settingsCarried?: string[] // SpinupWP settings written to match the source (see carrySiteSettings)
+  settingsFailed?: { what: string; error: string }[] // …and the ones that didn't take
+  basicAuthMissing?: boolean // the source is password-protected; the clone can't be (password unreadable)
+  // The source had a deploy script but the dest still reads back none after we set
+  // it again (SpinupWP drops a script set on create). The verify pane offers it for
+  // copy with a link to the dest's Git settings.
+  deployScriptLost?: boolean
+  deployScriptRestored?: boolean // SpinupWP dropped the script and we set it again
+  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
@@ -387,6 +402,52 @@ const INTERRUPTED_LOCAL_SETUP_MSG = "Interrupted by a restart — the local copy
 const SERVER_DONE = new Set(["deployed", "completed", "provisioned", "finished", "success"])
 const SERVER_FAIL = new Set(["failed", "errored", "error"])
 
+// SpinupWP clears a deploy script sent with POST /sites a minute or two after the
+// create (seen at ~90s, 2026-09-24). A PUT made before that would be wiped along
+// with it, so the restore below waits until this long after the create.
+const DEPLOY_SCRIPT_WIPE_MS = 150_000
+
+// Put a cloned git site's deploy script and push-to-deploy back to the source's
+// values if the dest reads back different, then re-read so only what's still
+// wrong is reported. Best-effort: a failed write or read never fails the clone.
+async function restoreDestGit(
+  client: SpinupWPClientLike,
+  destSiteId: number,
+  site: Pick<CloneSiteState, "domain" | "deployScript" | "pushEnabled">,
+  createdAt: number | undefined,
+  logger: CloneLogger | null | undefined,
+  onWait: () => void,
+): Promise<{ deployScriptLost: boolean; deployScriptRestored: boolean; pushMismatch: boolean } | undefined> {
+  const wantScript = site.deployScript?.trim()
+  const diff = (dest: Site) => ({
+    script: !!wantScript && !dest.git?.deploy_script?.trim(),
+    push: site.pushEnabled != null && dest.git?.push_enabled !== site.pushEnabled,
+  })
+  try {
+    const wait = createdAt != null ? DEPLOY_SCRIPT_WIPE_MS - (Date.now() - createdAt) : 0
+    if (wait > 0) {
+      onWait()
+      await new Promise((r) => setTimeout(r, wait))
+    }
+    const before = diff(await client.getSite(destSiteId))
+    if (!before.script && !before.push) return { deployScriptLost: false, deployScriptRestored: false, pushMismatch: false }
+    const payload: UpdateSiteGitPayload = {
+      ...(before.script ? { deploy_script: wantScript } : {}),
+      ...(before.push ? { push_to_deploy: site.pushEnabled } : {}),
+    }
+    try {
+      await client.updateSiteGit(destSiteId, payload)
+      logger?.log({ event: "git-restore", domain: site.domain, fields: Object.keys(payload) })
+    } catch (err) {
+      logger?.log({ event: "git-restore", domain: site.domain, fields: Object.keys(payload), error: (err as Error).message })
+    }
+    const after = diff(await client.getSite(destSiteId))
+    return { deployScriptLost: after.script, deployScriptRestored: before.script && !after.script, pushMismatch: after.push }
+  } catch {
+    return undefined // unknown — say nothing rather than guess
+  }
+}
+
 export function isNewServerInFlight(j: NewServerJob | null | undefined): boolean {
   return j != null && j.status !== "done" && j.status !== "failed"
 }
@@ -3573,6 +3634,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,
@@ -3801,7 +3865,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 →
@@ -3818,6 +3882,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
         // DB password can't be recovered to re-stamp wp-config, so a leftover from a
         // prior run must be removed first (create will surface a clear conflict).
         let destSiteId = site.destSiteId
+        let createdAt: number | undefined // when THIS run created the dest (see the git restore below)
         if (destSiteId == null) {
           let ev
           try {
@@ -3831,14 +3896,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 it's
+                    // set again with PUT /git once the site is done (see below). 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.
@@ -3863,7 +3932,11 @@ 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.
+            if (site.pageCache != null) payload.page_cache = { enabled: site.pageCache }
             ev = await client.createSite(payload)
+            createdAt = Date.now()
             logger?.log({ event: "create-requested", domain: site.domain, eventId: ev?.event_id })
           } catch (err) {
             return fail("create", err instanceof ApiError ? err.message : (err as Error).message)
@@ -3928,7 +4001,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)
@@ -3937,8 +4010,28 @@ 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, sourceWpCron: cron.sourceWpCron, destWpCron: cron.destWpCron })
+        // SpinupWP settings the create can't carry: page cache details, the nginx
+        // security toggles, redirects, WP cron interval. Best-effort like the crontab.
+        let settings: SettingsCarryResult | undefined
+        if (destSiteId != null) {
+          set((s) => ({ ...s, step: "config", detail: "settings" }))
+          settings = await carrySiteSettings(client, site.sourceSiteId, destSiteId, { source: cron.sourceWpCron, dest: cron.destWpCron }, logger ? (e) => logger.log({ domain: site.domain, ...e }) : undefined)
+        }
+        // Did the dest keep the deploy script we sent on create? It usually doesn't
+        // (see the create payload), so re-read and, if it's gone, set it again with
+        // PUT /git — push-to-deploy too, should it read back different. Only what's
+        // still wrong after that is flagged for the user.
+        const git = site.gitRepo && destSiteId != null ? await restoreDestGit(client, destSiteId, site, createdAt, logger, () => set((s) => ({ ...s, step: "config", detail: "restoring deploy script", stageStartedAt: Date.now() }))) : undefined
+        const deployScriptLost = git?.deployScriptLost ?? false
+        const pushMismatch = git?.pushMismatch ?? false
+        const deployScriptRestored = git?.deployScriptRestored ?? false
+        logger?.log({ event: "site-done", domain: site.domain, sourceWebrootRel, destWebrootRel, deployScriptLost, deployScriptRestored, pushMismatch, settingsCarried: settings?.carried, settingsFailed: settings?.failed, basicAuthMissing: settings?.basicAuthMissing })
+        set((s) => ({ ...s, step: "done", detail: undefined, error: undefined, failedStep: undefined, sourceWebrootRel, destWebrootRel, cronAdded: cron.added, cronError: cron.ok ? undefined : cron.error, deployScriptLost, deployScriptRestored, pushMismatch, settingsCarried: settings?.carried, settingsFailed: settings?.failed, basicAuthMissing: settings?.basicAuthMissing }))
       } catch (err) {
         fail(site.step, (err as Error).message)
       }

package/src/ui/views/CloneWizard.tsx

@@ -16,8 +16,8 @@ import { Panel, Spinner } from "../components.tsx"
 import { StatusBar } from "../StatusBar.tsx"
 import { openUrl, copyToClipboard } from "../../lib/open.ts"
 import { consoleForHost } from "../../lib/providers.ts"
-import { serverWebUrl } from "../../lib/spinupweb.ts"
-import { useStore, cloneNeedsGitAccess, type CloneStep, type CloneSiteStep, type RepoKeyState } from "../store.tsx"
+import { serverWebUrl, siteGitUrl, siteWebUrl } from "../../lib/spinupweb.ts"
+import { useStore, cloneNeedsGitAccess, type CloneStep, type CloneSiteStep, type CloneSiteState, type RepoKeyState } from "../store.tsx"
 import type { VerifyCheck } from "../../lib/serverClone.ts"
 
 // Choosing an existing server as the dest is a first-class feature now (the `d` picker
@@ -36,6 +36,12 @@ const STEP_GITACCESS = { step: "gitaccess" as CloneStep, label: "Git access" }
 const STEP_CLONE = { step: "clone" as CloneStep, label: "Clone sites" }
 const STEP_CUTOVER = { step: "cutover" as CloneStep, label: "DNS cutover" }
 // The Git-access step only appears when a Bedrock site is selected (deploy-key onboarding).
+// A clone setting the user has to finish in SpinupWP: basic auth (its password
+// can't be read), or a setting whose carry-over failed.
+function needsSettingsHand(s: CloneSiteState): boolean {
+  return !!s.basicAuthMissing || !!s.settingsFailed?.length
+}
+
 function stepsFor(needsGit: boolean): { step: CloneStep; label: string }[] {
   return needsGit
     ? [STEP_PLAN, STEP_SERVER, STEP_TRUST, STEP_GITACCESS, STEP_CLONE, STEP_CUTOVER]
@@ -305,6 +311,16 @@ export function CloneWizard() {
           return cloneRetrySite(verifyOpen)
         }
         if (name === "v" && drilled?.step === "done") return verifyCloneSite(verifyOpen)
+        // g — the dest's Git settings need a hand (lost deploy script, push-to-deploy
+        // mismatch): open them, with the source's script on the clipboard when it's
+        // missing, so re-entering it is one paste.
+        if (name === "g" && (drilled?.deployScriptLost || drilled?.pushMismatch) && drilled.destSiteId != null) {
+          if (drilled.deployScriptLost && drilled.deployScript) copyToClipboard(drilled.deployScript)
+          return openUrl(siteGitUrl(drilled.destSiteId, accountSlug))
+        }
+        // w — a setting needs doing by hand (basic auth, or one that didn't carry):
+        // open the new site in SpinupWP.
+        if (name === "w" && drilled && needsSettingsHand(drilled) && drilled.destSiteId != null) return openUrl(siteWebUrl(drilled.destSiteId, accountSlug))
         return
       }
       const n = sel.length
@@ -726,7 +742,7 @@ export function CloneWizard() {
           {selected.map((s, i) => {
             const active = !["queued", "done", "error"].includes(s.step)
             const cur = i === idx
-            const vmark = s.verify ? (s.verify.ok ? " ✓verified" : " ✕mismatch") : s.verifying ? " verifying…" : ""
+            const vmark = (s.verify ? (s.verify.ok ? " ✓verified" : " ✕mismatch") : s.verifying ? " verifying…" : "") + (s.deployScriptLost || s.pushMismatch || s.cronError || needsSettingsHand(s) ? " · ⚠ see verify" : "")
             return (
               <box key={s.sourceSiteId} style={{ flexDirection: "row", height: 1, backgroundColor: cur ? theme.bgAlt : undefined }}>
                 {active ? <Spinner color={theme.brand} /> : <text content={s.step === "done" ? "✓" : s.step === "error" ? "✕" : "○"} fg={s.step === "done" ? theme.good : s.step === "error" ? theme.bad : theme.textFaint} style={{ flexShrink: 0 }} />}
@@ -793,7 +809,8 @@ export function CloneWizard() {
               {v.checks.map(row)}
               <box style={{ flexGrow: 1 }} />
               <text content={v.ok ? "✓ Clone matches the source." : "✕ Differences found — review the ✕ rows above."} fg={v.ok ? theme.good : theme.bad} wrapMode="none" />
-              <text content="v re-run · ← back to roster" fg={theme.textFaint} wrapMode="none" />
+              {cloneNotes(site)}
+              <text content={`v re-run${site.deployScriptLost ? " · g copy deploy script + open Git settings" : site.pushMismatch ? " · g open Git settings" : ""}${needsSettingsHand(site) ? " · w open in SpinupWP" : ""} · ← back to roster`} fg={theme.textFaint} wrapMode="none" />
             </>
           ) : (
             <text content="Press v to compare this clone against its source." fg={theme.textDim} wrapMode="none" />
@@ -803,6 +820,36 @@ export function CloneWizard() {
     )
   }
 
+  // What the clone did beyond files + DB, and anything left for the user to do.
+  function cloneNotes(site: CloneSiteState) {
+    const cron = site.cronError
+      ? { text: `✕ Crontab not carried over: ${site.cronError}`, fg: theme.bad }
+      : site.cronAdded?.length
+        ? { text: `✓ Crontab: carried ${site.cronAdded.length} line${site.cronAdded.length === 1 ? "" : "s"} you added on the source`, fg: theme.good }
+        : null
+    return (
+      <>
+        {cron ? <text content={cron.text} fg={cron.fg} wrapMode="none" /> : null}
+        {site.settingsCarried?.length ? <text content={`✓ Settings matched to the source: ${site.settingsCarried.join(" · ")}`} fg={theme.good} wrapMode="none" /> : null}
+        {site.settingsFailed?.map((f) => (
+          <text key={f.what} content={`✕ Couldn't match ${f.what}: ${f.error} — press w to set it in SpinupWP`} fg={theme.bad} wrapMode="none" />
+        ))}
+        {site.basicAuthMissing ? (
+          <text content="⚠ The source is password-protected (basic auth) and the clone isn't — SpinupWP won't reveal the password; press w to set it" fg={theme.warn} wrapMode="none" />
+        ) : null}
+        {site.pushMismatch ? (
+          <text content={`⚠ Push-to-deploy is ${site.pushEnabled ? "off" : "on"} here but ${site.pushEnabled ? "on" : "off"} on the source — switch it in the new site's Git settings (g)`} fg={theme.warn} wrapMode="none" />
+        ) : null}
+        {site.deployScriptRestored ? (
+          <text content="✓ Deploy script: SpinupWP dropped the one set on create, so it was set again from the source" fg={theme.good} wrapMode="none" />
+        ) : null}
+        {site.deployScriptLost ? (
+          <text content="⚠ SpinupWP didn't keep this site's deploy script, even when set again — press g to copy the source's and paste it into the new site's Git settings" fg={theme.warn} wrapMode="none" />
+        ) : null}
+      </>
+    )
+  }
+
   // Failure drill-down — the FULL error for one failed site (the roster truncates it),
   // plus where the complete stage-by-stage log lives on disk.
   function failurePane(siteId: number) {
@@ -856,7 +903,7 @@ export function CloneWizard() {
       if (verifyOpen != null) {
         const drilled = job!.sites.find((s) => s.sourceSiteId === verifyOpen)
         if (drilled?.step === "error") return [{ key: "r", label: "retry site" }, { key: "←", label: "back" }, { key: "esc", label: "close" }]
-        return [{ key: "v", label: "re-run" }, { key: "←", label: "back" }, { key: "esc", label: "close" }]
+        return [{ key: "v", label: "re-run" }, ...(drilled?.deployScriptLost || drilled?.pushMismatch ? [{ key: "g", label: "Git settings" }] : []), ...(drilled && needsSettingsHand(drilled) ? [{ key: "w", label: "SpinupWP" }] : []), { key: "←", label: "back" }, { key: "esc", label: "close" }]
       }
       const done = selected.filter((s) => s.step === "done").length
       const errored = selected.filter((s) => s.step === "error").length