@funnycode/myclaude 0.1.95 → 0.1.97

package/dist/myclaude.mjs

@@ -4,8 +4,8 @@
 // MACRO - build-time constants (injected by build.ts)
 // MACRO injected by build script
 globalThis.MACRO = {
-  VERSION: "0.1.95",
-  BUILD_TIME: "2026-07-18T09:09:23.186Z",
+  VERSION: "0.1.97",
+  BUILD_TIME: "2026-07-18T15:18:43.301Z",
   PACKAGE_URL: "@funnycode/myclaude",
   NATIVE_PACKAGE_URL: "@funnycode/myclaude",
   VERSION_CHANGELOG: '',
@@ -117484,7 +117484,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@funnycode/myclaude",
-    version: "0.1.95",
+    version: "0.1.97",
     private: false,
     description: "An open-source AI coding assistant in your terminal - powered by Claude",
     license: "MIT",
@@ -210146,214 +210146,6 @@ var init_postSamplingHooks = __esm(() => {
   postSamplingHooks = [];
 });
 
-// node_modules/async-mutex/index.mjs
-class Semaphore {
-  constructor(_value, _cancelError = E_CANCELED) {
-    this._value = _value;
-    this._cancelError = _cancelError;
-    this._queue = [];
-    this._weightedWaiters = [];
-  }
-  acquire(weight = 1, priority = 0) {
-    if (weight <= 0)
-      throw new Error(`invalid weight ${weight}: must be positive`);
-    return new Promise((resolve25, reject2) => {
-      const task = { resolve: resolve25, reject: reject2, weight, priority };
-      const i3 = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
-      if (i3 === -1 && weight <= this._value) {
-        this._dispatchItem(task);
-      } else {
-        this._queue.splice(i3 + 1, 0, task);
-      }
-    });
-  }
-  runExclusive(callback_1) {
-    return __awaiter$2(this, arguments, undefined, function* (callback, weight = 1, priority = 0) {
-      const [value, release] = yield this.acquire(weight, priority);
-      try {
-        return yield callback(value);
-      } finally {
-        release();
-      }
-    });
-  }
-  waitForUnlock(weight = 1, priority = 0) {
-    if (weight <= 0)
-      throw new Error(`invalid weight ${weight}: must be positive`);
-    if (this._couldLockImmediately(weight, priority)) {
-      return Promise.resolve();
-    } else {
-      return new Promise((resolve25) => {
-        if (!this._weightedWaiters[weight - 1])
-          this._weightedWaiters[weight - 1] = [];
-        insertSorted(this._weightedWaiters[weight - 1], { resolve: resolve25, priority });
-      });
-    }
-  }
-  isLocked() {
-    return this._value <= 0;
-  }
-  getValue() {
-    return this._value;
-  }
-  setValue(value) {
-    this._value = value;
-    this._dispatchQueue();
-  }
-  release(weight = 1) {
-    if (weight <= 0)
-      throw new Error(`invalid weight ${weight}: must be positive`);
-    this._value += weight;
-    this._dispatchQueue();
-  }
-  cancel() {
-    this._queue.forEach((entry) => entry.reject(this._cancelError));
-    this._queue = [];
-  }
-  _dispatchQueue() {
-    this._drainUnlockWaiters();
-    while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
-      this._dispatchItem(this._queue.shift());
-      this._drainUnlockWaiters();
-    }
-  }
-  _dispatchItem(item) {
-    const previousValue = this._value;
-    this._value -= item.weight;
-    item.resolve([previousValue, this._newReleaser(item.weight)]);
-  }
-  _newReleaser(weight) {
-    let called = false;
-    return () => {
-      if (called)
-        return;
-      called = true;
-      this.release(weight);
-    };
-  }
-  _drainUnlockWaiters() {
-    if (this._queue.length === 0) {
-      for (let weight = this._value;weight > 0; weight--) {
-        const waiters = this._weightedWaiters[weight - 1];
-        if (!waiters)
-          continue;
-        waiters.forEach((waiter) => waiter.resolve());
-        this._weightedWaiters[weight - 1] = [];
-      }
-    } else {
-      const queuedPriority = this._queue[0].priority;
-      for (let weight = this._value;weight > 0; weight--) {
-        const waiters = this._weightedWaiters[weight - 1];
-        if (!waiters)
-          continue;
-        const i3 = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
-        (i3 === -1 ? waiters : waiters.splice(0, i3)).forEach((waiter) => waiter.resolve());
-      }
-    }
-  }
-  _couldLockImmediately(weight, priority) {
-    return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
-  }
-}
-function insertSorted(a2, v2) {
-  const i3 = findIndexFromEnd(a2, (other) => v2.priority <= other.priority);
-  a2.splice(i3 + 1, 0, v2);
-}
-function findIndexFromEnd(a2, predicate) {
-  for (let i3 = a2.length - 1;i3 >= 0; i3--) {
-    if (predicate(a2[i3])) {
-      return i3;
-    }
-  }
-  return -1;
-}
-
-class Mutex {
-  constructor(cancelError) {
-    this._semaphore = new Semaphore(1, cancelError);
-  }
-  acquire() {
-    return __awaiter$1(this, arguments, undefined, function* (priority = 0) {
-      const [, releaser] = yield this._semaphore.acquire(1, priority);
-      return releaser;
-    });
-  }
-  runExclusive(callback, priority = 0) {
-    return this._semaphore.runExclusive(() => callback(), 1, priority);
-  }
-  isLocked() {
-    return this._semaphore.isLocked();
-  }
-  waitForUnlock(priority = 0) {
-    return this._semaphore.waitForUnlock(1, priority);
-  }
-  release() {
-    if (this._semaphore.isLocked())
-      this._semaphore.release();
-  }
-  cancel() {
-    return this._semaphore.cancel();
-  }
-}
-var E_TIMEOUT, E_ALREADY_LOCKED, E_CANCELED, __awaiter$2 = function(thisArg, _arguments, P2, generator) {
-  function adopt(value) {
-    return value instanceof P2 ? value : new P2(function(resolve25) {
-      resolve25(value);
-    });
-  }
-  return new (P2 || (P2 = Promise))(function(resolve25, reject2) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject2(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject2(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve25(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-}, __awaiter$1 = function(thisArg, _arguments, P2, generator) {
-  function adopt(value) {
-    return value instanceof P2 ? value : new P2(function(resolve25) {
-      resolve25(value);
-    });
-  }
-  return new (P2 || (P2 = Promise))(function(resolve25, reject2) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject2(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject2(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve25(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var init_async_mutex = __esm(() => {
-  E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
-  E_ALREADY_LOCKED = new Error("mutex already locked");
-  E_CANCELED = new Error("request for lock canceled");
-});
-
 // src/services/api/dumpPrompts.ts
 import { createHash as createHash5 } from "crypto";
 import { promises as fs11 } from "fs";
@@ -210366,34 +210158,24 @@ function enqueueDumpRequest(agentIdOrSessionId, callback) {
     dumpRequestQueue.set(agentIdOrSessionId, []);
   }
   dumpRequestQueue.get(agentIdOrSessionId).push(callback);
-  processQueue(agentIdOrSessionId);
+  if (!processingFlags.has(agentIdOrSessionId)) {
+    processingFlags.add(agentIdOrSessionId);
+    processQueue(agentIdOrSessionId);
+  }
 }
 async function processQueue(agentIdOrSessionId) {
-  const mapRelease = await dumpRequestMapMutex.acquire();
-  let mutex = dumpRequestMutexes.get(agentIdOrSessionId);
-  if (!mutex) {
-    mutex = new Mutex;
-    dumpRequestMutexes.set(agentIdOrSessionId, mutex);
-  }
-  mapRelease();
-  const release = await mutex.acquire();
   try {
-    const queue = dumpRequestQueue.get(agentIdOrSessionId);
-    if (!queue || queue.length === 0) {
-      dumpRequestQueue.delete(agentIdOrSessionId);
-      dumpRequestMutexes.delete(agentIdOrSessionId);
-      return;
-    }
-    const callback = queue.shift();
-    await callback();
-    if (queue.length > 0) {
-      setImmediate(() => processQueue(agentIdOrSessionId));
-    } else {
-      dumpRequestQueue.delete(agentIdOrSessionId);
-      dumpRequestMutexes.delete(agentIdOrSessionId);
+    while (true) {
+      const queue = dumpRequestQueue.get(agentIdOrSessionId);
+      if (!queue || queue.length === 0) {
+        break;
+      }
+      const callback = queue.shift();
+      await callback();
     }
   } finally {
-    release();
+    dumpRequestQueue.delete(agentIdOrSessionId);
+    processingFlags.delete(agentIdOrSessionId);
   }
 }
 function clearDumpState(agentIdOrSessionId) {
@@ -210441,10 +210223,12 @@ function initFingerprint(req) {
 async function dumpRequest(body, ts, state, filePath) {
   if (false)
     ;
+  if (process.env.USER_TYPE !== "ant")
+    return;
   try {
     const req = jsonParse(body);
     addApiRequestToCache(req);
-    if (process.env.USER_TYPE !== "ant" || process.env.DUMP_PROMPTS !== "1")
+    if (process.env.DUMP_PROMPTS !== "1")
       return;
     logForDebugging("DUMP_PROMPTS is enabled. This will write full API payloads (including system prompts, user messages, and tool definitions) to the filesystem. This is intended for debugging only and should NOT be used in production.", { level: "warn" });
     const entries = [];
@@ -210577,35 +210361,29 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
             jsonStringify({ type: "response", timestamp, data })
           ]);
         } catch (err2) {
-          try {
-            logForDebugging(`dumpPrompts.response handler error: ${err2}`, { level: "error" });
-          } catch {}
+          logError2(`dumpPrompts.response handler error: ${err2}`);
         }
       })().catch((err2) => {
-        try {
-          logForDebugging(`dumpPrompts.response handler unhandled rejection: ${err2}`, { level: "error" });
-        } catch {}
+        logError2(`dumpPrompts.response handler unhandled rejection: ${err2}`);
       });
     }
     return response;
   };
 }
-var MAX_CACHED_REQUESTS = 5, cachedApiRequests, dumpState, dumpRequestQueue, dumpRequestMutexes, dumpRequestMapMutex;
+var MAX_CACHED_REQUESTS = 5, cachedApiRequests, dumpState, dumpRequestQueue, processingFlags;
 var init_dumpPrompts = __esm(() => {
   init_state();
   init_envUtils();
   init_slowOperations();
   init_debug();
   init_log3();
-  init_async_mutex();
   if (process.env.USER_TYPE === "ant" && process.env.DUMP_PROMPTS === "1") {
     logForDebugging("DUMP_PROMPTS is enabled. This will write full API payloads (including system prompts, user messages, and tool definitions) to the filesystem. This is intended for debugging only and should NOT be used in production.", { level: "warn" });
   }
   cachedApiRequests = [];
   dumpState = new Map;
   dumpRequestQueue = new Map;
-  dumpRequestMutexes = new Map;
-  dumpRequestMapMutex = new Mutex;
+  processingFlags = new Set;
 });
 
 // src/utils/abortController.ts
@@ -301139,6 +300917,214 @@ var init_gracefulShutdown = __esm(() => {
   };
 });
 
+// node_modules/async-mutex/index.mjs
+class Semaphore {
+  constructor(_value, _cancelError = E_CANCELED) {
+    this._value = _value;
+    this._cancelError = _cancelError;
+    this._queue = [];
+    this._weightedWaiters = [];
+  }
+  acquire(weight = 1, priority = 0) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    return new Promise((resolve28, reject2) => {
+      const task = { resolve: resolve28, reject: reject2, weight, priority };
+      const i3 = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
+      if (i3 === -1 && weight <= this._value) {
+        this._dispatchItem(task);
+      } else {
+        this._queue.splice(i3 + 1, 0, task);
+      }
+    });
+  }
+  runExclusive(callback_1) {
+    return __awaiter$2(this, arguments, undefined, function* (callback, weight = 1, priority = 0) {
+      const [value, release] = yield this.acquire(weight, priority);
+      try {
+        return yield callback(value);
+      } finally {
+        release();
+      }
+    });
+  }
+  waitForUnlock(weight = 1, priority = 0) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    if (this._couldLockImmediately(weight, priority)) {
+      return Promise.resolve();
+    } else {
+      return new Promise((resolve28) => {
+        if (!this._weightedWaiters[weight - 1])
+          this._weightedWaiters[weight - 1] = [];
+        insertSorted(this._weightedWaiters[weight - 1], { resolve: resolve28, priority });
+      });
+    }
+  }
+  isLocked() {
+    return this._value <= 0;
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(value) {
+    this._value = value;
+    this._dispatchQueue();
+  }
+  release(weight = 1) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    this._value += weight;
+    this._dispatchQueue();
+  }
+  cancel() {
+    this._queue.forEach((entry) => entry.reject(this._cancelError));
+    this._queue = [];
+  }
+  _dispatchQueue() {
+    this._drainUnlockWaiters();
+    while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
+      this._dispatchItem(this._queue.shift());
+      this._drainUnlockWaiters();
+    }
+  }
+  _dispatchItem(item) {
+    const previousValue = this._value;
+    this._value -= item.weight;
+    item.resolve([previousValue, this._newReleaser(item.weight)]);
+  }
+  _newReleaser(weight) {
+    let called = false;
+    return () => {
+      if (called)
+        return;
+      called = true;
+      this.release(weight);
+    };
+  }
+  _drainUnlockWaiters() {
+    if (this._queue.length === 0) {
+      for (let weight = this._value;weight > 0; weight--) {
+        const waiters = this._weightedWaiters[weight - 1];
+        if (!waiters)
+          continue;
+        waiters.forEach((waiter) => waiter.resolve());
+        this._weightedWaiters[weight - 1] = [];
+      }
+    } else {
+      const queuedPriority = this._queue[0].priority;
+      for (let weight = this._value;weight > 0; weight--) {
+        const waiters = this._weightedWaiters[weight - 1];
+        if (!waiters)
+          continue;
+        const i3 = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
+        (i3 === -1 ? waiters : waiters.splice(0, i3)).forEach((waiter) => waiter.resolve());
+      }
+    }
+  }
+  _couldLockImmediately(weight, priority) {
+    return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
+  }
+}
+function insertSorted(a2, v2) {
+  const i3 = findIndexFromEnd(a2, (other) => v2.priority <= other.priority);
+  a2.splice(i3 + 1, 0, v2);
+}
+function findIndexFromEnd(a2, predicate) {
+  for (let i3 = a2.length - 1;i3 >= 0; i3--) {
+    if (predicate(a2[i3])) {
+      return i3;
+    }
+  }
+  return -1;
+}
+
+class Mutex {
+  constructor(cancelError) {
+    this._semaphore = new Semaphore(1, cancelError);
+  }
+  acquire() {
+    return __awaiter$1(this, arguments, undefined, function* (priority = 0) {
+      const [, releaser] = yield this._semaphore.acquire(1, priority);
+      return releaser;
+    });
+  }
+  runExclusive(callback, priority = 0) {
+    return this._semaphore.runExclusive(() => callback(), 1, priority);
+  }
+  isLocked() {
+    return this._semaphore.isLocked();
+  }
+  waitForUnlock(priority = 0) {
+    return this._semaphore.waitForUnlock(1, priority);
+  }
+  release() {
+    if (this._semaphore.isLocked())
+      this._semaphore.release();
+  }
+  cancel() {
+    return this._semaphore.cancel();
+  }
+}
+var E_TIMEOUT, E_ALREADY_LOCKED, E_CANCELED, __awaiter$2 = function(thisArg, _arguments, P2, generator) {
+  function adopt(value) {
+    return value instanceof P2 ? value : new P2(function(resolve28) {
+      resolve28(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve28, reject2) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve28(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}, __awaiter$1 = function(thisArg, _arguments, P2, generator) {
+  function adopt(value) {
+    return value instanceof P2 ? value : new P2(function(resolve28) {
+      resolve28(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve28, reject2) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve28(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var init_async_mutex = __esm(() => {
+  E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
+  E_ALREADY_LOCKED = new Error("mutex already locked");
+  E_CANCELED = new Error("request for lock canceled");
+});
+
 // src/services/api/grove.ts
 function memoizeWithTTL(fn, ttlMs) {
   let lastCachedAt = 0;
@@ -301154,14 +301140,9 @@ function memoizeWithTTL(fn, ttlMs) {
       const result = await memoized(...args);
       if (result && typeof result === "object" && "success" in result && result.success === true) {
         lastCachedAt = Date.now();
-      } else if (result && typeof result === "object" && "success" in result && result.success === false) {
-        originalClear();
-        lastCachedAt = 0;
-      }
+      } else if (result && typeof result === "object" && "success" in result && result.success === false) {}
       return result;
     } catch (error49) {
-      originalClear();
-      lastCachedAt = -1;
       return { success: false };
     }
   };
@@ -301225,13 +301206,21 @@ async function isQualifiedForGrove() {
   const cachedEntry = globalConfig2.groveConfigCache?.[accountId];
   const now2 = Date.now();
   if (!cachedEntry) {
-    logForDebugging("Grove: No cache, fetching config in background (dialog skipped this session)");
-    fetchAndStoreGroveConfig(accountId);
+    logForDebugging("Grove: No cache, fetching config synchronously");
+    await fetchAndStoreGroveConfig(accountId);
+    const updatedConfig = getGlobalConfig().groveConfigCache?.[accountId];
+    if (updatedConfig) {
+      return updatedConfig.grove_enabled;
+    }
     return false;
   }
   if (now2 - cachedEntry.timestamp > GROVE_CACHE_EXPIRATION_MS) {
-    logForDebugging("Grove: Cache stale, returning cached data and refreshing in background");
-    fetchAndStoreGroveConfig(accountId);
+    logForDebugging("Grove: Cache stale, refreshing config");
+    await fetchAndStoreGroveConfig(accountId);
+    const updatedConfig = getGlobalConfig().groveConfigCache?.[accountId];
+    if (updatedConfig) {
+      return updatedConfig.grove_enabled;
+    }
     return cachedEntry.grove_enabled;
   }
   logForDebugging("Grove: Using fresh cached config");
@@ -301247,27 +301236,41 @@ async function fetchAndStoreGroveConfig(accountId) {
   mapRelease();
   const release = await mutex.acquire();
   try {
-    const result = await getGroveNoticeConfig();
-    if (!result.success) {
-      return;
-    }
-    const groveEnabled = result.data.grove_enabled;
-    const cachedEntry = getGlobalConfig().groveConfigCache?.[accountId];
-    if (cachedEntry?.grove_enabled === groveEnabled && Date.now() - cachedEntry.timestamp <= GROVE_CACHE_EXPIRATION_MS) {
-      return;
-    }
-    saveGlobalConfig((current) => ({
-      ...current,
-      groveConfigCache: {
-        ...current.groveConfigCache,
-        [accountId]: {
-          grove_enabled: groveEnabled,
-          timestamp: Date.now()
+    let lastError;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      try {
+        const result = await getGroveNoticeConfig();
+        if (!result.success) {
+          if (attempt < 2) {
+            await new Promise((resolve28) => setTimeout(resolve28, 500));
+            continue;
+          }
+          return;
+        }
+        const groveEnabled = result.data.grove_enabled;
+        const cachedEntry = getGlobalConfig().groveConfigCache?.[accountId];
+        if (cachedEntry?.grove_enabled === groveEnabled && Date.now() - cachedEntry.timestamp <= GROVE_CACHE_EXPIRATION_MS) {
+          return;
+        }
+        saveGlobalConfig((current) => ({
+          ...current,
+          groveConfigCache: {
+            ...current.groveConfigCache,
+            [accountId]: {
+              grove_enabled: groveEnabled,
+              timestamp: Date.now()
+            }
+          }
+        }));
+        return;
+      } catch (err2) {
+        lastError = err2 instanceof Error ? err2 : new Error(String(err2));
+        if (attempt < 2) {
+          await new Promise((resolve28) => setTimeout(resolve28, 500));
         }
       }
-    }));
-  } catch (err2) {
-    logForDebugging(`Grove: Failed to fetch and store config: ${err2}`);
+    }
+    logForDebugging(`Grove: Failed to fetch and store config after 3 attempts: ${lastError}`);
   } finally {
     release();
   }
@@ -301360,7 +301363,6 @@ var init_grove = __esm(() => {
       return { success: true, data: response.data };
     } catch (err2) {
       logError2(err2);
-      getGroveSettings.cache.clear?.();
       return { success: false };
     }
   }, GROVE_CACHE_EXPIRATION_MS);
@@ -301402,7 +301404,6 @@ var init_grove = __esm(() => {
       if (axios_default.isAxiosError(err2) && err2.code === "ECONNABORTED") {
         logForDebugging(`Grove: API request timed out after ${GROVE_API_TIMEOUT_MS}ms. This may cause the Grove dialog to be suppressed for users with slow connections.`);
       }
-      getGroveNoticeConfig.cache.clear?.();
       return { success: false };
     }
   }, GROVE_CACHE_EXPIRATION_MS);
@@ -342446,7 +342447,9 @@ async function getSessionLogs(sessionId, url3) {
     return null;
   }
   const headers = { Authorization: `Bearer ${sessionToken}` };
-  const logs2 = await fetchSessionLogsFromUrl(sessionId, url3, headers);
+  const sequential2 = getOrCreateSequential(sessionId);
+  const result = await sequential2(sessionId, url3, headers, true);
+  const logs2 = result;
   if (logs2 && logs2.length > 0) {
     const lastEntry = logs2.at(-1);
     if (lastEntry && "uuid" in lastEntry && lastEntry.uuid) {
@@ -453788,17 +453791,36 @@ var init_FeedColumn = __esm(() => {
 // src/services/api/referral.ts
 async function fetchReferralEligibility(campaign = "claude_code_guest_pass") {
   const { accessToken, orgUUID } = await prepareApiRequest();
+  const existingPromise = fetchInProgressMap.get(orgUUID);
+  if (existingPromise) {
+    logForDebugging(`Passes: Reusing in-flight eligibility fetch for org ${orgUUID}`);
+    return existingPromise;
+  }
   const headers = {
     ...getOAuthHeaders(accessToken),
     "x-organization-uuid": orgUUID
   };
   const url3 = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/referral/eligibility`;
-  const response = await axios_default.get(url3, {
-    headers,
-    params: { campaign },
-    timeout: 5000
+  let resolvePromise;
+  const promise3 = new Promise((resolve47) => {
+    resolvePromise = resolve47;
   });
-  return response.data;
+  fetchInProgressMap.set(orgUUID, promise3);
+  (async () => {
+    try {
+      const response = await axios_default.get(url3, {
+        headers,
+        params: { campaign },
+        timeout: 5000
+      });
+      resolvePromise(response.data);
+    } catch (error49) {
+      logError2(error49);
+      fetchInProgressMap.delete(orgUUID);
+      throw error49;
+    }
+  })();
+  return promise3;
 }
 async function fetchReferralRedemptions(campaign = "claude_code_guest_pass") {
   const { accessToken, orgUUID } = await prepareApiRequest();
@@ -453878,41 +453900,26 @@ async function fetchAndStorePassesEligibility() {
   if (!orgId) {
     return null;
   }
-  const existingPromise = fetchInProgressMap.get(orgId);
-  if (existingPromise) {
-    logForDebugging(`Passes: Reusing in-flight eligibility fetch for org ${orgId}`);
-    return existingPromise;
+  try {
+    const response = await fetchReferralEligibility();
+    const cacheEntry = {
+      ...response,
+      timestamp: Date.now()
+    };
+    saveGlobalConfig((current) => ({
+      ...current,
+      passesEligibilityCache: {
+        ...current.passesEligibilityCache,
+        [orgId]: cacheEntry
+      }
+    }));
+    logForDebugging(`Passes eligibility cached for org ${orgId}: ${response.eligible}`);
+    return response;
+  } catch (error49) {
+    logForDebugging("Failed to fetch and cache passes eligibility");
+    logError2(error49);
+    return null;
   }
-  let resolvePromise;
-  const promise3 = new Promise((resolve47) => {
-    resolvePromise = resolve47;
-  });
-  fetchInProgressMap.set(orgId, promise3);
-  (async () => {
-    try {
-      const response = await fetchReferralEligibility();
-      const cacheEntry = {
-        ...response,
-        timestamp: Date.now()
-      };
-      saveGlobalConfig((current) => ({
-        ...current,
-        passesEligibilityCache: {
-          ...current.passesEligibilityCache,
-          [orgId]: cacheEntry
-        }
-      }));
-      logForDebugging(`Passes eligibility cached for org ${orgId}: ${response.eligible}`);
-      resolvePromise(response);
-    } catch (error49) {
-      logForDebugging("Failed to fetch and cache passes eligibility");
-      logError2(error49);
-      resolvePromise(null);
-    } finally {
-      fetchInProgressMap.delete(orgId);
-    }
-  })();
-  return promise3;
 }
 async function getCachedOrFetchPassesEligibility() {
   if (!shouldCheckForPasses()) {