spinuptui 1.1.0 → 1.1.1

package/CHANGELOG.md

@@ -11,6 +11,16 @@ version; such changes are called out here.
 
 ## [Unreleased]
 
+## [1.1.1] - 2026-10-01
+
+### Changed
+- **`spinuptui ssh-exec` allows `wp user list`, `wp user get` and `wp user list-caps`.** The read-only guard used to refuse everything under `wp user`, reads included, which got in the way of checking when an account was registered. Creating, deleting and changing users is still denied.
+
+### Fixed
+- **`spinuptui ssh-exec` no longer lets Redis writes through.** The read-only guard had no patterns for Redis, so `redis-cli CONFIG SET …`, `FLUSHALL`, `FLUSHDB`, `BGSAVE` and plain `SET`/`DEL` all ran as if they were diagnostics. `redis-cli` is now allowed only with a known read — `ping`, `info`, `dbsize`, `lastsave`, `config get`, `memory doctor|stats|usage`, `latency latest|history`, `slowlog get|len`, `client list|info` and a few key-inspection reads — and anything else is denied, including unrecognised options and a bare `redis-cli` fed from stdin. The denial message names the verb or option that was refused.
+- **`spinuptui ssh-exec` no longer lets unlisted WP-CLI writes through.** The guard denied a dozen named WP-CLI writes and allowed every other command, so `wp transient delete`, `wp search-replace`, `wp eval`, `wp plugin uninstall`, `wp cron event run` and more ran as diagnostics. `wp` is now allowed only with a known read (`plugin list`, `option get`, `core version`, `cache type`, `cron event list`, `db size` and the like), and the `--exec`, `--require`, `--ssh` and `--http` flags are refused on any command. Two reads that used to pass are now denied: `wp config get` and `wp config list`, because they print the database password into the audit log.
+- **The update command now actually updates.** The About panel (`?`) now suggests `bun add -g spinuptui@latest --no-cache`. Without `--no-cache`, Bun can answer `@latest` from its cached copy of npm's package list, which right after a release can still name the previous version, so the command reported success and left you where you were.
+
 ## [1.1.0] - 2026-09-30
 
 ### Added
@@ -1469,7 +1479,8 @@ Initial tagged release.
 ### Notes
 - Read-only release: works with a SpinupWP **Read Only** API token.
 
-[Unreleased]: https://github.com/mwender/spinupwp-tui/compare/v1.1.0...HEAD
+[Unreleased]: https://github.com/mwender/spinupwp-tui/compare/v1.1.1...HEAD
+[1.1.1]: https://github.com/mwender/spinupwp-tui/compare/v1.1.0...v1.1.1
 [1.1.0]: https://github.com/mwender/spinupwp-tui/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/mwender/spinupwp-tui/compare/v0.28.0...v1.0.0
 [0.28.0]: https://github.com/mwender/spinupwp-tui/compare/v0.27.0...v0.28.0

package/README.md

@@ -165,10 +165,14 @@ to the version in the header (and in the `?` About panel).
 
 - **Homebrew:** `brew upgrade spinuptui` (the About panel shows the same
   command).
