untappd-mcp 2.1.2 → 2.2.0

package/dist/bundle.js

@@ -1585,8 +1585,8 @@ var require_regexes = __commonJS({
     }
     exports.ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
     exports.ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-    var mac3 = (delimiter) => {
-      const escapedDelim = util.escapeRegex(delimiter ?? ":");
+    var mac3 = (delimiter2) => {
+      const escapedDelim = util.escapeRegex(delimiter2 ?? ":");
       return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
     };
     exports.mac = mac3;
@@ -5000,7 +5000,7 @@ var require_memoizer = __commonJS({
       return bucket;
     }
     var handoff2;
-    var open2 = [];
+    var open3 = [];
     var memo3 = {
       alloc(_inst, payload, empty) {
         const bucket = handoff2;
@@ -5009,7 +5009,7 @@ var require_memoizer = __commonJS({
         handoff2 = void 0;
         const entry = { value: empty, issues: null };
         bucket.set(payload.value, entry);
-        open2.push(entry);
+        open3.push(entry);
         return empty;
       },
       guard(inst) {
@@ -5080,10 +5080,10 @@ var require_memoizer = __commonJS({
               return payload;
             }
             handoff2 = bucket;
-            const depth = open2.length;
+            const depth = open3.length;
             const result = base(payload, ctx);
             handoff2 = void 0;
-            const entry = open2.length > depth ? open2.pop() : void 0;
+            const entry = open3.length > depth ? open3.pop() : void 0;
             if (result instanceof Promise) {
               return result.then((r) => {
                 if (entry)
@@ -23315,6 +23315,33 @@ var storage2 = new AsyncLocalStorage2();
 function withCallerCapabilities(capabilities, fn) {
   return capabilities ? storage2.run(capabilities, fn) : fn();
 }
+function currentCallerCapabilities() {
+  return storage2.getStore();
+}
+var ENVELOPE_CAPABILITIES_KEY = "io.modelcontextprotocol/clientCapabilities";
+var ELICITATION_MODES = ["form", "url"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function callerCapabilities(ctx) {
+  const envelope = isRecord(ctx) && isRecord(ctx.mcpReq) ? ctx.mcpReq.envelope : void 0;
+  if (isRecord(envelope)) {
+    const declared = envelope[ENVELOPE_CAPABILITIES_KEY];
+    if (isRecord(declared))
+      return declared;
+  }
+  return currentCallerCapabilities();
+}
+function callerAcceptsFormElicitation(ctx) {
+  const capabilities = callerCapabilities(ctx);
+  if (!capabilities)
+    return void 0;
+  const elicitation = capabilities.elicitation;
+  if (!isRecord(elicitation))
+    return false;
+  const namedModes = ELICITATION_MODES.filter((mode) => mode in elicitation);
+  return namedModes.length === 0 || namedModes.includes("form");
+}
 
 // node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create2 = Object.create;
@@ -27713,6 +27740,37 @@ var inputRequired = Object.assign(buildInputRequired, {
     return { method: "roots/list" };
   }
 });
+function acceptedContent(responses, key, schema) {
+  const view = inputResponse(responses, key);
+  if (view.kind !== "elicit" || view.action !== "accept" || view.content === void 0) return void 0;
+  if (schema === void 0) return view.content;
+  const outcome = schema["~standard"].validate(view.content);
+  if (outcome instanceof Promise) throw new TypeError("acceptedContent(responses, key, schema) requires a synchronously-validating schema");
+  return outcome.issues === void 0 ? outcome.value : void 0;
+}
+function inputResponse(responses, key) {
+  if (responses === void 0 || typeof responses !== "object" || responses === null) return { kind: "missing" };
+  const entry = responses[key];
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return { kind: "missing" };
+  const candidate = entry;
+  if (candidate["action"] === "accept" || candidate["action"] === "decline" || candidate["action"] === "cancel") {
+    const content = candidate["content"];
+    return {
+      kind: "elicit",
+      action: candidate["action"],
+      ...content !== null && typeof content === "object" && !Array.isArray(content) && { content }
+    };
+  }
+  if (Array.isArray(candidate["roots"])) return {
+    kind: "roots",
+    roots: candidate["roots"]
+  };
+  if (typeof candidate["role"] === "string" && candidate["content"] !== void 0) return {
+    kind: "sampling",
+    result: candidate
+  };
+  return { kind: "missing" };
+}
 var REQUEST_STATE_ONLY_LEG_PACING_MS = 250;
 function inputRequiredRoundsExceededMessage(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
@@ -37760,14 +37818,14 @@ function serveStdio(factory, options = {}) {
     return false;
   };
   const answerLegacyRejection = (request, reason, requestedVersion) => {
-    const rejection2 = modernOnlyStrictRejection({
+    const rejection3 = modernOnlyStrictRejection({
       kind: "legacy",
       reason,
       ...requestedVersion !== void 0 && { requestedVersion }
     }, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
-    if (rejection2 === void 0) return Promise.resolve();
-    reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only stdio connection (${rejection2.cell}): ${rejection2.message}`));
-    return writeErrorResponse(request.id, rejection2.code, rejection2.message, rejection2.data);
+    if (rejection3 === void 0) return Promise.resolve();
+    reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only stdio connection (${rejection3.cell}): ${rejection3.message}`));
+    return writeErrorResponse(request.id, rejection3.code, rejection3.message, rejection3.data);
   };
   const onInstanceClosed = (channel) => {
     if (closing || channel === discarding) return;
@@ -40052,8 +40110,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter) => {
-  const escapedDelim = escapeRegex(delimiter ?? ":");
+var mac = (delimiter2) => {
+  const escapedDelim = escapeRegex(delimiter2 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 };
 var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -57758,6 +57816,11 @@ var MEDIA_QUALIFIER = "(?:primary|secondary|main|default|cover|hero|profile|mast
 var MEDIA_KEY = new RegExp(`^(?:(?:${MEDIA_QUALIFIER}|${MEDIA_NOUN})[_-]?)?${MEDIA_NOUN}s?(?:[_-]?(?:link|uri|url|src)s?)?$`, "i");
 
 // node_modules/@chrischall/mcp-utils/dist/response/index.js
+function textResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
 function errorResult(message) {
   return {
     content: [{ type: "text", text: redactSecrets(message) }],
@@ -57765,6 +57828,418 @@ function errorResult(message) {
   };
 }
 
+// node_modules/@chrischall/mcp-utils/dist/server/confirmation.js
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+
+// node_modules/@chrischall/mcp-utils/dist/server/canonical.js
+function canonicalJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return JSON.stringify(value);
+  if (value === void 0)
+    return "null";
+  if (typeof value === "number")
+    return Number.isFinite(value) ? JSON.stringify(value) : `{"$num":"${String(value)}"}`;
+  if (typeof value === "bigint")
+    return `{"$bigint":"${value.toString()}"}`;
+  if (typeof value === "function" || typeof value === "symbol") {
+    throw new TypeError(`confirmation: cannot bind a ${typeof value} argument value.`);
+  }
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  if (value instanceof Date) {
+    return `{"$date":${JSON.stringify(Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString())}}`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    const bytes = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    return `{"$bytes":${JSON.stringify(bytes.toString("base64"))}}`;
+  }
+  if (value instanceof ArrayBuffer)
+    return `{"$bytes":${JSON.stringify(Buffer.from(value).toString("base64"))}}`;
+  if (value instanceof Map) {
+    const entries2 = [...value.entries()].map(([k, v]) => `[${canonicalJson(k)},${canonicalJson(v)}]`).sort();
+    return `{"$map":[${entries2.join(",")}]}`;
+  }
+  if (value instanceof Set) {
+    return `{"$set":[${[...value].map(canonicalJson).sort().join(",")}]}`;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) {
+    throw new TypeError("confirmation: cannot bind a non-plain object argument value (class instance).");
+  }
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(escapeKey(k))}:${canonicalJson(v)}`).join(",")}}`;
+}
+function escapeKey(key) {
+  return key.startsWith("$") ? `$${key}` : key;
+}
+
+// node_modules/@chrischall/mcp-utils/dist/server/confirmation.js
+var DEFAULT_REQUEST_KEY = "confirmation";
+var DEFAULT_CONFIRMATION_LABEL = "Confirm this action should proceed.";
+var UNSUPPORTED_NOTE = "Nothing was done because this client cannot show a confirmation prompt (it declares no MCP elicitation capability), and this action is never taken without one";
+var STATE_PREFIX = "mcpu.confirm.v1.";
+function bindingKey(binding) {
+  if (binding.ttlSeconds !== void 0 && !(Number.isFinite(binding.ttlSeconds) && binding.ttlSeconds > 0)) {
+    throw new RangeError("requireConfirmation: binding.ttlSeconds must be a finite number greater than 0.");
+  }
+  const key = typeof binding.key === "string" ? Buffer.from(binding.key, "utf8") : Buffer.from(binding.key);
+  if (key.length < 32) {
+    throw new RangeError("requireConfirmation: binding.key must be at least 32 bytes.");
+  }
+  return key;
+}
+function commitment(action, args) {
+  return createHash("sha256").update(`${action}\0${canonicalJson(args)}`).digest("base64url");
+}
+function mintState(key, action, binding) {
+  const exp = Math.floor(Date.now() / 1e3) + (binding.ttlSeconds ?? 600);
+  const body = Buffer.from(JSON.stringify({ c: commitment(action, binding.args), exp })).toString("base64url");
+  const mac3 = createHmac("sha256", key).update(`${STATE_PREFIX}${body}`).digest("base64url");
+  return `${STATE_PREFIX}${body}.${mac3}`;
+}
+function verifyState(key, action, binding, state) {
+  if (typeof state !== "string" || !state.startsWith(STATE_PREFIX))
+    return false;
+  const rest = state.slice(STATE_PREFIX.length);
+  const dot = rest.indexOf(".");
+  if (dot < 0)
+    return false;
+  const body = rest.slice(0, dot);
+  const mac3 = Buffer.from(rest.slice(dot + 1), "base64url");
+  const expected = createHmac("sha256", key).update(`${STATE_PREFIX}${body}`).digest();
+  if (mac3.length !== expected.length || !timingSafeEqual(mac3, expected))
+    return false;
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+  } catch {
+    return false;
+  }
+  if (typeof payload.exp !== "number" || payload.exp * 1e3 <= Date.now())
+    return false;
+  const want = Buffer.from(commitment(action, binding.args));
+  const got = Buffer.from(typeof payload.c === "string" ? payload.c : "");
+  return got.length === want.length && timingSafeEqual(got, want);
+}
+function echoedState(ctx) {
+  const accessor = ctx.mcpReq.requestState;
+  return typeof accessor === "function" ? accessor() : void 0;
+}
+function requireConfirmation(ctx, options) {
+  const requestKey = options.requestKey ?? DEFAULT_REQUEST_KEY;
+  const key = options.binding ? bindingKey(options.binding) : void 0;
+  const confirmationSchema = external_exports.object({
+    confirmed: external_exports.boolean().describe(options.confirmationLabel ?? DEFAULT_CONFIRMATION_LABEL)
+  });
+  const ask = () => {
+    const preview = {
+      action: options.action,
+      ...options.details === void 0 ? {} : { details: options.details }
+    };
+    return inputRequired({
+      inputRequests: {
+        [requestKey]: inputRequired.elicit({
+          message: `${options.message}
+${JSON.stringify(preview, null, 2)}`,
+          requestedSchema: confirmationSchema
+        })
+      },
+      ...key && options.binding ? { requestState: mintState(key, options.action, options.binding) } : {}
+    });
+  };
+  const response = inputResponse(ctx.mcpReq.inputResponses, requestKey);
+  const accepted = acceptedContent(ctx.mcpReq.inputResponses, requestKey, confirmationSchema);
+  if (response.kind === "missing") {
+    if (callerAcceptsFormElicitation(ctx) === false) {
+      return textResult({
+        confirmed: false,
+        dispatched: false,
+        action: options.action,
+        reason: "confirmation-unsupported",
+        note: options.unsupportedNote ? `${UNSUPPORTED_NOTE}. ${options.unsupportedNote}` : `${UNSUPPORTED_NOTE}.`
+      });
+    }
+    return ask();
+  }
+  if (response.kind === "elicit" && response.action === "accept" && accepted?.confirmed === true) {
+    if (key && options.binding) {
+      const state = echoedState(ctx);
+      if (state === void 0 || state === null) {
+        return errorResult(`Confirmation for ${options.action} was accepted, but the retry carried no requestState, so it cannot be checked against the prompt that was shown. Nothing was done. The likely cause is that the MCP client or host does not round-trip requestState (it must echo the requestState from the input_required result back on the retry); asking again would loop.`);
+      }
+      if (!verifyState(key, options.action, options.binding, state))
+        return ask();
+    }
+    return void 0;
+  }
+  return textResult({
+    confirmed: false,
+    cancelled: true,
+    action: options.action,
+    note: "Nothing was changed because the confirmation was declined, cancelled, or left unchecked."
+  });
+}
+
+// node_modules/@chrischall/mcp-utils/dist/server/confirm-token.js
+import { createHash as createHash2, createHmac as createHmac2, randomBytes, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+function createSpentTokenStore() {
+  const spent = /* @__PURE__ */ new Map();
+  return {
+    has: (nonce) => spent.has(nonce),
+    add: (nonce, exp) => {
+      spent.set(nonce, exp);
+    },
+    prune: (now) => {
+      for (const [nonce, exp] of spent)
+        if (exp < now)
+          spent.delete(nonce);
+    },
+    clear: () => spent.clear(),
+    get size() {
+      return spent.size;
+    }
+  };
+}
+var PROCESS_SPENT = createSpentTokenStore();
+var PREFIX = "mcpu.token.v1.";
+var DEFAULT_TTL_SECONDS = 600;
+function tokenKey(key) {
+  const bytes = typeof key === "string" ? Buffer.from(key, "utf8") : Buffer.from(key);
+  if (bytes.length < 32)
+    throw new RangeError("confirm token: key must be at least 32 bytes.");
+  return bytes;
+}
+function ttlOf(ttlSeconds) {
+  if (ttlSeconds === void 0)
+    return DEFAULT_TTL_SECONDS;
+  if (!(Number.isFinite(ttlSeconds) && ttlSeconds > 0)) {
+    throw new RangeError("confirm token: ttlSeconds must be a finite number greater than 0.");
+  }
+  return ttlSeconds;
+}
+function sign(key, body) {
+  return createHmac2("sha256", key).update(`${PREFIX}${body}`).digest();
+}
+function hashConfirmPayload(payload) {
+  return createHash2("sha256").update(canonicalJson(payload)).digest("base64url");
+}
+function issueConfirmToken(key, binding, options = {}) {
+  const k = tokenKey(key);
+  const now = options.now ?? Date.now();
+  const exp = now + ttlOf(options.ttlSeconds) * 1e3;
+  const claims = {
+    t: binding.tool,
+    ...binding.account === void 0 ? {} : { a: binding.account },
+    g: binding.target,
+    ...binding.revision === void 0 ? {} : { r: binding.revision },
+    h: binding.payloadHash,
+    exp,
+    n: randomBytes(16).toString("base64url")
+  };
+  const body = Buffer.from(JSON.stringify(claims), "utf8").toString("base64url");
+  return { token: `${PREFIX}${body}.${sign(k, body).toString("base64url")}`, expiresAt: new Date(exp).toISOString() };
+}
+function parseClaims(body) {
+  try {
+    const claims = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+    return claims && typeof claims === "object" ? claims : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function verifyConfirmToken(key, token, binding, options = {}) {
+  const k = tokenKey(key);
+  const now = options.now ?? Date.now();
+  const spent = options.spent ?? PROCESS_SPENT;
+  spent.prune(now);
+  if (!token.startsWith(PREFIX))
+    return { ok: false, error: "TOKEN_INVALID" };
+  const rest = token.slice(PREFIX.length);
+  const dot = rest.indexOf(".");
+  const body = dot < 0 ? "" : rest.slice(0, dot);
+  const mac3 = Buffer.from(dot < 0 ? "" : rest.slice(dot + 1), "base64url");
+  const expected = sign(k, body);
+  if (!body || mac3.length !== expected.length || !timingSafeEqual2(mac3, expected))
+    return { ok: false, error: "TOKEN_INVALID" };
+  const claims = parseClaims(body);
+  if (!claims)
+    return { ok: false, error: "TOKEN_INVALID" };
+  if (claims.t !== binding.tool || claims.a !== binding.account || claims.g !== binding.target) {
+    return { ok: false, error: "TOKEN_INVALID" };
+  }
+  if (spent.has(claims.n))
+    return { ok: false, error: "TOKEN_REUSED" };
+  if (now > claims.exp)
+    return { ok: false, error: "TOKEN_EXPIRED" };
+  if (claims.r !== binding.revision)
+    return { ok: false, error: "DRAFT_CHANGED", reason: "revision-changed" };
+  if (claims.h !== binding.payloadHash)
+    return { ok: false, error: "DRAFT_CHANGED", reason: "payload-changed" };
+  spent.add(claims.n, claims.exp);
+  return { ok: true };
+}
+var CONFIRM_TOKEN_INSTRUCTION = "Show this preview to the user verbatim and proceed only after they explicitly approve in chat. Then call again with confirmToken.";
+var confirmTokenParam = external_exports.string().optional().describe(`ONLY for the two-step confirmation fallback (a client without MCP elicitation). The confirmToken from this same tool's phase-1 "confirmation-required" response, passed back ONLY after the user has seen that preview and explicitly approved it in chat \u2014 never on the first call, never invented, never reused. Call again with the same arguments. Ignored when the client supports elicitation.`);
+var TOKEN_ERROR_NOTE = {
+  TOKEN_EXPIRED: "Nothing was sent or changed: the confirmToken expired. Call again WITHOUT confirmToken for a fresh preview, and ask the user to approve it again.",
+  TOKEN_REUSED: "Nothing was sent or changed by this call: this confirmToken was already used, and one approval acts once. If doing it again is really intended, call again WITHOUT confirmToken and get a new approval.",
+  TOKEN_INVALID: "Nothing was sent or changed: this confirmToken was not issued by this server for this tool, account and target (or the server has restarted since). Call again WITHOUT confirmToken for a fresh preview and approval."
+};
+var CHANGED_NOTE = {
+  "revision-changed": "Nothing was sent or changed: the target was edited since the user approved it (its version rotated), so what would happen is not what they saw.",
+  "payload-changed": "Nothing was sent or changed: what would happen no longer matches what the user approved."
+};
+function isToolResult(value) {
+  return Array.isArray(value.content);
+}
+function rejection2(data) {
+  return { ...textResult({ status: "confirmation-rejected", confirmed: false, dispatched: false, ...data }), isError: true };
+}
+async function tokenConfirmation(action, fb) {
+  const subject = await fb.subject();
+  if (isToolResult(subject))
+    return subject;
+  const binding = {
+    tool: fb.tool,
+    ...fb.account === void 0 ? {} : { account: fb.account },
+    target: subject.target,
+    ...subject.revision === void 0 ? {} : { revision: subject.revision },
+    payloadHash: hashConfirmPayload(subject.payload)
+  };
+  const phaseOne = () => {
+    const { token, expiresAt } = issueConfirmToken(fb.key, binding, { ttlSeconds: fb.ttlSeconds });
+    return {
+      action,
+      preview: subject.preview,
+      confirmToken: token,
+      expiresAt,
+      ttlSeconds: ttlOf(fb.ttlSeconds),
+      instruction: fb.instruction ?? CONFIRM_TOKEN_INSTRUCTION
+    };
+  };
+  if (!fb.confirmToken) {
+    return textResult({ status: "confirmation-required", confirmed: false, dispatched: false, ...phaseOne() });
+  }
+  const verdict = verifyConfirmToken(fb.key, fb.confirmToken, binding, { spent: fb.spent });
+  if (verdict.ok)
+    return void 0;
+  if (verdict.error === "DRAFT_CHANGED") {
+    return rejection2({
+      error: "DRAFT_CHANGED",
+      reason: verdict.reason,
+      note: `${CHANGED_NOTE[verdict.reason]} The current preview and a fresh confirmToken are below.`,
+      ...phaseOne()
+    });
+  }
+  return rejection2({ error: verdict.error, action, note: TOKEN_ERROR_NOTE[verdict.error] });
+}
+async function requireConfirmationWithFallback(ctx, options) {
+  const { tokenFallback, ...confirmation } = options;
+  if (tokenFallback && callerAcceptsFormElicitation(ctx) === false) {
+    return tokenConfirmation(options.action, tokenFallback);
+  }
+  return requireConfirmation(ctx, confirmation);
+}
+
+// node_modules/@chrischall/mcp-utils/dist/server/confirm-env.js
+import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
+
+// node_modules/@chrischall/mcp-utils/dist/config/index.js
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+var PLACEHOLDER_RE = /^\$\{[^}]*\}$/;
+function readEnvVar(key, opts = {}) {
+  const env = opts.env ?? process.env;
+  const raw = env[key];
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed.length > 0 && trimmed !== "undefined" && trimmed !== "null" && !PLACEHOLDER_RE.test(trimmed)) {
+      return trimmed;
+    }
+  }
+  return opts.default;
+}
+function expandPath(p) {
+  let expanded = p;
+  if (p === "~") {
+    expanded = homedir();
+  } else if (p.startsWith("~/")) {
+    expanded = join(homedir(), p.slice(2));
+  }
+  return isAbsolute(expanded) ? expanded : resolve(expanded);
+}
+async function loadDotenvSafely(opts = {}) {
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      "dotenv"
+    );
+    const result = mod.config({
+      ...opts.path !== void 0 ? { path: opts.path } : {},
+      override: opts.override ?? false,
+      quiet: true
+    });
+    return result.error === void 0;
+  } catch {
+    return false;
+  }
+}
+
+// node_modules/@chrischall/mcp-utils/dist/server/confirm-env.js
+var MODES = /* @__PURE__ */ new Set(["ask-user", "auto", "refuse"]);
+var DEFAULT_TTL_SECONDS2 = 600;
+var warned = /* @__PURE__ */ new Set();
+function readConfirmMode(env = process.env) {
+  const raw = readEnvVar("MCP_CONFIRM_MODE", { env })?.trim().toLowerCase();
+  if (!raw)
+    return "ask-user";
+  if (MODES.has(raw))
+    return raw;
+  if (!warned.has(raw)) {
+    warned.add(raw);
+    process.stderr.write(`MCP_CONFIRM_MODE="${raw}" is not one of ask-user, auto, refuse; treating it as refuse.
+`);
+  }
+  return "refuse";
+}
+function confirmTtlFromEnv(env = process.env) {
+  const raw = readEnvVar("MCP_CONFIRM_TTL_SECONDS", { env })?.trim();
+  return raw && /^[1-9]\d*$/.test(raw) ? Number(raw) : DEFAULT_TTL_SECONDS2;
+}
+var processKey;
+function confirmKeyFromEnv(env = process.env) {
+  const secret = readEnvVar("MCP_CONFIRM_SECRET", { env });
+  if (secret)
+    return createHash3("sha256").update(secret, "utf8").digest();
+  processKey ??= randomBytes2(32);
+  return processKey;
+}
+var CONFIRM_TOKEN_AUTO_INSTRUCTION = "Nothing has been done yet. Review this preview; if it is what was intended, call again with the same arguments plus confirmToken. (This server runs with MCP_CONFIRM_MODE=auto, so the user's approval in chat is not required.)";
+var REFUSE_HINT = "Set MCP_CONFIRM_MODE=ask-user on the server to allow two-step confirmation instead.";
+function confirmationFromEnv(options) {
+  const { tool, account, confirmToken, subject, instruction, spent, env = process.env, ...confirmation } = options;
+  const mode = readConfirmMode(env);
+  if (mode === "refuse") {
+    return {
+      ...confirmation,
+      unsupportedNote: confirmation.unsupportedNote ? `${confirmation.unsupportedNote} ${REFUSE_HINT}` : REFUSE_HINT
+    };
+  }
+  return {
+    ...confirmation,
+    tokenFallback: {
+      key: confirmKeyFromEnv(env),
+      tool,
+      ...account === void 0 ? {} : { account },
+      ...confirmToken === void 0 ? {} : { confirmToken },
+      subject,
+      ttlSeconds: confirmTtlFromEnv(env),
+      instruction: mode === "auto" ? CONFIRM_TOKEN_AUTO_INSTRUCTION : instruction ?? CONFIRM_TOKEN_INSTRUCTION,
+      ...spent === void 0 ? {} : { spent }
+    }
+  };
+}
+
 // node_modules/@chrischall/mcp-utils/dist/server/index.js
 var SERVER_PROTOCOL_VERSIONS = Object.freeze([
   "2026-07-28",
@@ -57940,49 +58415,9 @@ function runMcp(opts) {
   return handle;
 }
 
-// node_modules/@chrischall/mcp-utils/dist/config/index.js
-import { homedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
-var PLACEHOLDER_RE = /^\$\{[^}]*\}$/;
-function readEnvVar(key, opts = {}) {
-  const env = opts.env ?? process.env;
-  const raw = env[key];
-  if (typeof raw === "string") {
-    const trimmed = raw.trim();
-    if (trimmed.length > 0 && trimmed !== "undefined" && trimmed !== "null" && !PLACEHOLDER_RE.test(trimmed)) {
-      return trimmed;
-    }
-  }
-  return opts.default;
-}
-function expandPath(p) {
-  let expanded = p;
-  if (p === "~") {
-    expanded = homedir();
-  } else if (p.startsWith("~/")) {
-    expanded = join(homedir(), p.slice(2));
-  }
-  return isAbsolute(expanded) ? expanded : resolve(expanded);
-}
-async function loadDotenvSafely(opts = {}) {
-  try {
-    const mod = await import(
-      /* @vite-ignore */
-      "dotenv"
-    );
-    const result = mod.config({
-      ...opts.path !== void 0 ? { path: opts.path } : {},
-      override: opts.override ?? false,
-      quiet: true
-    });
-    return result.error === void 0;
-  } catch {
-    return false;
-  }
-}
-
 // node_modules/@chrischall/mcp-utils/dist/fs/index.js
 import { openAsBlob } from "node:fs";
+import { open as open2 } from "node:fs/promises";
 
 // node_modules/@chrischall/mcp-utils/dist/fs/confine.js
 import { existsSync, realpathSync } from "node:fs";
@@ -58019,6 +58454,24 @@ function assertPathWithinRoots(path, roots) {
   throw new Error(`Path is outside the allowed directories: ${path}`);
 }
 
+// node_modules/@chrischall/mcp-utils/dist/fs/output.js
+function sniffMimeBytes(bytes) {
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (buf.length >= 8 && buf.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (buf.length >= 3 && buf[0] === 255 && buf[1] === 216 && buf[2] === 255) {
+    return "image/jpeg";
+  }
+  if (buf.length >= 12 && buf.subarray(0, 4).toString("latin1") === "RIFF" && buf.subarray(8, 12).toString("latin1") === "WEBP") {
+    return "image/webp";
+  }
+  if (buf.length >= 4 && buf.subarray(0, 4).toString("latin1") === "GIF8") {
+    return "image/gif";
+  }
+  return void 0;
+}
+
 // node_modules/@chrischall/mcp-utils/dist/fs/index.js
 async function fileBlob(path, opts = {}) {
   const target = opts.allowedRoots ? assertPathWithinRoots(path, opts.allowedRoots) : path;
@@ -58033,6 +58486,22 @@ async function fileBlob(path, opts = {}) {
   }
   return blob;
 }
+async function readFileHead(path, bytes, opts = {}) {
+  const target = opts.allowedRoots ? assertPathWithinRoots(path, opts.allowedRoots) : path;
+  let fh;
+  try {
+    fh = await open2(target, "r");
+  } catch {
+    throw new Error(`Cannot read file: ${path}`);
+  }
+  try {
+    const buf = Buffer.alloc(bytes);
+    const { bytesRead } = await fh.read(buf, 0, bytes, 0);
+    return buf.subarray(0, bytesRead);
+  } finally {
+    await fh.close();
+  }
+}
 
 // node_modules/@chrischall/mcp-utils/dist/http/index.js
 function buildQueryString(params) {
@@ -58091,7 +58560,7 @@ function toolAnnotations(opts = {}) {
 }
 
 // src/version.ts
-var VERSION = "2.1.2";
+var VERSION = "2.2.0";
 
 // src/client.ts
 import { dirname as dirname2, join as join2 } from "path";
@@ -58598,7 +59067,9 @@ var SCHEMA_STATEMENTS = [
      beers_offset       INTEGER,
      beers_total        INTEGER,
      beers_complete     INTEGER NOT NULL DEFAULT 0,
-     served_backfill_last INTEGER NOT NULL DEFAULT 0
+     served_backfill_last INTEGER NOT NULL DEFAULT 0,
+     beers_accepted_gap INTEGER NOT NULL DEFAULT 0,
+     beers_rescan_target INTEGER
    )`
 ];
 var MIGRATIONS = [
@@ -58607,7 +59078,9 @@ var MIGRATIONS = [
   "ALTER TABLE sync_state ADD COLUMN beers_offset INTEGER",
   "ALTER TABLE sync_state ADD COLUMN beers_total INTEGER",
   "ALTER TABLE sync_state ADD COLUMN beers_complete INTEGER NOT NULL DEFAULT 0",
-  "ALTER TABLE sync_state ADD COLUMN served_backfill_last INTEGER NOT NULL DEFAULT 0"
+  "ALTER TABLE sync_state ADD COLUMN served_backfill_last INTEGER NOT NULL DEFAULT 0",
+  "ALTER TABLE sync_state ADD COLUMN beers_accepted_gap INTEGER NOT NULL DEFAULT 0",
+  "ALTER TABLE sync_state ADD COLUMN beers_rescan_target INTEGER"
 ];
 var CheckinStoreCore = class {
   constructor(db) {
@@ -58729,7 +59202,9 @@ var CheckinStoreCore = class {
       beers_offset: num(row.beers_offset),
       beers_total: num(row.beers_total),
       beers_complete: Number(row.beers_complete) === 1,
-      served_backfill_last: Number(row.served_backfill_last) === 1
+      served_backfill_last: Number(row.served_backfill_last) === 1,
+      beers_accepted_gap: num(row.beers_accepted_gap) ?? 0,
+      beers_rescan_target: num(row.beers_rescan_target)
     };
   }
   /**
@@ -58753,19 +59228,22 @@ var CheckinStoreCore = class {
       beers_offset: pick2("beers_offset", null),
       beers_total: pick2("beers_total", null),
       beers_complete: pick2("beers_complete", false),
-      served_backfill_last: pick2("served_backfill_last", false)
+      served_backfill_last: pick2("served_backfill_last", false),
+      beers_accepted_gap: pick2("beers_accepted_gap", 0),
+      beers_rescan_target: pick2("beers_rescan_target", 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, checkins_truncated, beers_offset, beers_total, beers_complete, served_backfill_last)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         (username, oldest_max_id, newest_checkin_id, catchup_max_id, last_synced_at, backfill_complete, total_checkins, checkins_truncated, beers_offset, beers_total, beers_complete, served_backfill_last, beers_accepted_gap, beers_rescan_target)
+       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,
          checkins_truncated=excluded.checkins_truncated, beers_offset=excluded.beers_offset,
          beers_total=excluded.beers_total, beers_complete=excluded.beers_complete,
-         served_backfill_last=excluded.served_backfill_last`,
+         served_backfill_last=excluded.served_backfill_last, beers_accepted_gap=excluded.beers_accepted_gap,
+         beers_rescan_target=excluded.beers_rescan_target`,
       [
         key,
         next.oldest_max_id,
@@ -58778,7 +59256,9 @@ var CheckinStoreCore = class {
         next.beers_offset,
         next.beers_total,
         next.beers_complete ? 1 : 0,
-        next.served_backfill_last ? 1 : 0
+        next.served_backfill_last ? 1 : 0,
+        next.beers_accepted_gap,
+        next.beers_rescan_target
       ]
     );
   }
@@ -59621,6 +60101,22 @@ function registerDiscoverTools(server, client2) {
   );
 }
 
+// src/tools/confirm.ts
+var CONFIRM_FLOW = "Asks the user to confirm first: a confirmation prompt where the client supports one; otherwise the first call returns a preview and a confirmToken, and only a repeat call with that token proceeds (see MCP_CONFIRM_MODE).";
+function confirmWrite(ctx, c) {
+  return requireConfirmationWithFallback(
+    ctx,
+    confirmationFromEnv({
+      action: c.action,
+      message: c.message,
+      details: c.preview,
+      tool: c.tool,
+      confirmToken: c.confirmToken,
+      subject: () => ({ target: String(c.target), payload: c.payload, preview: c.preview })
+    })
+  );
+}
+
 // src/tools/friends.ts
 var TargetUidSchema = external_exports.number().int().positive().describe("The target user id (uid) \u2014 from a user profile (response.user.uid) or a friends-list item");
 var ACTIONS = [
@@ -59659,7 +60155,7 @@ function registerFriendActionTools(server, client2) {
       action.tool,
       {
         title: action.title,
-        description: `${action.detail} Acts on YOUR account and affects a real relationship with another person. Without confirm: true it returns a dry-run preview and makes NO network call; with confirm: true it performs the action. Note: this endpoint path is taken from the Untappd app but is not otherwise independently verified.`,
+        description: `${action.detail} Acts on YOUR account and affects a real relationship with another person. ${CONFIRM_FLOW} Note: this endpoint path is taken from the Untappd app but is not otherwise independently verified.`,
         // All four reach ANOTHER PERSON — the description says so itself: "affects
         // a real relationship with another person". A friend request cannot be
         // un-sent, and a rejection cannot be un-rejected, so none of them has an
@@ -59667,18 +60163,21 @@ function registerFriendActionTools(server, client2) {
         annotations: toolAnnotations({ title: action.title, readOnly: false, idempotent: true, openWorld: true, destructive: true }),
         inputSchema: external_exports.object({
           target_uid: TargetUidSchema,
-          confirm: schemaConfirm
+          confirmToken: confirmTokenParam
         })
       },
-      async ({ target_uid, confirm }) => {
-        if (confirm !== true) {
-          return minifiedResult({
-            dryRun: true,
-            action: action.path,
-            target_uid,
-            note: `Dry run \u2014 re-run with confirm: true to ${action.verb} user ${target_uid}.`
-          });
-        }
+      async ({ target_uid, confirmToken }, ctx) => {
+        const request = { method: "POST", path: `/friend/${action.path}/${target_uid}` };
+        const gate = await confirmWrite(ctx, {
+          tool: action.tool,
+          action: `untappd.friend_${action.path}`,
+          message: `Review and confirm: ${action.verb} Untappd user ${target_uid}.`,
+          confirmToken,
+          target: target_uid,
+          payload: request,
+          preview: { action: action.path, target_uid, ...request, note: `Will ${action.verb} user ${target_uid}.` }
+        });
+        if (gate) return gate;
         const data = await client2.write("POST", `/friend/${action.path}/${target_uid}`);
         return minifiedResult({ done: true, action: action.path, target_uid, result: data?.result });
       }
@@ -59693,22 +60192,25 @@ function registerWishlistTools(server, client2) {
     "untappd_wishlist_add",
     {
       title: "Add a beer to your wishlist",
-      description: "Add a beer to YOUR Untappd wishlist by its bid. Without confirm: true it returns a dry-run preview and makes NO network call; with confirm: true it adds. Writes to your account.",
+      description: `Add a beer to YOUR Untappd wishlist by its bid. Writes to your account. ${CONFIRM_FLOW}`,
       annotations: toolAnnotations({ title: "Add a beer to your wishlist", readOnly: false, idempotent: true, openWorld: true, destructive: false }),
       inputSchema: external_exports.object({
         bid: BidSchema2,
-        confirm: schemaConfirm
+        confirmToken: confirmTokenParam
       })
     },
-    async ({ bid, confirm }) => {
-      if (confirm !== true) {
-        return minifiedResult({
-          dryRun: true,
-          action: "wishlist_add",
-          bid,
-          note: "Dry run \u2014 re-run with confirm: true to add this beer to your wishlist."
-        });
-      }
+    async ({ bid, confirmToken }, ctx) => {
+      const request = { method: "GET", path: "/user/wishlist/add", query: { bid } };
+      const gate = await confirmWrite(ctx, {
+        tool: "untappd_wishlist_add",
+        action: "untappd.wishlist_add",
+        message: "Review and confirm adding this beer to your Untappd wishlist:",
+        confirmToken,
+        target: bid,
+        payload: request,
+        preview: { action: "wishlist_add", bid, ...request, note: "Adds this beer to your Untappd wishlist." }
+      });
+      if (gate) return gate;
       const data = await client2.write("GET", "/user/wishlist/add", { query: { bid } });
       return minifiedResult({ added: true, bid, result: data?.result });
     }
@@ -59717,22 +60219,25 @@ function registerWishlistTools(server, client2) {
     "untappd_wishlist_remove",
     {
       title: "Remove a beer from your wishlist",
-      description: "Remove a beer from YOUR Untappd wishlist by its bid. Without confirm: true it returns a dry-run preview and makes NO network call; with confirm: true it removes. Writes to your account.",
+      description: `Remove a beer from YOUR Untappd wishlist by its bid. Writes to your account. ${CONFIRM_FLOW}`,
       annotations: toolAnnotations({ title: "Remove a beer from your wishlist", readOnly: false, idempotent: true, openWorld: true, destructive: false }),
       inputSchema: external_exports.object({
         bid: BidSchema2,
-        confirm: schemaConfirm
+        confirmToken: confirmTokenParam
       })
     },
-    async ({ bid, confirm }) => {
-      if (confirm !== true) {
-        return minifiedResult({
-          dryRun: true,
-          action: "wishlist_remove",
-          bid,
-          note: "Dry run \u2014 re-run with confirm: true to remove this beer from your wishlist."
-        });
-      }
+    async ({ bid, confirmToken }, ctx) => {
+      const request = { method: "GET", path: "/user/wishlist/delete", query: { bid } };
+      const gate = await confirmWrite(ctx, {
+        tool: "untappd_wishlist_remove",
+        action: "untappd.wishlist_remove",
+        message: "Review and confirm removing this beer from your Untappd wishlist:",
+        confirmToken,
+        target: bid,
+        payload: request,
+        preview: { action: "wishlist_remove", bid, ...request, note: "Removes this beer from your Untappd wishlist." }
+      });
+      if (gate) return gate;
       const data = await client2.write("GET", "/user/wishlist/delete", { query: { bid } });
       return minifiedResult({ removed: true, bid, result: data?.result });
     }
@@ -59740,42 +60245,149 @@ function registerWishlistTools(server, client2) {
 }
 
 // src/tools/checkin.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { extname } from "node:path";
+import { createReadStream, realpathSync as realpathSync2, statSync } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { pipeline } from "node:stream/promises";
+import { delimiter, extname } from "node:path";
 var CheckinIdSchema = external_exports.number().int().positive().describe("Untappd check-in id");
 var PHOTO_CONTENT_TYPES = { jpg: "image/jpeg", png: "image/png" };
 function photoExt(path) {
   const ext = extname(path).slice(1).toLowerCase();
   return ext === "jpeg" ? "jpg" : ext;
 }
+var MAX_PHOTO_BYTES = 15 * 1024 * 1024;
+function photoRoots() {
+  const raw = readEnvVar("UNTAPPD_PHOTO_DIR");
+  const roots = raw?.split(delimiter).filter(Boolean);
+  return roots && roots.length > 0 ? roots : void 0;
+}
+async function checkPhoto(photoPath) {
+  const ext = photoExt(photoPath);
+  if (!(ext in PHOTO_CONTENT_TYPES)) {
+    throw createHelpfulError(`Unsupported photo type "${ext || "(none)"}".`, {
+      hint: "Attach a .jpg, .jpeg, or .png file."
+    });
+  }
+  const roots = photoRoots();
+  if (roots) {
+    try {
+      assertPathWithinRoots(photoPath, roots);
+    } catch {
+      throw createHelpfulError("The photo is outside the allowed photo directory.", {
+        hint: "UNTAPPD_PHOTO_DIR restricts which files can be attached to a check-in."
+      });
+    }
+  }
+  let real;
+  let size;
+  try {
+    real = realpathSync2(photoPath);
+    const st = statSync(real);
+    if (!st.isFile()) throw new Error("not a file");
+    size = st.size;
+  } catch {
+    throw new McpToolError("Photo file not found or not readable.");
+  }
+  if (size > MAX_PHOTO_BYTES) {
+    throw createHelpfulError(`Photo is too large (${size} bytes; the limit is ${MAX_PHOTO_BYTES}).`, {
+      hint: "Attach a normal-sized JPEG or PNG photo."
+    });
+  }
+  const sniffed = sniffMimeBytes(await readFileHead(real, 16));
+  if (sniffed !== PHOTO_CONTENT_TYPES[ext]) {
+    throw createHelpfulError(
+      sniffed === "image/jpeg" || sniffed === "image/png" ? `Photo content (${sniffed}) does not match its .${ext} extension.` : "The file is not a JPEG or PNG image.",
+      { hint: "Attach a real .jpg/.jpeg or .png photo." }
+    );
+  }
+  return { path: real, size_bytes: size, ext, content_type: sniffed };
+}
+async function photoSha256(path) {
+  const hash2 = createHash4("sha256");
+  await pipeline(createReadStream(path), hash2);
+  return hash2.digest("hex");
+}
 var RatingSchema = external_exports.number().min(0).max(5).refine((r) => Math.round(r * 4) === r * 4, { message: "rating must be a multiple of 0.25" });
-function localTimezone() {
-  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-  const gmt_offset = -(/* @__PURE__ */ new Date()).getTimezoneOffset() / 60;
-  return { timezone, gmt_offset };
+function gmtOffsetHours(timeZone, at) {
+  const name = new Intl.DateTimeFormat("en-US", { timeZone, timeZoneName: "longOffset" }).formatToParts(at).find((p) => p.type === "timeZoneName")?.value;
+  const m = /GMT([+-])(\d{1,2})(?::(\d{2}))?/.exec(name ?? "");
+  if (!m) return 0;
+  const hours = Number(m[2]) + Number(m[3] ?? 0) / 60;
+  return m[1] === "-" ? -hours : hours;
+}
+function checkinTimezone(requested) {
+  const timezone = requested ?? readEnvVar("UNTAPPD_TIMEZONE") ?? (Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC");
+  try {
+    return { timezone, gmt_offset: gmtOffsetHours(timezone, /* @__PURE__ */ new Date()) };
+  } catch {
+    throw createHelpfulError(`Unknown timezone "${timezone}".`, {
+      hint: 'Pass an IANA timezone name such as "America/New_York" or "Europe/London".'
+    });
+  }
+}
+var RECOVERY_WINDOW_MS = 3e4;
+async function nonIdempotentWrite(run, unknownOutcome) {
+  try {
+    return await run();
+  } catch (e) {
+    if (e instanceof UnreachableError) throw new McpToolError(unknownOutcome);
+    throw e;
+  }
+}
+async function findRecentCheckin(client2, bid, sentAt) {
+  const self = client2.loginName;
+  if (!self) return null;
+  try {
+    const data = await client2.get(
+      `/user/checkins/${encodeURIComponent(self)}`,
+      { limit: 5 }
+    );
+    const matches = [];
+    for (const it of data?.checkins?.items ?? []) {
+      const c = it;
+      const at = Date.parse(c.created_at ?? "");
+      if (c.beer?.bid === bid && typeof c.checkin_id === "number" && at >= sentAt - RECOVERY_WINDOW_MS) {
+        matches.push(c.checkin_id);
+      }
+    }
+    if (matches.length === 1) return matches[0];
+  } catch {
+  }
+  return null;
 }
 function registerCheckinTools(server, client2) {
   server.registerTool(
     "untappd_toast",
     {
       title: "Toast an Untappd check-in",
-      description: "Toast (like) a check-in on YOUR account. This endpoint is a TOGGLE: calling it on a check-in you have already toasted removes the toast. Without confirm: true it returns a dry-run preview and makes NO network call; with confirm: true it posts. Writes to your Untappd account and is visible to others.",
+      description: `Toast (like) a check-in on YOUR account. This endpoint is a TOGGLE: calling it on a check-in you have already toasted removes the toast. Writes to your Untappd account and is visible to others. ${CONFIRM_FLOW}`,
       annotations: toolAnnotations({ title: "Toast an Untappd check-in", readOnly: false, idempotent: false, openWorld: true, destructive: false }),
       inputSchema: external_exports.object({
         checkin_id: CheckinIdSchema,
-        confirm: schemaConfirm
+        confirmToken: confirmTokenParam
       })
     },
-    async ({ checkin_id, confirm }) => {
-      if (confirm !== true) {
-        return minifiedResult({
-          dryRun: true,
+    async ({ checkin_id, confirmToken }, ctx) => {
+      const request = { method: "POST", path: `/checkin/toast/${checkin_id}` };
+      const gate = await confirmWrite(ctx, {
+        tool: "untappd_toast",
+        action: "untappd.toast",
+        message: "Review and confirm toggling your toast on this Untappd check-in:",
+        confirmToken,
+        target: checkin_id,
+        payload: request,
+        preview: {
           action: "toast",
           checkin_id,
-          note: "Dry run \u2014 re-run with confirm: true to toggle your toast on this check-in."
-        });
-      }
-      const data = await client2.write("POST", `/checkin/toast/${checkin_id}`);
+          ...request,
+          note: "Toggles your toast on this check-in (removes it if you have already toasted)."
+        }
+      });
+      if (gate) return gate;
+      const data = await nonIdempotentWrite(
+        () => client2.write("POST", `/checkin/toast/${checkin_id}`),
+        `Untappd did not answer the toast request for check-in ${checkin_id} in time, so it may or may not have been applied. Toast is a TOGGLE: retrying could remove a toast that did land. Check with untappd_checkin_info (checkin_id ${checkin_id}) before retrying.`
+      );
       return minifiedResult({ toggled: true, checkin_id, result: data?.result, like_type: data?.like_type });
     }
   );
@@ -59783,25 +60395,36 @@ function registerCheckinTools(server, client2) {
     "untappd_add_comment",
     {
       title: "Comment on an Untappd check-in",
-      description: "Post a comment on a check-in from YOUR account. Without confirm: true it returns a dry-run preview and makes NO network call; with confirm: true it posts. Writes to your Untappd account and is visible to others.",
+      description: "Post a comment on a check-in from YOUR account. Writes to your Untappd account and is visible to others. " + CONFIRM_FLOW,
       annotations: toolAnnotations({ title: "Comment on an Untappd check-in", readOnly: false, idempotent: false, openWorld: true, destructive: false }),
       inputSchema: external_exports.object({
         checkin_id: CheckinIdSchema,
         comment: external_exports.string().min(1).max(2e3).describe("Comment text to post"),
-        confirm: schemaConfirm
+        confirmToken: confirmTokenParam
       })
     },
-    async ({ checkin_id, comment, confirm }) => {
-      if (confirm !== true) {
-        return minifiedResult({
-          dryRun: true,
+    async ({ checkin_id, comment, confirmToken }, ctx) => {
+      const request = { method: "POST", path: `/checkin/addcomment/${checkin_id}`, form: { comment } };
+      const gate = await confirmWrite(ctx, {
+        tool: "untappd_add_comment",
+        action: "untappd.add_comment",
+        message: "Review and confirm posting this comment from your Untappd account:",
+        confirmToken,
+        target: checkin_id,
+        payload: request,
+        preview: {
           action: "add_comment",
           checkin_id,
           comment,
-          note: "Dry run \u2014 re-run with confirm: true to post this comment to your Untappd account."
-        });
-      }
-      const data = await client2.write("POST", `/checkin/addcomment/${checkin_id}`, { form: { comment } });
+          ...request,
+          note: "Posts this comment to the check-in from your Untappd account, visible to others."
+        }
+      });
+      if (gate) return gate;
+      const data = await nonIdempotentWrite(
+        () => client2.write("POST", `/checkin/addcomment/${checkin_id}`, { form: { comment } }),
+        `Untappd did not answer in time, so the comment may have been posted already. Check the comments with untappd_checkin_info (checkin_id ${checkin_id}) before retrying, or it may be posted twice.`
+      );
       return minifiedResult({ posted: true, checkin_id, response: data });
     }
   );
@@ -59809,22 +60432,25 @@ function registerCheckinTools(server, client2) {
     "untappd_delete_comment",
     {
       title: "Delete a comment from an Untappd check-in",
-      description: "Delete one of YOUR comments by its comment id (the id from a check-in's comments list). Without confirm: true it returns a dry-run preview and makes NO network call; with confirm: true it deletes.",
+      description: `Delete one of YOUR comments by its comment id (the id from a check-in's comments list). ${CONFIRM_FLOW}`,
       annotations: toolAnnotations({ title: "Delete a comment from an Untappd check-in", readOnly: false, idempotent: true, openWorld: true, destructive: true }),
       inputSchema: external_exports.object({
         comment_id: external_exports.number().int().positive().describe("Untappd comment id (from a check-in's comments.items)"),
-        confirm: schemaConfirm
+        confirmToken: confirmTokenParam
       })
     },
-    async ({ comment_id, confirm }) => {
-      if (confirm !== true) {
-        return minifiedResult({
-          dryRun: true,
-          action: "delete_comment",
-          comment_id,
-          note: "Dry run \u2014 re-run with confirm: true to delete this comment from your Untappd account."
-        });
-      }
+    async ({ comment_id, confirmToken }, ctx) => {
+      const request = { method: "POST", path: `/checkin/deletecomment/${comment_id}` };
+      const gate = await confirmWrite(ctx, {
+        tool: "untappd_delete_comment",
+        action: "untappd.delete_comment",
+        message: "Review and confirm deleting this comment from your Untappd account:",
+        confirmToken,
+        target: comment_id,
+        payload: request,
+        preview: { action: "delete_comment", comment_id, ...request, note: "Deletes this comment from your Untappd account." }
+      });
+      if (gate) return gate;
       const data = await client2.write("POST", `/checkin/deletecomment/${comment_id}`);
       return minifiedResult({ deleted: true, comment_id, result: data?.result });
     }
@@ -59833,22 +60459,30 @@ function registerCheckinTools(server, client2) {
     "untappd_delete_checkin",
     {
       title: "Delete an Untappd check-in",
-      description: "Permanently delete one of YOUR check-ins by its id. This is destructive and cannot be undone. Without confirm: true it returns a dry-run preview and makes NO network call; with confirm: true it deletes.",
+      description: `Permanently delete one of YOUR check-ins by its id. This is destructive and cannot be undone. ${CONFIRM_FLOW}`,
       annotations: toolAnnotations({ title: "Delete an Untappd check-in", readOnly: false, idempotent: true, openWorld: true, destructive: true }),
       inputSchema: external_exports.object({
         checkin_id: CheckinIdSchema,
-        confirm: schemaConfirm
+        confirmToken: confirmTokenParam
       })
     },
-    async ({ checkin_id, confirm }) => {
-      if (confirm !== true) {
-        return minifiedResult({
-          dryRun: true,
+    async ({ checkin_id, confirmToken }, ctx) => {
+      const request = { method: "POST", path: `/checkin/delete/${checkin_id}` };
+      const gate = await confirmWrite(ctx, {
+        tool: "untappd_delete_checkin",
+        action: "untappd.delete_checkin",
+        message: "Review and confirm PERMANENTLY deleting this Untappd check-in:",
+        confirmToken,
+        target: checkin_id,
+        payload: request,
+        preview: {
           action: "delete_checkin",
           checkin_id,
-          note: "Dry run \u2014 re-run with confirm: true to PERMANENTLY delete this check-in. This cannot be undone."
-        });
-      }
+          ...request,
+          note: "PERMANENTLY deletes this check-in. This cannot be undone."
+        }
+      });
+      if (gate) return gate;
       const data = await client2.write("POST", `/checkin/delete/${checkin_id}`);
       return minifiedResult({ deleted: true, checkin_id, result: data?.result });
     }
@@ -59857,31 +60491,29 @@ function registerCheckinTools(server, client2) {
     "untappd_checkin",
     {
       title: "Check in a beer on Untappd",
-      description: "Post a NEW beer check-in to YOUR Untappd account \u2014 this publishes to your public feed. Provide the beer id (bid) from untappd_search_beer; optionally a rating (0\u20135 in 0.25 steps), a shout (comment), a venue via foursquare_id, and a local photo via photo_path (JPEG/PNG). Without confirm: true it returns a dry-run preview of the exact fields and makes NO network call; with confirm: true it posts.",
+      description: `Post a NEW beer check-in to YOUR Untappd account \u2014 this publishes to your public feed. Provide the beer id (bid) from untappd_search_beer; optionally a rating (0\u20135 in 0.25 steps), a shout (comment), a venue via foursquare_id, and a local photo via photo_path (JPEG/PNG). The preview shows the exact fields and photo that will be posted. ${CONFIRM_FLOW}`,
       annotations: toolAnnotations({ title: "Check in a beer on Untappd", readOnly: false, idempotent: false, openWorld: true, destructive: false }),
       inputSchema: external_exports.object({
         bid: external_exports.number().int().positive().describe("Untappd beer id to check in (from untappd_search_beer)"),
         rating: RatingSchema.optional().describe("Rating 0\u20135 in 0.25 increments (omit for no rating)"),
         shout: external_exports.string().max(2e3).optional().describe("Optional shout / comment text for the check-in"),
         foursquare_id: external_exports.string().optional().describe("Optional Foursquare venue id to tag the check-in location"),
-        photo_path: external_exports.string().optional().describe("Optional path to a local JPEG/PNG photo to attach to the check-in"),
+        photo_path: external_exports.string().optional().describe(
+          "Optional path to a local JPEG/PNG photo (max 15 MB) to attach \u2014 it is published publicly. Only use a file the user explicitly chose; the preview shows the resolved path and size for them to confirm."
+        ),
         geolat: external_exports.number().optional().describe("Optional latitude of the check-in"),
         geolng: external_exports.number().optional().describe("Optional longitude of the check-in"),
         container_id: external_exports.number().int().optional().describe("Optional serving container id (e.g. 1 = draft, 2 = bottle, 3 = can)"),
-        confirm: schemaConfirm
+        timezone: external_exports.string().min(1).optional().describe(
+          "The drinker's IANA timezone (e.g. America/New_York), which sets the check-in's local time. Defaults to UNTAPPD_TIMEZONE, else the server's own zone \u2014 which on a hosted connector is usually UTC, so pass it when you know where the user is."
+        ),
+        confirmToken: confirmTokenParam
       })
     },
-    async ({ bid, rating, shout, foursquare_id, photo_path, geolat, geolng, container_id, confirm }) => {
-      const { timezone, gmt_offset } = localTimezone();
-      let ext;
-      if (photo_path !== void 0) {
-        ext = photoExt(photo_path);
-        if (!(ext in PHOTO_CONTENT_TYPES)) {
-          throw createHelpfulError(`Unsupported photo type "${ext || "(none)"}".`, {
-            hint: "Attach a .jpg, .jpeg, or .png file."
-          });
-        }
-      }
+    async ({ bid, rating, shout, foursquare_id, photo_path, geolat, geolng, container_id, timezone: requestedTz, confirmToken }, ctx) => {
+      const { timezone, gmt_offset } = checkinTimezone(requestedTz);
+      const photo = photo_path !== void 0 ? await checkPhoto(photo_path) : void 0;
+      const photo_sha256 = photo ? await photoSha256(photo.path) : void 0;
       const form = {
         bid,
         rating: rating !== void 0 ? rating.toFixed(2) : void 0,
@@ -59892,31 +60524,57 @@ function registerCheckinTools(server, client2) {
         container_id,
         timezone,
         gmt_offset,
-        is_photo: photo_path !== void 0 ? "true" : "false",
-        photo_file_ext: photo_path !== void 0 ? ext : void 0,
+        is_photo: photo ? "true" : "false",
+        photo_file_ext: photo?.ext,
         platform: "ios"
       };
-      if (confirm !== true) {
-        return minifiedResult({
-          dryRun: true,
+      const request = { method: "POST", path: "/checkin/add", form };
+      const gate = await confirmWrite(ctx, {
+        tool: "untappd_checkin",
+        action: "untappd.checkin",
+        message: "Review and confirm posting this check-in to your public Untappd feed:",
+        confirmToken,
+        target: bid,
+        payload: { ...request, photo, photo_sha256 },
+        preview: {
           action: "checkin",
-          form,
-          photo: photo_path !== void 0 ? { path: photo_path, note: "will be uploaded after the check-in is created" } : void 0,
-          note: "Dry run \u2014 re-run with confirm: true to POST this check-in to your public Untappd feed."
-        });
-      }
+          ...request,
+          photo: photo ? { ...photo, note: "this exact file will be uploaded PUBLICLY after the check-in is created" } : void 0,
+          note: "POSTs this check-in to your public Untappd feed."
+        }
+      });
+      if (gate) return gate;
       let blob;
-      if (photo_path !== void 0) {
-        if (!existsSync2(photo_path)) throw new McpToolError(`Photo file not found: ${photo_path}`);
-        blob = await fileBlob(photo_path);
+      if (photo) {
+        blob = await fileBlob(photo.path, { maxBytes: MAX_PHOTO_BYTES, label: "Photo", allowedRoots: photoRoots() });
+      }
+      const sentAt = Date.now();
+      let data;
+      try {
+        data = await client2.write("POST", "/checkin/add", { form });
+      } catch (e) {
+        if (!(e instanceof UnreachableError)) throw e;
+        const found = await findRecentCheckin(client2, bid, sentAt);
+        if (found === null) {
+          throw new McpToolError(
+            "Untappd did not answer the check-in request in time, so the check-in may have been created anyway (it could not be confirmed either way). Look at your latest check-ins with untappd_user_checkins before retrying \u2014 retrying a check-in that did land posts it twice."
+          );
+        }
+        return minifiedResult({
+          checked_in: true,
+          checkin_id: found,
+          recovered: true,
+          photo_attached: false,
+          ...photo ? { photo_error: `Check-in ${found} was created, but its photo upload URL was lost with the timed-out response, so no photo was attached.` } : {},
+          note: "Untappd did not answer in time, but the check-in was found on your account \u2014 it was created. Do not retry."
+        });
       }
-      const data = await client2.write("POST", "/checkin/add", { form });
       let photo_attached = false;
       let photo_error;
-      if (photo_path !== void 0) {
+      if (photo) {
         if (data?.photo_upload?.url && data.checkin_id) {
           try {
-            await client2.putBinary(data.photo_upload.url, blob, PHOTO_CONTENT_TYPES[ext]);
+            await client2.putBinary(data.photo_upload.url, blob, photo.content_type);
             await client2.write("POST", "/photo/uploadComplete", {
               form: { checkin_id: data.checkin_id, destination_url: data.photo_upload.destination_url }
             });
@@ -60226,6 +60884,7 @@ async function syncCheckins(client2, cache, rawUsername, options = {}) {
 
 // src/cache/sync-beers.ts
 var PAGE_LIMIT2 = 50;
+var RESUME_OVERLAP = 10;
 async function fetchBeersPage(client2, encodedUser, offset) {
   const data = await client2.get(
     `/user/beers/${encodedUser}`,
@@ -60248,8 +60907,11 @@ async function syncUserBeers(client2, cache, rawUsername, maxPages = 10) {
   const now = () => (/* @__PURE__ */ new Date()).toISOString();
   const prior = await cache.getState(rawUsername);
   const incremental = (prior?.beers_complete ?? false) && !!prior?.last_synced_at;
-  let offset = incremental ? 0 : prior?.beers_offset ?? 0;
+  let refreshing = incremental;
+  let offset = incremental ? 0 : Math.max(0, (prior?.beers_offset ?? 0) - RESUME_OVERLAP);
   let total = prior?.beers_total ?? null;
+  let acceptedGap = prior?.beers_accepted_gap ?? 0;
+  let rescanTarget = incremental ? null : prior?.beers_rescan_target ?? null;
   let complete = false;
   let pages = 0;
   let added = 0;
@@ -60263,31 +60925,41 @@ async function syncUserBeers(client2, cache, rawUsername, maxPages = 10) {
       });
     }
   };
+  const gapNow = async () => total === null ? 0 : total - await cache.distinctBeersCount(rawUsername);
   for (; pages < maxPages && !complete; ) {
     const page = pages === 0 ? await firstFetch(offset) : await fetchBeersPage(client2, encodedUser, offset);
     pages++;
     if (page.total !== null) total = page.total;
-    if (page.items.length === 0) {
-      complete = true;
-      await cache.setState(rawUsername, {
-        beers_offset: incremental ? total ?? offset : offset,
-        beers_total: total,
-        beers_complete: true,
-        last_synced_at: now()
-      });
-      break;
+    let atEnd = page.items.length === 0;
+    if (!atEnd) {
+      const rows = rowsOf2(rawUsername, page.items);
+      const netNew = await cache.upsertDistinctBeers(rawUsername, rows);
+      added += netNew;
+      offset += page.items.length;
+      if (total !== null && offset >= total) atEnd = true;
+      else if (page.items.length < PAGE_LIMIT2) atEnd = true;
+      else if (refreshing && netNew === 0) atEnd = true;
+      else if (rescanTarget !== null && await gapNow() <= rescanTarget) atEnd = true;
+    }
+    if (atEnd) {
+      const gap = await gapNow();
+      if (gap > acceptedGap && rescanTarget === null) {
+        rescanTarget = acceptedGap;
+        acceptedGap = gap;
+        refreshing = false;
+        offset = 0;
+      } else {
+        complete = true;
+        rescanTarget = null;
+        acceptedGap = Math.max(0, gap);
+      }
     }
-    const rows = rowsOf2(rawUsername, page.items);
-    const netNew = await cache.upsertDistinctBeers(rawUsername, rows);
-    added += netNew;
-    offset += page.items.length;
-    if (total !== null && offset >= total) complete = true;
-    else if (page.items.length < PAGE_LIMIT2) complete = true;
-    else if (incremental && netNew === 0) complete = true;
     await cache.setState(rawUsername, {
-      beers_offset: incremental ? total ?? offset : offset,
+      beers_offset: refreshing ? total ?? offset : offset,
       beers_total: total,
       beers_complete: complete,
+      beers_accepted_gap: acceptedGap,
+      beers_rescan_target: rescanTarget,
       last_synced_at: now()
     });
   }