spinuptui 1.3.0-alpha.1 → 1.3.0-alpha.2

package/src/modules/scheduler.ts

@@ -0,0 +1,146 @@
+// Scheduler's module declaration: the station's clock. Its status is the
+// one-question answer to "is the station alive?" — how long ago the dispatcher
+// last ticked.
+
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+import { tryLock } from "../lib/flock.ts"
+import { loadConfig } from "../config.ts"
+import { beaconFromConfig } from "../lib/beacon.ts"
+import { nextRunText, parseWhen } from "../lib/schedule.ts"
+import { listSources, loadJobs, loadState, readLastTick, type Source } from "../lib/schedulerJobs.ts"
+import { readClaim, stationName } from "../lib/schedulerGit.ts"
+import { moduleStateDir, moduleWorkDir, type ModuleCheck, type ModuleDefinition, type ModuleStatus } from "./contract.ts"
+
+// Three missed ticks.
+export const TICK_STALE_MS = 15 * 60_000
+const RECENT_FAILURE_MS = 24 * 60 * 60_000
+
+function claimText(s: Source): string {
+  const holder = readClaim(s)
+  if (s.queueOnly) return holder ? `run by ${holder}; released here, this machine only queues` : "released here; this machine only queues"
+  if (!holder) return "unclaimed: the next dispatcher tick here claims it"
+  return holder === stationName() ? "run by this station" : `run by ${holder}; this machine only queues`
+}
+
+function tickRunning(): boolean {
+  try {
+    const lock = tryLock(join(moduleStateDir("scheduler"), "tick.lock"))
+    if (!lock) return true
+    lock.release()
+  } catch {
+    // No lock support: assume nothing is running.
+  }
+  return false
+}
+
+function age(ms: number): string {
+  const m = Math.round(ms / 60_000)
+  if (m < 1) return "just now"
+  if (m < 120) return `${m} min ago`
+  const h = Math.round(m / 60)
+  return h < 48 ? `${h} h ago` : `${Math.round(h / 24)} days ago`
+}
+
+export const schedulerModule: ModuleDefinition = {
+  id: "scheduler",
+  name: "Scheduler",
+  summary: "Follow-ups that run themselves: the fix you shipped today gets checked tomorrow without you remembering.",
+  dependsOn: ["beacon"],
+  configKey: "scheduler",
+  stateDir: () => moduleStateDir("scheduler"),
+  workDir: () => moduleWorkDir("scheduler"),
+  jobs: [],
+  async status(): Promise<ModuleStatus> {
+    const cfg = loadConfig()
+    const d = cfg.scheduler?.dispatcher
+    const checks: ModuleCheck[] = []
+    const installed = !!d && existsSync(d.unitPath)
+    checks.push({
+      name: "dispatcher",
+      ok: installed,
+      detail: installed ? `${d!.label}, every 5 min` : d ? `unit file missing (${d.unitPath})` : "not installed",
+    })
+    const last = readLastTick()
+    const lastAge = last ? Date.now() - Date.parse(last.at) : null
+    const fresh = lastAge !== null && lastAge < TICK_STALE_MS
+    // A tick still holding its lock is alive: a long agent job can take 30
+    // minutes, and the station isn't dead while it runs.
+    const running = !fresh && tickRunning()
+    checks.push({
+      name: "last tick",
+      ok: !installed || fresh || running,
+      detail:
+        (last ? `${age(lastAge!)} (${last.via})${last.errors.length ? `, ${last.errors.length} problem${last.errors.length === 1 ? "" : "s"}: ${last.errors[0]}` : ""}` : "never") +
+        (running ? "; a tick is running now" : ""),
+    })
+    const now = new Date()
+    let active = 0
+    const failed: string[] = []
+    for (const s of listSources(cfg)) {
+      const exists = existsSync(s.path)
+      // The local folder appears on first use, so its absence is normal.
+      if (s.name !== "local" || exists) checks.push({ name: `source ${s.name}`, ok: exists, detail: exists ? `${s.path}${s.git ? ` (git, ${claimText(s)})` : ""}` : `${s.path} does not exist` })
+      if (!exists) continue
+      for (const j of loadJobs(s)) {
+        if (j.problems.length) {
+          failed.push(`${s.name}/${j.name} invalid`)
+          continue
+        }
+        const st = loadState(s, j.header.id!)
+        let next = "?"
+        try {
+          next = nextRunText(j.header, st, now)
+        } catch {
+          // validateJob already accepted it; leave "?".
+        }
+        if (next !== "expired" && next !== "done") active++
+        // A failure was paged when it happened; it stays news for a day, not
+        // until the job expires.
+        const recent = st.last_run ? now.getTime() - parseWhen(st.last_run).getTime() < RECENT_FAILURE_MS : st.last_status === "auth"
+        if (st.last_status && st.last_status !== "ok" && next !== "expired" && recent) failed.push(`${s.name}/${j.header.id} ${st.last_status}`)
+      }
+    }
+    checks.push({ name: "jobs", ok: failed.length === 0, detail: `${active} active${failed.length ? `; not ok in the last day: ${failed.slice(0, 3).join(", ")}` : ""}` })
+    const beacon = beaconFromConfig(cfg)
+    checks.push({ name: "digests", ok: beacon.channels.length > 0, detail: beacon.channels.length ? `via Beacon (${beacon.defaultChannel ?? "no default"})` : "Beacon isn't set up, so runs aren't reported" })
+
+    if (!installed && !d) {
+      return {
+        id: "scheduler",
+        state: "not_configured",
+        summary: "Dispatcher not installed",
+        checks,
+        remedy: "spinuptui scheduler install --plan",
+      }
+    }
+    const failing = checks.find((c) => !c.ok)
+    return {
+      id: "scheduler",
+      state: failing ? "degraded" : "ok",
+      summary: failing ? `${failing.name}: ${failing.detail}` : `ticking (${checks[1]!.detail.split(" (")[0]}), ${active} active job${active === 1 ? "" : "s"}`,
+      checks,
+      ...(failing ? { remedy: failing.name === "dispatcher" || failing.name === "last tick" ? "spinuptui scheduler install --apply" : "spinuptui scheduler list" } : {}),
+    }
+  },
+}
+
+// The next few follow-ups due, soonest first, for the Modules screen.
+export function upcomingRuns(limit = 5): { source: string; id: string; next: string }[] {
+  const now = new Date()
+  const out: { source: string; id: string; next: string }[] = []
+  for (const s of listSources(loadConfig())) {
+    if (!existsSync(s.path)) continue
+    for (const j of loadJobs(s)) {
+      if (j.problems.length) continue
+      try {
+        const next = nextRunText(j.header, loadState(s, j.header.id!), now)
+        if (next !== "expired" && next !== "done") out.push({ source: s.name, id: j.header.id!, next })
+      } catch {
+        // Skip a job whose schedule can't be read.
+      }
+    }
+  }
+  // Fixed times sort before "every N min", which has no single next time.
+  return out.sort((a, b) => (a.next.startsWith("every") ? 1 : 0) - (b.next.startsWith("every") ? 1 : 0) || a.next.localeCompare(b.next)).slice(0, limit)
+}