-- **Package install:** `bun add -g spinuptui@latest` (the About panel shows
-  the same command). Don't use `bun update -g` — while spinuptui is pre-1.0,
-  it records a caret range (e.g. `^0.22.2`) that excludes every later minor
-  release, so `update -g` reports success but silently doesn't update.
+- **Package install:** `bun add -g spinuptui@latest --no-cache` (the About
+  panel shows the same command). `--no-cache` matters: without it Bun can
+  answer `@latest` from its cached copy of the registry, which right after a
+  release may still name the previous version — the command reports success
+  and installs nothing new. Don't use `bun update -g` either — while spinuptui
+  was pre-1.0, it recorded a caret range (e.g. `^0.22.2`) that excludes every
+  later minor release, so `update -g` reports success but silently doesn't
+  update.
 - **Source checkout:** press **`u`** in the About panel to update in place
   (`git pull --ff-only`; refuses if you have uncommitted changes, and never
   merges/rebases). It can't hot-reload the already-running process, so it tells

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spinuptui",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "SpinupTUI — a terminal dashboard for browsing, monitoring, and managing your SpinupWP servers and sites.",
   "type": "module",
   "bin": {

package/src/lib/appUpdate.ts

@@ -162,7 +162,14 @@ export function updateCommand(): string | null {
 // hits the same wall until the following minor bump. Verified live against a
 // real stale install (0.22.2 -> 0.24.0): `update -g` exited 0 without updating,
 // `add -g spinuptui@latest` updated correctly.
-export const PACKAGE_UPDATE_CMD = "bun add -g spinuptui@latest"
+//
+// `--no-cache` because Bun answers `@latest` from its own cached copy of the
+// registry metadata when it has one. Right after a release that copy can still
+// name the previous version, so the add "succeeds" without contacting npm and
+// installs nothing new — seen live on 1.1.0's release day: two runs installed
+// 1.0.0 while the registry already served 1.1.0; the same command with
+// `--no-cache` installed 1.1.0 at once.
+export const PACKAGE_UPDATE_CMD = "bun add -g spinuptui@latest --no-cache"
 
 // The real checkout directory, resolved through Bun's module system rather
 // than process.cwd() — `spinuptui` is typically a global symlink invoked from

package/src/lib/sshExecPolicy.ts

@@ -8,13 +8,6 @@ const DANGEROUS_PATTERNS: RegExp[] = [
   /\b(rm|mv|chmod|chown|reboot|shutdown|kill|truncate)\b/i,
   /systemctl\s+(restart|stop|reload)\b/i,
   /service\s+\S+\s+restart\b/i,
-  /wp\s+plugin\s+(activate|deactivate|install|update|delete)\b/i,
-  /wp\s+theme\s+(activate|delete|install)\b/i,
-  /wp\s+db\s+(query|import|reset)\b/i,
-  /wp\s+option\s+(update|delete|add)\b/i,
-  /wp\s+user\b/i,
-  /wp\s+core\s+(update|install)\b/i,
-  /wp\s+(rewrite\s+flush|cache\s+flush)\b/i,
   /crontab\s+-[re]\b/i,
   /sed\s+-i\b/i,
   /\b(DROP\s+TABLE|INSERT\s+INTO|DELETE\s+FROM)\b/i,
@@ -32,12 +25,131 @@ function hasUnsafeRedirect(cmd: string): boolean {
   return />/.test(stripped)
 }
 
+// redis-cli has a verb grammar a deny-list can't enumerate (CONFIG SET, FLUSHALL,
+// CLIENT PAUSE, plain SET/DEL/EXPIRE, …), and generic patterns like /\bset\b/
+// would collide with awk in ordinary log analysis. So it is allowlisted instead:
+// every redis-cli in the command must name a known read, and anything else is
+// denied — an unknown verb, an unknown flag (--pipe, --eval, --rdb, --cluster and
+// --lru-test all write), or no verb at all (bare redis-cli takes commands on stdin).
+// Deliberately left out though read-only: KEYS and MONITOR (both can stall a busy
+// instance) and GET (dumps cached values into the log).
+const REDIS_READ_VERBS = new Set([
+  "ping", "info", "dbsize", "lastsave", "time", "role",
+  "scan", "type", "ttl", "pttl", "exists", "strlen",
+])
+const REDIS_READ_SUBVERBS: Record<string, Set<string>> = {
+  config: new Set(["get"]),
+  memory: new Set(["doctor", "stats", "usage", "malloc-stats"]),
+  latency: new Set(["latest", "history", "doctor"]),
+  slowlog: new Set(["get", "len"]),
+  client: new Set(["list", "info"]),
+}
+const REDIS_VALUE_FLAGS = new Set(["-h", "-p", "-s", "-a", "-n", "-u", "--user", "--pass"])
+const REDIS_BARE_FLAGS = new Set(["--no-auth-warning", "--raw", "--no-raw", "--tls", "-c", "-e", "-2", "-3"])
+
+// Shared by the per-tool allowlists below. A segment is what follows the tool
+// name up to the next shell operator.
+const SEGMENT = "([^|;&()`<>\\n]*)"
+// Drop a quote pair around a token, and a stray closing quote left by an
+// enclosing `ssh host '…'` / `bash -c "…"`.
+const clean = (t: string) => t.replace(/^(['"])(.*)\1$/, "$2").replace(/['"]+$/, "").toLowerCase()
+// A token that opens a quote it doesn't close (`-a 'pw ping' flushall`) would
+// shift which later token we read as the verb.
+const hasOpenQuote = (t: string) => /['"]/.test(t) && !/^[^'"]*(['"])[^'"]*\1$/.test(t)
+
+// Returns why the command is unsafe, or null. Looks at every `redis-cli` in the
+// string, wherever it appears — including inside `bash -c '…'`, `sudo`, `xargs`,
+// or a grep pattern — so a mention that isn't an invocation (`which redis-cli`)
+// is denied too; that is the price of not having to recognise command position.
+function unsafeRedisCli(cmd: string): string | null {
+  for (const m of cmd.matchAll(new RegExp(`\\bredis-cli\\b${SEGMENT}`, "g"))) {
+    const tokens = (m[1] ?? "").trim().split(/\s+/).filter(Boolean)
+    if (tokens.length === 1 && /^(-v|--version)$/.test(clean(tokens[0]!))) continue
+    let i = 0
+    for (; i < tokens.length; i++) {
+      const flag = clean(tokens[i]!)
+      if (!flag.startsWith("-")) break
+      if (REDIS_BARE_FLAGS.has(flag)) continue
+      if (!REDIS_VALUE_FLAGS.has(flag)) return `redis-cli option \`${flag}\` is not on the read-only allowlist`
+      if (hasOpenQuote(tokens[++i] ?? "")) return "redis-cli option value has quoting this guard can't read safely"
+    }
+    const verb = clean(tokens[i] ?? "")
+    if (!verb) return "redis-cli with no command reads commands from stdin"
+    if (REDIS_READ_VERBS.has(verb)) continue
+    const sub = clean(tokens[i + 1] ?? "")
+    if (REDIS_READ_SUBVERBS[verb]?.has(sub)) continue
+    return `redis-cli \`${[verb, sub].filter(Boolean).join(" ")}\` is not on the read-only allowlist`
+  }
+  return null
+}
+
+// WP-CLI gets the same treatment: the deny patterns this replaces listed a dozen
+// writes and missed the rest (`transient delete`, `search-replace`, `eval`, …),
+// while blanket-denying reads like `wp user list`. Each entry is a full command
+// path. Left out on purpose: `db query`/`eval`/`shell` (arbitrary SQL or PHP),
+// `db export` (writes a file), `config get|list` (prints the DB password) and
+// `cron test` (spawns a cron run).
+const WP_READ_COMMANDS = new Set([
+  "core version", "core is-installed", "core verify-checksums", "core check-update",
+  "plugin list", "plugin get", "plugin status", "plugin is-active", "plugin is-installed", "plugin path", "plugin verify-checksums",
+  "theme list", "theme get", "theme status", "theme is-active", "theme is-installed", "theme path",
+  "option get", "option list", "transient get", "transient list", "cache type",
+  "user list", "user get", "user list-caps", "role list", "cap list",
+  "post list", "post get", "site list", "rewrite list",
+  "cron event list", "cron schedule list",
+  "db size", "db tables", "db prefix", "db check",
+  "config path", "config has", "maintenance-mode status", "maintenance-mode is-active",
+  "cli version", "cli info", "cli check-update",
+  "doctor list", "doctor check", "profile stage", "profile hook",
+])
+// Global flags that run code or send the command somewhere else. Per-command
+// flags (--format, --field, --status, …) are too many to allowlist.
+const WP_UNSAFE_FLAGS = /(^|\s)['"]?--(exec|require|ssh|http)\b/
+
+// Unlike redis-cli, `wp` is only treated as an invocation when it stands alone
+// and is followed by a word — a bare `wp` just prints help, and this keeps paths
+// (`wp-content`, Bedrock's `web/wp`) from tripping it.
+function unsafeWpCli(cmd: string): string | null {
+  // `wp 2>/dev/null plugin delete x` must not end the segment at the redirect.
+  const stripped = cmd.replace(/\d?>{1,2}\s*(\/dev\/null\b|&\d+)/g, "")
+  for (const m of stripped.matchAll(new RegExp(`(?<![\\w.$-])wp(?:-cli\\.phar)?(?=\\s)${SEGMENT}(.?)`, "gs"))) {
+    const segment = m[1] ?? ""
+    if (WP_UNSAFE_FLAGS.test(segment)) return "wp --exec/--require/--ssh/--http can run code or target another host"
+    const tokens = segment.trim().split(/\s+/).filter(Boolean)
+    let i = 0
+    for (; i < tokens.length && tokens[i]!.replace(/^['"]/, "").startsWith("-"); i++) {
+      if (hasOpenQuote(tokens[i]!)) return "wp option value has quoting this guard can't read safely"
+    }
+    const words: string[] = []
+    for (; i < tokens.length && words.length < 3; i++) {
+      const word = clean(tokens[i]!)
+      if (word.startsWith("-")) break
+      if (word) words.push(word)
+    }
+    if (words.length === 0) {
+      // `wp </dev/stdin plugin delete` — the command sits past a redirect we stopped at.
+      if (m[2] === "<" || m[2] === ">") return "wp followed by a redirect hides its command from this guard"
+      continue
+    }
+    if ([3, 2].some((n) => words.length >= n && WP_READ_COMMANDS.has(words.slice(0, n).join(" ")))) continue
+    return `wp \`${words.slice(0, 2).join(" ")}\` is not on the read-only allowlist`
+  }
+  return null
+}
+
 export interface SshCommandVerdict {
   decision: "allow" | "deny"
   reason: string
 }
 
 export function classifySshCommand(cmd: string): SshCommandVerdict {
+  const unsafeTool = unsafeRedisCli(cmd) ?? unsafeWpCli(cmd)
+  if (unsafeTool) {
+    return {
+      decision: "deny",
+      reason: `${unsafeTool} — spinuptui ssh-exec only runs read-only diagnostic commands.`,
+    }
+  }
   if (DANGEROUS_PATTERNS.some((re) => re.test(cmd)) || hasUnsafeRedirect(cmd)) {
     return {
       decision: "deny",

package/src/ui/Help.tsx

@@ -129,6 +129,24 @@ function SectionBlock({ section }: { section: Section }) {
   )
 }
 
+// Greedy word wrap for a shell command, so a line never breaks inside a flag.
+// Continuation lines are indented two columns by the caller, hence `width - 2`.
+function wrapAtSpaces(text: string, width: number): string[] {
+  const lines: string[] = []
+  let cur = ""
+  for (const word of text.split(" ")) {
+    const limit = lines.length === 0 ? width : width - 2
+    if (cur && cur.length + 1 + word.length > limit) {
+      lines.push(cur)
+      cur = word
+    } else {
+      cur = cur ? `${cur} ${word}` : word
+    }
+  }
+  if (cur) lines.push(cur)
+  return lines
+}
+
 function ShortcutColumn({ sections, width }: { sections: Section[]; width: number }) {
   return (
     <box style={{ flexDirection: "column", width, flexShrink: 0 }}>
@@ -194,7 +212,11 @@ function AboutColumn({
       {installChannel() !== "git" ? (
         <>
           {line("Manual:")}
-          {line(updateCommand() ?? "", theme.text)}
+          {/* Broken at spaces by hand: the package command is wider than the
+              About column, and OpenTUI's own wrap splits "--no-cache" at its hyphen. */}
+          {wrapAtSpaces(updateCommand() ?? "", width).map((l, i) => (
+            <text key={i} content={i === 0 ? l : `  ${l}`} fg={theme.text} wrapMode="none" />
+          ))}
         </>
       ) : (
         <>