untappd-mcp 1.3.1 → 1.4.0

package/dist/bundle.js

@@ -31184,7 +31184,7 @@ function toolAnnotations(opts = {}) {
 }
 
 // src/version.ts
-var VERSION = "1.3.1";
+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,17 +32382,14 @@ 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/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";
+// src/cache/store.ts
 function asDict2(v) {
   return v && typeof v === "object" && !Array.isArray(v) ? v : {};
 }
@@ -32406,60 +32428,47 @@ function normaliseDate(v) {
   const t = Date.parse(s);
   return Number.isNaN(t) ? s : new Date(t).toISOString();
 }
-var SCHEMA = `
-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 CheckinCache = class _CheckinCache {
-  db;
+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;
-    this.db.exec(SCHEMA);
-    this.migrate();
-  }
-  // Forward-compat for a sync_state table created before a column existed. Each
-  // ADD COLUMN throws harmlessly if the column is already present.
-  migrate() {
-    for (const col of ["catchup_max_id INTEGER"]) {
+    for (const stmt of SCHEMA_STATEMENTS) this.db.execScript(stmt);
+    for (const mig of MIGRATIONS) {
       try {
-        this.db.exec(`ALTER TABLE sync_state ADD COLUMN ${col}`);
+        this.db.execScript(mig);
       } catch {
       }
     }
   }
-  /** 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();
-  }
+  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
@@ -32469,7 +32478,7 @@ var CheckinCache = class _CheckinCache {
     if (rows.length === 0) return 0;
     const key = username.toLowerCase();
     const before = this.cachedCount(username);
-    const stmt = this.db.prepare(`
+    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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -32477,12 +32486,10 @@ var CheckinCache = class _CheckinCache {
         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.exec("BEGIN");
-    try {
+        venue_id=excluded.venue_id, venue_name=excluded.venue_name, created_at=excluded.created_at`;
+    this.db.transaction(() => {
       for (const r of rows) {
-        stmt.run(
+        this.db.run(sql, [
           r.checkin_id,
           key,
           r.bid,
@@ -32496,34 +32503,41 @@ var CheckinCache = class _CheckinCache {
           r.venue_id,
           r.venue_name,
           r.created_at
-        );
+        ]);
       }
-      this.db.exec("COMMIT");
-    } catch (e) {
-      this.db.exec("ROLLBACK");
-      throw e;
-    }
+    });
     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.prepare("SELECT COUNT(*) AS n FROM checkins WHERE username = ?").get(username.toLowerCase());
-    return row.n;
+    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.prepare("SELECT COUNT(DISTINCT bid) AS n FROM checkins WHERE username = ? AND bid IS NOT NULL").get(username.toLowerCase());
-    return row.n;
+    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.prepare("SELECT MAX(checkin_id) AS m FROM checkins WHERE username = ?").get(username.toLowerCase());
-    return row.m;
+    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.prepare("SELECT * FROM sync_state WHERE username = ?").get(username.toLowerCase());
+    const row = this.db.get("SELECT * FROM sync_state WHERE username = ?", [username.toLowerCase()]);
     if (!row) return void 0;
-    return { ...row, username: row.username, backfill_complete: row.backfill_complete === 1 };
+    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
@@ -32543,22 +32557,23 @@ var CheckinCache = class _CheckinCache {
       backfill_complete: pick2("backfill_complete", false),
       total_checkins: pick2("total_checkins", null)
     };
-    this.db.prepare(
+    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`
-    ).run(
-      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
+       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. */
@@ -32574,16 +32589,18 @@ var CheckinCache = class _CheckinCache {
       params.push(`%${escapeLike(opts.beerName)}%`);
     }
     const clause = where.join(" AND ");
-    const agg = this.db.prepare(`SELECT COUNT(*) AS n, MAX(rating) AS best FROM checkins WHERE ${clause}`).get(...params);
-    const matches = this.db.prepare(
+    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`
-    ).all(...params);
+       FROM checkins WHERE ${clause} ORDER BY checkin_id DESC LIMIT 25`,
+      params
+    );
+    const count2 = Number(agg?.n ?? 0);
     return {
-      had: agg.n > 0,
-      count: agg.n,
+      had: count2 > 0,
+      count: count2,
       last_date: matches[0]?.created_at ?? null,
-      best_rating: agg.best,
+      best_rating: num(agg?.best),
       matches
     };
   }
@@ -32624,16 +32641,45 @@ var CheckinCache = class _CheckinCache {
     }
     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);
