spinuptui 1.2.0-alpha.1 → 1.2.1

package/src/lib/beaconSetup.ts

@@ -1,143 +0,0 @@
-// Guided Beacon setup, shared by `spinuptui beacon setup` and the Modules
-// screen: check a bot token, find the chat to page by waiting for the user to
-// message the bot, send a test, save.
-//
-// Creating the bot itself can't be automated — Telegram only issues bots through
-// a chat with @BotFather — so that step is instructions. Finding the chat id is
-// the part people get stuck on, and it can be: once the user messages the bot,
-// Telegram's getUpdates hands us the chat. Stale updates (anything already
-// waiting when setup starts) are skipped so an old conversation can't be picked
-// by mistake. Reading updates acknowledges them on Telegram's side; Beacon never
-// uses updates for anything else, so nothing is lost.
-
-import { loadConfig, saveConfig, type BeaconStored, type BeaconTelegramChannel } from "../config.ts"
-import { beaconSend, telegramCall, telegramGetMe, type Fetch, type TelegramIdentity } from "./beacon.ts"
-
-export const BOTFATHER_URL = "https://t.me/BotFather"
-export const BOTFATHER_STEPS = [
-  "Open @BotFather in Telegram (t.me/BotFather) and send /newbot.",
-  "Pick a display name, then a username ending in “bot”.",
-  "BotFather replies with a token like 123456789:AAE… — copy it.",
-]
-
-// A loose shape check so a mis-paste fails fast with a clear message instead of
-// a round trip to Telegram.
-export function looksLikeBotToken(token: string): boolean {
-  return /^\d{5,}:[A-Za-z0-9_-]{30,}$/.test(token.trim())
-}
-
-export async function verifyBotToken(token: string, fetchImpl?: Fetch): Promise<TelegramIdentity> {
-  if (!looksLikeBotToken(token)) return { ok: false, error: "That doesn't look like a bot token (expected digits, a colon, then a long code)." }
-  return telegramGetMe(token.trim(), fetchImpl)
-}
-
-export function botLink(username: string): string {
-  return `https://t.me/${username}`
-}
-
-export interface FoundChat {
-  chatId: string
-  kind: "private" | "group" | "supergroup" | "channel"
-  label: string // "Jane Doe (@jane)" / "Ops alerts"
-}
-
-export type DiscoverResult = { ok: true; chat: FoundChat } | { ok: false; reason: "timeout" | "cancelled" | "conflict" | "error"; message: string }
-
-interface TgChat {
-  id: number
-  type: FoundChat["kind"]
-  title?: string
-  first_name?: string
-  last_name?: string
-  username?: string
-}
-interface TgUpdate {
-  update_id: number
-  message?: { chat: TgChat }
-  channel_post?: { chat: TgChat }
-  my_chat_member?: { chat: TgChat }
-}
-
-function describeChat(c: TgChat): FoundChat {
-  const name = c.title || [c.first_name, c.last_name].filter(Boolean).join(" ") || String(c.id)
-  return { chatId: String(c.id), kind: c.type, label: c.username ? `${name} (@${c.username})` : name }
-}
-
-function conflictMessage(error: string | undefined): string {
-  return /webhook/i.test(error ?? "")
-    ? "This bot has a webhook set, so Telegram won't hand its messages to Beacon. Use a bot made just for alerts, or remove the webhook."
-    : "Something else is reading this bot's messages right now. Stop it, or use a bot made just for alerts."
-}
-
-// Wait for the next message to the bot (or the bot being added to a group or
-// channel) and return that chat. Long-polls in 25-second rounds until
-// `timeoutMs` or the signal aborts.
-export async function discoverChat(
-  token: string,
-  opts: { timeoutMs?: number; signal?: AbortSignal; fetchImpl?: Fetch } = {},
-): Promise<DiscoverResult> {
-  const deadline = Date.now() + (opts.timeoutMs ?? 5 * 60_000)
-  const call = (params: Record<string, string>, timeoutMs: number) =>
-    telegramCall(token, "getUpdates", params, opts.fetchImpl, { timeoutMs, signal: opts.signal })
-
-  // Skip whatever is already queued: only a message sent from now on counts.
-  const first = await call({ timeout: "0" }, 15_000)
-  if (!first.ok) {
-    if (first.error === "cancelled") return { ok: false, reason: "cancelled", message: "Cancelled." }
-    if (first.status === 409) return { ok: false, reason: "conflict", message: conflictMessage(first.error) }
-    return { ok: false, reason: "error", message: `Couldn't read the bot's messages: ${first.error}` }
-  }
-  const stale = (first.result as TgUpdate[] | undefined) ?? []
-  let offset = stale.length ? Math.max(...stale.map((u) => u.update_id)) + 1 : 0
-
-  while (Date.now() < deadline) {
-    const wait = Math.max(1, Math.min(25, Math.floor((deadline - Date.now()) / 1000)))
-    const r = await call({ offset: String(offset), timeout: String(wait), allowed_updates: JSON.stringify(["message", "channel_post", "my_chat_member"]) }, (wait + 10) * 1000)
-    if (!r.ok) {
-      if (r.error === "cancelled") return { ok: false, reason: "cancelled", message: "Cancelled." }
-      if (r.status === 409) return { ok: false, reason: "conflict", message: conflictMessage(r.error) }
-      // A dropped long-poll is routine; pause and keep listening.
-      await new Promise((res) => setTimeout(res, 2000))
-      continue
-    }
-    for (const u of (r.result as TgUpdate[] | undefined) ?? []) {
-      offset = Math.max(offset, u.update_id + 1)
-      const chat = u.message?.chat ?? u.channel_post?.chat ?? u.my_chat_member?.chat
-      if (chat) {
-        // Acknowledge it so a re-run doesn't see the same message as stale-but-new.
-        await call({ offset: String(offset), timeout: "0" }, 15_000)
-        return { ok: true, chat: describeChat(chat) }
-      }
-    }
-  }
-  return { ok: false, reason: "timeout", message: "No message reached the bot in time." }
-}
-
-export function channelExists(name: string): boolean {
-  return Boolean(loadConfig().beacon?.channels?.[name])
-}
-
-// The name a guided setup configures: the stored default if there is one (so
-// re-running setup repairs the pager rather than adding a second one), else "pager".
-export function setupChannelName(): string {
-  const stored = loadConfig().beacon
-  const def = stored?.defaultChannel
-  return def && stored?.channels?.[def] ? def : "pager"
-}
-
-export async function saveBeaconChannel(name: string, channel: BeaconTelegramChannel, makeDefault: boolean): Promise<{ isDefault: boolean }> {
-  const stored: BeaconStored = loadConfig().beacon ?? {}
-  const channels = { ...(stored.channels ?? {}), [name]: channel }
-  const isDefault = makeDefault || !stored.defaultChannel || stored.defaultChannel === name
-  await saveConfig({ beacon: { ...stored, channels, ...(isDefault ? { defaultChannel: name } : {}) } })
-  return { isDefault }
-}
-
-// Send the "connected" message on a channel that isn't saved yet. Credentials
-// that can't deliver are never stored, so callers save only after this succeeds.
-export async function sendConnectedMessage(name: string, channel: BeaconTelegramChannel, fetchImpl?: Fetch) {
-  return beaconSend({ channels: [{ name, channel, env: false }], defaultChannel: name }, `Beacon connected: channel "${name}" will page this chat.`, {
-    log: false,
-    fetchImpl,
-  })
-}

