komado 0.1.0

package/README.md

@@ -0,0 +1,208 @@
+# komado
+
+A terminal manga reader. Browse and read from **MangaDex** (online) or your **local
+library** (CBZ/ZIP archives and image folders), rendered straight into the terminal
+with [Ink](https://github.com/vadimdemedes/ink).
+
+```
+ komado
+ a terminal manga reader · MangaDex + local files
+
+  › Search MangaDex      online catalog
+    Popular on MangaDex   most followed
+    Local library         your CBZ / folders
+    Continue reading      resume
+    Settings              config & library paths
+    Quit
+```
+
+## Features
+
+- **Two sources, one reader.** MangaDex and local files are normalized into a single
+  shape, so search / details / reader / progress treat them identically.
+- **Image rendering with graceful upgrade.** A pure-JS Unicode half-block renderer works
+  in any 24-bit terminal; if [`chafa`](https://hpjansson.org/chafa/) is installed it’s
+  auto-used for sharper output. Falls back automatically if anything goes wrong.
+- **Reader UX.** Vertical scroll for tall pages, page/chapter navigation, fit-to-screen
+  toggle, runtime renderer switching, and next-page prefetch.
+- **Reading progress.** Where you left off is saved per manga and resumable from
+  *Continue reading*.
+- **Sign in to MangaDex (optional).** Log in to browse your **followed library**, see
+  which chapters you've already read, and **sync progress back** — finishing a chapter
+  marks it read on MangaDex. Reading itself needs no account.
+- **Offline-friendly.** Point it at folders of `.cbz`/`.zip` or loose images.
+
+## Requirements
+
+- Node.js **≥ 20** (developed on Node 22).
+- A 24-bit-color terminal (most modern ones).
+- Optional but recommended: **`chafa`** for higher-fidelity rendering.
+  - Debian/Ubuntu: `sudo apt install chafa` · macOS: `brew install chafa`
+
+## Install
+
+One line — fetches the latest, builds it, and drops a `komado` launcher on your PATH:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/RyuPrad/komado/main/install.sh | bash
+```
+
+Then just type **`komado`**. Re-run that same command any time to update. It needs
+`git`, **Node ≥ 20**, and `npm`; it installs to `~/.local/share/komado` with the
+launcher in `~/.local/bin` (override via `KOMADO_APP_DIR` / `KOMADO_BIN_DIR`).
+
+Uninstall: `rm -rf ~/.local/share/komado ~/.local/bin/komado` (add `~/.komado` to also
+drop your saved progress and login).
+
+### From source (for development)
+
+```bash
+npm install     # also builds dist/ via the prepare script
+npm start       # rebuilds, then launches the reader
+```
+
+The UI is JSX, transpiled to `dist/` by esbuild (`npm run build`). Check what your
+terminal supports and where state is stored:
+
+```bash
+npm run doctor
+```
+
+Render a single image (path or URL) at the best fidelity your terminal allows — handy
+for testing sixel/kitty terminals:
+
+```bash
+node dist/cli.js render ./cover.jpg
+node dist/cli.js render https://example.com/page.png 100
+```
+
+## Keys
+
+| Context | Keys | Action |
+|---|---|---|
+| Lists | `↑`/`↓` or `j`/`k`, `g`/`G`, `PgUp`/`PgDn` | move / jump / page |
+| Lists | `enter` | open · `/` focus search · `esc` back |
+| Reader | `↑`/`↓` or `j`/`k` | scroll within a page |
+| Reader | `←`/`→` or `a`/`d`, `space` | previous / next page |
+| Reader | `N` / `P` | next / previous chapter |
+| Reader | `f` | toggle fit-to-screen |
+| Reader | `r` | cycle renderer (`auto` → `halfblock` → `chafa`) |
+| Global | `q` | quit · `esc` back |
+
+## Rendering quality
+
+Readable text needs real pixels. At startup the app probes your terminal (run
+`npm run doctor` to see the result):
+
+- **sixel or kitty graphics supported** → opening a chapter launches a
+  full-resolution **pixel viewer** (chafa straight to the terminal). It renders
+  full-width with vertical pan by default; press `f` to toggle whole-page fit.
+  Keys: `←`/`→` or `a`/`d` page · `↑`/`↓` pan · `N`/`P` chapter · `f` fit · `q` back.
+- **neither** → the in-Ink **cell reader** is used (Unicode half-blocks, or
+  chafa symbols when available). Fine for art, coarse for small lettering —
+  that's the hard ceiling of character-cell rendering.
+
+Terminals with pixel support include kitty, WezTerm, Ghostty, foot, recent
+Windows Terminal (≥ 1.22), and VS Code's terminal (with image support enabled).
+
+## MangaDex account (optional)
+
+Reading from MangaDex needs **no account**. Signing in only adds personalization:
+
+- **My Library** — browse the manga you follow on MangaDex.
+- **Read-markers** — chapters you've already read are marked in the chapter list.
+- **Progress sync** — finishing a chapter pushes a read-marker back to MangaDex.
+
+MangaDex uses OAuth2 **personal clients**, so logging in is a one-time setup:
+
+1. On [mangadex.org](https://mangadex.org) → **Settings → API Clients**, create a
+   personal client and note its **client ID** and **client secret**. (A new client may
+   need staff approval before it works.)
+2. In the app: **Settings → Log in to MangaDex…**, then enter the client id/secret plus
+   your MangaDex username and password.
+
+The session is **durable** — it requests an `offline_access` token and persists it, so
+you stay logged in across restarts until you explicitly **log out** (Settings). Only the
+client id/secret + refresh token are stored, in `~/.komado/credentials.json` (mode
+`600`); your password is never written to disk. Toggle write-back any time with
+**Settings → Sync reading progress**.
+
+## Local library layout
+
+Add library folders in **Settings → Add library path…**. Within a library folder:
+
+```
+My Library/
+  Berserk/                 # folder = a manga
+    Chapter 1/             #   image subfolder = a chapter
+      001.jpg 002.jpg …
+    Chapter 2.cbz          #   …or a .cbz/.zip = a chapter
+  One Shot.cbz             # a standalone .cbz = a single-chapter manga
+```
+
+Pages are ordered naturally (`2` before `10`). Both `.cbz`/`.zip` and `.cbr`/`.rar`
+archives are supported (RAR via the WASM `node-unrar-js`, no system binary needed).
+
+## Where state lives
+
+Everything is self-contained under `~/.komado/` (override with `KOMADO_HOME`):
+
+- `config.json` — preferences + library paths
+- `progress.json` — reading progress
+- `credentials.json` — MangaDex login (client id/secret + refresh token; mode `600`)
+- `cache/` — scratch space for the renderer
+
+## Architecture
+
+The layering mirrors a route→controller→service→db backend, adapted for a TUI:
+
+```
+cli.js → app.js (screen stack) → screens → hooks/state → sources/* → HTTP | filesystem
+                                     └──────────────→ render/* (image → terminal)
+```
+
+- **`src/sources/*`** — each source (`mangadex`, `local`) implements the same interface
+  (`search`, `getManga`, `listChapters`, `getPages`, `loadPageBuffer`) and returns the
+  unified `{ data, pagination, meta }` envelope. The only source-specific seam is
+  `loadPageBuffer`, which resolves raw bytes.
+- **`src/domain/shape.js`** — the unified `Manga`/`Chapter` contract.
+- **`src/render/*`** — capability detection + half-block (`sharp`) and `chafa` backends
+  behind one `renderInline()` dispatcher, with half-block as the always-works fallback.
+- **`src/lib/*`** — cross-cutting utilities ported from a server toolkit:
+  `fetchWithBackoff` (retries 429/5xx + timeout), `createCache` (TTL + negative caching
+  + stampede protection), `AppError`/typed errors, the response `envelope`.
+- **`src/components/*` + `src/hooks/*`** — Ink UI. Effects use a cancelled-flag/abort
+  guard against out-of-order responses, and reading progress writes are debounced.
+
+## Development
+
+UI is plain JSX in `.js` files, transpiled to `dist/` by esbuild (a small
+`scripts/build.mjs` does a transpile-only, structure-preserving build — no bundling,
+so package imports stay external).
+
+```bash
+npm run build    # src/ → dist/  (esbuild, JSX automatic runtime)
+npm run lint     # ESLint 9 (flat config, eslint-plugin-react + react-hooks)
+npm test         # Vitest: lib/source unit tests + an ink-testing-library UI test
+```
+
+`npm test` covers the cache, backoff, envelope, natural sort, MangaDex normalization,
+MangaDex auth (token refresh, offline-scope fallback, session handling) and the authed
+source methods, the local source (folder + `.cbz` + `.cbr`), and an end-to-end UI walk
+(home → local manga → reader) via ink-testing-library. The `.cbr` test is skipped
+automatically where the `rar` binary isn't available.
+
+## Roadmap
+
+- True sixel/kitty fullscreen page view (beyond the standalone `render` command)
+- On-disk page cache for offline re-reads of MangaDex chapters
+
+## Legal
+
+Uses the public MangaDex API for personal reading. Respect MangaDex’s
+[terms](https://api.mangadex.org/docs/) and rate limits, and support official releases
+where available.
+
+## License
+
+MIT

package/dist/app.js

@@ -0,0 +1,59 @@
+import { jsx } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, useApp, useInput } from "ink";
+import { UIContext } from "./ui-context.js";
+import { useStdoutDimensions } from "./hooks/useStdoutDimensions.js";
+import { flushProgress } from "./state/store.js";
+import { HomeScreen } from "./components/screens/HomeScreen.js";
+import { SearchScreen } from "./components/screens/SearchScreen.js";
+import { MangaScreen } from "./components/screens/MangaScreen.js";
+import { ReaderScreen } from "./components/screens/ReaderScreen.js";
+import { SettingsScreen } from "./components/screens/SettingsScreen.js";
+import { ContinueScreen } from "./components/screens/ContinueScreen.js";
+import { LoginScreen } from "./components/screens/LoginScreen.js";
+import { LibraryScreen } from "./components/screens/LibraryScreen.js";
+const SCREENS = {
+  home: HomeScreen,
+  search: SearchScreen,
+  manga: MangaScreen,
+  reader: ReaderScreen,
+  settings: SettingsScreen,
+  continue: ContinueScreen,
+  login: LoginScreen,
+  library: LibraryScreen
+};
+function App({ caps = {}, onViewer, initialRoute = null }) {
+  const { exit } = useApp();
+  const dimensions = useStdoutDimensions();
+  const [stack, setStack] = useState(
+    initialRoute ? [{ name: "home", params: {} }, initialRoute] : [{ name: "home", params: {} }]
+  );
+  const [typing, setTyping] = useState(false);
+  const navigate = useCallback((name, params = {}) => setStack((s) => [...s, { name, params }]), []);
+  const goBack = useCallback(() => setStack((s) => s.length > 1 ? s.slice(0, -1) : s), []);
+  const replace = useCallback((name, params = {}) => setStack((s) => [...s.slice(0, -1), { name, params }]), []);
+  const quit = useCallback(() => {
+    flushProgress();
+    exit();
+  }, [exit]);
+  useInput((input, key) => {
+    if (typing) return;
+    if (input === "q") quit();
+    else if (key.escape) goBack();
+  });
+  const current = stack[stack.length - 1];
+  const Screen = SCREENS[current.name] || HomeScreen;
+  const openReader = useCallback(
+    (payload) => {
+      const pixel = onViewer && (caps.sixel || caps.kitty) && caps.chafa && !process.env.KOMADO_NO_PIXEL;
+      if (pixel) onViewer(payload);
+      else navigate("reader", payload);
+    },
+    [onViewer, caps, navigate]
+  );
+  const ctx = { navigate, goBack, replace, exit: quit, setTyping, dimensions, caps, openReader };
+  return /* @__PURE__ */ jsx(UIContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 1, children: /* @__PURE__ */ jsx(Screen, { params: current.params }, `${stack.length}:${current.name}`) }) });
+}
+export {
+  App
+};

