watchwhere 0.2.2 → 0.3.0

package/README.md

@@ -61,6 +61,10 @@ ww --version
 - self-host your own proxy from [`proxy/`](./proxy) if you'd rather not use
   the hosted one
 
+## attribution
+
+this product uses the TMDB API but is not endorsed or certified by TMDB.
+
 ## license
 
 MIT

package/package.json

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

package/src/commands/init.ts

@@ -3,7 +3,12 @@ import { c } from "../colors.ts";
 import { loadConfig, saveConfig } from "../config.ts";
 import { resolveLocale, t } from "../i18n.ts";
 import { getCachedRegionProviders } from "../cache.ts";
-import { usingProxy, verifyToken } from "../tmdb.ts";
+import {
+  applyRegionPinning,
+  isSubscriptionProvider,
+  usingProxy,
+  verifyToken,
+} from "../tmdb.ts";
 import { pickLanguage } from "./lang.ts";
 
 export async function runInit(): Promise<void> {
@@ -50,7 +55,11 @@ export async function runInit(): Promise<void> {
   const language = await pickLanguage(m, existing?.language);
 
   process.stdout.write(c.dim(`  ${m.loadingProviders(region)}`));
-  const providers = await getCachedRegionProviders(region, tmdbToken.trim());
+  const allProviders = await getCachedRegionProviders(region, tmdbToken.trim());
+  const providers = applyRegionPinning(
+    allProviders.filter(isSubscriptionProvider),
+    region,
+  );
   console.log(c.dim(m.providersFound(providers.length)));
 
   if (providers.length === 0) {

package/src/commands/search.ts

@@ -4,10 +4,12 @@ import { resolveLocale, t } from "../i18n.ts";
 import { picker } from "../picker.ts";
 import { editableInput } from "../prompts.ts";
 import {
+  getReleaseDates,
   getWatchProviders,
   searchAll,
   type MediaItem,
   type TmdbProvider,
+  type TmdbReleaseDate,
 } from "../tmdb.ts";
 
 const PAGE_SIZE = 10;
@@ -34,6 +36,54 @@ function joinNames(providers: ReadonlyArray<TmdbProvider> | undefined): string {
   return providers?.map((p) => p.provider_name).join(", ") ?? "";
 }
 
+// pick at most one entry per modern format (4k / blu-ray / dvd), latest first.
+// older formats (laserdisc, vhs, steelbook, etc.) are dropped to keep output tight.
+const PHYSICAL_FORMATS: ReadonlyArray<{ key: string; match: RegExp }> = [
+  { key: "4k uhd", match: /\b(4k|uhd)\b/i },
+  { key: "blu-ray", match: /blu.?ray/i },
+  { key: "dvd", match: /\bdvd\b/i },
+];
+
+function printPhysical(
+  releases: ReadonlyArray<TmdbReleaseDate>,
+  region: string,
+  m: ReturnType<typeof t>,
+): void {
+  const physical = releases
+    .filter((r) => r.type === 5 && r.note.trim() !== "")
+    .sort((a, b) => b.release_date.localeCompare(a.release_date));
+  if (physical.length === 0) return;
+
+  const byFormat = new Map<string, TmdbReleaseDate>();
+  for (const r of physical) {
+    for (const fmt of PHYSICAL_FORMATS) {
+      if (fmt.match.test(r.note) && !byFormat.has(fmt.key)) {
+        byFormat.set(fmt.key, r);
+        break;
+      }
+    }
+  }
+  if (byFormat.size === 0) return;
+
+  const ordered = PHYSICAL_FORMATS.map((fmt) => byFormat.get(fmt.key)).filter(
+    (r): r is TmdbReleaseDate => r !== undefined,
+  );
+
+  console.log();
+  console.log(c.dim(`  ${m.physicalLabel} (${region})`));
+  const width = Math.max(
+    ...PHYSICAL_FORMATS.filter((fmt) => byFormat.has(fmt.key)).map(
+      (fmt) => fmt.key.length,
+    ),
+  );
+  for (const r of ordered) {
+    const key = PHYSICAL_FORMATS.find((fmt) => fmt.match.test(r.note))!.key;
+    const label = pad(key, width + 2);
+    const date = r.release_date.slice(0, 10);
+    console.log(`  ${c.dim(label)}${date}`);
+  }
+}
+
 async function pickItem(
   results: ReadonlyArray<MediaItem>,
   m: ReturnType<typeof t>,
@@ -86,7 +136,13 @@ async function displayItem(
   m: ReturnType<typeof t>,
 ): Promise<void> {
   process.stdout.write(c.dim(`  ${m.fetchingProviders(cfg.region)}`));
-  const providers = await getWatchProviders(item.id, item.mediaType, cfg.tmdbToken);
+  const [providers, releases] = await Promise.all([
+    getWatchProviders(item.id, item.mediaType, cfg.tmdbToken),
+    // physical releases only exist for movies; failures don't break the search
+    item.mediaType === "movie"
+      ? getReleaseDates(item.id, cfg.tmdbToken).catch(() => null)
+      : Promise.resolve(null),
+  ]);
   console.log(c.dim(m.done));
 
   const regionData = providers.results[cfg.region];
@@ -142,9 +198,21 @@ async function displayItem(
     if (buy.length > 0) console.log(`  ${pad(m.buy, 10)}${joinNames(buy)}`);
   }
 
-  if (regionData.link) {
-    console.log();
-    console.log(`  ${c.dim(m.link)}  ${c.cyan(regionData.link)}`);
+  if (releases) {
+    // physical release data on TMDB is sparse outside of US; if the user's
+    // region has nothing labeled, fall back to US so the feature still works
+    const inRegion =
+      releases.results.find((r) => r.iso_3166_1 === cfg.region)?.release_dates ?? [];
+    const hasLabeled = inRegion.some(
+      (r) => r.type === 5 && r.note.trim() !== "",
+    );
+    if (hasLabeled) {
+      printPhysical(inRegion, cfg.region, m);
+    } else {
+      const usReleases =
+        releases.results.find((r) => r.iso_3166_1 === "US")?.release_dates ?? [];
+      printPhysical(usReleases, "US", m);
+    }
   }
 }
 

package/src/commands/subs.ts

@@ -3,6 +3,7 @@ import { c } from "../colors.ts";
 import { loadConfig, saveConfig } from "../config.ts";
 import { resolveLocale, t } from "../i18n.ts";
 import { getCachedRegionProviders } from "../cache.ts";
+import { applyRegionPinning, isSubscriptionProvider } from "../tmdb.ts";
 
 export async function runSubs(): Promise<void> {
   const cfg = await loadConfig();
@@ -12,7 +13,11 @@ export async function runSubs(): Promise<void> {
   const m = t(resolveLocale(cfg.language));
 
   process.stdout.write(c.dim(`  ${m.loadingProviders(cfg.region)}`));
-  const providers = await getCachedRegionProviders(cfg.region, cfg.tmdbToken);
+  const allProviders = await getCachedRegionProviders(cfg.region, cfg.tmdbToken);
+  const providers = applyRegionPinning(
+    allProviders.filter(isSubscriptionProvider),
+    cfg.region,
+  );
   console.log(c.dim(m.providersFound(providers.length)));
 
   if (providers.length === 0) {

package/src/i18n.ts

@@ -52,7 +52,6 @@ interface Catalog {
   ads: string;
   rent: string;
   buy: string;
-  link: string;
 
   // config (show)
   noConfigYet: string;
@@ -127,6 +126,13 @@ interface Catalog {
   // non-TTY
   ttyRequired: (cmd: string) => string;
   ambiguousQuery: (n: number) => string;
+
+  // update notifier
+  updateAvailable: (version: string) => string;
+
+  // physical releases
+  physicalLabel: string;
+  noPhysicalRelease: string;
 }
 
 const en: Catalog = {
@@ -160,7 +166,6 @@ const en: Catalog = {
   ads: "ads",
   rent: "rent",
   buy: "buy",
-  link: "link",
 
   noConfigYet: "no config yet — run `ww init` first.",
   resolvingNames: "resolving subscription names… ",
@@ -228,8 +233,13 @@ 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)`,
+
+  physicalLabel: "physical",
+  noPhysicalRelease: "no physical release in this region",
 };
 
 const tr: Catalog = {
@@ -265,7 +275,6 @@ const tr: Catalog = {
   ads: "reklamlı",
   rent: "kirala",
   buy: "satın al",
-  link: "bağlantı",
 
   noConfigYet: "henüz config yok — önce `ww init` çalıştır.",
   resolvingNames: "abonelik isimleri çözümleniyor… ",
@@ -334,8 +343,13 @@ 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)`,
+
+  physicalLabel: "fiziksel",
+  noPhysicalRelease: "bu bölgede fiziksel release yok",
 };
 
 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.yellow("›")} ${c.dim(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/tmdb.ts

@@ -72,6 +72,24 @@ export interface TmdbProvidersListResponse {
   readonly results: ReadonlyArray<TmdbProvider>;
 }
 
+export interface TmdbReleaseDate {
+  readonly certification: string;
+  readonly iso_639_1: string;
+  readonly note: string;
+  readonly release_date: string;
+  readonly type: number;
+}
+
+export interface TmdbReleaseDatesByRegion {
+  readonly iso_3166_1: string;
+  readonly release_dates: ReadonlyArray<TmdbReleaseDate>;
+}
+
+export interface TmdbReleaseDatesResponse {
+  readonly id: number;
+  readonly results: ReadonlyArray<TmdbReleaseDatesByRegion>;
+}
+
 export class TmdbError extends Error {
   constructor(
     message: string,
@@ -169,6 +187,16 @@ export function getWatchProviders(
   );
 }
 
+export function getReleaseDates(
+  id: number,
+  token: string,
+): Promise<TmdbReleaseDatesResponse> {
+  return tmdbFetch<TmdbReleaseDatesResponse>(
+    `/movie/${id}/release_dates`,
+    token,
+  );
+}
+
 export function toMediaItem(
   item: TmdbMovie | TmdbTv,
   mediaType: MediaType,
@@ -239,3 +267,50 @@ export async function verifyToken(token: string): Promise<boolean> {
     return false;
   }
 }
+
+// rental-only storefronts on TMDB. these aren't subscriptions, so they
+// shouldn't pollute the "your subs" picker. they still appear correctly
+// under rent/buy sections for individual movies.
+const RENTAL_ONLY_IDS: ReadonlySet<number> = new Set([
+  2,   // Apple TV (storefront, not Apple TV+)
+  3,   // Google Play Movies
+  7,   // Fandango at Home (formerly Vudu)
+  10,  // Amazon Video (a-la-carte rental, separate from Prime Video)
+  68,  // Microsoft Store
+  192, // YouTube (rental, separate from YouTube Premium)
+]);
+
+export function isSubscriptionProvider(provider: TmdbProvider): boolean {
+  return !RENTAL_ONLY_IDS.has(provider.provider_id);
+}
+
+// per-region pin order. provider ids listed here float to the top in the
+// listed order; everything else falls back to TMDB's display_priority.
+// regions not listed use TMDB order unchanged.
+const REGION_PIN_ORDER: Record<string, ReadonlyArray<number>> = {
+  TR: [
+    8,    // Netflix
+    119,  // Amazon Prime Video
+    337,  // Disney Plus
+    1899, // Max (HBO Max)
+    11,   // MUBI
+    188,  // YouTube Premium
+  ],
+};
+
+export function applyRegionPinning(
+  providers: ReadonlyArray<TmdbProvider>,
+  region: string,
+): ReadonlyArray<TmdbProvider> {
+  const pinned = REGION_PIN_ORDER[region];
+  if (!pinned || pinned.length === 0) return providers;
+  const orderById = new Map(pinned.map((id, i) => [id, i]));
+  const top: TmdbProvider[] = [];
+  const rest: TmdbProvider[] = [];
+  for (const p of providers) {
+    if (orderById.has(p.provider_id)) top.push(p);
+    else rest.push(p);
+  }
+  top.sort((a, b) => orderById.get(a.provider_id)! - orderById.get(b.provider_id)!);
+  return [...top, ...rest];
+}

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;
+  }
+}