untappd-mcp 2.5.1 → 2.5.2

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "MCP server for Untappd — beers, breweries, venues, check-ins, wishlists, and your friend feed",
-    "version": "2.5.1"
+    "version": "2.5.2"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "Untappd",
       "source": "./",
       "description": "MCP server for Untappd — search beers/breweries/venues, read profiles/check-ins/wishlists, and post check-ins, toasts, and comments",
-      "version": "2.5.1",
+      "version": "2.5.2",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "untappd-mcp",
   "displayName": "Untappd",
-  "version": "2.5.1",
+  "version": "2.5.2",
   "description": "MCP server for Untappd — search beers/breweries/venues, read check-ins and wishlists, and post check-ins, toasts, and comments",
   "author": {
     "name": "Chris Hall",

package/dist/bundle.js

@@ -59906,7 +59906,7 @@ function toolAnnotations(opts = {}) {
 }
 
 // src/version.ts
-var VERSION = "2.5.1";
+var VERSION = "2.5.2";
 
 // src/client.ts
 import { dirname as dirname2, join as join4 } from "path";
@@ -66702,7 +66702,7 @@ var NodeSqlDriver = class {
     return this.prepared(sql).all(...params);
   }
   transaction(fn) {
-    this.db.exec("BEGIN IMMEDIATE");
+    retryBusy(() => this.db.exec("BEGIN IMMEDIATE"));
     try {
       fn();
       this.db.exec("COMMIT");
@@ -66728,19 +66728,25 @@ var CheckinCache = class _CheckinCache extends LocalCacheStore {
   static open(path) {
     if (path !== ":memory:") preparePrivateFile(path);
     const db = new DatabaseSync(path);
-    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
-    if (path !== ":memory:") {
-      db.exec("PRAGMA journal_mode = WAL");
-      db.exec("PRAGMA synchronous = NORMAL");
+    try {
+      db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+      if (path !== ":memory:") {
+        retryBusy(() => {
+          if (journalModeOf(db) !== "wal") db.exec("PRAGMA journal_mode = WAL");
+        });
+        db.exec("PRAGMA synchronous = NORMAL");
+      }
+      const cache = new _CheckinCache(db, path);
+      if (path !== ":memory:") tightenSidecars(path);
+      return cache;
+    } catch (e) {
+      db.close();
+      throw e;
     }
-    const cache = new _CheckinCache(db, path);
-    if (path !== ":memory:") tightenSidecars(path);
-    return cache;
   }
   /** The SQLite journal mode actually in effect (`wal` for a file, `memory` for :memory:). */
   journalMode() {
-    const row = this.db.prepare("PRAGMA journal_mode").get();
-    return String(row?.journal_mode ?? "unknown");
+    return journalModeOf(this.db);
   }
   /** On-disk footprint: the db file plus its -wal/-shm side files. */
   fileInfo() {
@@ -66779,6 +66785,28 @@ function bestEffortChmod(path, mode) {
   }
 }
 var BUSY_TIMEOUT_MS = 5e3;
+function journalModeOf(db) {
+  const row = db.prepare("PRAGMA journal_mode").get();
+  return String(row?.journal_mode ?? "unknown");
+}
+function isBusy(e) {
+  const code2 = e?.errcode;
+  return typeof code2 === "number" && ((code2 & 255) === 5 || (code2 & 255) === 6);
+}
+var sleepCell = new Int32Array(new SharedArrayBuffer(4));
+function retryBusy(fn, timeoutMs = BUSY_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return fn();
+    } catch (e) {
+      const left = deadline - Date.now();
+      if (!isBusy(e) || left <= 0) throw e;
+      const wait = Math.min(100, 5 * 2 ** Math.min(attempt, 5)) + Math.random() * 5;
+      Atomics.wait(sleepCell, 0, 0, Math.min(wait, left));
+    }
+  }
+}
 function defaultCachePath() {
   const file2 = readEnvVar("UNTAPPD_CACHE_DB");
   if (file2) return file2 === ":memory:" ? file2 : absolutise(file2);

package/dist/cache/db.js

@@ -47,7 +47,9 @@ class NodeSqlDriver {
         // IMMEDIATE takes the write lock up front. A DEFERRED transaction that
         // reads and then writes can hit SQLITE_BUSY on the lock upgrade, which
         // busy_timeout does NOT retry — the failure mode of two hosts open at once.
-        this.db.exec('BEGIN IMMEDIATE');
+        // BEGIN itself can still get a handler-less SQLITE_BUSY (e.g. while another
+        // process recovers the WAL), so it is retried too.
+        retryBusy(() => this.db.exec('BEGIN IMMEDIATE'));
         try {
             fn();
             this.db.exec('COMMIT');
@@ -78,23 +80,36 @@ export class CheckinCache extends LocalCacheStore {
         if (path !== ':memory:')
             preparePrivateFile(path);
         const db = new DatabaseSync(path);
-        // Set before the schema/migration transaction so even that waits out a
-        // second process instead of failing. WAL lets readers and one writer run
-        // concurrently (two hosts open at once); NORMAL sync is the WAL-safe default.
-        db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
-        if (path !== ':memory:') {
-            db.exec('PRAGMA journal_mode = WAL');
-            db.exec('PRAGMA synchronous = NORMAL');
+        try {
+            // Set before the schema/migration transaction so even that waits out a
+            // second process instead of failing. WAL lets readers and one writer run
+            // concurrently (two hosts open at once); NORMAL sync is the WAL-safe default.
+            db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+            if (path !== ':memory:') {
+                // Switching a fresh file to WAL needs an exclusive lock, and when another
+                // process is opening it too SQLite answers SQLITE_BUSY WITHOUT calling
+                // the busy handler (#256) — so busy_timeout never applies and this has
+                // to retry itself. Once the file is WAL (the switch is persistent) a
+                // later open skips the switch entirely.
+                retryBusy(() => {
+                    if (journalModeOf(db) !== 'wal')
+                        db.exec('PRAGMA journal_mode = WAL');
+                });
+                db.exec('PRAGMA synchronous = NORMAL');
+            }
+            const cache = new CheckinCache(db, path);
+            if (path !== ':memory:')
+                tightenSidecars(path);
+            return cache;
+        }
+        catch (e) {
+            db.close();
+            throw e;
         }
-        const cache = new CheckinCache(db, path);
-        if (path !== ':memory:')
-            tightenSidecars(path);
-        return cache;
     }
     /** The SQLite journal mode actually in effect (`wal` for a file, `memory` for :memory:). */
     journalMode() {
-        const row = this.db.prepare('PRAGMA journal_mode').get();
-        return String(row?.journal_mode ?? 'unknown');
+        return journalModeOf(this.db);
     }
     /** On-disk footprint: the db file plus its -wal/-shm side files. */
     fileInfo() {
@@ -152,6 +167,39 @@ function bestEffortChmod(path, mode) {
 }
 // How long a write waits for another process's lock before failing.
 const BUSY_TIMEOUT_MS = 5000;
+function journalModeOf(db) {
+    const row = db.prepare('PRAGMA journal_mode').get();
+    return String(row?.journal_mode ?? 'unknown');
+}
+/** SQLITE_BUSY / SQLITE_LOCKED, including their extended codes (e.g. BUSY_RECOVERY). */
+function isBusy(e) {
+    const code = e?.errcode;
+    return typeof code === 'number' && ((code & 0xff) === 5 || (code & 0xff) === 6);
+}
+const sleepCell = new Int32Array(new SharedArrayBuffer(4));
+/**
+ * Run `fn`, retrying a SQLITE_BUSY that SQLite raised without consulting the
+ * busy handler, until {@link BUSY_TIMEOUT_MS} after the FIRST attempt. A BUSY
+ * that already waited out busy_timeout lands past that deadline and is thrown
+ * as-is, so the total wait never exceeds busy_timeout's. The driver is
+ * synchronous, so the backoff blocks (Atomics.wait) like busy_timeout does.
+ */
+export function retryBusy(fn, timeoutMs = BUSY_TIMEOUT_MS) {
+    const deadline = Date.now() + timeoutMs;
+    for (let attempt = 0;; attempt++) {
+        try {
+            return fn();
+        }
+        catch (e) {
+            const left = deadline - Date.now();
+            if (!isBusy(e) || left <= 0)
+                throw e;
+            // 5, 10, 20 … ms, capped at 100, plus jitter so colliding opens spread out.
+            const wait = Math.min(100, 5 * 2 ** Math.min(attempt, 5)) + Math.random() * 5;
+            Atomics.wait(sleepCell, 0, 0, Math.min(wait, left));
+        }
+    }
+}
 /**
  * The on-disk cache path, always ABSOLUTE: `$UNTAPPD_CACHE_DB` (a file), else
  * `$UNTAPPD_CACHE_DIR/checkins.db`, else `~/.untappd-mcp/checkins.db`.

package/dist/version.js

@@ -3,4 +3,4 @@
 // json's `extra-files`), and `versionSyncTest` guards that it stays equal to
 // package.json. Import VERSION wherever the version is needed rather than
 // re-declaring it.
-export const VERSION = '2.5.1'; // x-release-please-version
+export const VERSION = '2.5.2'; // x-release-please-version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "untappd-mcp",
-  "version": "2.5.1",
+  "version": "2.5.2",
   "mcpName": "io.github.chrischall/untappd-mcp",
   "description": "Untappd MCP server for Claude — developed and maintained by AI (Claude Code)",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/untappd-mcp",
     "source": "github"
   },
-  "version": "2.5.1",
+  "version": "2.5.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "untappd-mcp",
-      "version": "2.5.1",
+      "version": "2.5.2",
       "transport": {
         "type": "stdio"
       },