untappd-mcp 1.3.0 → 1.4.0

package/dist/bundle.js

@@ -101,7 +101,7 @@ var require_code = __commonJS({
     }
     exports._ = _;
     var plus = new _Code("+");
-    function str(strs, ...args) {
+    function str2(strs, ...args) {
       const expr = [safeStringify(strs[0])];
       let i = 0;
       while (i < args.length) {
@@ -112,7 +112,7 @@ var require_code = __commonJS({
       optimize(expr);
       return new _Code(expr);
     }
-    exports.str = str;
+    exports.str = str2;
     function addCodeArg(code, arg) {
       if (arg instanceof _Code)
         code.push(...arg._items);
@@ -155,7 +155,7 @@ var require_code = __commonJS({
       return;
     }
     function strConcat(c1, c2) {
-      return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
+      return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str2`${c1}${c2}`;
     }
     exports.strConcat = strConcat;
     function interpolate(x) {
@@ -1117,22 +1117,22 @@ var require_util = __commonJS({
       return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
     }
     exports.schemaRefOrVal = schemaRefOrVal;
-    function unescapeFragment(str) {
-      return unescapeJsonPointer(decodeURIComponent(str));
+    function unescapeFragment(str2) {
+      return unescapeJsonPointer(decodeURIComponent(str2));
     }
     exports.unescapeFragment = unescapeFragment;
-    function escapeFragment(str) {
-      return encodeURIComponent(escapeJsonPointer(str));
+    function escapeFragment(str2) {
+      return encodeURIComponent(escapeJsonPointer(str2));
     }
     exports.escapeFragment = escapeFragment;
-    function escapeJsonPointer(str) {
-      if (typeof str == "number")
-        return `${str}`;
-      return str.replace(/~/g, "~0").replace(/\//g, "~1");
+    function escapeJsonPointer(str2) {
+      if (typeof str2 == "number")
+        return `${str2}`;
+      return str2.replace(/~/g, "~0").replace(/\//g, "~1");
     }
     exports.escapeJsonPointer = escapeJsonPointer;
-    function unescapeJsonPointer(str) {
-      return str.replace(/~1/g, "/").replace(/~0/g, "~");
+    function unescapeJsonPointer(str2) {
+      return str2.replace(/~1/g, "/").replace(/~0/g, "~");
     }
     exports.unescapeJsonPointer = unescapeJsonPointer;
     function eachItem(xs, f) {
@@ -2157,8 +2157,8 @@ var require_json_schema_traverse = __commonJS({
         post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
       }
     }
-    function escapeJsonPtr(str) {
-      return str.replace(/~/g, "~0").replace(/\//g, "~1");
+    function escapeJsonPtr(str2) {
+      return str2.replace(/~/g, "~0").replace(/\//g, "~1");
     }
   }
 });
@@ -3222,10 +3222,10 @@ var require_utils = __commonJS({
         return { host, isIPV6: false };
       }
     }
-    function findToken(str, token) {
+    function findToken(str2, token) {
       let ind = 0;
-      for (let i = 0; i < str.length; i++) {
-        if (str[i] === token) ind++;
+      for (let i = 0; i < str2.length; i++) {
+        if (str2[i] === token) ind++;
       }
       return ind;
     }
@@ -3962,7 +3962,7 @@ var require_core = __commonJS({
     var util_1 = require_util();
     var $dataRefSchema = require_data();
     var uri_1 = require_uri();
-    var defaultRegExp = (str, flags) => new RegExp(str, flags);
+    var defaultRegExp = (str2, flags) => new RegExp(str2, flags);
     defaultRegExp.code = "new RegExp";
     var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
     var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
@@ -4757,16 +4757,16 @@ var require_ucs2length = __commonJS({
   "node_modules/ajv/dist/runtime/ucs2length.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    function ucs2length(str) {
-      const len = str.length;
+    function ucs2length(str2) {
+      const len = str2.length;
       let length = 0;
       let pos = 0;
       let value;
       while (pos < len) {
         length++;
-        value = str.charCodeAt(pos++);
+        value = str2.charCodeAt(pos++);
         if (value >= 55296 && value <= 56319 && pos < len) {
-          value = str.charCodeAt(pos);
+          value = str2.charCodeAt(pos);
           if ((value & 64512) === 56320)
             pos++;
         }
@@ -6649,8 +6649,8 @@ var require_formats = __commonJS({
     }
     var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
     var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-    function date5(str) {
-      const matches = DATE.exec(str);
+    function date5(str2) {
+      const matches = DATE.exec(str2);
       if (!matches)
         return false;
       const year = +matches[1];
@@ -6669,8 +6669,8 @@ var require_formats = __commonJS({
     }
     var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
     function getTime(strictTimeZone) {
-      return function time3(str) {
-        const matches = TIME.exec(str);
+      return function time3(str2) {
+        const matches = TIME.exec(str2);
         if (!matches)
           return false;
         const hr = +matches[1];
@@ -6716,8 +6716,8 @@ var require_formats = __commonJS({
     var DATE_TIME_SEPARATOR = /t|\s/i;
     function getDateTime(strictTimeZone) {
       const time3 = getTime(strictTimeZone);
-      return function date_time(str) {
-        const dateTime = str.split(DATE_TIME_SEPARATOR);
+      return function date_time(str2) {
+        const dateTime = str2.split(DATE_TIME_SEPARATOR);
         return dateTime.length === 2 && date5(dateTime[0]) && time3(dateTime[1]);
       };
     }
@@ -6742,13 +6742,13 @@ var require_formats = __commonJS({
     }
     var NOT_URI_FRAGMENT = /\/|:/;
     var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
-    function uri(str) {
-      return NOT_URI_FRAGMENT.test(str) && URI.test(str);
+    function uri(str2) {
+      return NOT_URI_FRAGMENT.test(str2) && URI.test(str2);
     }
     var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
-    function byte(str) {
+    function byte(str2) {
       BYTE.lastIndex = 0;
-      return BYTE.test(str);
+      return BYTE.test(str2);
     }
     var MIN_INT32 = -(2 ** 31);
     var MAX_INT32 = 2 ** 31 - 1;
@@ -6762,11 +6762,11 @@ var require_formats = __commonJS({
       return true;
     }
     var Z_ANCHOR = /[^\\]\\Z/;
-    function regex(str) {
-      if (Z_ANCHOR.test(str))
+    function regex(str2) {
+      if (Z_ANCHOR.test(str2))
         return false;
       try {
-        new RegExp(str);
+        new RegExp(str2);
         return true;
       } catch (e) {
         return false;
@@ -11306,14 +11306,14 @@ function promiseAllObject(promisesObj) {
 }
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str = "";
+  let str2 = "";
   for (let i = 0; i < length; i++) {
-    str += chars[Math.floor(Math.random() * chars.length)];
+    str2 += chars[Math.floor(Math.random() * chars.length)];
   }
-  return str;
+  return str2;
 }
-function esc(str) {
-  return JSON.stringify(str);
+function esc(str2) {
+  return JSON.stringify(str2);
 }
 function slugify(input) {
   return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -11427,8 +11427,8 @@ var primitiveTypes = /* @__PURE__ */ new Set([
   "symbol",
   "undefined"
 ]);
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str2) {
+  return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function clone(inst, def, params) {
   const cl = new inst._zod.constr(def ?? inst._zod.def);
@@ -31067,8 +31067,8 @@ function redactSecrets(text) {
   return text.replace(BEARER_RE, "$1[REDACTED]").replace(BASIC_AUTH_RE, "$1[REDACTED]").replace(SET_COOKIE_RE, "$1$2=[REDACTED]").replace(COOKIE_HEADER_RE, (_m, prefix, pairs) => `${prefix}${pairs.replace(/=[^;,\s]*/g, "=[REDACTED]")}`).replace(API_KEY_RE, "[REDACTED]").replace(QUERY_SECRET_RE, "$1[REDACTED]").replace(AWS_SIGV4_RE, "$1[REDACTED]").replace(JSON_SECRET_DQ_RE, "$1[REDACTED]$2").replace(JSON_SECRET_SQ_RE, "$1[REDACTED]$2").replace(JWT_RE, "[REDACTED]");
 }
 function truncateErrorMessage(text, max = DEFAULT_ERROR_MESSAGE_MAX) {
-  const str = text === null || text === void 0 ? "" : String(text);
-  const redacted = redactSecrets(str);
+  const str2 = text === null || text === void 0 ? "" : String(text);
+  const redacted = redactSecrets(str2);
   if (redacted.length <= max)
     return redacted;
   return `${redacted.slice(0, max)}\u2026 [truncated]`;
@@ -31184,7 +31184,7 @@ function toolAnnotations(opts = {}) {
 }
 
 // src/version.ts
-var VERSION = "1.3.0";
+var VERSION = "1.4.0";
 
 // src/client.ts
 import { dirname, join } from "path";
@@ -32333,21 +32333,46 @@ function registerCheckinTools(server, client2) {
   );
 }
 
+// src/tools/diagnostics.ts
+function registeredToolNames(server) {
+  const reg = server._registeredTools;
+  return reg ? Object.keys(reg).sort() : [];
+}
+function toolsHash(names) {
+  let h = 2166136261;
+  const s = names.join(",");
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function toolInventory(server) {
+  const names = registeredToolNames(server);
+  return { tool_count: names.length, tools_hash: toolsHash(names), tools: names };
+}
+function logRegisteredTools(server, context) {
+  const names = registeredToolNames(server);
+  console.error(`[untappd-mcp] ${context}: ${names.length} tools registered [${toolsHash(names)}]: ${names.join(", ")}`);
+}
+
 // src/tools/utilities.ts
 function registerUtilityTools(server, client2) {
   server.registerTool(
     "untappd_healthcheck",
     {
       title: "Untappd healthcheck",
-      description: "Verify Untappd connectivity and that credentials are configured and can log in. Performs a lightweight authenticated request (your recent feed) and reports whether it succeeded. Read-only.",
+      description: "Verify Untappd connectivity and that credentials are configured and can log in. Performs a lightweight authenticated request (your recent feed) and reports whether it succeeded, plus the running server version and the exact set of tools this build exposes (count, a stable hash, and their names) so you can confirm which build is live. Read-only.",
       annotations: toolAnnotations({ title: "Untappd healthcheck", readOnly: true, idempotent: true, openWorld: true }),
       inputSchema: {}
     },
     async () => {
+      const build = { server_version: VERSION, ...toolInventory(server) };
       if (!client2.configured) {
         return textResult({
           ok: false,
           configured: false,
+          ...build,
           note: "Untappd credentials are not set. Configure UNTAPPD_USERNAME, UNTAPPD_PASSWORD, UNTAPPD_CLIENT_ID, and UNTAPPD_CLIENT_SECRET."
         });
       }
@@ -32357,14 +32382,647 @@ function registerUtilityTools(server, client2) {
         configured: true,
         account: client2.loginName,
         feed_reachable: feed?.checkins !== void 0,
+        ...build,
         note: "Logged in to Untappd and fetched the friend feed successfully."
       });
     }
   );
 }
 
+// src/cache/store.ts
+function asDict2(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function mapCheckinRow(username, item) {
+  const c = asDict2(item);
+  const checkin_id = num(c.checkin_id);
+  if (checkin_id === null) return null;
+  const beer = asDict2(c.beer);
+  const brewery = asDict2(c.brewery);
+  const venue = asDict2(c.venue);
+  return {
+    checkin_id,
+    username,
+    bid: num(beer.bid),
+    beer_name: str(beer.beer_name),
+    brewery_id: num(brewery.brewery_id),
+    brewery_name: str(brewery.brewery_name),
+    beer_style: str(beer.beer_style),
+    abv: num(beer.beer_abv),
+    rating: num(c.rating_score),
+    comment: str(c.checkin_comment),
+    venue_id: num(venue.venue_id),
+    venue_name: str(venue.venue_name),
+    created_at: normaliseDate(c.created_at)
+  };
+}
+function normaliseDate(v) {
+  const s = str(v);
+  if (!s) return null;
+  const t = Date.parse(s);
+  return Number.isNaN(t) ? s : new Date(t).toISOString();
+}
+var SCHEMA_STATEMENTS = [
+  `CREATE TABLE IF NOT EXISTS checkins (
+     checkin_id   INTEGER PRIMARY KEY,
+     username     TEXT NOT NULL,
+     bid          INTEGER,
+     beer_name    TEXT,
+     brewery_id   INTEGER,
+     brewery_name TEXT,
+     beer_style   TEXT,
+     abv          REAL,
+     rating       REAL,
+     comment      TEXT,
+     venue_id     INTEGER,
+     venue_name   TEXT,
+     created_at   TEXT
+   )`,
+  `CREATE INDEX IF NOT EXISTS idx_checkins_user_bid ON checkins(username, bid)`,
+  `CREATE INDEX IF NOT EXISTS idx_checkins_user_brewery ON checkins(username, brewery_id)`,
+  `CREATE TABLE IF NOT EXISTS sync_state (
+     username          TEXT PRIMARY KEY,
+     oldest_max_id     INTEGER,
+     newest_checkin_id INTEGER,
+     catchup_max_id    INTEGER,
+     last_synced_at    TEXT,
+     backfill_complete INTEGER NOT NULL DEFAULT 0,
+     total_checkins    INTEGER
+   )`
+];
+var MIGRATIONS = ["ALTER TABLE sync_state ADD COLUMN catchup_max_id INTEGER"];
+var CheckinStoreCore = class {
+  constructor(db) {
+    this.db = db;
+    for (const stmt of SCHEMA_STATEMENTS) this.db.execScript(stmt);
+    for (const mig of MIGRATIONS) {
+      try {
+        this.db.execScript(mig);
+      } catch {
+      }
+    }
+  }
+  db;
+  /**
+   * Upsert a batch of rows (dedupe on checkin_id) inside one transaction and
+   * return the NET number of newly-inserted rows (updates to existing rows count
+   * as 0), which is what "rows added" reports.
+   */
+  upsertCheckins(username, rows) {
+    if (rows.length === 0) return 0;
+    const key = username.toLowerCase();
+    const before = this.cachedCount(username);
+    const sql = `
+      INSERT INTO checkins
+        (checkin_id, username, bid, beer_name, brewery_id, brewery_name, beer_style, abv, rating, comment, venue_id, venue_name, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(checkin_id) DO UPDATE SET
+        username=excluded.username, bid=excluded.bid, beer_name=excluded.beer_name,
+        brewery_id=excluded.brewery_id, brewery_name=excluded.brewery_name, beer_style=excluded.beer_style,
+        abv=excluded.abv, rating=excluded.rating, comment=excluded.comment,
+        venue_id=excluded.venue_id, venue_name=excluded.venue_name, created_at=excluded.created_at`;
+    this.db.transaction(() => {
+      for (const r of rows) {
+        this.db.run(sql, [
+          r.checkin_id,
+          key,
+          r.bid,
+          r.beer_name,
+          r.brewery_id,
+          r.brewery_name,
+          r.beer_style,
+          r.abv,
+          r.rating,
+          r.comment,
+          r.venue_id,
+          r.venue_name,
+          r.created_at
+        ]);
+      }
+    });
+    return this.cachedCount(username) - before;
+  }
+  /** Total cached check-ins for a user (= distinct check-ins, since PK is checkin_id). */
+  cachedCount(username) {
+    const row = this.db.get("SELECT COUNT(*) AS n FROM checkins WHERE username = ?", [username.toLowerCase()]);
+    return Number(row?.n ?? 0);
+  }
+  /** Distinct beers (unique bids) cached for a user. */
+  distinctBeerCount(username) {
+    const row = this.db.get(
+      "SELECT COUNT(DISTINCT bid) AS n FROM checkins WHERE username = ? AND bid IS NOT NULL",
+      [username.toLowerCase()]
+    );
+    return Number(row?.n ?? 0);
+  }
+  /** Highest cached checkin_id for a user (the true newest once contiguous), or null. */
+  newestCachedId(username) {
+    const row = this.db.get("SELECT MAX(checkin_id) AS m FROM checkins WHERE username = ?", [username.toLowerCase()]);
+    return num(row?.m);
+  }
+  getState(username) {
+    const row = this.db.get("SELECT * FROM sync_state WHERE username = ?", [username.toLowerCase()]);
+    if (!row) return void 0;
+    return {
+      username: String(row.username),
+      oldest_max_id: num(row.oldest_max_id),
+      newest_checkin_id: num(row.newest_checkin_id),
+      catchup_max_id: num(row.catchup_max_id),
+      last_synced_at: str(row.last_synced_at),
+      backfill_complete: Number(row.backfill_complete) === 1,
+      total_checkins: num(row.total_checkins)
+    };
+  }
+  /**
+   * Insert-or-merge sync state. Only keys PRESENT in `patch` are written, so an
+   * explicit `null` (e.g. clearing `oldest_max_id` when backfill completes)
+   * overrides the stored value — a `??` merge could not do that.
+   */
+  setState(username, patch) {
+    const key = username.toLowerCase();
+    const cur = this.getState(key);
+    const pick2 = (k, fallback) => k in patch ? patch[k] : cur?.[k] ?? fallback;
+    const next = {
+      username: key,
+      oldest_max_id: pick2("oldest_max_id", null),
+      newest_checkin_id: pick2("newest_checkin_id", null),
+      catchup_max_id: pick2("catchup_max_id", null),
+      last_synced_at: pick2("last_synced_at", null),
+      backfill_complete: pick2("backfill_complete", false),
+      total_checkins: pick2("total_checkins", null)
+    };
+    this.db.run(
+      `INSERT INTO sync_state (username, oldest_max_id, newest_checkin_id, catchup_max_id, last_synced_at, backfill_complete, total_checkins)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(username) DO UPDATE SET
+         oldest_max_id=excluded.oldest_max_id, newest_checkin_id=excluded.newest_checkin_id,
+         catchup_max_id=excluded.catchup_max_id,
+         last_synced_at=excluded.last_synced_at, backfill_complete=excluded.backfill_complete,
+         total_checkins=excluded.total_checkins`,
+      [
+        key,
+        next.oldest_max_id,
+        next.newest_checkin_id,
+        next.catchup_max_id,
+        next.last_synced_at,
+        next.backfill_complete ? 1 : 0,
+        next.total_checkins
+      ]
+    );
+  }
+  /** Exact bid match or case-insensitive substring match on beer name. */
+  hasHad(username, opts) {
+    const where = ["username = ?"];
+    const params = [username.toLowerCase()];
+    if (opts.bid !== void 0) {
+      where.push("bid = ?");
+      params.push(opts.bid);
+    }
+    if (opts.beerName !== void 0) {
+      where.push("beer_name LIKE ? COLLATE NOCASE");
+      params.push(`%${escapeLike(opts.beerName)}%`);
+    }
+    const clause = where.join(" AND ");
+    const agg = this.db.get(`SELECT COUNT(*) AS n, MAX(rating) AS best FROM checkins WHERE ${clause}`, params);
+    const matches = this.db.all(
+      `SELECT checkin_id, bid, beer_name, rating, venue_name, created_at
+       FROM checkins WHERE ${clause} ORDER BY checkin_id DESC LIMIT 25`,
+      params
+    );
+    const count2 = Number(agg?.n ?? 0);
+    return {
+      had: count2 > 0,
+      count: count2,
+      last_date: matches[0]?.created_at ?? null,
+      best_rating: num(agg?.best),
+      matches
+    };
+  }
+  query(username, filters) {
+    const where = ["username = ?"];
+    const params = [username.toLowerCase()];
+    if (filters.brewery_id !== void 0) {
+      where.push("brewery_id = ?");
+      params.push(filters.brewery_id);
+    }
+    if (filters.brewery !== void 0) {
+      where.push("brewery_name LIKE ? COLLATE NOCASE");
+      params.push(`%${escapeLike(filters.brewery)}%`);
+    }
+    if (filters.style !== void 0) {
+      where.push("beer_style LIKE ? COLLATE NOCASE");
+      params.push(`%${escapeLike(filters.style)}%`);
+    }
+    if (filters.min_rating !== void 0) {
+      where.push("rating >= ?");
+      params.push(filters.min_rating);
+    }
+    if (filters.venue !== void 0) {
+      where.push("venue_name LIKE ? COLLATE NOCASE");
+      params.push(`%${escapeLike(filters.venue)}%`);
+    }
+    if (filters.venue_id !== void 0) {
+      where.push("venue_id = ?");
+      params.push(filters.venue_id);
+    }
+    if (filters.date_from !== void 0) {
+      where.push("substr(created_at, 1, 10) >= ?");
+      params.push(filters.date_from);
+    }
+    if (filters.date_to !== void 0) {
+      where.push("substr(created_at, 1, 10) <= ?");
+      params.push(filters.date_to);
+    }
+    const order = filters.sort === "oldest" ? "checkin_id ASC" : filters.sort === "highest_rated" ? "rating DESC, checkin_id DESC" : filters.sort === "lowest_rated" ? "rating ASC, checkin_id DESC" : "checkin_id DESC";
+    const limit = Math.min(Math.max(filters.limit ?? 25, 1), 200);
+    return this.db.all(
+      `SELECT * FROM checkins WHERE ${where.join(" AND ")} ORDER BY ${order} LIMIT ?`,
+      [...params, limit]
+    );
+  }
+};
+var LocalCacheStore = class {
+  constructor(core) {
+    this.core = core;
+  }
+  core;
+  async upsertCheckins(username, rows) {
+    return this.core.upsertCheckins(username, rows);
+  }
+  async cachedCount(username) {
+    return this.core.cachedCount(username);
+  }
+  async distinctBeerCount(username) {
+    return this.core.distinctBeerCount(username);
+  }
+  async newestCachedId(username) {
+    return this.core.newestCachedId(username);
+  }
+  async getState(username) {
+    return this.core.getState(username);
+  }
+  async setState(username, patch) {
+    this.core.setState(username, patch);
+  }
+  async hasHad(username, opts) {
+    return this.core.hasHad(username, opts);
+  }
+  async query(username, filters) {
+    return this.core.query(username, filters);
+  }
+};
+function escapeLike(s) {
+  return s.replace(/[%_]/g, " ");
+}
+
+// src/cache/sync.ts
+var PAGE_LIMIT = 50;
+async function fetchPage(client2, encodedUser, maxId) {
+  const data = await client2.get(
+    `/user/checkins/${encodedUser}`,
+    { limit: PAGE_LIMIT, max_id: maxId }
+  );
+  const box = data?.checkins ?? {};
+  const items = Array.isArray(box.items) ? box.items : [];
+  const raw = box.pagination?.max_id;
+  const nextMaxId = typeof raw === "number" && raw > 0 ? raw : null;
+  return { items, nextMaxId };
+}
+function rowsOf(username, items) {
+  const rows = [];
+  for (const it of items) {
+    const r = mapCheckinRow(username, it);
+    if (r) rows.push(r);
+  }
+  return rows;
+}
+async function fetchTotalCheckins(client2, encodedUser) {
+  try {
+    const info = await client2.get(`/user/info/${encodedUser}`);
+    const t = info?.user?.stats?.total_checkins;
+    return typeof t === "number" ? t : null;
+  } catch {
+    return null;
+  }
+}
+async function syncCheckins(client2, cache, rawUsername, maxPages = 10) {
+  const encodedUser = encodeURIComponent(rawUsername);
+  const prior = await cache.getState(rawUsername);
+  const priorNewest = prior?.newest_checkin_id ?? null;
+  let pages = 0;
+  let added = 0;
+  let newest = priorNewest;
+  let backfillComplete = prior?.backfill_complete ?? false;
+  let oldestMaxId = prior?.oldest_max_id ?? null;
+  let catchupMaxId = prior?.catchup_max_id ?? null;
+  let catchupInProgress = catchupMaxId !== null;
+  const now = () => (/* @__PURE__ */ new Date()).toISOString();
+  const firstFetch = async (maxId) => {
+    try {
+      return await fetchPage(client2, encodedUser, maxId);
+    } catch (e) {
+      if (e instanceof RateLimitError) throw e;
+      throw createHelpfulError(`Could not fetch check-ins for "${rawUsername}": ${messageOf(e)}`, {
+        hint: "Untappd only returns another user's check-ins if their account is public or they're your friend. If the account is private, add them as a friend (untappd_add_friend) first, or sync only your own account."
+      });
+    }
+  };
+  if (priorNewest !== null) {
+    let maxId = catchupMaxId ?? void 0;
+    let caughtUp = false;
+    for (; pages < maxPages; ) {
+      const page = pages === 0 ? await firstFetch(maxId) : await fetchPage(client2, encodedUser, maxId);
+      pages++;
+      if (page.items.length === 0) {
+        caughtUp = true;
+        break;
+      }
+      const rows = rowsOf(rawUsername, page.items);
+      added += await cache.upsertCheckins(rawUsername, rows);
+      const oldestOnPage = rows[rows.length - 1].checkin_id;
+      if (oldestOnPage <= priorNewest) {
+        caughtUp = true;
+        break;
+      }
+      if (page.nextMaxId === null) {
+        caughtUp = true;
+        backfillComplete = true;
+        oldestMaxId = null;
+        break;
+      }
+      catchupMaxId = page.nextMaxId;
+      await cache.setState(rawUsername, { catchup_max_id: catchupMaxId, last_synced_at: now() });
+      maxId = page.nextMaxId;
+    }
+    if (caughtUp) {
+      newest = await cache.newestCachedId(rawUsername);
+      catchupMaxId = null;
+      catchupInProgress = false;
+      await cache.setState(rawUsername, {
+        newest_checkin_id: newest,
+        catchup_max_id: null,
+        backfill_complete: backfillComplete,
+        oldest_max_id: oldestMaxId,
+        last_synced_at: now()
+      });
+    } else {
+      catchupInProgress = true;
+    }
+  }
+  if (!backfillComplete && !catchupInProgress) {
+    let maxId = oldestMaxId ?? void 0;
+    for (; pages < maxPages; ) {
+      const first = pages === 0;
+      const page = first ? await firstFetch(maxId) : await fetchPage(client2, encodedUser, maxId);
+      pages++;
+      if (page.items.length === 0) {
+        backfillComplete = true;
+        break;
+      }
+      const rows = rowsOf(rawUsername, page.items);
+      added += await cache.upsertCheckins(rawUsername, rows);
+      if (newest === null) newest = rows[0].checkin_id;
+      oldestMaxId = page.nextMaxId;
+      if (page.nextMaxId === null) backfillComplete = true;
+      await cache.setState(rawUsername, {
+        newest_checkin_id: newest,
+        oldest_max_id: oldestMaxId,
+        backfill_complete: backfillComplete,
+        last_synced_at: now()
+      });
+      if (backfillComplete) break;
+      maxId = page.nextMaxId ?? void 0;
+    }
+  }
+  const total = await fetchTotalCheckins(client2, encodedUser);
+  const cached2 = await cache.cachedCount(rawUsername);
+  await cache.setState(rawUsername, {
+    newest_checkin_id: newest,
+    oldest_max_id: oldestMaxId,
+    catchup_max_id: catchupMaxId,
+    backfill_complete: backfillComplete,
+    total_checkins: total,
+    last_synced_at: now()
+  });
+  const backfillPercent = total && total > 0 ? Math.min(100, Math.round(cached2 / total * 100)) : backfillComplete && !catchupInProgress ? 100 : null;
+  const anotherRunNeeded = !backfillComplete || catchupInProgress;
+  const note = catchupInProgress ? "More new check-ins remain than fit in this run \u2014 run untappd_sync_checkins again to finish catching up the newest check-ins." : backfillComplete ? "Full history is cached. Re-run occasionally to pick up new check-ins." : `Backfill incomplete \u2014 run untappd_sync_checkins again to fetch the next ${maxPages} pages of older check-ins.`;
+  return {
+    username: rawUsername,
+    rows_added: added,
+    pages_fetched: pages,
+    cached_checkins: cached2,
+    distinct_beers: await cache.distinctBeerCount(rawUsername),
+    total_checkins: total,
+    backfill_percent: backfillPercent,
+    backfill_complete: backfillComplete,
+    catchup_in_progress: catchupInProgress,
+    another_run_needed: anotherRunNeeded,
+    last_synced_at: now(),
+    note
+  };
+}
+
+// src/tools/cache.ts
+var UsernameArg2 = external_exports.string().min(1).optional().describe("Untappd username. Omit to use your own configured account (UNTAPPD_USERNAME).");
+function resolveUser2(username, loginName) {
+  const u = username ?? loginName;
+  if (!u) {
+    throw createHelpfulError("No username given and no configured account to fall back to.", {
+      hint: "Pass `username`, or set UNTAPPD_USERNAME so cache tools default to your own account."
+    });
+  }
+  return u;
+}
+async function freshness(cache, username) {
+  const state = await cache.getState(username);
+  const cached2 = await cache.cachedCount(username);
+  const backfillComplete = state?.backfill_complete ?? false;
+  const percent = state?.total_checkins && state.total_checkins > 0 ? Math.min(100, Math.round(cached2 / state.total_checkins * 100)) : backfillComplete ? 100 : null;
+  const catchupInProgress = (state?.catchup_max_id ?? null) !== null;
+  let caveat;
+  if (!state || state.last_synced_at === null) {
+    caveat = "This user has never been synced \u2014 the cache is EMPTY. Run untappd_sync_checkins first; results here are not authoritative.";
+  } else if (catchupInProgress) {
+    caveat = "A batch of the newest check-ins is still being caught up (last sync ran out of pages). Recent check-ins may be missing \u2014 run untappd_sync_checkins again to finish.";
+  } else if (!backfillComplete) {
+    caveat = `Backfill is incomplete${percent !== null ? ` (~${percent}% of history cached)` : ""}. A "not found" result may be a false negative for older check-ins \u2014 run untappd_sync_checkins again to keep backfilling.`;
+  }
+  return {
+    last_synced_at: state?.last_synced_at ?? null,
+    backfill_complete: backfillComplete,
+    catchup_in_progress: catchupInProgress,
+    backfill_percent: percent,
+    cached_checkins: cached2,
+    distinct_beers: await cache.distinctBeerCount(username),
+    ...caveat ? { caveat } : {}
+  };
+}
+function registerCacheTools(server, client2, cacheProvider) {
+  server.registerTool(
+    "untappd_sync_checkins",
+    {
+      title: "Sync Untappd check-ins into the cache",
+      description: "Fetch a user's check-ins into a persistent cache so history can be queried without paging the API. Incremental (stops once it reaches already-cached check-ins) and resumable: if the backfill is not yet complete it pages backwards up to max_pages per call and persists progress after every page, so run it repeatedly until another_run_needed is false. Syncing another user requires their account be public or a friend. Omit username for your own account.",
+      annotations: toolAnnotations({ title: "Sync Untappd check-ins into the cache", readOnly: false, idempotent: false, openWorld: true }),
+      inputSchema: {
+        username: UsernameArg2,
+        max_pages: external_exports.number().int().min(1).max(50).optional().describe("Total pages (50 check-ins each) to fetch this run, incremental + backfill (default 10). Keep modest to respect the ~100 calls/hour rate limit.")
+      }
+    },
+    async ({ username, max_pages }) => {
+      const user = resolveUser2(username, client2.loginName);
+      const summary = await syncCheckins(client2, cacheProvider(), user, max_pages ?? 10);
+      return textResult(summary);
+    }
+  );
+  server.registerTool(
+    "untappd_cache_has_had",
+    {
+      title: "Check if a user has had a beer (from the cache)",
+      description: 'Answer "has this user ever checked in this beer?" from the cache only \u2014 NO API call. Match by exact bid, or by a case-insensitive substring of the beer name. Returns whether they had it, how many times, the best rating, the last date, and the matching check-ins. Always reports cache freshness so you can caveat incomplete data. Requires bid or beer_name. Run untappd_sync_checkins first.',
+      annotations: toolAnnotations({ title: "Check if a user has had a beer (from the cache)", readOnly: true, idempotent: true, openWorld: false }),
+      inputSchema: {
+        username: UsernameArg2,
+        bid: external_exports.number().int().positive().optional().describe("Exact Untappd beer id to look for"),
+        beer_name: external_exports.string().min(1).optional().describe("Case-insensitive substring match on the beer name")
+      }
+    },
+    async ({ username, bid, beer_name }) => {
+      if (bid === void 0 && beer_name === void 0) {
+        throw createHelpfulError("Provide either bid or beer_name.", { hint: "bid is exact; beer_name is a case-insensitive substring match." });
+      }
+      const user = resolveUser2(username, client2.loginName);
+      const cache = cacheProvider();
+      const result = await cache.hasHad(user, { bid, beerName: beer_name });
+      return textResult({ username: user, query: { bid, beer_name }, ...result, freshness: await freshness(cache, user) });
+    }
+  );
+  server.registerTool(
+    "untappd_cache_has_had_many",
+    {
+      title: "Batch-check many beers against the cache",
+      description: "Cross-check a list of beer ids against a user's cached history in ONE call \u2014 NO API call. Returns had/not-had per bid (with count and last date when had). Ideal for checking a whole venue menu at once. Run untappd_sync_checkins first; the freshness block flags if the cache is incomplete.",
+      annotations: toolAnnotations({ title: "Batch-check many beers against the cache", readOnly: true, idempotent: true, openWorld: false }),
+      inputSchema: {
+        username: UsernameArg2,
+        bids: external_exports.array(external_exports.number().int().positive()).min(1).max(500).describe("Beer ids to check (1\u2013500)")
+      }
+    },
+    async ({ username, bids }) => {
+      const user = resolveUser2(username, client2.loginName);
+      const cache = cacheProvider();
+      const seen = /* @__PURE__ */ new Set();
+      const results = [];
+      let hadCount = 0;
+      for (const bid of bids) {
+        if (seen.has(bid)) continue;
+        seen.add(bid);
+        const r = await cache.hasHad(user, { bid });
+        if (r.had) hadCount++;
+        results.push({ bid, had: r.had, count: r.count, last_date: r.last_date, best_rating: r.best_rating });
+      }
+      return textResult({
+        username: user,
+        checked: seen.size,
+        had: hadCount,
+        not_had: seen.size - hadCount,
+        results,
+        freshness: await freshness(cache, user)
+      });
+    }
+  );
+  server.registerTool(
+    "untappd_cache_query",
+    {
+      title: "Query cached check-ins with filters",
+      description: "Query a user's cached check-ins by brewery, style, minimum rating, venue, and/or date range, with sorting and a limit \u2014 from the cache only, NO API call. Returns the matching check-ins plus cache freshness. Run untappd_sync_checkins first.",
+      annotations: toolAnnotations({ title: "Query cached check-ins with filters", readOnly: true, idempotent: true, openWorld: false }),
+      inputSchema: {
+        username: UsernameArg2,
+        brewery_id: external_exports.number().int().positive().optional().describe("Exact brewery id"),
+        brewery: external_exports.string().min(1).optional().describe("Case-insensitive substring match on brewery name"),
+        style: external_exports.string().min(1).optional().describe('Case-insensitive substring match on beer style (e.g. "IPA")'),
+        min_rating: external_exports.number().min(0).max(5).optional().describe("Only check-ins you rated at least this (0\u20135)"),
+        venue: external_exports.string().min(1).optional().describe("Case-insensitive substring match on venue name"),
+        venue_id: external_exports.number().int().positive().optional().describe("Exact venue id"),
+        date_from: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Only check-ins on/after this date (YYYY-MM-DD, UTC)"),
+        date_to: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Only check-ins on/before this date (YYYY-MM-DD, UTC)"),
+        sort: external_exports.enum(["recent", "oldest", "highest_rated", "lowest_rated"]).optional().describe("Sort order (default recent first)"),
+        limit: external_exports.number().int().min(1).max(200).optional().describe("Max rows (1\u2013200, default 25)")
+      }
+    },
+    async ({ username, ...filters }) => {
+      const user = resolveUser2(username, client2.loginName);
+      const cache = cacheProvider();
+      const rows = await cache.query(user, filters);
+      return textResult({ username: user, count: rows.length, filters, results: rows, freshness: await freshness(cache, user) });
+    }
+  );
+}
+
+// src/cache/db.ts
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { homedir } from "node:os";
+var NodeSqlDriver = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  execScript(sql) {
+    this.db.exec(sql);
+  }
+  run(sql, params) {
+    this.db.prepare(sql).run(...params);
+  }
+  get(sql, params) {
+    return this.db.prepare(sql).get(...params);
+  }
+  all(sql, params) {
+    return this.db.prepare(sql).all(...params);
+  }
+  transaction(fn) {
+    this.db.exec("BEGIN");
+    try {
+      fn();
+      this.db.exec("COMMIT");
+    } catch (e) {
+      this.db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+};
+var CheckinCache = class _CheckinCache extends LocalCacheStore {
+  constructor(db) {
+    super(new CheckinStoreCore(new NodeSqlDriver(db)));
+    this.db = db;
+  }
+  db;
+  /** Open (creating parent dirs) a file-backed cache, or `:memory:` for tests. */
+  static open(path) {
+    if (path !== ":memory:") mkdirSync(dirname2(path), { recursive: true });
+    return new _CheckinCache(new DatabaseSync(path));
+  }
+  close() {
+    this.db.close();
+  }
+};
+function defaultCachePath() {
+  return readEnvVar("UNTAPPD_CACHE_DB") ?? join2(homedir(), ".untappd-mcp", "checkins.db");
+}
+
 // src/index.ts
 var client = new UntappdClient();
+var nodeCache;
+var nodeCacheProvider = () => nodeCache ??= CheckinCache.open(defaultCachePath());
 await runMcp({
   name: "untappd-mcp",
   version: VERSION,
@@ -32380,6 +33038,12 @@ await runMcp({
     (s) => registerFriendActionTools(s, client),
     (s) => registerWishlistTools(s, client),
     (s) => registerCheckinTools(s, client),
-    (s) => registerUtilityTools(s, client)
+    (s) => registerUtilityTools(s, client),
+    // The stdio server backs the cache with a local `node:sqlite` file; the
+    // remote Cloudflare connector (src/worker.ts) backs the same cache tools
+    // with a per-user Durable Object instead.
+    (s) => registerCacheTools(s, client, nodeCacheProvider),
+    // Keep last: logs the full registered toolset (count + names) at startup.
+    (s) => logRegisteredTools(s, "stdio")
   ]
 });