watchwhere 0.2.3 → 0.3.1

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.3",
+  "version": "0.3.1",
   "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) {
@@ -68,6 +77,7 @@ export async function runInit(): Promise<void> {
     choices,
     pageSize: 15,
     loop: false,
+    theme: { keybindings: ["vim"] },
   });
 
   const saved = await saveConfig({

package/src/commands/search.ts

@@ -4,15 +4,30 @@ 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;
 const SOFT_LIMIT = 25;
 const OVERVIEW_MAX = 140;
+const OLDEST_FILM_YEAR = 1888;
+
+function parseQuery(input: string): { query: string; year?: number } {
+  const match = input.match(/^(.+?)\s+(\d{4})$/);
+  if (match && match[1] && match[2]) {
+    const year = Number.parseInt(match[2], 10);
+    const maxYear = new Date().getFullYear() + 2;
+    if (year >= OLDEST_FILM_YEAR && year <= maxYear) {
+      return { query: match[1].trim(), year };
+    }
+  }
+  return { query: input };
+}
 
 function year(date: string | null): string {
   return date && date.length >= 4 ? date.slice(0, 4) : "????";
@@ -34,6 +49,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 +149,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 +211,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);
+    }
   }
 }
 
@@ -153,14 +234,29 @@ export async function runSearch(query: string, cfg: Config): Promise<void> {
   let currentQuery = query.trim();
   if (!currentQuery) throw new Error(m.searchEmpty);
 
-  // pipe mode: no prompts
-  if (!process.stdin.isTTY) {
-    process.stdout.write(c.dim(`  ${m.searching(currentQuery)}`));
-    const results = await searchAll(currentQuery, cfg.tmdbToken, {
-      region: cfg.region,
+  const runSearchOnce = async (
+    raw: string,
+  ): Promise<ReadonlyArray<MediaItem>> => {
+    const parsed = parseQuery(raw);
+    const displayQ = parsed.year
+      ? `${parsed.query} (${parsed.year})`
+      : parsed.query;
+    process.stdout.write(c.dim(`  ${m.searching(displayQ)}`));
+    // no region: TMDB returns regional release dates with region param,
+    // but year filter expects original release year
+    const all = await searchAll(parsed.query, cfg.tmdbToken, {
       language: cfg.language,
     });
+    const results = parsed.year
+      ? all.filter((r) => r.date?.slice(0, 4) === String(parsed.year))
+      : all;
     console.log(c.dim(m.resultsCount(results.length)));
+    return results;
+  };
+
+  // pipe mode: no prompts
+  if (!process.stdin.isTTY) {
+    const results = await runSearchOnce(currentQuery);
     if (results.length === 0) throw new Error(m.noMatch);
     if (results.length > 1) throw new Error(m.ambiguousQuery(results.length));
     await displayItem(results[0]!, cfg, m);
@@ -168,12 +264,7 @@ export async function runSearch(query: string, cfg: Config): Promise<void> {
   }
 
   while (true) {
-    process.stdout.write(c.dim(`  ${m.searching(currentQuery)}`));
-    const results = await searchAll(currentQuery, cfg.tmdbToken, {
-      region: cfg.region,
-      language: cfg.language,
-    });
-    console.log(c.dim(m.resultsCount(results.length)));
+    const results = await runSearchOnce(currentQuery);
 
     let picked: MediaItem | null = null;
     if (results.length > 0) {

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) {
@@ -30,6 +35,7 @@ export async function runSubs(): Promise<void> {
     })),
     pageSize: 15,
     loop: false,
+    theme: { keybindings: ["vim"] },
   });
 
   const added = subscriptions.filter((id) => !current.has(id)).length;

package/src/i18n.ts

@@ -52,7 +52,6 @@ interface Catalog {
   ads: string;
   rent: string;
   buy: string;
-  link: string;
 
   // config (show)
   noConfigYet: string;
@@ -119,6 +118,7 @@ interface Catalog {
   tokenExpired: string;
   networkOffline: string;
   networkTimeout: string;
+  rateLimited: string;
   relativeNow: string;
   relativeMinutes: (n: number) => string;
   relativeHours: (n: number) => string;
@@ -130,6 +130,10 @@ interface Catalog {
 
   // update notifier
   updateAvailable: (version: string) => string;
+
+  // physical releases
+  physicalLabel: string;
+  noPhysicalRelease: string;
 }
 
 const en: Catalog = {
@@ -163,7 +167,6 @@ const en: Catalog = {
   ads: "ads",
   rent: "rent",
   buy: "buy",
-  link: "link",
 
   noConfigYet: "no config yet — run `ww init` first.",
   resolvingNames: "resolving subscription names… ",
@@ -226,6 +229,7 @@ const en: Catalog = {
   tokenExpired: "TMDB token rejected (401). run `ww init` to re-enter it.",
   networkOffline: "couldn't reach TMDB. check your internet connection.",
   networkTimeout: "TMDB request timed out. try again, or check your connection.",
+  rateLimited: "rate limit hit. try again in an hour, or set WATCHWHERE_PROXY=off to use your own TMDB token.",
   relativeNow: "just now",
   relativeMinutes: (n) => `${n} min ago`,
   relativeHours: (n) => `${n} hr ago`,
@@ -235,6 +239,9 @@ const en: Catalog = {
   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 = {
@@ -270,7 +277,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,6 +340,7 @@ const tr: Catalog = {
   tokenExpired: "TMDB token reddedildi (401). yenilemek için `ww init` çalıştır.",
   networkOffline: "TMDB'ye ulaşılamadı. internet bağlantını kontrol et.",
   networkTimeout: "TMDB isteği zaman aşımına uğradı. tekrar dene veya bağlantını kontrol et.",
+  rateLimited: "rate limit doldu. bir saat sonra dene veya WATCHWHERE_PROXY=off ile kendi TMDB token'ını kullan.",
   relativeNow: "şimdi",
   relativeMinutes: (n) => `${n} dk önce`,
   relativeHours: (n) => `${n} saat önce`,
@@ -343,6 +350,9 @@ const tr: Catalog = {
   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

@@ -144,7 +144,7 @@ async function maybeNotifyUpdate(): Promise<void> {
     const cfg = await loadConfig().catch(() => null);
     const m = t(resolveLocale(cfg?.language));
     console.log();
-    console.log(c.dim(`  ${c.yellow("›")} ${m.updateAvailable(newer)}`));
+    console.log(`  ${c.yellow("›")} ${c.dim(m.updateAvailable(newer))}`);
   } catch {
     // best-effort, never block exit
   }
@@ -162,6 +162,7 @@ main().then(maybeNotifyUpdate).catch(async (err: unknown) => {
   let displayMsg = err instanceof Error ? err.message : String(err);
   if (err instanceof TmdbError) {
     if (err.status === 401) displayMsg = m.tokenExpired;
+    else if (err.status === 429) displayMsg = m.rateLimited;
     else if (err.status === 0 && err.message.includes("timed out")) {
       displayMsg = m.networkTimeout;
     } else if (err.status === 0) {

package/src/picker.ts

@@ -7,10 +7,14 @@ import {
   useKeypress,
   usePagination,
   usePrefix,
+  useRef,
   useState,
 } from "@inquirer/core";
+import { cursorHide } from "@inquirer/ansi";
 import { c } from "./colors.ts";
 
+const GG_TIMEOUT_MS = 500;
+
 export interface PickerChoice<Value> {
   readonly name: string;
   readonly value: Value;
@@ -50,9 +54,14 @@ const promptImpl = createPrompt<unknown | null, PickerConfig<unknown>>(
     const prefix = usePrefix({ status, theme });
     const items = config.choices;
     const [active, setActive] = useState(0);
+    const lastGAt = useRef(0);
 
     useKeypress((key) => {
-      if (key.name === "escape") {
+      // sequence is present at runtime but not in the type; cast to read it
+      const seq = (key as unknown as { sequence?: string }).sequence;
+
+      // esc or q: cancel
+      if (key.name === "escape" || seq === "q") {
         setCancelled(true);
         setStatus("done");
         done(null);
@@ -64,11 +73,29 @@ const promptImpl = createPrompt<unknown | null, PickerConfig<unknown>>(
         if (chosen) done(chosen.value);
         return;
       }
-      if (isUpKey(key, [])) {
+      // G (shift+g): bottom
+      if (seq === "G") {
+        setActive(items.length - 1);
+        return;
+      }
+      // gg: top (two g within timeout)
+      if (seq === "g") {
+        const now = Date.now();
+        if (now - lastGAt.current < GG_TIMEOUT_MS) {
+          setActive(0);
+          lastGAt.current = 0;
+        } else {
+          lastGAt.current = now;
+        }
+        return;
+      }
+      // up or k
+      if (isUpKey(key, []) || seq === "k") {
         if (active > 0) setActive(active - 1);
         return;
       }
-      if (isDownKey(key, [])) {
+      // down or j
+      if (isDownKey(key, []) || seq === "j") {
         if (active < items.length - 1) setActive(active + 1);
         return;
       }
@@ -98,7 +125,7 @@ const promptImpl = createPrompt<unknown | null, PickerConfig<unknown>>(
 
     const description = items[active]?.description;
     const helpLine = [
-      ["↑↓", "navigate"],
+      ["↑↓ jk", "navigate"],
       ["⏎", "select"],
       ...(config.extraKeys ?? []),
     ]
@@ -112,7 +139,7 @@ const promptImpl = createPrompt<unknown | null, PickerConfig<unknown>>(
       helpLine,
     ]
       .filter((line) => line !== "")
-      .join("\n");
+      .join("\n") + cursorHide;
   },
 );
 

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