package/src/ui/App.tsx

@@ -43,6 +43,7 @@ import { KumaSite } from "./views/KumaSite.tsx"
 import { Accounts } from "./views/Accounts.tsx"
 import { Modules } from "./views/Modules.tsx"
 import { BeaconSetup } from "./views/BeaconSetup.tsx"
+import { SchedulerInstall } from "./views/SchedulerInstall.tsx"
 
 const MIN_SPLASH_MS = 1200
 
@@ -92,7 +93,8 @@ export function App() {
     store.connectZoneTarget !== null ||
     store.dnsRecordsTarget !== null ||
     store.kumaSite !== null ||
-    store.beaconSetupOpen
+    store.beaconSetupOpen ||
+    store.schedulerInstallOpen
   useEffect(() => {
     store.setOverlayOpen(overlayActive)
   }, [overlayActive, store])
@@ -210,6 +212,7 @@ export function App() {
 
     // Beacon's guided setup (Modules tab) owns the keyboard while open.
     if (store.beaconSetupOpen) return
+    if (store.schedulerInstallOpen) return
 
     // A (Shift+a): the Accounts overlay — the header advertises it from every tab.
     if (key.shift && key.name === "a") return setShowAccounts(true)
@@ -299,6 +302,7 @@ export function App() {
       {store.dnsRecordsTarget && <DnsRecords />}
       {store.kumaSite && <KumaSite />}
       {store.beaconSetupOpen && <BeaconSetup />}
+      {store.schedulerInstallOpen && <SchedulerInstall />}
       {showAccounts && <Accounts onClose={() => setShowAccounts(false)} />}
       <ToastStack />
     </box>

package/src/ui/main.tsx

@@ -0,0 +1,42 @@
+// The dashboard: boots the OpenTUI renderer and mounts either the first-run
+// onboarding wizard (no token yet) or the main app wrapped in the data store.
+// Loaded by src/index.tsx with a dynamic import, only once no headless command
+// has claimed the arguments.
+
+import { useCallback, useMemo, useState } from "react"
+import { createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+import { hasToken, pinActiveProfile, setActiveProfile } from "../config.ts"
+import { StoreProvider } from "./store.tsx"
+import { App } from "./App.tsx"
+import { AccountsContext, type AccountsApi } from "./accounts.tsx"
+import { resetWpCoreJobs } from "./wpCoreJobs.tsx"
+import { Onboarding } from "./Onboarding.tsx"
+import { isDevMode } from "../dev/devMode.ts"
+
+export async function startDashboard({ forceLogin }: { forceLogin: boolean }): Promise<void> {
+  function Root() {
+    const [configured, setConfigured] = useState(isDevMode() ? true : forceLogin ? false : hasToken())
+    // The store is keyed by account: switching remounts it (see ui/accounts.tsx).
+    const [account, setAccount] = useState(() => pinActiveProfile())
+    const switchAccount = useCallback(async (id: string) => {
+      await setActiveProfile(id)
+      resetWpCoreJobs()
+      setAccount(id)
+    }, [])
+    const accounts = useMemo<AccountsApi>(() => ({ switchAccount }), [switchAccount])
+    if (!configured) {
+      return <Onboarding onComplete={() => setConfigured(true)} />
+    }
+    return (
+      <AccountsContext.Provider value={accounts}>
+        <StoreProvider key={account}>
+          <App />
+        </StoreProvider>
+      </AccountsContext.Provider>
+    )
+  }
+
+  const renderer = await createCliRenderer()
+  createRoot(renderer).render(<Root />)
+}

package/src/ui/store.tsx

@@ -748,6 +748,9 @@ interface StoreValue extends DataState {
   // Beacon's guided setup overlay, opened from the Modules tab.
   beaconSetupOpen: boolean
   setBeaconSetupOpen: (v: boolean) => void
+  // Scheduler's install plan + confirm overlay, opened from the Modules tab.
+  schedulerInstallOpen: boolean
+  setSchedulerInstallOpen: (v: boolean) => void
   // Whether the "needs a local copy" (forgotten) report overlay is open, and an
   // optional stack filter (set from the selected Stacks group when opened).
   forgottenOpen: boolean
@@ -1118,6 +1121,7 @@ export function StoreProvider({ children }: { children: ReactNode }) {
   const [localRoots, setLocalRoots] = useState<string[]>(() => [...cfgRef.current.localRoots])
   const [discoverOpen, setDiscoverOpen] = useState(false)
   const [beaconSetupOpen, setBeaconSetupOpen] = useState(false)
+  const [schedulerInstallOpen, setSchedulerInstallOpen] = useState(false)
   const [forgottenOpen, setForgottenOpen] = useState(false)
   const [forgottenStack, setForgottenStack] = useState<Stack | null>(null)
   const [linkReturnToForgotten, setLinkReturnToForgotten] = useState(false)
@@ -4540,6 +4544,8 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     setDiscoverOpen,
     beaconSetupOpen,
     setBeaconSetupOpen,
+    schedulerInstallOpen,
+    setSchedulerInstallOpen,
     forgottenOpen,
     setForgottenOpen,
     forgottenStack,

package/src/ui/views/Modules.tsx

@@ -16,6 +16,7 @@ import { MODULES, UPCOMING_MODULES } from "../../modules/index.ts"
 import type { ModuleId, ModuleStatus } from "../../modules/contract.ts"
 import { beaconFromConfig, beaconSend, testMessage } from "../../lib/beacon.ts"
 import { loadConfig } from "../../config.ts"
+import { upcomingRuns } from "../../modules/scheduler.ts"
 
 interface Card {
   id: ModuleId
@@ -42,16 +43,16 @@ function stateLabel(card: Card, status: ModuleStatus | undefined): { dot: string
 
 export function Modules({ rows }: { rows: number }) {
   const store = useStore()
-  const { route, inputMode, overlayOpen, beaconSetupOpen, setBeaconSetupOpen } = store
+  const { route, inputMode, overlayOpen, beaconSetupOpen, setBeaconSetupOpen, schedulerInstallOpen, setSchedulerInstallOpen } = store
   const [selected, setSelected] = useState(0)
   const [statuses, setStatuses] = useState<Map<ModuleId, ModuleStatus>>(new Map())
   const [testing, setTesting] = useState(false)
 
-  // Recompute on open and whenever the setup overlay closes (it may have
-  // changed the config). status() is cheap and never sends anything.
+  // Recompute on open and whenever a setup overlay closes (it may have changed
+  // the config). status() is cheap and never sends anything.
   const [tick, setTick] = useState(0)
   useEffect(() => {
-    if (beaconSetupOpen) return
+    if (beaconSetupOpen || schedulerInstallOpen) return
     let live = true
     void Promise.all(MODULES.map((m) => m.status())).then((list) => {
       if (live) setStatuses(new Map(list.map((s) => [s.id, s])))
@@ -59,7 +60,7 @@ export function Modules({ rows }: { rows: number }) {
     return () => {
       live = false
     }
-  }, [beaconSetupOpen, tick])
+  }, [beaconSetupOpen, schedulerInstallOpen, tick])
 
   const isActive = route === "modules" && !inputMode && !overlayOpen
   const card = CARDS[selected]!
@@ -88,6 +89,7 @@ export function Modules({ rows }: { rows: number }) {
       case "return":
       case "s":
         if (card.id === "beacon") return setBeaconSetupOpen(true)
+        if (card.id === "scheduler") return setSchedulerInstallOpen(true)
         return
       case "t":
         if (card.id === "beacon" && status && status.state !== "not_configured") return sendTest()
@@ -140,6 +142,7 @@ export function Modules({ rows }: { rows: number }) {
         hints={[
           { key: "↑↓/jk", label: "select" },
           ...(card.id === "beacon" ? [{ key: "⏎", label: beaconReady ? "reconfigure" : "set up" }] : []),
+          ...(card.id === "scheduler" ? [{ key: "⏎", label: status && status.state !== "not_configured" ? "reinstall" : "install" }] : []),
           ...(beaconReady ? [{ key: "t", label: testing ? "sending…" : "test page" }] : []),
         ]}
       />
@@ -191,6 +194,39 @@ function ModuleDetail({ card, status }: { card: Card; status: ModuleStatus | und
       {card.id === "beacon" && status.state !== "not_configured" && (
         <text content="⏎ reconfigure the pager  ·  t send a test page  ·  CLI: spinuptui beacon status" fg={theme.textFaint} />
       )}
+      {card.id === "scheduler" && <SchedulerDetail installed={status.state !== "not_configured"} />}
     </box>
   )
 }
+
+function SchedulerDetail({ installed }: { installed: boolean }) {
+  const [runs] = useState(() => upcomingRuns())
+  return (
+    <>
+      <box style={{ height: 1 }} />
+      {!installed && (
+        <>
+          <text
+            content="Scheduler runs follow-ups on this machine while you're away: queue a check for tomorrow at 8 and the result arrives on your pager. It's also the clock the other modules run on, so turning it on is what makes this machine a station."
+            fg={theme.textDim}
+          />
+          <box style={{ height: 1 }} />
+          <text content="Press ⏎ to see exactly what it installs, then confirm." fg={theme.accent} />
+          <box style={{ height: 1 }} />
+        </>
+      )}
+      <text content={runs.length ? "Next up:" : "No follow-ups queued."} fg={theme.textDim} />
+      {runs.map((r) => (
+        <box key={`${r.source}/${r.id}`} style={{ flexDirection: "row" }}>
+          <text content={`  ${r.next.padEnd(17)} `} fg={theme.text} wrapMode="none" style={{ flexShrink: 0 }} />
+          <text content={`${r.source}/${r.id}`} fg={theme.textDim} wrapMode="none" style={{ flexShrink: 1 }} />
+        </box>
+      ))}
+      <box style={{ height: 1 }} />
+      <text
+        content={`${installed ? "⏎ reinstall (repairs the unit)  ·  " : ""}CLI: spinuptui scheduler add | list | status`}
+        fg={theme.textFaint}
+      />
+    </>
+  )
+}

package/src/ui/views/SchedulerInstall.tsx

@@ -0,0 +1,172 @@
+// Scheduler's install overlay (Modules tab, ⏎ on Scheduler): shows exactly what
+// `spinuptui scheduler install --plan` would write and run, and applies it on
+// `y` — the confirm-before-firing pattern. Applying ends with the proving tick
+// (a tick that really ran under launchd), so "done" here means the station's
+// clock is running, not just that a file was written.
+
+import { useEffect, useState } from "react"
+import { useKeyboard } from "@opentui/react"
+import { theme } from "../../lib/theme.ts"
+import { truncate } from "../../lib/format.ts"
+import { Panel, Spinner, Centered } from "../components.tsx"
+import { StatusBar } from "../StatusBar.tsx"
+import { useStore } from "../store.tsx"
+import { applyInstall, binHasScheduler, NO_SCHEDULER, planInstall, type ApplyResult, type PlanResult } from "../../lib/schedulerInstall.ts"
+
+type Phase = "confirm" | "applying" | "done" | "error"
+
+export function SchedulerInstall() {
+  const { setSchedulerInstallOpen } = useStore()
+  const [plan, setPlan] = useState<PlanResult>(() => planInstall())
+  // Same refusal as `install --plan`: don't offer a plan whose binary has no
+  // Scheduler (it would launch the dashboard under launchd).
+  useEffect(() => {
+    if (!plan.ok) return
+    void binHasScheduler(plan).then((has) => {
+      if (!has) {
+        setPlan(NO_SCHEDULER)
+        setPhase("error")
+      }
+    })
+    // Checked once, for the plan computed on open.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [])
+  const [phase, setPhase] = useState<Phase>(plan.ok ? "confirm" : "error")
+  const [stage, setStage] = useState("")
+  const [result, setResult] = useState<ApplyResult | null>(null)
+  const [live, setLive] = useState(true)
+  useEffect(() => () => setLive(false), [])
+
+  const close = () => setSchedulerInstallOpen(false)
+
+  const apply = () => {
+    if (!plan.ok) return
+    setPhase("applying")
+    void applyInstall(plan, (s) => live && setStage(s)).then((r) => {
+      setResult(r)
+      setPhase(r.ok ? "done" : "error")
+    })
+  }
+
+  useKeyboard((key) => {
+    const name = key.name ?? ""
+    if (name === "escape" || name === "q") return close()
+    if (phase === "confirm" && name === "y" && plan.ok && plan.platform === "darwin") return apply()
+    if (phase === "error" && name === "r" && plan.ok) return setPhase("confirm")
+  })
+
+  return (
+    <box
+      style={{
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: "100%",
+        flexDirection: "column",
+        backgroundColor: theme.bg,
+        zIndex: 210,
+      }}
+    >
+      <box style={{ flexDirection: "row", height: 1, backgroundColor: theme.bgAlt, paddingLeft: 1, paddingRight: 1, alignItems: "center" }}>
+        <text content="⏱ Scheduler  " fg={theme.brand} style={{ flexShrink: 0 }} />
+        <text content="install the station's clock" fg={theme.text} wrapMode="none" style={{ flexShrink: 1 }} />
+      </box>
+      <Centered>{body()}</Centered>
+      <StatusBar hints={hints()} showGlobal={false} />
+    </box>
+  )
+
+  function body() {
+    if (phase === "applying") {
+      return (
+        <box style={{ flexDirection: "column", alignItems: "center" }}>
+          <box style={{ flexDirection: "row" }}>
+            <Spinner />
+            <text content={`  ${stage || "Installing…"}`} fg={theme.textDim} wrapMode="none" />
+          </box>
+          <box style={{ height: 1 }} />
+          <text content="Install finishes with a real tick from launchd (up to a minute)." fg={theme.textFaint} wrapMode="none" />
+        </box>
+      )
+    }
+    if (phase === "done" && result?.ok) {
+      return (
+        <Panel title=" Installed " active>
+          <box style={{ flexDirection: "column", width: 70, paddingTop: 1, paddingBottom: 1 }}>
+            <text content={`✓ ${result.label} is ticking: its first run under launchd was at ${new Date(result.tickAt).toLocaleTimeString()}.`} fg={theme.good} />
+            <box style={{ height: 1 }} />
+            <text content="Queue a follow-up from any session:" fg={theme.textDim} />
+            <text content={'  spinuptui scheduler add <id> --kind spinuptui --when "YYYY-MM-DD 08:00" \\'} fg={theme.accent} wrapMode="none" />
+            <text content={'      --expires YYYY-MM-DD --created-by "…" -- incidents example.com'} fg={theme.accent} wrapMode="none" />
+            <box style={{ height: 1 }} />
+            {result.notes.map((n) => (
+              <text key={n} content={`Note: ${n}`} fg={theme.textFaint} />
+            ))}
+            <text content="Esc to close" fg={theme.textFaint} />
+          </box>
+        </Panel>
+      )
+    }
+    if (phase === "error" || !plan.ok) {
+      const r = !plan.ok ? plan : result && !result.ok ? result : null
+      return (
+        <Panel title=" Can't install " active>
+          <box style={{ flexDirection: "column", width: 72, paddingTop: 1, paddingBottom: 1 }}>
+            <text content={`✕ ${r?.message ?? "Something went wrong."}`} fg={theme.bad} />
+            {r?.remedy && (
+              <>
+                <box style={{ height: 1 }} />
+                <text content={r.remedy} fg={theme.textDim} />
+              </>
+            )}
+            <box style={{ height: 1 }} />
+            <text content={plan.ok ? "Press r to see the plan again · Esc to close" : "Esc to close"} fg={theme.textFaint} />
+          </box>
+        </Panel>
+      )
+    }
+    const darwin = plan.platform === "darwin"
+    return (
+      <Panel title=" Install Scheduler's dispatcher " active>
+        <box style={{ flexDirection: "column", width: 76, paddingTop: 1, paddingBottom: 1 }}>
+          <text content="Runs at login and every 5 minutes, unattended:" fg={theme.text} />
+          <text content={`  ${truncate(plan.programArguments.join(" "), 72)}`} fg={theme.accent} wrapMode="none" />
+          <box style={{ height: 1 }} />
+          <text content={`Unit: ${truncate(plan.unitPath, 68)}`} fg={theme.textDim} wrapMode="none" />
+          <text content={`PATH: ${truncate(plan.env.PATH ?? "", 68)}`} fg={theme.textDim} wrapMode="none" />
+          <box style={{ height: 1 }} />
+          {plan.commands.map((c) => (
+            <text key={c} content={`· ${truncate(c, 72)}`} fg={theme.textDim} wrapMode="none" />
+          ))}
+          <box style={{ height: 1 }} />
+          {plan.notes.map((n) => (
+            <text key={n} content={`Note: ${n}`} fg={theme.textFaint} />
+          ))}
+          <box style={{ height: 1 }} />
+          <text
+            content={darwin ? "Press y to install · Esc to cancel" : "Installing on Linux isn't supported yet · Esc to close"}
+            fg={darwin ? theme.text : theme.warn}
+            wrapMode="none"
+          />
+        </box>
+      </Panel>
+    )
+  }
+
+  function hints() {
+    if (phase === "confirm" && plan.ok && plan.platform === "darwin") {
+      return [
+        { key: "y", label: "install" },
+        { key: "esc", label: "cancel" },
+      ]
+    }
+    if (phase === "error" && plan.ok) {
+      return [
+        { key: "r", label: "back to plan" },
+        { key: "esc", label: "close" },
+      ]
+    }
+    return [{ key: "esc", label: "close" }]
+  }
+}