mcp-metacritic 2.0.0 → 2.1.0

package/dist/mc/client.d.ts

@@ -124,7 +124,8 @@ type Sentiment = "all" | "positive" | "neutral" | "negative";
 interface ReviewPage<T> {
     reviews: T[];
     /** How many exist upstream, before limit and offset. */
-    totalResults: number;
+    /** What the site counted, or null where it published no count. */
+    totalResults: number | null;
     /** How many entries the response carried, which paging must advance by. */
     itemCount: number;
 }
@@ -136,7 +137,8 @@ interface WatchOffer {
 }
 interface TitlePage {
     titles: TitleSummary[];
-    totalResults: number;
+    /** What the site counted, or null where it published no count. */
+    totalResults: number | null;
     itemCount: number;
 }
 
@@ -166,6 +168,13 @@ interface Outcome<T> {
 }
 type Sort = keyof typeof SORT_BY;
 declare class McClient {
+    /**
+     * The reads that have gone out and not come back, by URL.
+     *
+     * A route answering several variants is read once, so this is keyed on the
+     * URL rather than on the cache key a variant makes.
+     */
+    private readonly reading;
     private readonly config;
     private readonly logger;
     private readonly limiter;
@@ -218,4 +227,5 @@ declare class McClient {
     private fetchParsed;
 }
 
-export { McClient, type McClientOptions, type Outcome, type Sort };
+export { McClient };
+export type { McClientOptions, Outcome, Sort };

package/dist/mc/client.js

@@ -2,7 +2,7 @@
 import process from "process";
 
 // src/version.ts
-var PKG_VERSION = "2.0.0";
+var PKG_VERSION = "2.1.0";
 var REPO_URL = "https://github.com/smeet666/mcp-metacritic";
 
 // src/config.ts
@@ -296,10 +296,28 @@ function sleep(ms) {
 var BACKOFF_BASE_MS = 2e3;
 var BACKOFF_FACTOR = 2;
 var BACKOFF_MAX_MS = 2e4;
+var MAX_BODY_BYTES = 8e6;
 function backoffDelay(attempt, random = Math.random) {
   const capped = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * BACKOFF_FACTOR ** attempt);
   return Math.round(capped * (0.5 + random() * 0.5));
 }
+async function readBounded(response, url) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
+    throw parseFailure(
+      url,
+      `the response declares ${declared} bytes, past the ${MAX_BODY_BYTES} this server reads`
+    );
+  }
+  const body = await response.text();
+  if (body.length > MAX_BODY_BYTES) {
+    throw parseFailure(
+      url,
+      `the response carries more than the ${MAX_BODY_BYTES} bytes this server reads`
+    );
+  }
+  return body;
+}
 function readAnswer(url, status, body, retryAfterMs, ownGuessMs) {
   if (status === 429 || status === 503 || status === 403) {
     return {
@@ -355,10 +373,10 @@ async function fetchText(url, deps) {
     let askedWaitMs = null;
     for (let attempt = 0; attempt <= config.maxRetries; attempt += 1) {
       if (attempt > 0) {
-        const delay = askedWaitMs ?? backoffDelay(attempt - 1);
+        const delay = askedWaitMs ?? Math.min(backoffDelay(attempt - 1), BACKOFF_MAX_MS);
         askedWaitMs = null;
         logger.info(`retry ${attempt}/${config.maxRetries} in ${delay}ms for ${url}`);
-        await sleep(Math.min(delay, BACKOFF_MAX_MS));
+        await sleep(delay);
       }
       let status;
       let body;
@@ -375,7 +393,7 @@ async function fetchText(url, deps) {
         });
         status = response.status;
         retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
-        body = await response.text();
+        body = await readBounded(response, url);
       } catch (error) {
         lastError = asTransportError(error, url);
         logger.debug(`${lastError.code} for ${url}: ${lastError.message}`);
@@ -590,6 +608,14 @@ var str = (value) => {
   const trimmed = value.trim();
   return trimmed === "" ? null : trimmed;
 };
+var line = (value) => {
+  const text = str(value);
+  return text === null ? null : text.replace(/\s*[\r\n]+\s*/g, " ");
+};
+var link = (value) => {
+  const text = str(value);
+  return text !== null && ABSOLUTE_URL.test(text) ? text : null;
+};
 var num = (value) => {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
@@ -628,8 +654,8 @@ function toSummary(node) {
     return null;
   }
   const id = intOf(node.id);
-  const slug = str(node.slug);
-  const title = str(node.title);
+  const slug = line(node.slug);
+  const title = line(node.title);
   const kind = kindOf(node.type);
   if (id === null || !slug || !title || !kind) {
     return null;
@@ -669,7 +695,7 @@ function parseTitlePage(raw, url, what) {
   }
   return {
     titles,
-    totalResults: intOf(data[FIELD.totalResults]) ?? titles.length,
+    totalResults: intOf(data[FIELD.totalResults]),
     itemCount: items.length
   };
 }
@@ -735,7 +761,7 @@ function parseDetail(raw, url, kind, slug) {
     throw parseFailure(url, "the response carries no item object");
   }
   const id = intOf(item.id);
-  const title = str(item.title);
+  const title = line(item.title);
   if (id === null || !title) {
     throw parseFailure(url, "the entry has no id or no title");
   }
@@ -748,7 +774,7 @@ function parseDetail(raw, url, kind, slug) {
     year: intOf(item.premiereYear),
     releaseDate: str(item.releaseDate),
     rating: str(item.rating),
-    metascore: num(critic.score),
+    metascore: aggregate(critic.score),
     userScore: null,
     sourceUrl: titlePageUrl(kind, slug),
     description: str(item.description),
@@ -773,10 +799,14 @@ function parseScore(raw, url, what) {
   if (max === null) {
     throw parseFailure(url, "the score carries no scale");
   }
+  const reviewCount = intOf(item.reviewCount);
   return {
-    score: aggregate(item.score),
+    // A zero here is read against what stands behind it. An entry nobody has
+    // rated is published as 0 out of 10 from 0 ratings, which is an absence; a
+    // zero with reviews counted behind it is a verdict those reviewers gave.
+    score: reviewCount ? num(item.score) : aggregate(item.score),
     max,
-    reviewCount: intOf(item.reviewCount),
+    reviewCount,
     positiveCount: intOf(item.positiveCount),
     neutralCount: intOf(item.neutralCount),
     negativeCount: intOf(item.negativeCount),
@@ -803,7 +833,7 @@ function parseCriticReviews(raw, url, what, sentiment) {
       continue;
     }
     const quote = str(node.quote);
-    const publication = str(node.publicationName);
+    const publication = line(node.publicationName);
     if (!(quote && publication)) {
       continue;
     }
@@ -811,8 +841,8 @@ function parseCriticReviews(raw, url, what, sentiment) {
       quote,
       score: num(node.score),
       publication,
-      author: str(node.author),
-      url: str(node.url),
+      author: line(node.author),
+      url: link(node.url),
       date: str(node.date)
     });
   }
@@ -821,7 +851,7 @@ function parseCriticReviews(raw, url, what, sentiment) {
   }
   return {
     reviews,
-    totalResults: intOf(data[FIELD.totalResults]) ?? reviews.length,
+    totalResults: intOf(data[FIELD.totalResults]),
     itemCount: bucket.length
   };
 }
@@ -844,22 +874,22 @@ function parseUserReviews(raw, url, what, sentiment) {
   }
   return {
     reviews,
-    totalResults: intOf(data[FIELD.totalResults]) ?? reviews.length,
+    totalResults: intOf(data[FIELD.totalResults]),
     itemCount: bucket.length
   };
 }
-function unwrapLink(link) {
-  if (!link) {
+function unwrapLink(wrapper) {
+  if (!wrapper) {
     return null;
   }
   try {
-    const target = new URL(link).searchParams.get("r");
+    const target = new URL(wrapper).searchParams.get("r");
     if (target && ABSOLUTE_URL.test(target)) {
       return target;
     }
   } catch {
   }
-  return link;
+  return ABSOLUTE_URL.test(wrapper) ? wrapper : null;
 }
 function parseOffers(raw, url, what) {
   const data = envelope(raw, url, what);
@@ -876,7 +906,7 @@ function parseOffers(raw, url, what) {
       if (!isObject(node)) {
         continue;
       }
-      const provider = str(node.providerName);
+      const provider = line(node.providerName);
       if (!provider) {
         continue;
       }
@@ -887,16 +917,23 @@ function parseOffers(raw, url, what) {
 }
 
 // src/mc/client.ts
-var BROWSER_IDENTITY = /mozilla\/|applewebkit|chrome\/|safari\/|gecko/i;
 function withGuarantees(config) {
-  const userAgent = BROWSER_IDENTITY.test(config.userAgent) ? `${config.userAgent} ${DEFAULT_USER_AGENT}` : config.userAgent;
+  const userAgent = config.userAgent.includes(DEFAULT_USER_AGENT) ? config.userAgent : `${config.userAgent} ${DEFAULT_USER_AGENT}`;
+  const asked = Number.isFinite(config.minIntervalMs) ? config.minIntervalMs : 0;
   return {
     ...config,
     userAgent,
-    minIntervalMs: Math.max(MIN_ALLOWED_INTERVAL_MS, config.minIntervalMs)
+    minIntervalMs: Math.max(MIN_ALLOWED_INTERVAL_MS, asked)
   };
 }
 var McClient = class {
+  /**
+   * The reads that have gone out and not come back, by URL.
+   *
+   * A route answering several variants is read once, so this is keyed on the
+   * URL rather than on the cache key a variant makes.
+   */
+  reading = /* @__PURE__ */ new Map();
   config;
   logger;
   limiter;
@@ -939,9 +976,10 @@ var McClient = class {
   }
   async browse(options) {
     const url = browseUrl(options);
+    const cache = options.sort === "score" ? this.catalogueCache : this.scoresCache;
     return await this.fetchParsed(
       url,
-      this.catalogueCache,
+      cache,
       (body) => parseTitlePage(body, url, `that ${options.kind} listing`)
     );
   }
@@ -1010,12 +1048,24 @@ var McClient = class {
       this.logger.debug(`cache hit ${key}`);
       return { data: hit, cached: true };
     }
-    const body = await fetchText(url, {
+    const inFlight = this.reading.get(url);
+    if (inFlight !== void 0) {
+      const body2 = await inFlight;
+      return { data: parse(body2), cached: true };
+    }
+    const reading = fetchText(url, {
       config: this.config,
       limiter: this.limiter,
       logger: this.logger,
       ...this.fetchImpl ? { fetchImpl: this.fetchImpl } : {}
     });
+    this.reading.set(url, reading);
+    let body;
+    try {
+      body = await reading;
+    } finally {
+      this.reading.delete(url);
+    }
     const data = parse(body);
     cache.set(key, data);
     return { data, cached: false };