@shuffleio/shuffle-mcps 0.0.15 → 0.0.17

package/dist/{appsCache-33KARY6K.mjs → appsCache-CFCVTF7D.mjs}

@@ -2,7 +2,7 @@ import {
   fetchApps,
   fetchAppsViaApiConfig,
   invalidateAppsCache
-} from "./chunk-FOMFBSUO.mjs";
+} from "./chunk-R3YLER6P.mjs";
 export {
   fetchApps,
   fetchAppsViaApiConfig,

package/dist/chunk-R3YLER6P.mjs

@@ -0,0 +1,325 @@
+// fetchBreaker.ts
+var FAIL_THRESHOLD = 12;
+var ROLLING_WINDOW_MS = 5e3;
+var COOLDOWN_MS = 3e4;
+var HARD_BURST_THRESHOLD = 30;
+var HARD_BURST_WINDOW_MS = 1e3;
+var state = /* @__PURE__ */ new Map();
+var installed = false;
+var allowedOrigins = /* @__PURE__ */ new Set();
+var getEntry = (key) => {
+  let entry = state.get(key);
+  if (!entry) {
+    entry = { failures: [], attempts: [], blockedUntil: 0, warned: false };
+    state.set(key, entry);
+  }
+  return entry;
+};
+var prune = (arr, now, windowMs) => {
+  const cutoff = now - windowMs;
+  while (arr.length && arr[0] < cutoff) arr.shift();
+};
+var keyFor = (input, init) => {
+  let urlStr;
+  let method = (init?.method || (typeof input !== "string" && "method" in input ? input.method : "GET") || "GET").toUpperCase();
+  if (typeof input === "string") urlStr = input;
+  else if (input instanceof URL) urlStr = input.toString();
+  else if (input && typeof input.url === "string") urlStr = input.url;
+  else return null;
+  try {
+    const u = new URL(urlStr, typeof window !== "undefined" ? window.location.href : "http://localhost");
+    if (allowedOrigins.size && !allowedOrigins.has(u.origin)) return null;
+    if (!u.pathname.startsWith("/api/")) return null;
+    return `${method} ${u.origin}${u.pathname}`;
+  } catch {
+    return null;
+  }
+};
+var synthetic503 = (key, retryInMs) => new Response(
+  JSON.stringify({
+    error: "circuit_breaker_open",
+    message: `Too many failures for ${key}. Cooling down for ${Math.ceil(retryInMs / 1e3)}s.`
+  }),
+  {
+    status: 503,
+    statusText: "Service Unavailable (circuit breaker)",
+    headers: { "Content-Type": "application/json", "Retry-After": String(Math.ceil(retryInMs / 1e3)) }
+  }
+);
+var registerProtectedOrigin = (url) => {
+  if (!url) return;
+  try {
+    const origin = new URL(url, typeof window !== "undefined" ? window.location.href : "http://localhost").origin;
+    allowedOrigins.add(origin);
+  } catch {
+  }
+};
+var installFetchBreaker = () => {
+  if (installed) return;
+  if (typeof window === "undefined" || typeof window.fetch !== "function") return;
+  installed = true;
+  const original = window.fetch.bind(window);
+  window.fetch = (async (input, init) => {
+    const key = keyFor(input, init);
+    if (!key) return original(input, init);
+    const entry = getEntry(key);
+    const now = Date.now();
+    if (entry.blockedUntil > now) {
+      return synthetic503(key, entry.blockedUntil - now);
+    }
+    entry.attempts.push(now);
+    prune(entry.attempts, now, HARD_BURST_WINDOW_MS);
+    if (entry.attempts.length > HARD_BURST_THRESHOLD) {
+      entry.blockedUntil = now + COOLDOWN_MS;
+      if (!entry.warned) {
+        entry.warned = true;
+        console.error(
+          `[fetchBreaker] Burst detected on ${key} (${entry.attempts.length} calls / ${HARD_BURST_WINDOW_MS}ms). Blocking for ${COOLDOWN_MS / 1e3}s. Fix the caller \u2014 this is almost always a missing useEffect dep or a render loop.`
+        );
+      }
+      return synthetic503(key, COOLDOWN_MS);
+    }
+    let response;
+    try {
+      response = await original(input, init);
+    } catch (err) {
+      const ts = Date.now();
+      entry.failures.push(ts);
+      prune(entry.failures, ts, ROLLING_WINDOW_MS);
+      if (entry.failures.length >= FAIL_THRESHOLD) {
+        entry.blockedUntil = ts + COOLDOWN_MS;
+        if (!entry.warned) {
+          entry.warned = true;
+          console.error(
+            `[fetchBreaker] ${entry.failures.length} network errors on ${key} in ${ROLLING_WINDOW_MS / 1e3}s. Blocking for ${COOLDOWN_MS / 1e3}s.`
+          );
+        }
+      }
+      throw err;
+    }
+    if (response.status >= 500 || response.status === 0) {
+      const ts = Date.now();
+      entry.failures.push(ts);
+      prune(entry.failures, ts, ROLLING_WINDOW_MS);
+      if (entry.failures.length >= FAIL_THRESHOLD) {
+        entry.blockedUntil = ts + COOLDOWN_MS;
+        if (!entry.warned) {
+          entry.warned = true;
+          console.error(
+            `[fetchBreaker] ${entry.failures.length} ${response.status}s on ${key} in ${ROLLING_WINDOW_MS / 1e3}s. Blocking for ${COOLDOWN_MS / 1e3}s.`
+          );
+        }
+      }
+    } else if (response.status < 400) {
+      entry.failures.length = 0;
+      entry.warned = false;
+    }
+    return response;
+  });
+};
+
+// api.ts
+installFetchBreaker();
+var DEV_BACKEND = "https://tunnel.schemaless.org";
+var PROD_BACKEND = "https://shuffler.io";
+var CLOUD_DOMAINS = ["security.shuffler.io", "shutdown.no"];
+var getEnvVar = (key) => {
+  try {
+    const meta = new Function("try { return import.meta } catch { return undefined }")();
+    return meta?.env?.[key];
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnvironment = () => {
+  if (getEnvVar("VITE_SHUFFLE_API_URL")) return false;
+  const hostname = typeof window !== "undefined" ? window.location.hostname : "";
+  return hostname.includes("lovableproject.com") || hostname.includes("id-preview--");
+};
+var isCloudDomain = () => {
+  const hostname = typeof window !== "undefined" ? window.location.hostname : "";
+  return CLOUD_DOMAINS.includes(hostname);
+};
+var isCloud = () => isCloudDomain();
+var isOnprem = () => !isDevEnvironment() && !isCloudDomain();
+var getDefaultBaseUrl = () => {
+  const envUrl = getEnvVar("VITE_SHUFFLE_API_URL");
+  if (envUrl) {
+    return envUrl;
+  }
+  if (isDevEnvironment()) return DEV_BACKEND;
+  if (isCloudDomain()) return PROD_BACKEND;
+  if (typeof window !== "undefined") {
+    return window.location.origin;
+  }
+  return PROD_BACKEND;
+};
+var _regionUrl = null;
+var _trackedOrgId = null;
+var _hostBaseUrl = null;
+var isShufflerSubdomain = (url) => {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname.endsWith(".shuffler.io") || parsed.hostname === "shuffler.io";
+  } catch {
+    return false;
+  }
+};
+var setRegionUrl = (regionUrl, orgId) => {
+  if (isDevEnvironment()) {
+    _trackedOrgId = orgId || null;
+    return;
+  }
+  _trackedOrgId = orgId || null;
+  if (regionUrl && isShufflerSubdomain(regionUrl)) {
+    const normalized = regionUrl.replace(/\/+$/, "");
+    if (normalized !== PROD_BACKEND) {
+      _regionUrl = normalized;
+      console.log(`[API] Region URL set to: ${_regionUrl}`);
+      return;
+    }
+  }
+  _regionUrl = null;
+};
+var resetRegionUrl = () => {
+  if (_regionUrl) {
+    console.log(`[API] Region URL reset to default (org changed)`);
+  }
+  _regionUrl = null;
+};
+var setHostBaseUrl = (url) => {
+  const next = url ? url.replace(/\/+$/, "") : null;
+  if (next === _hostBaseUrl) return;
+  _hostBaseUrl = next;
+  if (next) {
+    try {
+      registerProtectedOrigin(next);
+    } catch {
+    }
+  }
+};
+var getHostBaseUrl = () => _hostBaseUrl;
+var getTrackedOrgId = () => _trackedOrgId;
+var API_CONFIG = {
+  // Shuffle backend URL — host override beats region URL beats default.
+  get baseUrl() {
+    const url = _hostBaseUrl || _regionUrl || getDefaultBaseUrl();
+    try {
+      registerProtectedOrigin(url);
+    } catch {
+    }
+    return url;
+  },
+  // API version
+  version: "v1",
+  // Get API key from localStorage (for local development)
+  get apiKey() {
+    return localStorage.getItem("shuffle_api_key");
+  },
+  // Set API key in localStorage
+  setApiKey(key) {
+    if (key) {
+      localStorage.setItem("shuffle_api_key", key);
+    } else {
+      localStorage.removeItem("shuffle_api_key");
+    }
+  }
+};
+var getApiUrl = (endpoint) => {
+  return `${API_CONFIG.baseUrl}${endpoint}`;
+};
+var shuffleFetch = (url, init) => {
+  const { headers: extraHeaders, ...rest } = init || {};
+  return fetch(url, {
+    credentials: "include",
+    ...rest,
+    headers: {
+      ...getAuthHeader(),
+      ...extraHeaders
+    }
+  });
+};
+var getAuthHeader = (overrideOrgId) => {
+  const headers = {};
+  const apiKey = API_CONFIG.apiKey;
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  const orgId = overrideOrgId ?? _trackedOrgId;
+  if (orgId) {
+    headers["Org-Id"] = orgId;
+  }
+  return headers;
+};
+
+// appsCache.ts
+var TTL_MS = 3e4;
+var ERROR_TTL_MS = 3e4;
+var cache = /* @__PURE__ */ new Map();
+var cacheKey = (o) => `${o.baseUrl}|${o.path || "/api/v1/apps"}|${o.apiKey || ""}|${o.orgId || ""}`;
+var doFetch = async (o) => {
+  const headers = {};
+  if (o.apiKey) headers["Authorization"] = `Bearer ${o.apiKey}`;
+  if (o.orgId) headers["Org-Id"] = o.orgId;
+  const response = await fetch(`${o.baseUrl}${o.path || "/api/v1/apps"}`, {
+    credentials: "include",
+    headers
+  });
+  if (!response.ok) return [];
+  const data = await response.json();
+  if (Array.isArray(data)) return data;
+  return Array.isArray(data?.data) ? data.data : [];
+};
+var fetchApps = (opts) => {
+  const key = cacheKey(opts);
+  const entry = cache.get(key) || {};
+  if (entry.data && entry.fetchedAt && Date.now() - entry.fetchedAt < TTL_MS) {
+    return Promise.resolve(entry.data);
+  }
+  if (entry.promise) return entry.promise;
+  const promise = doFetch(opts).then((data) => {
+    cache.set(key, { data, fetchedAt: Date.now() });
+    return data;
+  }).catch(() => {
+    cache.set(key, { data: [], fetchedAt: Date.now() - (TTL_MS - ERROR_TTL_MS) });
+    return [];
+  });
+  cache.set(key, { ...entry, promise });
+  return promise;
+};
+var invalidateAppsCache = (opts) => {
+  if (!opts) {
+    cache.clear();
+    return;
+  }
+  cache.delete(cacheKey(opts));
+};
+var fetchAppsViaApiConfig = () => {
+  const headers = getAuthHeader();
+  const orgId = headers["Org-Id"] || null;
+  return fetchApps({
+    baseUrl: API_CONFIG.baseUrl,
+    apiKey: API_CONFIG.apiKey,
+    orgId
+  });
+};
+
+export {
+  registerProtectedOrigin,
+  installFetchBreaker,
+  isCloudDomain,
+  isCloud,
+  isOnprem,
+  setRegionUrl,
+  resetRegionUrl,
+  setHostBaseUrl,
+  getHostBaseUrl,
+  getTrackedOrgId,
+  API_CONFIG,
+  getApiUrl,
+  shuffleFetch,
+  getAuthHeader,
+  fetchApps,
+  invalidateAppsCache,
+  fetchAppsViaApiConfig
+};