package/src/lib/cliBeacon.ts

@@ -1,290 +0,0 @@
-// `spinuptui beacon …` and `spinuptui modules` — the CLI over lib/beacon.ts and
-// the module registry.
-//
-// Exit codes for `beacon send` are a contract callers branch on: 0 delivered;
-// 1 usage error or not configured (nothing was attempted, so a caller may fall
-// back to its own sender); 2 delivery failed after retries (Beacon tried — a
-// caller must not resend through another path, or a partial multi-part send
-// would be duplicated).
-
-import { readFileSync } from "node:fs"
-import { loadConfig, saveConfig, type BeaconStored } from "../config.ts"
-import { beaconFromConfig, beaconSend, maskChatId, maskToken, parseEnvFile, pickChannel, telegramGetMe, testMessage } from "./beacon.ts"
-import {
-  BOTFATHER_STEPS,
-  botLink,
-  channelExists,
-  discoverChat,
-  saveBeaconChannel,
-  sendConnectedMessage,
-  setupChannelName,
-  verifyBotToken,
-} from "./beaconSetup.ts"
-import { confirm, PromptCancelled, readLine } from "./prompt.ts"
-import { beaconModule } from "../modules/beacon.ts"
-import { allModuleStatuses, UPCOMING_MODULES } from "../modules/index.ts"
-import type { ModuleStatus } from "../modules/contract.ts"
-
-const VALUE_FLAGS = new Set(["--to", "--env-file"])
-
-function parse(list: string[]): { positionals: string[]; flags: Map<string, string>; rest: string | null } {
-  const dash = list.indexOf("--")
-  const head = dash === -1 ? list : list.slice(0, dash)
-  const positionals: string[] = []
-  const flags = new Map<string, string>()
-  for (let i = 0; i < head.length; i++) {
-    const a = head[i]!
-    if (a.startsWith("-") && a !== "-") {
-      if (VALUE_FLAGS.has(a)) {
-        flags.set(a, head[i + 1] ?? "")
-        i++
-      } else flags.set(a, "")
-      continue
-    }
-    positionals.push(a)
-  }
-  return { positionals, flags, rest: dash === -1 ? null : list.slice(dash + 1).join(" ") }
-}
-
-function fail(json: boolean, reason: string, message: string, remedy?: string): number {
-  if (json) console.log(JSON.stringify({ ok: false, reason, message, ...(remedy ? { remedy } : {}) }))
-  else {
-    console.error(message)
-    if (remedy) console.error(remedy)
-  }
-  return 1
-}
-
-const USAGE = `Usage:
-  spinuptui beacon setup [<name>]   (guided, in a terminal)
-  spinuptui beacon send [--to <channel>] [--silent] [--json] [<message> | -]
-  spinuptui beacon add telegram <name> [--env-file <path>] [--default] [--no-test]
-  spinuptui beacon remove <name>
-  spinuptui beacon test [--to <channel>] [--json]
-  spinuptui beacon status [--json]`
-
-function badValue(flags: Map<string, string>, name: string): boolean {
-  if (!flags.has(name)) return false
-  const v = flags.get(name)!
-  return !v || v.startsWith("-")
-}
-
-export async function runBeacon(argv: string[]): Promise<number> {
-  const { positionals, flags, rest } = parse(argv)
-  const json = flags.has("--json")
-  const sub = positionals[0]
-  for (const f of VALUE_FLAGS) if (badValue(flags, f)) return fail(json, "usage", `${f} needs a value.\n${USAGE}`)
-
-  if (sub === "setup") return setup(positionals.slice(1))
-  if (sub === "send") return send(positionals.slice(1), flags, rest, json)
-  if (sub === "test") return test(flags, json)
-  if (sub === "add") return add(positionals.slice(1), flags, json)
-  if (sub === "remove") return remove(positionals.slice(1), json)
-  if (sub === "status") return status(json)
-  return fail(json, "usage", USAGE)
-}
-
-async function send(pos: string[], flags: Map<string, string>, rest: string | null, json: boolean): Promise<number> {
-  // The message: everything after `--`, else the positionals, else stdin when it
-  // is `-` or absent and stdin isn't a terminal.
-  let text: string
-  if (rest !== null) text = rest
-  else if (pos.length > 0 && !(pos.length === 1 && pos[0] === "-")) text = pos.join(" ")
-  else if (pos[0] === "-" || !process.stdin.isTTY) text = await Bun.stdin.text()
-  else return fail(json, "usage", `No message: pass it as an argument or pipe it on stdin.\n${USAGE}`)
-  text = text.replace(/\s+$/, "")
-
-  const result = await beaconSend(beaconFromConfig(loadConfig()), text, {
-    to: flags.get("--to") ?? null,
-    silent: flags.has("--silent"),
-  })
-  if (json) console.log(JSON.stringify(result))
-  else if (!result.ok) {
-    console.error(result.message)
-    if (result.remedy) console.error(result.remedy)
-  }
-  if (result.ok) return 0
-  return result.reason === "delivery_failed" ? 2 : 1
-}
-
-async function test(flags: Map<string, string>, json: boolean): Promise<number> {
-  const result = await beaconSend(beaconFromConfig(loadConfig()), testMessage(), { to: flags.get("--to") ?? null })
-  if (json) console.log(JSON.stringify(result))
-  else if (result.ok) console.log(`Test message sent via ${result.channel}.`)
-  else {
-    console.error(result.message)
-    if (result.remedy) console.error(result.remedy)
-  }
-  if (result.ok) return 0
-  return result.reason === "delivery_failed" ? 2 : 1
-}
-
-const NAME_RE = /^[a-z0-9][a-z0-9-]{0,31}$/
-
-async function add(pos: string[], flags: Map<string, string>, json: boolean): Promise<number> {
-  const [type, name] = pos
-  if (type !== "telegram" || !name) return fail(json, "usage", USAGE)
-  if (!NAME_RE.test(name)) return fail(json, "usage", `Channel names are lowercase letters, digits and dashes (got "${name}").`)
-  if (name === "env") return fail(json, "usage", `"env" is reserved for the channel defined by SPINUPTUI_BEACON_* environment variables.`)
-
-  // Secrets come from a file or the environment, never argv (where `ps` shows them).
-  let source: Record<string, string | undefined> = process.env
-  const envFile = flags.get("--env-file")
-  if (envFile) {
-    try {
-      source = parseEnvFile(readFileSync(envFile, "utf8"))
-    } catch (err) {
-      return fail(json, "env_file_unreadable", `Couldn't read ${envFile}: ${(err as Error).message}`)
-    }
-  }
-  const botToken = source.TELEGRAM_BOT_TOKEN?.trim()
-  const chatId = source.TELEGRAM_CHAT_ID?.trim()
-  if (!botToken || !chatId) {
-    return fail(
-      json,
-      "missing_credentials",
-      `TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID must both be set ${envFile ? `in ${envFile}` : "in the environment"}.`,
-      "Put them in a KEY=VALUE file and pass --env-file <path>.",
-    )
-  }
-
-  // Credentials that can't deliver are never stored.
-  const me = await telegramGetMe(botToken)
-  if (!me.ok) {
-    if (json) console.log(JSON.stringify({ ok: false, reason: "token_rejected", message: `Telegram rejected the bot token: ${me.error}` }))
-    else console.error(`Telegram rejected the bot token: ${me.error}`)
-    return 2
-  }
-  const channel = { type: "telegram" as const, botToken, chatId }
-  if (!flags.has("--no-test")) {
-    const r = await sendConnectedMessage(name, channel)
-    if (!r.ok) {
-      if (json) console.log(JSON.stringify({ ...r, message: `Not saved. ${r.message}` }))
-      else console.error(`Not saved. ${r.message}`)
-      return 2
-    }
-  }
-
-  const previousDefault = loadConfig().beacon?.defaultChannel
-  const { isDefault } = await saveBeaconChannel(name, channel, flags.has("--default"))
-  const summary = {
-    ok: true,
-    channel: name,
-    bot: me.username ? `@${me.username}` : maskToken(botToken),
-    chat: maskChatId(chatId),
-    default: isDefault ? name : previousDefault,
-    tested: !flags.has("--no-test"),
-  }
-  if (json) console.log(JSON.stringify(summary))
-  else console.log(`Saved channel "${name}" (${summary.bot} → chat ${summary.chat})${isDefault ? ", now the default" : ""}.`)
-  return 0
-}
-
-// The guided path for someone without a bot yet. Interactive only: scripts and
-// provisioning use `add --env-file`.
-async function setup(pos: string[]): Promise<number> {
-  if (!process.stdin.isTTY || !process.stderr.isTTY) {
-    return fail(false, "needs_terminal", "`beacon setup` is interactive and needs a terminal.", "For scripts, use `spinuptui beacon add telegram <name> --env-file <path>`.")
-  }
-  const name = pos[0] ?? setupChannelName()
-  if (!NAME_RE.test(name) || name === "env") return fail(false, "usage", `"${name}" can't be a channel name (lowercase letters, digits and dashes; "env" is reserved).`)
-  const say = (line = "") => process.stderr.write(line + "\n")
-  try {
-    say("Beacon setup: page yourself on Telegram.")
-    say()
-    if (channelExists(name) && !(await confirm(`A channel named "${name}" already exists. Replace it?`, false))) return 1
-
-    say("1. Create a bot (skip if you already have one):")
-    for (const step of BOTFATHER_STEPS) say(`   · ${step}`)
-    say()
-    let token = ""
-    let username = ""
-    for (let attempt = 0; ; attempt++) {
-      token = (await readLine("2. Paste the bot token (hidden): ", { hidden: true })).trim()
-      const me = await verifyBotToken(token)
-      if (me.ok) {
-        username = me.username ?? ""
-        say(`   ✓ Bot ${username ? `@${username}` : "found"}`)
-        break
-      }
-      say(`   ✗ ${me.error}`)
-      if (attempt >= 2) return 2
-    }
-    say()
-    for (;;) {
-      say(`3. In Telegram, send any message to ${username ? `@${username} (${botLink(username)})` : "your bot"}.`)
-      say("   To page a group instead, add the bot to the group and send /start there.")
-      say("   Waiting up to 5 minutes… (Ctrl-C to cancel)")
-      const found = await discoverChat(token)
-      if (!found.ok) {
-        say(`   ✗ ${found.message}`)
-        if (found.reason === "timeout" && (await confirm("   Keep waiting?", true))) continue
-        return found.reason === "cancelled" ? 1 : 2
-      }
-      say(`   ✓ Found: ${found.chat.label} (${found.chat.kind} chat)`)
-      if (!(await confirm("   Page this chat?", true))) continue
-      const channel = { type: "telegram" as const, botToken: token, chatId: found.chat.chatId }
-      const sent = await sendConnectedMessage(name, channel)
-      if (!sent.ok) {
-        say(`   ✗ Couldn't send the test message: ${sent.message}. Nothing was saved.`)
-        return 2
-      }
-      const { isDefault } = await saveBeaconChannel(name, channel, false)
-      say()
-      say(`✓ Saved channel "${name}"${isDefault ? " (the default)" : ""}. A test message is on its way to that chat.`)
-      say(`  Try it: spinuptui beacon send "hello from $(hostname)"`)
-      return 0
-    }
-  } catch (err) {
-    if (err instanceof PromptCancelled) {
-      say("Cancelled; nothing was saved.")
-      return 1
-    }
-    throw err
-  }
-}
-
-async function remove(pos: string[], json: boolean): Promise<number> {
-  const name = pos[0]
-  if (!name) return fail(json, "usage", USAGE)
-  const stored: BeaconStored = loadConfig().beacon ?? {}
-  if (!stored.channels?.[name]) {
-    const resolved = pickChannel(beaconFromConfig(loadConfig()), name)
-    if (!("ok" in resolved) && resolved.env) {
-      return fail(json, "read_only", `"${name}" comes from SPINUPTUI_BEACON_* environment variables; unset them to remove it.`)
-    }
-    return fail(json, "unknown_channel", `No stored Beacon channel named "${name}".`)
-  }
-  const { [name]: _gone, ...channels } = stored.channels
-  const next: BeaconStored = { ...stored, channels }
-  if (next.defaultChannel === name) delete next.defaultChannel
-  await saveConfig({ beacon: next })
-  if (json) console.log(JSON.stringify({ ok: true, removed: name }))
-  else console.log(`Removed channel "${name}".`)
-  return 0
-}
-
-function printStatus(s: ModuleStatus & { name?: string }): void {
-  console.log(`${s.name ?? s.id}: ${s.state} — ${s.summary}`)
-  for (const c of s.checks) console.log(`  ${c.ok ? "✓" : "✗"} ${c.name}: ${c.detail}`)
-  if (s.remedy) console.log(`  → ${s.remedy}`)
-}
-
-async function status(json: boolean): Promise<number> {
-  const s = await beaconModule.status()
-  if (json) console.log(JSON.stringify({ ok: true, ...s }))
-  else printStatus({ ...s, name: beaconModule.name })
-  return 0
-}
-
-export async function runModules(argv: string[]): Promise<number> {
-  const json = argv.includes("--json")
-  const statuses = await allModuleStatuses()
-  const upcoming = UPCOMING_MODULES.map(({ id, name, summary }) => ({ id, name, about: summary }))
-  if (json) console.log(JSON.stringify({ ok: true, modules: statuses, upcoming }))
-  else {
-    for (const s of statuses) printStatus(s)
-    console.log(`Coming soon: ${upcoming.map((u) => u.name).join(", ")}`)
-  }
-  return 0
-}