package/dist/cli.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import { jsx } from "react/jsx-runtime";
+import process from "node:process";
+function printHelp() {
+  console.log(`komado \u2014 a terminal manga reader (MangaDex + local files)
+
+Usage:
+  komado                 launch the interactive reader
+  komado doctor          print terminal/image capabilities and config
+  komado render <img>    render one image (path or URL) at best fidelity
+  komado --version       print version
+  komado --help          show this help
+
+On a sixel/kitty terminal, opening a chapter launches a full-resolution pixel
+viewer:  \u2190/\u2192 or a/d page \xB7 \u2191/\u2193 pan \xB7 N/P chapter \xB7 f fit-width/whole-page \xB7 q back
+
+Otherwise the in-terminal cell reader is used:
+  \u2191/\u2193 or j/k   scroll        \u2190/\u2192 or h/l   prev/next page
+  space        page down     N / P        next/prev chapter
+  f            fit-to-screen r            cycle renderer
+  g / G        top / bottom  esc          back        q   quit
+`);
+}
+async function doctor() {
+  const { detectCapabilities, probeTerminal } = await import("./render/detect.js");
+  const { paths, ensureDirs } = await import("./config.js");
+  const { getConfig } = await import("./state/store.js");
+  ensureDirs();
+  const caps = detectCapabilities();
+  const cfg = getConfig();
+  const probe = await probeTerminal();
+  console.log("komado doctor\n");
+  console.log("Terminal:");
+  console.log(`  TERM=${caps.term}  TERM_PROGRAM=${caps.termProgram || "(none)"}`);
+  console.log(`  truecolor:        ${caps.truecolor}`);
+  if (probe.queried) {
+    console.log(`  kitty graphics:   ${probe.kitty}  (probed)`);
+    console.log(`  sixel:            ${probe.sixel}  (probed)`);
+    if (probe.cellW || probe.cellH) {
+      console.log(`  cell size:        ${probe.cellW ?? "?"}x${probe.cellH ?? "?"} px`);
+    }
+  } else {
+    console.log(`  kitty graphics:   ${caps.kitty}  (env guess \u2014 run in a real terminal to probe)`);
+    console.log(`  sixel:            ${caps.sixel}  (env guess \u2014 run in a real terminal to probe)`);
+  }
+  console.log(`  chafa:            ${caps.chafa ? caps.chafaVersion : "not installed"}`);
+  console.log(`  inline backend:   ${caps.chafa ? "chafa-symbols" : "half-block"}  (config.renderer=${cfg.renderer})`);
+  if (probe.queried) {
+    const protos = [probe.kitty && "kitty", probe.sixel && "sixel"].filter(Boolean);
+    console.log(
+      protos.length ? `
+  \u2192 Pixel graphics available (${protos.join(", ")}). Crisp rendering is possible:
+    test it with  node dist/cli.js render <some-image>` : "\n  \u2192 No pixel protocol detected \u2014 rendering is limited to character cells."
+    );
+  }
+  console.log("\nPaths:");
+  console.log(`  home:     ${paths.home}`);
+  console.log(`  config:   ${paths.configFile}`);
+  console.log(`  progress: ${paths.progressFile}`);
+  console.log(`  cache:    ${paths.cacheDir}`);
+  console.log("\nConfig:");
+  console.log(`  language:          ${cfg.language}`);
+  console.log(`  dataSaver:         ${cfg.dataSaver}`);
+  console.log(`  renderer:          ${cfg.renderer}`);
+  console.log(`  contentRating:     ${cfg.contentRating.join(", ")}`);
+  console.log(`  localLibraryPaths: ${cfg.localLibraryPaths.length ? cfg.localLibraryPaths.join(", ") : "(none \u2014 add in Settings)"}`);
+}
+async function renderCmd(target, rest) {
+  if (!target) {
+    console.error("usage: komado render <image-path-or-url> [width]");
+    process.exit(1);
+  }
+  const width = Number(rest[0]) || process.stdout.columns || 80;
+  let buf;
+  if (/^https?:/.test(target)) {
+    const { fetchWithBackoff } = await import("./lib/fetchWithBackoff.js");
+    const res = await fetchWithBackoff(target);
+    buf = Buffer.from(await res.arrayBuffer());
+  } else {
+    buf = await (await import("node:fs/promises")).readFile(target);
+  }
+  const { detectCapabilities } = await import("./render/detect.js");
+  const caps = detectCapabilities();
+  if (caps.chafa && process.stdout.isTTY) {
+    const os = await import("node:os");
+    const path = await import("node:path");
+    const { writeFile, unlink } = await import("node:fs/promises");
+    const sharp = (await import("sharp")).default;
+    const { imageSize } = await import("./render/image.js");
+    const { spawnChafaToTerminal } = await import("./render/chafa.js");
+    const { width: iw, height: ih } = await imageSize(buf);
+    const rows = Math.max(1, Math.round(ih / iw * width / 2));
+    const tmp = path.join(os.tmpdir(), `komado-render-${Date.now()}.png`);
+    await writeFile(tmp, await sharp(buf).png().toBuffer());
+    spawnChafaToTerminal(tmp, { cols: width, rows });
+    await unlink(tmp).catch(() => {
+    });
+  } else {
+    const { renderHalfBlock } = await import("./render/halfblock.js");
+    const out = await renderHalfBlock(buf, { cols: width });
+    process.stdout.write(out.lines.join("\n") + "\n");
+  }
+}
+async function runApp() {
+  const { ensureDirs, paths } = await import("./config.js");
+  const { appendFileSync } = await import("node:fs");
+  ensureDirs();
+  if (!process.stdout.isTTY) {
+    console.error("komado needs an interactive terminal (TTY). Run it directly in your terminal.");
+    process.exit(1);
+  }
+  const logCrash = (label, err) => {
+    try {
+      appendFileSync(paths.logFile, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${label}: ${err?.stack || err}
+`);
+    } catch {
+    }
+  };
+  const { detectCapabilities, probeTerminal } = await import("./render/detect.js");
+  const probed = process.env.KOMADO_FORCE_PIXEL ? { queried: true, sixel: true, kitty: false } : await probeTerminal();
+  const caps = { ...detectCapabilities(), ...probed };
+  const { render } = await import("ink");
+  const { App } = await import("./app.js");
+  const { runViewer } = await import("./sixel-reader.js");
+  const restore = () => process.stdout.write("\x1B[?25h\x1B[?1049l");
+  process.stdout.write("\x1B[?1049h\x1B[?25l");
+  process.on("exit", restore);
+  try {
+    let resumeRoute = null;
+    for (; ; ) {
+      let viewerRequest = null;
+      let instance;
+      const onViewer = (payload) => {
+        viewerRequest = payload;
+        setImmediate(() => {
+          try {
+            instance.unmount();
+          } catch (err) {
+            logCrash("unmount failed", err);
+          }
+        });
+      };
+      instance = render(/* @__PURE__ */ jsx(App, { caps, onViewer, initialRoute: resumeRoute }), {
+        exitOnCtrlC: true
+      });
+      try {
+        await instance.waitUntilExit();
+      } catch (err) {
+        logCrash("ink exited with error", err);
+      }
+      if (!viewerRequest) break;
+      process.stdin.resume();
+      try {
+        resumeRoute = await runViewer({ ...viewerRequest, caps });
+      } catch (err) {
+        logCrash("viewer crashed", err);
+        resumeRoute = { name: "manga", params: { sourceId: viewerRequest.sourceId, manga: viewerRequest.manga } };
+      }
+    }
+  } finally {
+    restore();
+    process.removeListener("exit", restore);
+  }
+}
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  switch (cmd) {
+    case "--help":
+    case "-h":
+      return printHelp();
+    case "--version":
+    case "-v": {
+      const { readFileSync } = await import("node:fs");
+      const url = new URL("../package.json", import.meta.url);
+      return console.log(JSON.parse(readFileSync(url, "utf8")).version);
+    }
+    case "doctor":
+      return doctor();
+    case "render":
+      return renderCmd(rest[0], rest.slice(1));
+    default:
+      return runApp();
+  }
+}
+main().catch(async (err) => {
+  process.stdout.write("\x1B[?25h\x1B[?1049l");
+  try {
+    const { appendFileSync } = await import("node:fs");
+    const { paths } = await import("./config.js");
+    appendFileSync(paths.logFile, `[${(/* @__PURE__ */ new Date()).toISOString()}] FATAL: ${err?.stack || err}
+`);
+  } catch {
+  }
+  console.error(err);
+  process.exit(1);
+});

package/dist/components/List.js

@@ -0,0 +1,41 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+function List({
+  items = [],
+  onSelect,
+  onHighlight,
+  renderItem,
+  height = 12,
+  isActive = true,
+  emptyText = "Nothing here yet."
+}) {
+  const [index, setIndex] = useState(0);
+  const count = items.length;
+  const selected = count ? Math.min(index, count - 1) : 0;
+  useEffect(() => {
+    if (count) onHighlight?.(items[selected], selected);
+  }, [selected, count]);
+  useInput((input, key) => {
+    if (!count) return;
+    if (key.downArrow || input === "j") setIndex(Math.min(count - 1, selected + 1));
+    else if (key.upArrow || input === "k") setIndex(Math.max(0, selected - 1));
+    else if (key.pageDown) setIndex(Math.min(count - 1, selected + height));
+    else if (key.pageUp) setIndex(Math.max(0, selected - height));
+    else if (input === "g") setIndex(0);
+    else if (input === "G") setIndex(count - 1);
+    else if (key.return) onSelect?.(items[selected], selected);
+  }, { isActive });
+  if (!count) {
+    return /* @__PURE__ */ jsx(Text, { dimColor: true, children: emptyText });
+  }
+  const start = Math.max(0, Math.min(selected - Math.floor(height / 2), Math.max(0, count - height)));
+  const slice = items.slice(start, start + height);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    slice.map((item, i) => renderItem(item, start + i === selected, start + i)),
+    count > height ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \xB7 ${selected + 1}/${count} \xB7` }, "more") : null
+  ] });
+}
+export {
+  List
+};

