komado 0.1.0

package/dist/components/screens/SettingsScreen.js

@@ -0,0 +1,144 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useUI } from "../../ui-context.js";
+import { getConfig, setConfig } from "../../state/store.js";
+import { scan } from "../../sources/local/index.js";
+import { isLoggedIn, logout } from "../../sources/mangadex/auth.js";
+import { detectCapabilities } from "../../render/detect.js";
+import { List } from "../List.js";
+import { Header, KeyHints } from "../ui.js";
+import { truncate } from "../../lib/text.js";
+const RENDERERS = ["auto", "halfblock", "chafa"];
+const RATING_PRESETS = [
+  ["safe"],
+  ["safe", "suggestive"],
+  ["safe", "suggestive", "erotica"],
+  ["safe", "suggestive", "erotica", "pornographic"]
+];
+const ratingLabel = (arr) => arr.join("+");
+const cycle = (list, current) => list[(list.indexOf(current) + 1) % list.length];
+function SettingsScreen() {
+  const ui = useUI();
+  const caps = detectCapabilities();
+  const [cfg, setCfg] = useState(getConfig());
+  const [editing, setEditing] = useState(null);
+  const [draft, setDraft] = useState("");
+  const [highlighted, setHighlighted] = useState(null);
+  const [, setTick] = useState(0);
+  const loggedIn = isLoggedIn();
+  useEffect(() => {
+    ui.setTyping(!!editing);
+    return () => ui.setTyping(false);
+  }, [editing]);
+  const save = (patch) => setCfg({ ...setConfig(patch) });
+  const items = [
+    {
+      id: "account",
+      kind: "account",
+      label: loggedIn ? "MangaDex account" : "Log in to MangaDex\u2026",
+      value: loggedIn ? "logged in \xB7 enter to log out" : "enter to log in"
+    },
+    ...loggedIn ? [{ id: "syncProgress", kind: "toggle", label: "Sync reading progress (MangaDex)", value: cfg.syncProgress ? "on" : "off" }] : [],
+    { id: "renderer", kind: "cycle", label: "Renderer", value: cfg.renderer + (caps.chafa ? "" : " (chafa N/A)") },
+    { id: "dataSaver", kind: "toggle", label: "Data saver (smaller images)", value: cfg.dataSaver ? "on" : "off" },
+    { id: "rating", kind: "cycle", label: "Content rating", value: ratingLabel(cfg.contentRating) },
+    { id: "language", kind: "edit", label: "Language (MangaDex)", value: cfg.language },
+    { id: "addPath", kind: "action", label: "Add library path\u2026", value: "" },
+    ...cfg.localLibraryPaths.map((p, i) => ({
+      id: `path:${i}`,
+      kind: "path",
+      pathIndex: i,
+      label: `Library: ${truncate(p, 48)}`,
+      value: "d to remove"
+    }))
+  ];
+  const activate = (item) => {
+    switch (item.kind) {
+      case "account":
+        if (loggedIn) {
+          logout();
+          return setTick((t) => t + 1);
+        }
+        return ui.navigate("login");
+      case "toggle":
+        if (item.id === "syncProgress") return save({ syncProgress: !cfg.syncProgress });
+        return save({ dataSaver: !cfg.dataSaver });
+      case "cycle":
+        if (item.id === "renderer") return save({ renderer: cycle(RENDERERS, cfg.renderer) });
+        if (item.id === "rating") {
+          const idx = RATING_PRESETS.findIndex((p) => ratingLabel(p) === ratingLabel(cfg.contentRating));
+          return save({ contentRating: RATING_PRESETS[(idx + 1) % RATING_PRESETS.length] });
+        }
+        return void 0;
+      case "edit":
+        setDraft(cfg.language);
+        return setEditing("language");
+      case "action":
+        setDraft("");
+        return setEditing("addPath");
+      default:
+        return void 0;
+    }
+  };
+  const submitEdit = () => {
+    if (editing === "language") {
+      save({ language: draft.trim() || "en" });
+    } else if (editing === "addPath" && draft.trim()) {
+      save({ localLibraryPaths: [...cfg.localLibraryPaths, draft.trim()] });
+      scan();
+    }
+    setEditing(null);
+    setDraft("");
+  };
+  useInput((input, key) => {
+    if (editing) {
+      if (key.escape) {
+        setEditing(null);
+        setDraft("");
+      }
+      return;
+    }
+    if (input === "d" && highlighted?.kind === "path") {
+      save({ localLibraryPaths: cfg.localLibraryPaths.filter((_, i) => i !== highlighted.pathIndex) });
+      scan();
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(
+      Header,
+      {
+        title: "Settings",
+        subtitle: `chafa: ${caps.chafa ? caps.chafaVersion : "not installed"} \xB7 backend: ${caps.chafa ? "chafa-symbols" : "half-block"}`
+      }
+    ),
+    editing ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyanBright", children: editing === "addPath" ? "New library path (folder of manga / CBZ):" : "Language code (e.g. en, fr, ja):" }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyanBright", children: "\u203A " }),
+        /* @__PURE__ */ jsx(TextInput, { value: draft, onChange: setDraft, onSubmit: submitEdit, focus: true })
+      ] }),
+      /* @__PURE__ */ jsx(KeyHints, { hints: [["enter", "save"], ["esc", "cancel"]] })
+    ] }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(
+        List,
+        {
+          items,
+          isActive: true,
+          height: Math.max(6, (ui.dimensions.rows || 24) - 7),
+          onSelect: activate,
+          onHighlight: (it) => setHighlighted(it),
+          renderItem: (it, active) => /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+            /* @__PURE__ */ jsx(Text, { inverse: active, color: active ? "cyanBright" : it.kind === "path" ? "blue" : void 0, children: ` ${it.label} ` }),
+            it.value ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: it.value }) : null
+          ] }, it.id)
+        }
+      ),
+      /* @__PURE__ */ jsx(KeyHints, { hints: [["\u2191\u2193", "move"], ["enter", "change"], ["d", "remove path"], ["esc", "back"]] })
+    ] })
+  ] });
+}
+export {
+  SettingsScreen
+};

