@xmem-ai/memcode 4.0.2

package/dist/services/mcp/xaaIdpLogin.js

@@ -0,0 +1,329 @@
+import {
+  exchangeAuthorization,
+  startAuthorization
+} from "@modelcontextprotocol/sdk/client/auth.js";
+import {
+  OpenIdProviderDiscoveryMetadataSchema
+} from "@modelcontextprotocol/sdk/shared/auth.js";
+import { randomBytes } from "crypto";
+import { createServer } from "http";
+import { parse } from "url";
+import xss from "xss";
+import { openBrowser } from "../../utils/browser.js";
+import { isEnvTruthy } from "../../utils/envUtils.js";
+import { toError } from "../../utils/errors.js";
+import { logMCPDebug } from "../../utils/log.js";
+import { getPlatform } from "../../utils/platform.js";
+import { getSecureStorage } from "../../utils/secureStorage/index.js";
+import { getInitialSettings } from "../../utils/settings/settings.js";
+import { jsonParse } from "../../utils/slowOperations.js";
+import { buildRedirectUri, findAvailablePort } from "./oauthPort.js";
+function isXaaEnabled() {
+  return isEnvTruthy(process.env.XCODE_ENABLE_XAA);
+}
+function getXaaIdpSettings() {
+  return getInitialSettings().xaaIdp;
+}
+const IDP_LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+const IDP_REQUEST_TIMEOUT_MS = 3e4;
+const ID_TOKEN_EXPIRY_BUFFER_S = 60;
+function issuerKey(issuer) {
+  try {
+    const u = new URL(issuer);
+    u.pathname = u.pathname.replace(/\/+$/, "");
+    u.host = u.host.toLowerCase();
+    return u.toString();
+  } catch {
+    return issuer.replace(/\/+$/, "");
+  }
+}
+function getCachedIdpIdToken(idpIssuer) {
+  const storage = getSecureStorage();
+  const data = storage.read();
+  const entry = data?.mcpXaaIdp?.[issuerKey(idpIssuer)];
+  if (!entry) return void 0;
+  const remainingMs = entry.expiresAt - Date.now();
+  if (remainingMs <= ID_TOKEN_EXPIRY_BUFFER_S * 1e3) return void 0;
+  return entry.idToken;
+}
+function saveIdpIdToken(idpIssuer, idToken, expiresAt) {
+  const storage = getSecureStorage();
+  const existing = storage.read() || {};
+  storage.update({
+    ...existing,
+    mcpXaaIdp: {
+      ...existing.mcpXaaIdp,
+      [issuerKey(idpIssuer)]: { idToken, expiresAt }
+    }
+  });
+}
+function saveIdpIdTokenFromJwt(idpIssuer, idToken) {
+  const expFromJwt = jwtExp(idToken);
+  const expiresAt = expFromJwt ? expFromJwt * 1e3 : Date.now() + 3600 * 1e3;
+  saveIdpIdToken(idpIssuer, idToken, expiresAt);
+  return expiresAt;
+}
+function clearIdpIdToken(idpIssuer) {
+  const storage = getSecureStorage();
+  const existing = storage.read();
+  const key = issuerKey(idpIssuer);
+  if (!existing?.mcpXaaIdp?.[key]) return;
+  delete existing.mcpXaaIdp[key];
+  storage.update(existing);
+}
+function saveIdpClientSecret(idpIssuer, clientSecret) {
+  const storage = getSecureStorage();
+  const existing = storage.read() || {};
+  return storage.update({
+    ...existing,
+    mcpXaaIdpConfig: {
+      ...existing.mcpXaaIdpConfig,
+      [issuerKey(idpIssuer)]: { clientSecret }
+    }
+  });
+}
+function getIdpClientSecret(idpIssuer) {
+  const storage = getSecureStorage();
+  const data = storage.read();
+  return data?.mcpXaaIdpConfig?.[issuerKey(idpIssuer)]?.clientSecret;
+}
+function clearIdpClientSecret(idpIssuer) {
+  const storage = getSecureStorage();
+  const existing = storage.read();
+  const key = issuerKey(idpIssuer);
+  if (!existing?.mcpXaaIdpConfig?.[key]) return;
+  delete existing.mcpXaaIdpConfig[key];
+  storage.update(existing);
+}
+async function discoverOidc(idpIssuer) {
+  const base = idpIssuer.endsWith("/") ? idpIssuer : idpIssuer + "/";
+  const url = new URL(".well-known/openid-configuration", base);
+  const res = await fetch(url, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(IDP_REQUEST_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    throw new Error(
+      `XAA IdP: OIDC discovery failed: HTTP ${res.status} at ${url}`
+    );
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new Error(
+      `XAA IdP: OIDC discovery returned non-JSON at ${url} (captive portal or proxy?)`
+    );
+  }
+  const parsed = OpenIdProviderDiscoveryMetadataSchema.safeParse(body);
+  if (!parsed.success) {
+    throw new Error(`XAA IdP: invalid OIDC metadata: ${parsed.error.message}`);
+  }
+  if (new URL(parsed.data.token_endpoint).protocol !== "https:") {
+    throw new Error(
+      `XAA IdP: refusing non-HTTPS token endpoint: ${parsed.data.token_endpoint}`
+    );
+  }
+  return parsed.data;
+}
+function jwtExp(jwt) {
+  const parts = jwt.split(".");
+  if (parts.length !== 3) return void 0;
+  try {
+    const payload = jsonParse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    return typeof payload.exp === "number" ? payload.exp : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function waitForCallback(port, expectedState, abortSignal, onListening) {
+  let server = null;
+  let timeoutId = null;
+  let abortHandler = null;
+  const cleanup = () => {
+    server?.removeAllListeners();
+    server?.on("error", () => {
+    });
+    server?.close();
+    server = null;
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    if (abortSignal && abortHandler) {
+      abortSignal.removeEventListener("abort", abortHandler);
+      abortHandler = null;
+    }
+  };
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    const resolveOnce = (v) => {
+      if (resolved) return;
+      resolved = true;
+      cleanup();
+      resolve(v);
+    };
+    const rejectOnce = (e) => {
+      if (resolved) return;
+      resolved = true;
+      cleanup();
+      reject(e);
+    };
+    if (abortSignal) {
+      abortHandler = () => rejectOnce(new Error("XAA IdP: login cancelled"));
+      if (abortSignal.aborted) {
+        abortHandler();
+        return;
+      }
+      abortSignal.addEventListener("abort", abortHandler, { once: true });
+    }
+    server = createServer((req, res) => {
+      const parsed = parse(req.url || "", true);
+      if (parsed.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const code = parsed.query.code;
+      const state = parsed.query.state;
+      const err = parsed.query.error;
+      if (err) {
+        const desc = parsed.query.error_description;
+        const safeErr = xss(err);
+        const safeDesc = desc ? xss(desc) : "";
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(
+          `<html><body><h3>IdP login failed</h3><p>${safeErr}</p><p>${safeDesc}</p></body></html>`
+        );
+        rejectOnce(new Error(`XAA IdP: ${err}${desc ? ` \u2014 ${desc}` : ""}`));
+        return;
+      }
+      if (state !== expectedState) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h3>State mismatch</h3></body></html>");
+        rejectOnce(new Error("XAA IdP: state mismatch (possible CSRF)"));
+        return;
+      }
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h3>Missing code</h3></body></html>");
+        rejectOnce(new Error("XAA IdP: callback missing code"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(
+        "<html><body><h3>IdP login complete \u2014 you can close this window.</h3></body></html>"
+      );
+      resolveOnce(code);
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        const findCmd = getPlatform() === "windows" ? `netstat -ano | findstr :${port}` : `lsof -ti:${port} -sTCP:LISTEN`;
+        rejectOnce(
+          new Error(
+            `XAA IdP: callback port ${port} is already in use. Run \`${findCmd}\` to find the holder.`
+          )
+        );
+      } else {
+        rejectOnce(new Error(`XAA IdP: callback server failed: ${err.message}`));
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+      try {
+        onListening();
+      } catch (e) {
+        rejectOnce(toError(e));
+      }
+    });
+    server.unref();
+    timeoutId = setTimeout(
+      (rej) => rej(new Error("XAA IdP: login timed out")),
+      IDP_LOGIN_TIMEOUT_MS,
+      rejectOnce
+    );
+    timeoutId.unref();
+  });
+}
+async function acquireIdpIdToken(opts) {
+  const { idpIssuer, idpClientId } = opts;
+  const cached = getCachedIdpIdToken(idpIssuer);
+  if (cached) {
+    logMCPDebug("xaa", `Using cached id_token for ${idpIssuer}`);
+    return cached;
+  }
+  logMCPDebug("xaa", `No cached id_token for ${idpIssuer}; starting OIDC login`);
+  const metadata = await discoverOidc(idpIssuer);
+  const port = opts.callbackPort ?? await findAvailablePort();
+  const redirectUri = buildRedirectUri(port);
+  const state = randomBytes(32).toString("base64url");
+  const clientInformation = {
+    client_id: idpClientId,
+    ...opts.idpClientSecret ? { client_secret: opts.idpClientSecret } : {}
+  };
+  const { authorizationUrl, codeVerifier } = await startAuthorization(
+    idpIssuer,
+    {
+      metadata,
+      clientInformation,
+      redirectUrl: redirectUri,
+      scope: "openid",
+      state
+    }
+  );
+  const authorizationCode = await waitForCallback(
+    port,
+    state,
+    opts.abortSignal,
+    () => {
+      if (opts.onAuthorizationUrl) {
+        opts.onAuthorizationUrl(authorizationUrl.toString());
+      }
+      if (!opts.skipBrowserOpen) {
+        logMCPDebug("xaa", `Opening browser to IdP authorization endpoint`);
+        void openBrowser(authorizationUrl.toString());
+      }
+    }
+  );
+  const tokens = await exchangeAuthorization(idpIssuer, {
+    metadata,
+    clientInformation,
+    authorizationCode,
+    codeVerifier,
+    redirectUri,
+    fetchFn: (url, init) => (
+      // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
+      fetch(url, {
+        ...init,
+        signal: AbortSignal.timeout(IDP_REQUEST_TIMEOUT_MS)
+      })
+    )
+  });
+  if (!tokens.id_token) {
+    throw new Error(
+      "XAA IdP: token response missing id_token (check scope=openid)"
+    );
+  }
+  const expFromJwt = jwtExp(tokens.id_token);
+  const expiresAt = expFromJwt ? expFromJwt * 1e3 : Date.now() + (tokens.expires_in ?? 3600) * 1e3;
+  saveIdpIdToken(idpIssuer, tokens.id_token, expiresAt);
+  logMCPDebug(
+    "xaa",
+    `Cached id_token for ${idpIssuer} (expires ${new Date(expiresAt).toISOString()})`
+  );
+  return tokens.id_token;
+}
+export {
+  acquireIdpIdToken,
+  clearIdpClientSecret,
+  clearIdpIdToken,
+  discoverOidc,
+  getCachedIdpIdToken,
+  getIdpClientSecret,
+  getXaaIdpSettings,
+  isXaaEnabled,
+  issuerKey,
+  saveIdpClientSecret,
+  saveIdpIdTokenFromJwt
+};

package/dist/services/mcpServerApproval.js

@@ -0,0 +1,28 @@
+import { jsx } from "react/jsx-runtime";
+import { MCPServerApprovalDialog } from "../components/MCPServerApprovalDialog.js";
+import { MCPServerMultiselectDialog } from "../components/MCPServerMultiselectDialog.js";
+import { KeybindingSetup } from "../keybindings/KeybindingProviderSetup.js";
+import { AppStateProvider } from "../state/AppState.js";
+import { getMcpConfigsByScope } from "./mcp/config.js";
+import { getProjectMcpServerStatus } from "./mcp/utils.js";
+async function handleMcpjsonServerApprovals(root) {
+  const {
+    servers: projectServers
+  } = getMcpConfigsByScope("project");
+  const pendingServers = Object.keys(projectServers).filter((serverName) => getProjectMcpServerStatus(serverName) === "pending");
+  if (pendingServers.length === 0) {
+    return;
+  }
+  await new Promise((resolve) => {
+    const done = () => void resolve();
+    if (pendingServers.length === 1 && pendingServers[0] !== void 0) {
+      const serverName = pendingServers[0];
+      root.render(/* @__PURE__ */ jsx(AppStateProvider, { children: /* @__PURE__ */ jsx(KeybindingSetup, { children: /* @__PURE__ */ jsx(MCPServerApprovalDialog, { serverName, onDone: done }) }) }));
+    } else {
+      root.render(/* @__PURE__ */ jsx(AppStateProvider, { children: /* @__PURE__ */ jsx(KeybindingSetup, { children: /* @__PURE__ */ jsx(MCPServerMultiselectDialog, { serverNames: pendingServers, onDone: done }) }) }));
+    }
+  });
+}
+export {
+  handleMcpjsonServerApprovals
+};

package/dist/services/memcodeLimits.js

@@ -0,0 +1,318 @@
+import { APIError } from "@anthropic-ai/sdk";
+import isEqual from "lodash-es/isEqual.js";
+import { getIsNonInteractiveSession } from "../bootstrap/state.js";
+import { isClaudeAISubscriber } from "../utils/auth.js";
+import { getModelBetas } from "../utils/betas.js";
+import { getGlobalConfig, saveGlobalConfig } from "../utils/config.js";
+import { logError } from "../utils/log.js";
+import { getSmallFastModel } from "../utils/model/model.js";
+import { isEssentialTrafficOnly } from "../utils/privacyLevel.js";
+import { logEvent } from "./analytics/index.js";
+import { getAPIMetadata } from "./api/memcode.js";
+import { getAnthropicClient } from "./api/client.js";
+import {
+  processRateLimitHeaders,
+  shouldProcessRateLimits
+} from "./rateLimitMocking.js";
+import {
+  getRateLimitErrorMessage,
+  getRateLimitWarning,
+  getUsingOverageText
+} from "./rateLimitMessages.js";
+const EARLY_WARNING_CONFIGS = [
+  {
+    rateLimitType: "five_hour",
+    claimAbbrev: "5h",
+    windowSeconds: 5 * 60 * 60,
+    thresholds: [{ utilization: 0.9, timePct: 0.72 }]
+  },
+  {
+    rateLimitType: "seven_day",
+    claimAbbrev: "7d",
+    windowSeconds: 7 * 24 * 60 * 60,
+    thresholds: [
+      { utilization: 0.75, timePct: 0.6 },
+      { utilization: 0.5, timePct: 0.35 },
+      { utilization: 0.25, timePct: 0.15 }
+    ]
+  }
+];
+const EARLY_WARNING_CLAIM_MAP = {
+  "5h": "five_hour",
+  "7d": "seven_day",
+  overage: "overage"
+};
+const RATE_LIMIT_DISPLAY_NAMES = {
+  five_hour: "session limit",
+  seven_day: "weekly limit",
+  seven_day_opus: "Advanced limit",
+  seven_day_sonnet: "Default limit",
+  overage: "extra usage limit"
+};
+function getRateLimitDisplayName(type) {
+  return RATE_LIMIT_DISPLAY_NAMES[type] || type;
+}
+function computeTimeProgress(resetsAt, windowSeconds) {
+  const nowSeconds = Date.now() / 1e3;
+  const windowStart = resetsAt - windowSeconds;
+  const elapsed = nowSeconds - windowStart;
+  return Math.max(0, Math.min(1, elapsed / windowSeconds));
+}
+let currentLimits = {
+  status: "allowed",
+  unifiedRateLimitFallbackAvailable: false,
+  isUsingOverage: false
+};
+let rawUtilization = {};
+function getRawUtilization() {
+  return rawUtilization;
+}
+function extractRawUtilization(headers) {
+  const result = {};
+  for (const [key, abbrev] of [
+    ["five_hour", "5h"],
+    ["seven_day", "7d"]
+  ]) {
+    const util = headers.get(
+      `anthropic-ratelimit-unified-${abbrev}-utilization`
+    );
+    const reset = headers.get(`anthropic-ratelimit-unified-${abbrev}-reset`);
+    if (util !== null && reset !== null) {
+      result[key] = { utilization: Number(util), resets_at: Number(reset) };
+    }
+  }
+  return result;
+}
+const statusListeners = /* @__PURE__ */ new Set();
+function emitStatusChange(limits) {
+  currentLimits = limits;
+  statusListeners.forEach((listener) => listener(limits));
+  const hoursTillReset = Math.round(
+    (limits.resetsAt ? limits.resetsAt - Date.now() / 1e3 : 0) / (60 * 60)
+  );
+  logEvent("memcode_limits_status_changed", {
+    status: limits.status,
+    unifiedRateLimitFallbackAvailable: limits.unifiedRateLimitFallbackAvailable,
+    hoursTillReset
+  });
+}
+async function makeTestQuery() {
+  const model = getSmallFastModel();
+  const anthropic = await getAnthropicClient({
+    maxRetries: 0,
+    model,
+    source: "quota_check"
+  });
+  const messages = [{ role: "user", content: "quota" }];
+  const betas = getModelBetas(model);
+  return anthropic.beta.messages.create({
+    model,
+    max_tokens: 1,
+    messages,
+    metadata: getAPIMetadata(),
+    ...betas.length > 0 ? { betas } : {}
+  }).asResponse();
+}
+async function checkQuotaStatus() {
+  if (isEssentialTrafficOnly()) {
+    return;
+  }
+  if (!shouldProcessRateLimits(isClaudeAISubscriber())) {
+    return;
+  }
+  if (getIsNonInteractiveSession()) {
+    return;
+  }
+  try {
+    const raw = await makeTestQuery();
+    extractQuotaStatusFromHeaders(raw.headers);
+  } catch (error) {
+    if (error instanceof APIError) {
+      extractQuotaStatusFromError(error);
+    }
+  }
+}
+function getHeaderBasedEarlyWarning(headers, unifiedRateLimitFallbackAvailable) {
+  for (const [claimAbbrev, rateLimitType] of Object.entries(
+    EARLY_WARNING_CLAIM_MAP
+  )) {
+    const surpassedThreshold = headers.get(
+      `anthropic-ratelimit-unified-${claimAbbrev}-surpassed-threshold`
+    );
+    if (surpassedThreshold !== null) {
+      const utilizationHeader = headers.get(
+        `anthropic-ratelimit-unified-${claimAbbrev}-utilization`
+      );
+      const resetHeader = headers.get(
+        `anthropic-ratelimit-unified-${claimAbbrev}-reset`
+      );
+      const utilization = utilizationHeader ? Number(utilizationHeader) : void 0;
+      const resetsAt = resetHeader ? Number(resetHeader) : void 0;
+      return {
+        status: "allowed_warning",
+        resetsAt,
+        rateLimitType,
+        utilization,
+        unifiedRateLimitFallbackAvailable,
+        isUsingOverage: false,
+        surpassedThreshold: Number(surpassedThreshold)
+      };
+    }
+  }
+  return null;
+}
+function getTimeRelativeEarlyWarning(headers, config, unifiedRateLimitFallbackAvailable) {
+  const { rateLimitType, claimAbbrev, windowSeconds, thresholds } = config;
+  const utilizationHeader = headers.get(
+    `anthropic-ratelimit-unified-${claimAbbrev}-utilization`
+  );
+  const resetHeader = headers.get(
+    `anthropic-ratelimit-unified-${claimAbbrev}-reset`
+  );
+  if (utilizationHeader === null || resetHeader === null) {
+    return null;
+  }
+  const utilization = Number(utilizationHeader);
+  const resetsAt = Number(resetHeader);
+  const timeProgress = computeTimeProgress(resetsAt, windowSeconds);
+  const shouldWarn = thresholds.some(
+    (t) => utilization >= t.utilization && timeProgress <= t.timePct
+  );
+  if (!shouldWarn) {
+    return null;
+  }
+  return {
+    status: "allowed_warning",
+    resetsAt,
+    rateLimitType,
+    utilization,
+    unifiedRateLimitFallbackAvailable,
+    isUsingOverage: false
+  };
+}
+function getEarlyWarningFromHeaders(headers, unifiedRateLimitFallbackAvailable) {
+  const headerBasedWarning = getHeaderBasedEarlyWarning(
+    headers,
+    unifiedRateLimitFallbackAvailable
+  );
+  if (headerBasedWarning) {
+    return headerBasedWarning;
+  }
+  for (const config of EARLY_WARNING_CONFIGS) {
+    const timeRelativeWarning = getTimeRelativeEarlyWarning(
+      headers,
+      config,
+      unifiedRateLimitFallbackAvailable
+    );
+    if (timeRelativeWarning) {
+      return timeRelativeWarning;
+    }
+  }
+  return null;
+}
+function computeNewLimitsFromHeaders(headers) {
+  const status = headers.get("anthropic-ratelimit-unified-status") || "allowed";
+  const resetsAtHeader = headers.get("anthropic-ratelimit-unified-reset");
+  const resetsAt = resetsAtHeader ? Number(resetsAtHeader) : void 0;
+  const unifiedRateLimitFallbackAvailable = headers.get("anthropic-ratelimit-unified-fallback") === "available";
+  const rateLimitType = headers.get(
+    "anthropic-ratelimit-unified-representative-claim"
+  );
+  const overageStatus = headers.get(
+    "anthropic-ratelimit-unified-overage-status"
+  );
+  const overageResetsAtHeader = headers.get(
+    "anthropic-ratelimit-unified-overage-reset"
+  );
+  const overageResetsAt = overageResetsAtHeader ? Number(overageResetsAtHeader) : void 0;
+  const overageDisabledReason = headers.get(
+    "anthropic-ratelimit-unified-overage-disabled-reason"
+  );
+  const isUsingOverage = status === "rejected" && (overageStatus === "allowed" || overageStatus === "allowed_warning");
+  let finalStatus = status;
+  if (status === "allowed" || status === "allowed_warning") {
+    const earlyWarning = getEarlyWarningFromHeaders(
+      headers,
+      unifiedRateLimitFallbackAvailable
+    );
+    if (earlyWarning) {
+      return earlyWarning;
+    }
+    finalStatus = "allowed";
+  }
+  return {
+    status: finalStatus,
+    resetsAt,
+    unifiedRateLimitFallbackAvailable,
+    ...rateLimitType && { rateLimitType },
+    ...overageStatus && { overageStatus },
+    ...overageResetsAt && { overageResetsAt },
+    ...overageDisabledReason && { overageDisabledReason },
+    isUsingOverage
+  };
+}
+function cacheExtraUsageDisabledReason(headers) {
+  const reason = headers.get("anthropic-ratelimit-unified-overage-disabled-reason") ?? null;
+  const cached = getGlobalConfig().cachedExtraUsageDisabledReason;
+  if (cached !== reason) {
+    saveGlobalConfig((current) => ({
+      ...current,
+      cachedExtraUsageDisabledReason: reason
+    }));
+  }
+}
+function extractQuotaStatusFromHeaders(headers) {
+  const isSubscriber = isClaudeAISubscriber();
+  if (!shouldProcessRateLimits(isSubscriber)) {
+    rawUtilization = {};
+    if (currentLimits.status !== "allowed" || currentLimits.resetsAt) {
+      const defaultLimits = {
+        status: "allowed",
+        unifiedRateLimitFallbackAvailable: false,
+        isUsingOverage: false
+      };
+      emitStatusChange(defaultLimits);
+    }
+    return;
+  }
+  const headersToUse = processRateLimitHeaders(headers);
+  rawUtilization = extractRawUtilization(headersToUse);
+  const newLimits = computeNewLimitsFromHeaders(headersToUse);
+  cacheExtraUsageDisabledReason(headersToUse);
+  if (!isEqual(currentLimits, newLimits)) {
+    emitStatusChange(newLimits);
+  }
+}
+function extractQuotaStatusFromError(error) {
+  if (!shouldProcessRateLimits(isClaudeAISubscriber()) || error.status !== 429) {
+    return;
+  }
+  try {
+    let newLimits = { ...currentLimits };
+    if (error.headers) {
+      const headersToUse = processRateLimitHeaders(error.headers);
+      rawUtilization = extractRawUtilization(headersToUse);
+      newLimits = computeNewLimitsFromHeaders(headersToUse);
+      cacheExtraUsageDisabledReason(headersToUse);
+    }
+    newLimits.status = "rejected";
+    if (!isEqual(currentLimits, newLimits)) {
+      emitStatusChange(newLimits);
+    }
+  } catch (e) {
+    logError(e);
+  }
+}
+export {
+  checkQuotaStatus,
+  currentLimits,
+  emitStatusChange,
+  extractQuotaStatusFromError,
+  extractQuotaStatusFromHeaders,
+  getRateLimitDisplayName,
+  getRateLimitErrorMessage,
+  getRateLimitWarning,
+  getRawUtilization,
+  getUsingOverageText,
+  statusListeners
+};

package/dist/services/memcodeLimitsHook.js

@@ -0,0 +1,21 @@
+import { useEffect, useState } from "react";
+import {
+  currentLimits,
+  statusListeners
+} from "./memcodeLimits.js";
+function usememCodeLimits() {
+  const [limits, setLimits] = useState({ ...currentLimits });
+  useEffect(() => {
+    const listener = (newLimits) => {
+      setLimits({ ...newLimits });
+    };
+    statusListeners.add(listener);
+    return () => {
+      statusListeners.delete(listener);
+    };
+  }, []);
+  return limits;
+}
+export {
+  usememCodeLimits
+};