@ahmd-sh/hntui 0.4.0 → 0.5.0

package/README.md

@@ -56,6 +56,14 @@ hntui
 
 Press `q` (or `Ctrl-C`) to quit.
 
+## Updating
+
+```bash
+hntui update
+```
+
+Checks the latest release and, for binary installs, replaces itself in place. Bun installs update with `bun add -g @ahmd-sh/hntui` instead (`hntui update` will tell you so). When a newer release exists, the status bar shows a quiet hint. `hntui --version` prints the installed version.
+
 ## Keybindings
 
 ### Story list

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahmd-sh/hntui",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Beautiful Hacker News browser for the terminal, built on OpenTUI + React + Bun",
   "type": "module",
   "module": "src/index.tsx",

package/src/App.tsx

@@ -12,6 +12,7 @@ import { useItems } from "./hooks/useItems"
 import { flattenTree, useCommentTree } from "./hooks/useCommentTree"
 import { useSaved } from "./hooks/useSaved"
 import { useHistory } from "./hooks/useHistory"
+import { useUpdateCheck } from "./hooks/useUpdateCheck"
 import { ALL_CATEGORIES, FEED_CATEGORIES } from "./api/types"
 import type { Category, FeedCategory, Item } from "./api/types"
 import { openUrl } from "./utils/openUrl"