package/dist/components/screens/ContinueScreen.js

@@ -0,0 +1,66 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text } from "ink";
+import { useUI } from "../../ui-context.js";
+import { getSource } from "../../sources/index.js";
+import { getAllProgress } from "../../state/store.js";
+import { makeManga } from "../../domain/shape.js";
+import { List } from "../List.js";
+import { Header, Spinner, ErrorView, KeyHints } from "../ui.js";
+import { truncate, relativeTime } from "../../lib/text.js";
+function ContinueScreen() {
+  const ui = useUI();
+  const entries = getAllProgress();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const open = async (entry) => {
+    const source = getSource(entry.source);
+    setLoading(true);
+    setError(null);
+    try {
+      const [manga, chRes] = await Promise.all([
+        source.getManga(entry.mangaId).catch(() => makeManga({ source: entry.source, id: entry.mangaId, title: entry.mangaTitle })),
+        source.listChapters(entry.mangaId, { limit: 500 })
+      ]);
+      const idx = chRes.data.findIndex((c) => c.id === entry.chapterId);
+      ui.openReader({
+        sourceId: entry.source,
+        manga,
+        chapters: chRes.data,
+        chapterIndex: Math.max(0, idx),
+        startPage: entry.page || 0
+      });
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  };
+  if (loading) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Header, { title: "Continue reading" }),
+      /* @__PURE__ */ jsx(Spinner, { label: "Opening" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Header, { title: "Continue reading", subtitle: "pick up where you left off" }),
+    error ? /* @__PURE__ */ jsx(ErrorView, { error }) : null,
+    /* @__PURE__ */ jsx(
+      List,
+      {
+        items: entries,
+        height: Math.max(5, (ui.dimensions.rows || 24) - 7),
+        onSelect: open,
+        emptyText: "No reading history yet.",
+        renderItem: (e, active) => /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsx(Text, { inverse: active, color: active ? "cyanBright" : void 0, children: ` ${truncate(e.mangaTitle || e.mangaId, 40)} \xB7 ${e.chapterNumber != null ? `Ch.${e.chapterNumber}` : "Oneshot"} p.${(e.page || 0) + 1} ` }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: relativeTime(e.updatedAt) })
+        ] }, `${e.source}:${e.mangaId}`)
+      }
+    ),
+    /* @__PURE__ */ jsx(KeyHints, { hints: [["\u2191\u2193", "move"], ["enter", "resume"], ["esc", "back"]] })
+  ] });
+}
+export {
+  ContinueScreen
+};