package/dist/components/ui.js

@@ -0,0 +1,33 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text } from "ink";
+const FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function Spinner({ label = "Loading" }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const t = setInterval(() => setFrame((f) => (f + 1) % FRAMES.length), 80);
+    return () => clearInterval(t);
+  }, []);
+  return /* @__PURE__ */ jsx(Text, { color: "cyan", children: `${FRAMES[frame]} ${label}\u2026` });
+}
+function Header({ title, subtitle }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: "magentaBright", bold: true, children: title }),
+    subtitle ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: subtitle }) : null
+  ] });
+}
+function ErrorView({ error }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { color: "red", bold: true, children: `\u2716 ${error?.message || "Something went wrong"}` }),
+    error?.statusCode ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: `status ${error.statusCode}` }) : null
+  ] });
+}
+function KeyHints({ hints = [] }) {
+  return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: hints.map(([k, l]) => `${k} ${l}`).join("   ") }) });
+}
+export {
+  ErrorView,
+  Header,
+  KeyHints,
+  Spinner
+};

package/dist/config.js

@@ -0,0 +1,51 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+const usingDefaultHome = !process.env.KOMADO_HOME;
+const HOME = usingDefaultHome ? path.join(os.homedir(), ".komado") : path.resolve(process.env.KOMADO_HOME);
+const LEGACY_HOME = path.join(os.homedir(), ".manga-tui");
+const paths = {
+  home: HOME,
+  configFile: path.join(HOME, "config.json"),
+  progressFile: path.join(HOME, "progress.json"),
+  credentialsFile: path.join(HOME, "credentials.json"),
+  cacheDir: path.join(HOME, "cache"),
+  logFile: path.join(HOME, "komado.log")
+};
+function ensureDirs() {
+  if (usingDefaultHome && !fs.existsSync(HOME) && fs.existsSync(LEGACY_HOME)) {
+    try {
+      fs.renameSync(LEGACY_HOME, HOME);
+    } catch {
+    }
+  }
+  fs.mkdirSync(paths.home, { recursive: true });
+  fs.mkdirSync(paths.cacheDir, { recursive: true });
+}
+const DEFAULT_CONFIG = {
+  localLibraryPaths: [],
+  // directories scanned by the local source
+  language: "en",
+  // preferred MangaDex translatedLanguage
+  contentRating: ["safe", "suggestive"],
+  dataSaver: true,
+  // smaller MangaDex page images — ideal for a terminal
+  renderer: "auto",
+  // auto | halfblock | chafa
+  theme: "default",
+  syncProgress: true
+  // push read-markers to MangaDex while logged in
+};
+const MANGADEX = {
+  api: "https://api.mangadex.org",
+  auth: "https://auth.mangadex.org/realms/mangadex/protocol/openid-connect/token",
+  uploads: "https://uploads.mangadex.org",
+  userAgent: "komado/0.1 (+https://github.com/RyuPrad/komado)",
+  pageLimit: 20
+};
+export {
+  DEFAULT_CONFIG,
+  MANGADEX,
+  ensureDirs,
+  paths
+};