package/src/lib/prompt.ts

@@ -1,47 +0,0 @@
-// Minimal line prompts for interactive CLI subcommands (not the TUI). Prompts go
-// to stderr so stdout stays clean. `hidden` reads in raw mode and echoes a dot
-// per character, for secrets: they never appear on screen or in argv.
-
-export class PromptCancelled extends Error {}
-
-export function readLine(question: string, opts: { hidden?: boolean } = {}): Promise<string> {
-  const stdin = process.stdin
-  process.stderr.write(question)
-  return new Promise((resolve, reject) => {
-    let buf = ""
-    const raw = Boolean(stdin.isTTY)
-    if (raw) stdin.setRawMode(true)
-    stdin.resume()
-    const done = (err: Error | null) => {
-      stdin.off("data", onData)
-      if (raw) stdin.setRawMode(false)
-      stdin.pause()
-      process.stderr.write("\n")
-      if (err) reject(err)
-      else resolve(buf)
-    }
-    const onData = (chunk: Buffer) => {
-      for (const ch of chunk.toString("utf8")) {
-        if (ch === "\u0003" || ch === "\u0004") return done(new PromptCancelled("cancelled"))
-        if (ch === "\r" || ch === "\n") return done(null)
-        if (ch === "\u007f" || ch === "\b") {
-          if (buf.length) {
-            buf = buf.slice(0, -1)
-            if (raw) process.stderr.write("\b \b")
-          }
-          continue
-        }
-        if (ch < " ") continue
-        buf += ch
-        if (raw) process.stderr.write(opts.hidden ? "•" : ch)
-      }
-    }
-    stdin.on("data", onData)
-  })
-}
-
-export async function confirm(question: string, defaultYes: boolean): Promise<boolean> {
-  const answer = (await readLine(`${question} ${defaultYes ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase()
-  if (!answer) return defaultYes
-  return answer === "y" || answer === "yes"
-}

package/src/modules/beacon.ts

@@ -1,51 +0,0 @@
-// Beacon's module declaration: the first implementation of the contract.
-
-import { loadConfig } from "../config.ts"
-import { beaconFromConfig, lastSendLogEntry, maskChatId, maskToken } from "../lib/beacon.ts"
-import { moduleStateDir, type ModuleCheck, type ModuleDefinition, type ModuleStatus } from "./contract.ts"
-
-export const beaconModule: ModuleDefinition = {
-  id: "beacon",
-  name: "Beacon",
-  summary: "Tells you when something needs you: one pager for the fleet and every module.",
-  dependsOn: [],
-  configKey: "beacon",
-  stateDir: () => moduleStateDir("beacon"),
-  jobs: [],
-  async status(): Promise<ModuleStatus> {
-    const beacon = beaconFromConfig(loadConfig())
-    if (beacon.channels.length === 0) {
-      return {
-        id: "beacon",
-        state: "not_configured",
-        summary: "No channels configured",
-        checks: [],
-        remedy: "spinuptui beacon add telegram <name> --env-file <path>",
-      }
-    }
-    const checks: ModuleCheck[] = beacon.channels.map((c) => ({
-      name: `channel ${c.name}`,
-      ok: true,
-      detail: `telegram bot ${maskToken(c.channel.botToken)} → chat ${maskChatId(c.channel.chatId)}${c.env ? " (from environment)" : ""}${c.name === beacon.defaultChannel ? ", default" : ""}`,
-    }))
-    checks.push({
-      name: "default channel",
-      ok: beacon.defaultChannel !== null,
-      detail: beacon.defaultChannel ?? "none — senders must pass --to",
-    })
-    const last = lastSendLogEntry()
-    checks.push({
-      name: "last send",
-      ok: last?.ok ?? true,
-      detail: last ? `${last.ok ? "delivered" : `failed (${last.error})`} via ${last.channel} at ${last.at}` : "nothing sent yet",
-    })
-    const failing = checks.find((c) => !c.ok)
-    return {
-      id: "beacon",
-      state: failing ? "degraded" : "ok",
-      summary: failing ? `${failing.name}: ${failing.detail}` : `${beacon.channels.length} channel${beacon.channels.length === 1 ? "" : "s"}, default ${beacon.defaultChannel}`,
-      checks,
-      ...(failing ? { remedy: "spinuptui beacon test" } : {}),
-    }
-  },
-}

package/src/modules/contract.ts

@@ -1,61 +0,0 @@
-// The module contract (docs/2026-10-16_beacon-and-module-contract-spec.md).
-//
-// A module is a feature that keeps working after the TUI is closed. Each one
-// describes itself with a ModuleDefinition so `spinuptui modules`, the future
-// Modules screen and `station setup` are views over the same data rather than
-// knowing every module by hand.
-//
-// Rules the shape encodes:
-// - Config is a machine-level top-level key in config.json named after the
-//   module, written only by deliberate setup commands.
-// - Anything a module writes while running goes in its state directory, never
-//   config.json (whose writes are neither atomic nor locked).
-// - Recurring work is declared in `jobs` for Scheduler to run; a module never
-//   installs an OS scheduler unit of its own.
-// - status() is computed on demand, is cheap, and never sends anything.
-
-import { join } from "node:path"
-import { configDir } from "../config.ts"
-
-export type ModuleId = "beacon" | "scheduler" | "sentinel" | "samurai"
-
-export interface ScheduledJobDecl {
-  id: string // e.g. "sentinel.tick"
-  every?: string // e.g. "5m"
-  at?: string // e.g. "08:00"
-  // A spinuptui subcommand's arguments, never a path into a checkout.
-  command: string[]
-}
-
-export interface ModuleCheck {
-  name: string
-  ok: boolean
-  detail: string
-}
-
-export interface ModuleStatus {
-  id: ModuleId
-  state: "not_configured" | "ok" | "degraded"
-  summary: string
-  checks: ModuleCheck[]
-  remedy?: string
-}
-
-export interface ModuleDefinition {
-  id: ModuleId
-  name: string
-  // Outcome copy, shared with the landing page's module card.
-  summary: string
-  dependsOn: ModuleId[]
-  configKey: string
-  stateDir(): string
-  jobs: ScheduledJobDecl[]
-  status(): Promise<ModuleStatus>
-}
-
-export function moduleStateDir(id: ModuleId): string {
-  return join(configDir(), "modules", id)
-}
-
-// A module that hasn't shipped yet: just enough to draw its card.
-export type UpcomingModule = Pick<ModuleDefinition, "id" | "name" | "summary" | "dependsOn">

package/src/modules/index.ts

@@ -1,34 +0,0 @@
-// Every module SpinupTUI ships, in dependency order, plus the ones still to come
-// (shown as "coming soon" on the Modules screen and in `spinuptui modules`).
-
-import type { ModuleDefinition, UpcomingModule } from "./contract.ts"
-import { beaconModule } from "./beacon.ts"
-
-export const MODULES: ModuleDefinition[] = [beaconModule]
-
-// Outcome copy only — the same lines feed the landing page. An entry moves to
-// MODULES (and out of here) when the module ships.
-export const UPCOMING_MODULES: UpcomingModule[] = [
-  {
-    id: "scheduler",
-    name: "Scheduler",
-    summary: "Follow-ups that run themselves: the fix you shipped today gets checked tomorrow without you remembering.",
-    dependsOn: ["beacon"],
-  },
-  {
-    id: "sentinel",
-    name: "Sentinel",
-    summary: "Watches the fleet, works out what actually broke, and writes it up.",
-    dependsOn: ["beacon", "scheduler"],
-  },
-  {
-    id: "samurai",
-    name: "Samurai",
-    summary: "Defends your sites at the nginx layer, proactively and when Sentinel spots an attack, with your approval.",
-    dependsOn: ["beacon", "scheduler", "sentinel"],
-  },
-]
-
-export async function allModuleStatuses() {
-  return Promise.all(MODULES.map(async (m) => ({ name: m.name, about: m.summary, dependsOn: m.dependsOn, ...(await m.status()) })))
-}