watchwhere 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watchwhere",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "region-aware streaming availability CLI — find which of your subs has a given title",
   "type": "module",
   "bin": {

package/src/i18n.ts

@@ -127,6 +127,9 @@ interface Catalog {
   // non-TTY
   ttyRequired: (cmd: string) => string;
   ambiguousQuery: (n: number) => string;
+
+  // update notifier
+  updateAvailable: (version: string) => string;
 }
 
 const en: Catalog = {
@@ -228,8 +231,10 @@ const en: Catalog = {
   relativeHours: (n) => `${n} hr ago`,
   relativeDays: (n) => `${n} day${n === 1 ? "" : "s"} ago`,
 
-  ttyRequired: (cmd) => `\`ww ${cmd}\` is interactive — run it in a terminal, not a pipe.`,
-  ambiguousQuery: (n) => `${n} matches — query is ambiguous. refine, or run interactively.`,
+  ttyRequired: (cmd) => `\`ww ${cmd}\` is interactive. run it in a terminal, not a pipe.`,
+  ambiguousQuery: (n) => `${n} matches, query is ambiguous. refine, or run interactively.`,
+
+  updateAvailable: (version) => `new version available: ${version} (bun install -g watchwhere)`,
 };
 
 const tr: Catalog = {
@@ -334,8 +339,10 @@ const tr: Catalog = {
   relativeHours: (n) => `${n} saat önce`,
   relativeDays: (n) => `${n} gün önce`,
 
-  ttyRequired: (cmd) => `\`ww ${cmd}\` interaktif — pipe'da değil, terminalde çalıştır.`,
-  ambiguousQuery: (n) => `${n} eşleşme var — sorgu belirsiz. daralt veya interaktif çalıştır.`,
+  ttyRequired: (cmd) => `\`ww ${cmd}\` interaktif. pipe'da değil, terminalde çalıştır.`,
+  ambiguousQuery: (n) => `${n} eşleşme var, sorgu belirsiz. daralt veya interaktif çalıştır.`,
+
+  updateAvailable: (version) => `yeni sürüm var: ${version} (bun install -g watchwhere)`,
 };
 
 const CATALOGS: Record<Locale, Catalog> = { en, tr };

package/src/index.ts

@@ -10,6 +10,7 @@ import { runSubs } from "./commands/subs.ts";
 import { runLang } from "./commands/lang.ts";
 import { runRegion } from "./commands/region.ts";
 import { TmdbError } from "./tmdb.ts";
+import { checkForUpdate } from "./update-check.ts";
 
 function usage(m: ReturnType<typeof t>): string {
   return [
@@ -125,7 +126,31 @@ async function main(): Promise<void> {
   await runSearch(args.join(" "), cfg);
 }
 
-main().catch(async (err: unknown) => {
+async function maybeNotifyUpdate(): Promise<void> {
+  // skip on quick lookups, only show after real work
+  const first = process.argv[2];
+  if (
+    !first ||
+    first === "--version" ||
+    first === "-v" ||
+    first === "--help" ||
+    first === "-h"
+  ) {
+    return;
+  }
+  try {
+    const newer = await checkForUpdate(pkg.version);
+    if (!newer) return;
+    const cfg = await loadConfig().catch(() => null);
+    const m = t(resolveLocale(cfg?.language));
+    console.log();
+    console.log(c.dim(`  ${c.yellow("›")} ${m.updateAvailable(newer)}`));
+  } catch {
+    // best-effort, never block exit
+  }
+}
+
+main().then(maybeNotifyUpdate).catch(async (err: unknown) => {
   const cfg = await loadConfig().catch(() => null);
   const m = t(resolveLocale(cfg?.language));
 

package/src/update-check.ts

@@ -0,0 +1,73 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CACHE_DIR = join(homedir(), ".watchwhere", "cache");
+const CACHE_FILE = join(CACHE_DIR, "update.json");
+const TTL_MS = 24 * 60 * 60 * 1000;
+const REGISTRY_URL = "https://registry.npmjs.org/watchwhere/latest";
+const FETCH_TIMEOUT_MS = 3000;
+
+interface UpdateCache {
+  checkedAt: string;
+  latest: string;
+}
+
+function parseCache(raw: unknown): UpdateCache | null {
+  if (typeof raw !== "object" || raw === null) return null;
+  const v = raw as { checkedAt?: unknown; latest?: unknown };
+  if (typeof v.checkedAt !== "string" || typeof v.latest !== "string") return null;
+  return { checkedAt: v.checkedAt, latest: v.latest };
+}
+
+async function readCache(): Promise<UpdateCache | null> {
+  try {
+    const raw = await readFile(CACHE_FILE, "utf8");
+    const parsed = parseCache(JSON.parse(raw) as unknown);
+    if (!parsed) return null;
+    const age = Date.now() - Date.parse(parsed.checkedAt);
+    if (Number.isNaN(age) || age > TTL_MS || age < 0) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+async function writeCache(latest: string): Promise<void> {
+  await mkdir(CACHE_DIR, { recursive: true, mode: 0o700 });
+  const entry: UpdateCache = { checkedAt: new Date().toISOString(), latest };
+  await writeFile(CACHE_FILE, JSON.stringify(entry), "utf8");
+}
+
+function isNewer(latest: string, current: string): boolean {
+  const a = latest.split(".").map((n) => Number.parseInt(n, 10));
+  const b = current.split(".").map((n) => Number.parseInt(n, 10));
+  for (let i = 0; i < 3; i++) {
+    const ai = a[i] ?? 0;
+    const bi = b[i] ?? 0;
+    if (Number.isNaN(ai) || Number.isNaN(bi)) return false;
+    if (ai > bi) return true;
+    if (ai < bi) return false;
+  }
+  return false;
+}
+
+export async function checkForUpdate(currentVersion: string): Promise<string | null> {
+  try {
+    const cached = await readCache();
+    if (cached) {
+      return isNewer(cached.latest, currentVersion) ? cached.latest : null;
+    }
+    const res = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      headers: { Accept: "application/json" },
+    });
+    if (!res.ok) return null;
+    const data = (await res.json()) as { version?: string };
+    if (typeof data.version !== "string") return null;
+    writeCache(data.version).catch(() => {});
+    return isNewer(data.version, currentVersion) ? data.version : null;
+  } catch {
+    return null;
+  }
+}