package/dist/domain/shape.js

@@ -0,0 +1,44 @@
+const globalKey = (source, id) => `${source}:${id}`;
+function makeManga(p) {
+  return {
+    source: p.source,
+    id: String(p.id),
+    key: globalKey(p.source, p.id),
+    title: p.title || "Untitled",
+    altTitles: p.altTitles || [],
+    description: p.description || "",
+    authors: p.authors || [],
+    status: p.status || "unknown",
+    tags: p.tags || [],
+    coverUrl: p.coverUrl || null,
+    language: p.language || "en",
+    chaptersCount: p.chaptersCount ?? null,
+    raw: p.raw
+  };
+}
+function makeChapter(p) {
+  return {
+    source: p.source,
+    id: String(p.id),
+    key: globalKey(p.source, p.id),
+    mangaKey: p.mangaKey,
+    number: p.number ?? null,
+    // string like "12.5", or null for oneshots
+    volume: p.volume ?? null,
+    title: p.title || "",
+    language: p.language || "en",
+    pages: p.pages ?? null,
+    publishedAt: p.publishedAt || null,
+    raw: p.raw
+  };
+}
+function chapterLabel(ch) {
+  const head = ch.number != null && ch.number !== "" ? `Ch. ${ch.number}${ch.volume != null && ch.volume !== "" ? ` (Vol. ${ch.volume})` : ""}` : "Oneshot";
+  return ch.title ? `${head} \u2014 ${ch.title}` : head;
+}
+export {
+  chapterLabel,
+  globalKey,
+  makeChapter,
+  makeManga
+};

package/dist/hooks/useStdoutDimensions.js

@@ -0,0 +1,17 @@
+import { useState, useEffect } from "react";
+function useStdoutDimensions() {
+  const read = () => ({
+    cols: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24
+  });
+  const [size, setSize] = useState(read);
+  useEffect(() => {
+    const onResize = () => setSize(read());
+    process.stdout.on("resize", onResize);
+    return () => process.stdout.off("resize", onResize);
+  }, []);
+  return size;
+}
+export {
+  useStdoutDimensions
+};

package/dist/lib/AppError.js

@@ -0,0 +1,37 @@
+class AppError extends Error {
+  constructor(message, statusCode = 500, opts = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.isOperational = true;
+    if (opts.cause) this.cause = opts.cause;
+    if (opts.meta) Object.assign(this, opts.meta);
+  }
+}
+class NotFoundError extends AppError {
+  constructor(message = "Not found", opts) {
+    super(message, 404, opts);
+  }
+}
+class SourceError extends AppError {
+  constructor(message = "Source unavailable", opts) {
+    super(message, 502, opts);
+  }
+}
+class UnsupportedError extends AppError {
+  constructor(message = "Unsupported", opts) {
+    super(message, 422, opts);
+  }
+}
+class AuthError extends AppError {
+  constructor(message = "Authentication required", opts) {
+    super(message, 401, opts);
+  }
+}
+export {
+  AppError,
+  AuthError,
+  NotFoundError,
+  SourceError,
+  UnsupportedError
+};

package/dist/lib/cache.js