@@ -50,6 +51,7 @@ export function App() {
   const { items: feedItems, loading: feedItemsLoading } = useItems(visibleIds)
   const { entries: savedEntries, idSet: savedIds, isSaved, toggle: toggleSave } = useSaved()
   const { entries: historyEntries, idSet: viewedIds, markViewed, clear: clearHistory } = useHistory()
+  const updateAvailable = useUpdateCheck()
 
   const savedIdList = useMemo(() => savedEntries.map((e) => e.id), [savedEntries])
   const { items: savedItemsRaw, loading: savedLoading } = useItems(
@@ -584,6 +586,7 @@ export function App() {
           view={view.kind === "detail" ? "detail" : "list"}
           category={category}
           loading={statusLoading}
+          updateAvailable={updateAvailable}
           message={
             view.kind === "resolveError"
               ? view.error._tag === "HnItemGone"

package/src/components/StatusBar.tsx

@@ -7,9 +7,10 @@ interface Props {
   category?: Category
   loading?: boolean
   message?: string
+  updateAvailable?: string | null
 }
 
-export function StatusBar({ view, category, loading, message }: Props) {
+export function StatusBar({ view, category, loading, message, updateAvailable }: Props) {
   const t = useTheme()
   const hints =
     view === "list"
@@ -34,6 +35,9 @@ export function StatusBar({ view, category, loading, message }: Props) {
       {loading ? <Loader /> : null}
       <text fg={t.statusHint} {...selectionColors(t)}>{message ?? hints}</text>
       <box flexGrow={1} />
+      {updateAvailable ? (
+        <text fg={t.textDim} {...selectionColors(t)}>{`v${updateAvailable} · hntui update`}</text>
+      ) : null}
       <text fg={t.statusHint} {...selectionColors(t)}>? help</text>
     </box>
   )

package/src/hooks/useUpdateCheck.ts

@@ -0,0 +1,29 @@
+import { useEffect, useState } from "react"
+import { Effect, Fiber } from "effect"
+import { AppRuntime } from "../runtime"
+import { VERSION } from "../version"
+import { compareVersions, fetchLatestVersion } from "../utils/selfUpdate"
+
+// One check per app launch, silently skipped when offline: returns the newer
+// version string when a release is ahead of this build, otherwise null.
+export function useUpdateCheck(): string | null {
+  const [latest, setLatest] = useState<string | null>(null)
+
+  useEffect(() => {
+    const fiber = AppRuntime.runFork(
+      // fetchLatestVersion never throws (5s timeout, null on any failure)
+      Effect.promise(() => fetchLatestVersion()).pipe(
+        Effect.andThen((v) =>
+          Effect.sync(() => {
+            if (v && compareVersions(v, VERSION) > 0) setLatest(v)
+          }),
+        ),
+      ),
+    )
+    return () => {
+      AppRuntime.runFork(Fiber.interrupt(fiber))
+    }
+  }, [])
+
+  return latest
+}

package/src/index.tsx

@@ -3,6 +3,19 @@ import { createCliRenderer } from "@opentui/core"
 import { createRoot } from "@opentui/react"
 import "opentui-spinner/react"
 import { App } from "./App"
+import { VERSION } from "./version"
+import { selfUpdate } from "./utils/selfUpdate"
 
-const renderer = await createCliRenderer({ useMouse: true })
-createRoot(renderer).render(<App />)
+const arg = process.argv[2]
+if (arg === "--version" || arg === "-v" || arg === "version") {
+  console.log(`hntui ${VERSION}`)
+  process.exit(0)
+} else if (arg === "update") {
+  process.exit(await selfUpdate())
+} else if (arg) {
+  console.error(`hntui: unknown command "${arg}"\nusage: hntui [update | --version]`)
+  process.exit(1)
+} else {
+  const renderer = await createCliRenderer({ useMouse: true })
+  createRoot(renderer).render(<App />)
+}

package/src/utils/selfUpdate.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test"
+import { compareVersions, releaseAsset } from "./selfUpdate"
+
+describe("compareVersions", () => {
+  test("orders plain versions", () => {
+    expect(compareVersions("0.4.0", "0.3.0")).toBeGreaterThan(0)
+    expect(compareVersions("0.3.0", "0.4.0")).toBeLessThan(0)
+    expect(compareVersions("0.4.0", "0.4.0")).toBe(0)
+  })
+
+  test("compares numerically, not lexically", () => {
+    expect(compareVersions("0.10.0", "0.9.0")).toBeGreaterThan(0)
+    expect(compareVersions("1.0.0", "0.99.99")).toBeGreaterThan(0)
+  })
+
+  test("tolerates missing segments", () => {
+    expect(compareVersions("1.0", "1.0.0")).toBe(0)
+    expect(compareVersions("1", "1.0.1")).toBeLessThan(0)
+  })
+})
+
+describe("releaseAsset", () => {
+  test("maps supported platforms", () => {
+    expect(releaseAsset("darwin", "arm64")).toBe("hntui-darwin-arm64.tar.gz")
+    expect(releaseAsset("linux", "x64")).toBe("hntui-linux-x64.tar.gz")
+    expect(releaseAsset("linux", "arm64")).toBe("hntui-linux-arm64.tar.gz")
+  })
+
+  test("unsupported platforms get null (Intel macOS, windows)", () => {
+    expect(releaseAsset("darwin", "x64")).toBeNull()
+    expect(releaseAsset("win32", "x64")).toBeNull()
+  })
+})

package/src/utils/selfUpdate.ts

@@ -0,0 +1,120 @@
+import { chmodSync, mkdtempSync, renameSync, rmSync } from "fs"
+import { dirname, join } from "path"
+import { VERSION } from "../version"
+
+const REPO = "ahmd-sh/hntui"
+const LATEST_URL = `https://github.com/${REPO}/releases/latest`
+
+// "1.2.3" vs "1.10.0" → negative if a < b, 0 if equal, positive if a > b
+export function compareVersions(a: string, b: string): number {
+  const pa = a.split(".").map(Number)
+  const pb = b.split(".").map(Number)
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0)
+    if (d !== 0) return d
+  }
+  return 0
+}
+
+// which release tarball serves this machine, or null if none exists
+export function releaseAsset(platform: string, arch: string): string | null {
+  if (platform === "darwin" && arch === "arm64") return "hntui-darwin-arm64.tar.gz"
+  if (platform === "linux" && (arch === "x64" || arch === "arm64"))
+    return `hntui-linux-${arch}.tar.gz`
+  return null
+}
+
+// The releases/latest page redirects to .../tag/vX.Y.Z — the version is in a
+// header of a tiny response: no API, no auth, no rate-limit concerns.
+export async function fetchLatestVersion(timeoutMs = 5000): Promise<string | null> {
+  try {
+    const res = await fetch(LATEST_URL, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    const location = res.headers.get("location") ?? ""
+    const m = location.match(/\/tag\/v(\d+\.\d+\.\d+)$/)
+    return m ? m[1]! : null
+  } catch {
+    return null
+  }
+}
+
+type Channel = "binary" | "bun" | "dev"
+
+// A compiled executable runs from bun's virtual filesystem; under the bun
+// runtime, a global install lives in node_modules, a source checkout doesn't.
+function installChannel(): Channel {
+  if (import.meta.url.includes("$bunfs")) return "binary"
+  return import.meta.path.includes("node_modules") ? "bun" : "dev"
+}
+
+// `hntui update` — returns a process exit code.
+export async function selfUpdate(): Promise<number> {
+  const latest = await fetchLatestVersion()
+  if (!latest) {
+    console.error("hntui: couldn't reach GitHub to check the latest release.")
+    return 1
+  }
+  if (compareVersions(latest, VERSION) <= 0) {
+    console.log(`hntui ${VERSION} is up to date (latest release is v${latest}).`)
+    return 0
+  }
+
+  console.log(`hntui ${VERSION} → v${latest} available.`)
+  const channel = installChannel()
+  if (channel === "bun") {
+    console.log("This copy was installed with Bun — update it with:\n  bun add -g @ahmd-sh/hntui")
+    return 0
+  }
+  if (channel === "dev") {
+    console.log("Running from a source checkout — update it with git pull.")
+    return 0
+  }
+
+  const asset = releaseAsset(process.platform, process.arch)
+  if (!asset) {
+    console.error(
+      `hntui: no prebuilt binary for ${process.platform}-${process.arch}.\n` +
+        "Install with Bun instead:  bun add -g @ahmd-sh/hntui",
+    )
+    return 1
+  }
+
+  const target = process.execPath
+  const targetDir = dirname(target)
+  console.log(`downloading ${asset} ...`)
+  const res = await fetch(`https://github.com/${REPO}/releases/latest/download/${asset}`)
+  if (!res.ok) {
+    console.error(`hntui: download failed (HTTP ${res.status}).`)
+    return 1
+  }
+
+  // extract in the target's own directory: the final rename must not cross
+  // filesystems, and renaming over a running executable is safe (the running
+  // process keeps its inode; the path points at the new file)
+  let tmpDir: string | null = null
+  try {
+    tmpDir = mkdtempSync(join(targetDir, ".hntui-update-"))
+    const tarPath = join(tmpDir, asset)
+    await Bun.write(tarPath, res)
+    const tar = Bun.spawn(["tar", "-xzf", tarPath, "-C", tmpDir], {
+      stdout: "ignore",
+      stderr: "pipe",
+    })
+    if ((await tar.exited) !== 0) {
+      console.error(`hntui: extract failed: ${await new Response(tar.stderr).text()}`)
+      return 1
+    }
+    const fresh = join(tmpDir, "hntui")
+    chmodSync(fresh, 0o755)
+    renameSync(fresh, target)
+    console.log(`updated to v${latest}  (${target})`)
+    return 0
+  } catch (err) {
+    console.error(`hntui: update failed: ${err}\nIs ${targetDir} writable?`)
+    return 1
+  } finally {
+    if (tmpDir) rmSync(tmpDir, { recursive: true, force: true })
+  }
+}

package/src/version.ts

@@ -0,0 +1,4 @@
+import pkg from "../package.json"
+
+// Inlined at build time — compiled binaries carry their version with them.
+export const VERSION: string = pkg.version