package/dist/components/screens/HomeScreen.js

@@ -0,0 +1,59 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useUI } from "../../ui-context.js";
+import { List } from "../List.js";
+import { Header, KeyHints } from "../ui.js";
+import { getAllProgress } from "../../state/store.js";
+import { isLoggedIn } from "../../sources/mangadex/auth.js";
+function HomeScreen() {
+  const ui = useUI();
+  const hasProgress = getAllProgress().length > 0;
+  const items = [
+    { id: "search", label: "Search MangaDex", hint: "online catalog" },
+    { id: "browse", label: "Popular on MangaDex", hint: "most followed" },
+    ...isLoggedIn() ? [{ id: "library", label: "My Library (MangaDex)", hint: "your follows" }] : [],
+    { id: "local", label: "Local library", hint: "your CBZ / folders" },
+    ...hasProgress ? [{ id: "continue", label: "Continue reading", hint: "resume" }] : [],
+    { id: "settings", label: "Settings", hint: "config & library paths" },
+    { id: "quit", label: "Quit", hint: "" }
+  ];
+  const onSelect = (item) => {
+    switch (item.id) {
+      case "search":
+        return ui.navigate("search", { sourceId: "mangadex", mode: "search" });
+      case "browse":
+        return ui.navigate("search", { sourceId: "mangadex", mode: "browse" });
+      case "library":
+        return ui.navigate("library", { sourceId: "mangadex" });
+      case "local":
+        return ui.navigate("search", { sourceId: "local", mode: "browse" });
+      case "continue":
+        return ui.navigate("continue");
+      case "settings":
+        return ui.navigate("settings");
+      case "quit":
+        return ui.exit();
+      default:
+        return void 0;
+    }
+  };
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Header, { title: "komado", subtitle: "a terminal manga reader \xB7 MangaDex + local files" }),
+    /* @__PURE__ */ jsx(
+      List,
+      {
+        items,
+        height: items.length,
+        onSelect,
+        renderItem: (item, active) => /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { inverse: active, color: active ? "cyanBright" : void 0, children: ` ${active ? "\u203A" : " "} ${item.label} ` }),
+          item.hint ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  ${item.hint}` }) : null
+        ] }, item.id)
+      }
+    ),
+    /* @__PURE__ */ jsx(KeyHints, { hints: [["\u2191\u2193", "move"], ["enter", "select"], ["q", "quit"]] })
+  ] });
+}
+export {
+  HomeScreen
+};