@@ -0,0 +1,54 @@
+function createCache({ ttlMs = 6e4, negativeTtlMs = 5e3, max = 500 } = {}) {
+  const store = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  function get(key) {
+    const entry = store.get(key);
+    if (!entry) return void 0;
+    if (entry.expires <= Date.now()) {
+      store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  function set(key, value, ttl) {
+    const isEmpty = value === null || value === void 0;
+    const life = ttl ?? (isEmpty ? negativeTtlMs : ttlMs);
+    store.set(key, { value, expires: Date.now() + life });
+    if (store.size > max) {
+      const oldest = store.keys().next().value;
+      store.delete(oldest);
+    }
+  }
+  async function wrap(key, fn, ttl) {
+    const cached = get(key);
+    if (cached !== void 0) return cached;
+    if (inflight.has(key)) return inflight.get(key);
+    const promise = (async () => {
+      try {
+        const value = await fn();
+        set(key, value, ttl);
+        return value;
+      } finally {
+        inflight.delete(key);
+      }
+    })();
+    inflight.set(key, promise);
+    return promise;
+  }
+  return {
+    get,
+    set,
+    wrap,
+    delete: (key) => store.delete(key),
+    clear: () => {
+      store.clear();
+      inflight.clear();
+    },
+    get size() {
+      return store.size;
+    }
+  };
+}
+export {
+  createCache
+};

package/dist/lib/catchAsync.js

@@ -0,0 +1,12 @@
+function catchAsync(fn) {
+  return async (...args) => {
+    try {
+      return { data: await fn(...args), error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  };
+}
+export {
+  catchAsync
+};

package/dist/lib/envelope.js

@@ -0,0 +1,15 @@
+function envelope(data, { pagination = null, meta = {} } = {}) {
+  return { data, pagination, meta };
+}
+function paginate({ offset = 0, limit = 0, total = 0 } = {}) {
+  return {
+    offset,
+    limit,
+    total,
+    hasMore: total > 0 ? offset + limit < total : false
+  };
+}
+export {
+  envelope,
+  paginate
+};

package/dist/lib/fetchWithBackoff.js

@@ -0,0 +1,65 @@
+import { SourceError } from "./AppError.js";
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(signal.reason ?? new Error("aborted"));
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(signal.reason ?? new Error("aborted"));
+    }, { once: true });
+  });
+}
+async function fetchWithBackoff(url, options = {}) {
+  const {
+    retries = 4,
+    baseDelayMs = 500,
+    maxDelayMs = 8e3,
+    timeoutMs = 2e4,
+    signal: extSignal,
+    ...fetchOpts
+  } = options;
+  let attempt = 0;
+  for (; ; ) {
+    const ctrl = new AbortController();
+    const onExtAbort = () => ctrl.abort(extSignal.reason);
+    if (extSignal) {
+      if (extSignal.aborted) ctrl.abort(extSignal.reason);
+      else extSignal.addEventListener("abort", onExtAbort, { once: true });
+    }
+    const timer = setTimeout(() => ctrl.abort(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
+    try {
+      const res = await fetch(url, { ...fetchOpts, signal: ctrl.signal });
+      if ((res.status === 429 || res.status >= 500) && attempt < retries) {
+        const retryAfter = Number(res.headers.get("retry-after"));
+        const delay = Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1e3 : Math.min(maxDelayMs, baseDelayMs * 2 ** attempt) + Math.random() * 200;
+        attempt += 1;
+        await sleep(delay, extSignal);
+        continue;
+      }
+      return res;
+    } catch (err) {
+      if (extSignal?.aborted) throw err;
+      if (attempt < retries) {
+        const delay = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt) + Math.random() * 200;
+        attempt += 1;
+        await sleep(delay, extSignal);
+        continue;
+      }
+      throw new SourceError(`Request failed: ${url}`, { cause: err });
+    } finally {
+      clearTimeout(timer);
+      extSignal?.removeEventListener("abort", onExtAbort);
+    }
+  }
+}
+async function fetchJson(url, options = {}) {
+  const res = await fetchWithBackoff(url, options);
+  if (!res.ok) {
+    throw new SourceError(`HTTP ${res.status} for ${url}`, { meta: { statusCode: res.status } });
+  }
+  return res.json();
+}
+export {
+  fetchJson,
+  fetchWithBackoff
+};

package/dist/lib/logger.js

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import { paths } from "../config.js";
+const enabled = !!process.env.KOMADO_DEBUG;
+let stream = null;
+function out() {
+  if (!enabled) return null;
+  if (!stream) {
+    try {
+      fs.mkdirSync(paths.home, { recursive: true });
+      stream = fs.createWriteStream(paths.logFile, { flags: "a" });
+    } catch {
+      stream = null;
+    }
+  }
+  return stream;
+}
+function fmt(arg) {
+  if (typeof arg === "string") return arg;
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+}
+function write(level, args) {
+  const s = out();
+  if (!s) return;
+  s.write(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${level} ${args.map(fmt).join(" ")}
+`);
+}
+const logger = {
+  enabled,
+  debug: (...a) => write("DEBUG", a),
+  info: (...a) => write("INFO", a),
+  warn: (...a) => write("WARN", a),
+  error: (...a) => write("ERROR", a)
+};
+export {
+  logger
+};

package/dist/lib/natsort.js

@@ -0,0 +1,7 @@
+const collator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
+const naturalCompare = (a, b) => collator.compare(String(a), String(b));
+const naturalSort = (arr, key = (x) => x) => [...arr].sort((a, b) => naturalCompare(key(a), key(b)));
+export {
+  naturalCompare,
+  naturalSort
+};

package/dist/lib/text.js

@@ -0,0 +1,20 @@
+function truncate(str, max) {
+  const s = String(str ?? "");
+  if (max <= 1 || s.length <= max) return s;
+  return s.slice(0, Math.max(1, max - 1)) + "\u2026";
+}
+function relativeTime(ts) {
+  if (!ts) return "";
+  const diff = Date.now() - ts;
+  const mins = Math.round(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.round(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  const days = Math.round(hrs / 24);
+  return `${days}d ago`;
+}
+export {
+  relativeTime,
+  truncate
+};

package/dist/render/chafa.js

@@ -0,0 +1,56 @@
+import { execFile, spawnSync } from "node:child_process";
+import { promisify } from "node:util";
+import { writeFile, unlink, mkdir } from "node:fs/promises";
+import path from "node:path";
+import sharp from "sharp";
+import { paths } from "../config.js";
+import { detectCapabilities } from "./detect.js";
+const execFileAsync = promisify(execFile);
+let dirReady = false;
+async function ensureTempDir() {
+  if (dirReady) return;
+  await mkdir(paths.cacheDir, { recursive: true });
+  dirReady = true;
+}
+async function withTempImage(buffer, fn) {
+  await ensureTempDir();
+  const file = path.join(
+    paths.cacheDir,
+    `chafa-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.png`
+  );
+  await writeFile(file, buffer);
+  try {
+    return await fn(file);
+  } finally {
+    unlink(file).catch(() => {
+    });
+  }
+}
+async function renderChafaSymbols(buffer, { cols = 80 } = {}) {
+  const meta = await sharp(buffer).metadata();
+  const aspect = (meta.height || 1) / (meta.width || 1);
+  const rows = Math.max(1, Math.round(aspect * cols / 2));
+  const stdout = await withTempImage(
+    buffer,
+    (file) => execFileAsync(
+      "chafa",
+      ["--format", "symbols", "--colors", "full", "--size", `${cols}x${rows}`, file],
+      { maxBuffer: 96 * 1024 * 1024 }
+    ).then((r) => r.stdout)
+  );
+  const lines = stdout.replace(/\n+$/, "").split("\n");
+  return { lines, cols, rows: lines.length };
+}
+function spawnChafaToTerminal(file, { cols, rows } = {}) {
+  if (!detectCapabilities().chafa) return false;
+  const args = ["--colors", "full"];
+  if (cols && rows) args.push("--size", `${cols}x${rows}`);
+  args.push(file);
+  const res = spawnSync("chafa", args, { stdio: ["ignore", "inherit", "inherit"] });
+  return res.status === 0;
+}
+export {
+  renderChafaSymbols,
+  spawnChafaToTerminal,
+  withTempImage
+};