-    const rows = this.db.prepare(`SELECT * FROM checkins WHERE ${where.join(" AND ")} ORDER BY ${order} LIMIT ?`).all(...params, limit);
-    return rows;
+    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, " ");
 }
-function defaultCachePath() {
-  return readEnvVar("UNTAPPD_CACHE_DB") ?? join2(homedir(), ".untappd-mcp", "checkins.db");
-}
 
 // src/cache/sync.ts
 var PAGE_LIMIT = 50;
@@ -32667,7 +32713,7 @@ async function fetchTotalCheckins(client2, encodedUser) {
 }
 async function syncCheckins(client2, cache, rawUsername, maxPages = 10) {
   const encodedUser = encodeURIComponent(rawUsername);
-  const prior = cache.getState(rawUsername);
+  const prior = await cache.getState(rawUsername);
   const priorNewest = prior?.newest_checkin_id ?? null;
   let pages = 0;
   let added = 0;
@@ -32698,7 +32744,7 @@ async function syncCheckins(client2, cache, rawUsername, maxPages = 10) {
         break;
       }
       const rows = rowsOf(rawUsername, page.items);
-      added += cache.upsertCheckins(rawUsername, rows);
+      added += await cache.upsertCheckins(rawUsername, rows);
       const oldestOnPage = rows[rows.length - 1].checkin_id;
       if (oldestOnPage <= priorNewest) {
         caughtUp = true;
@@ -32711,14 +32757,14 @@ async function syncCheckins(client2, cache, rawUsername, maxPages = 10) {
         break;
       }
       catchupMaxId = page.nextMaxId;
-      cache.setState(rawUsername, { catchup_max_id: catchupMaxId, last_synced_at: now() });
+      await cache.setState(rawUsername, { catchup_max_id: catchupMaxId, last_synced_at: now() });
       maxId = page.nextMaxId;
     }
     if (caughtUp) {
-      newest = cache.newestCachedId(rawUsername);
+      newest = await cache.newestCachedId(rawUsername);
       catchupMaxId = null;
       catchupInProgress = false;
-      cache.setState(rawUsername, {
+      await cache.setState(rawUsername, {
         newest_checkin_id: newest,
         catchup_max_id: null,
         backfill_complete: backfillComplete,
@@ -32740,11 +32786,11 @@ async function syncCheckins(client2, cache, rawUsername, maxPages = 10) {
         break;
       }
       const rows = rowsOf(rawUsername, page.items);
-      added += cache.upsertCheckins(rawUsername, rows);
+      added += await cache.upsertCheckins(rawUsername, rows);
       if (newest === null) newest = rows[0].checkin_id;
       oldestMaxId = page.nextMaxId;
       if (page.nextMaxId === null) backfillComplete = true;
-      cache.setState(rawUsername, {
+      await cache.setState(rawUsername, {
         newest_checkin_id: newest,
         oldest_max_id: oldestMaxId,
         backfill_complete: backfillComplete,
@@ -32755,8 +32801,8 @@ async function syncCheckins(client2, cache, rawUsername, maxPages = 10) {
     }
   }
   const total = await fetchTotalCheckins(client2, encodedUser);
-  const cached2 = cache.cachedCount(rawUsername);
-  cache.setState(rawUsername, {
+  const cached2 = await cache.cachedCount(rawUsername);
+  await cache.setState(rawUsername, {
     newest_checkin_id: newest,
     oldest_max_id: oldestMaxId,
     catchup_max_id: catchupMaxId,
@@ -32772,7 +32818,7 @@ async function syncCheckins(client2, cache, rawUsername, maxPages = 10) {
     rows_added: added,
     pages_fetched: pages,
     cached_checkins: cached2,
-    distinct_beers: cache.distinctBeerCount(rawUsername),
+    distinct_beers: await cache.distinctBeerCount(rawUsername),
     total_checkins: total,
     backfill_percent: backfillPercent,
     backfill_complete: backfillComplete,
@@ -32794,9 +32840,9 @@ function resolveUser2(username, loginName) {
   }
   return u;
 }
-function freshness(cache, username) {
-  const state = cache.getState(username);
-  const cached2 = cache.cachedCount(username);
+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;
@@ -32814,17 +32860,17 @@ function freshness(cache, username) {
     catchup_in_progress: catchupInProgress,
     backfill_percent: percent,
     cached_checkins: cached2,
-    distinct_beers: cache.distinctBeerCount(username),
+    distinct_beers: await cache.distinctBeerCount(username),
     ...caveat ? { caveat } : {}
   };
 }
-function registerCacheTools(server, client2, cacheProvider = defaultCacheProvider()) {
+function registerCacheTools(server, client2, cacheProvider) {
   server.registerTool(
     "untappd_sync_checkins",
     {
-      title: "Sync Untappd check-ins into the local cache",
-      description: "Fetch a user's check-ins into a local SQLite 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 backfill_complete is true. 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 local cache", readOnly: false, idempotent: false, openWorld: true }),
+      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.")
@@ -32839,9 +32885,9 @@ function registerCacheTools(server, client2, cacheProvider = defaultCacheProvide
   server.registerTool(
     "untappd_cache_has_had",
     {
-      title: "Check if a user has had a beer (from local cache)",
-      description: 'Answer "has this user ever checked in this beer?" from the LOCAL 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 local cache)", readOnly: true, idempotent: true, openWorld: false }),
+      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"),
@@ -32854,16 +32900,16 @@ function registerCacheTools(server, client2, cacheProvider = defaultCacheProvide
       }
       const user = resolveUser2(username, client2.loginName);
       const cache = cacheProvider();
-      const result = cache.hasHad(user, { bid, beerName: beer_name });
-      return textResult({ username: user, query: { bid, beer_name }, ...result, freshness: freshness(cache, user) });
+      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 local cache",
+      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 local cache", readOnly: true, idempotent: true, openWorld: false }),
+      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)")
@@ -32878,7 +32924,7 @@ function registerCacheTools(server, client2, cacheProvider = defaultCacheProvide
       for (const bid of bids) {
         if (seen.has(bid)) continue;
         seen.add(bid);
-        const r = cache.hasHad(user, { 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 });
       }
@@ -32888,7 +32934,7 @@ function registerCacheTools(server, client2, cacheProvider = defaultCacheProvide
         had: hadCount,
         not_had: seen.size - hadCount,
         results,
-        freshness: freshness(cache, user)
+        freshness: await freshness(cache, user)
       });
     }
   );
@@ -32896,7 +32942,7 @@ function registerCacheTools(server, client2, cacheProvider = defaultCacheProvide
     "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 LOCAL cache only, NO API call. Returns the matching check-ins plus cache freshness. Run untappd_sync_checkins first.",
+      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,
@@ -32915,18 +32961,68 @@ function registerCacheTools(server, client2, cacheProvider = defaultCacheProvide
     async ({ username, ...filters }) => {
       const user = resolveUser2(username, client2.loginName);
       const cache = cacheProvider();
-      const rows = cache.query(user, filters);
-      return textResult({ username: user, count: rows.length, filters, results: rows, freshness: freshness(cache, user) });
+      const rows = await cache.query(user, filters);
+      return textResult({ username: user, count: rows.length, filters, results: rows, freshness: await freshness(cache, user) });
     }
   );
 }
-function defaultCacheProvider() {
-  let cache;
-  return () => cache ??= CheckinCache.open(defaultCachePath());
+
+// 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,
@@ -32943,9 +33039,11 @@ await runMcp({
     (s) => registerWishlistTools(s, client),
     (s) => registerCheckinTools(s, client),
     (s) => registerUtilityTools(s, client),
-    // Cache tools live only on the Node/stdio server: they need a local SQLite
-    // file, which the filesystem-less Cloudflare Worker (src/worker.ts) can't
-    // provide, so they are intentionally NOT registered there.
-    (s) => registerCacheTools(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")
   ]
 });