@githat/nextjs 0.2.0

package/dist/index.mjs

@@ -0,0 +1,627 @@
+"use client";
+
+// src/provider.tsx
+import { createContext, useState, useEffect, useCallback, useMemo, useRef } from "react";
+
+// src/config.ts
+var DEFAULT_API_URL = "https://api.githat.io";
+var TOKEN_KEYS = {
+  accessToken: "githat_access_token",
+  refreshToken: "githat_refresh_token",
+  user: "githat_user",
+  org: "githat_org"
+};
+function resolveConfig(config) {
+  return {
+    publishableKey: config.publishableKey,
+    apiUrl: config.apiUrl || DEFAULT_API_URL,
+    signInUrl: config.signInUrl || "/sign-in",
+    signUpUrl: config.signUpUrl || "/sign-up",
+    afterSignInUrl: config.afterSignInUrl || "/dashboard",
+    afterSignOutUrl: config.afterSignOutUrl || "/"
+  };
+}
+
+// src/client.ts
+var _refreshPromise = null;
+async function refreshTokens(apiUrl, appKey) {
+  const refreshToken = typeof window !== "undefined" ? localStorage.getItem(TOKEN_KEYS.refreshToken) : null;
+  if (!refreshToken) return false;
+  let orgId = null;
+  try {
+    const orgStr = localStorage.getItem(TOKEN_KEYS.org);
+    if (orgStr) orgId = JSON.parse(orgStr).id;
+  } catch {
+  }
+  try {
+    const res = await fetch(`${apiUrl}/auth/refresh`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-GitHat-App-Key": appKey
+      },
+      body: JSON.stringify({ refreshToken, orgId })
+    });
+    if (!res.ok) return false;
+    const data = await res.json();
+    if (data.accessToken) localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
+    if (data.refreshToken) localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
+    if (data.org) localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.org));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearAuth() {
+  if (typeof window === "undefined") return;
+  Object.values(TOKEN_KEYS).forEach((key) => localStorage.removeItem(key));
+  window.dispatchEvent(new CustomEvent("githat:auth-changed", {
+    detail: { user: null, org: null, signedIn: false }
+  }));
+}
+function createClient(apiUrl, appKey) {
+  async function fetchApi(endpoint, options = {}) {
+    const url = `${apiUrl}${endpoint}`;
+    const token = typeof window !== "undefined" ? localStorage.getItem(TOKEN_KEYS.accessToken) : null;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-GitHat-App-Key": appKey,
+      ...token && { Authorization: `Bearer ${token}` },
+      ...options.headers
+    };
+    const response = await fetch(url, { ...options, headers });
+    if (response.status === 401) {
+      if (!_refreshPromise) {
+        _refreshPromise = refreshTokens(apiUrl, appKey).finally(() => {
+          _refreshPromise = null;
+        });
+      }
+      const refreshed = await _refreshPromise;
+      if (refreshed) {
+        const newToken = localStorage.getItem(TOKEN_KEYS.accessToken);
+        const retryResponse = await fetch(url, {
+          ...options,
+          headers: {
+            ...headers,
+            ...newToken && { Authorization: `Bearer ${newToken}` }
+          }
+        });
+        const retryData = await retryResponse.json();
+        if (!retryResponse.ok) throw new Error(retryData.error || "Request failed");
+        return retryData;
+      }
+      clearAuth();
+      throw new Error("Session expired");
+    }
+    const data = await response.json();
+    if (!response.ok) throw new Error(data.error || "Request failed");
+    return data;
+  }
+  return { fetchApi, clearAuth };
+}
+
+// src/provider.tsx
+import { jsx } from "react/jsx-runtime";
+var GitHatContext = createContext(null);
+function GitHatProvider({ config: rawConfig, children }) {
+  const config = useMemo(() => resolveConfig(rawConfig), [rawConfig]);
+  const clientRef = useRef(createClient(config.apiUrl, config.publishableKey));
+  const [user, setUser] = useState(null);
+  const [org, setOrg] = useState(null);
+  const [isSignedIn, setIsSignedIn] = useState(false);
+  const [isLoading, setIsLoading] = useState(true);
+  const [authError, setAuthError] = useState(null);
+  useEffect(() => {
+    const token = localStorage.getItem(TOKEN_KEYS.accessToken);
+    const storedUser = localStorage.getItem(TOKEN_KEYS.user);
+    if (token && storedUser) {
+      clientRef.current.fetchApi("/auth/me").then((data) => {
+        const u = data.user || JSON.parse(storedUser);
+        setUser(u);
+        const storedOrg = localStorage.getItem(TOKEN_KEYS.org);
+        setOrg(data.currentOrg || (storedOrg ? JSON.parse(storedOrg) : null));
+        setIsSignedIn(true);
+        setAuthError(null);
+      }).catch((err) => {
+        if (err.message === "Session expired") {
+          clientRef.current.clearAuth();
+        } else {
+          try {
+            setUser(JSON.parse(storedUser));
+          } catch {
+          }
+          setAuthError(err.message || "Failed to verify session");
+        }
+      }).finally(() => setIsLoading(false));
+    } else {
+      setIsLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    const handleAuthChanged = (e) => {
+      const detail = e.detail;
+      if (detail?.signedIn === false) {
+        setIsSignedIn(false);
+        setUser(null);
+        setOrg(null);
+      } else if (detail?.signedIn === true && detail?.user) {
+        setUser(detail.user);
+        setIsSignedIn(true);
+        if (detail.org) setOrg(detail.org);
+      }
+    };
+    window.addEventListener("githat:auth-changed", handleAuthChanged);
+    return () => window.removeEventListener("githat:auth-changed", handleAuthChanged);
+  }, []);
+  const signIn = useCallback(async (email, password) => {
+    const data = await clientRef.current.fetchApi("/auth/login", {
+      method: "POST",
+      body: JSON.stringify({ email, password })
+    });
+    localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
+    localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
+    localStorage.setItem(TOKEN_KEYS.user, JSON.stringify(data.user));
+    if (data.org) localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.org));
+    setUser(data.user);
+    setOrg(data.org || null);
+    setIsSignedIn(true);
+    window.dispatchEvent(new CustomEvent("githat:auth-changed", {
+      detail: { user: data.user, org: data.org, signedIn: true }
+    }));
+  }, []);
+  const signUp = useCallback(async (signUpData) => {
+    const data = await clientRef.current.fetchApi("/auth/register", {
+      method: "POST",
+      body: JSON.stringify(signUpData)
+    });
+    localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
+    localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
+    localStorage.setItem(TOKEN_KEYS.user, JSON.stringify(data.user));
+    if (data.org) localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.org));
+    setUser(data.user);
+    setOrg(data.org || null);
+    setIsSignedIn(true);
+    window.dispatchEvent(new CustomEvent("githat:auth-changed", {
+      detail: { user: data.user, org: data.org, signedIn: true }
+    }));
+    return { requiresVerification: !data.user.emailVerified, email: signUpData.email };
+  }, []);
+  const signOut = useCallback(async () => {
+    try {
+      await clientRef.current.fetchApi("/auth/logout", { method: "POST" });
+    } catch {
+    }
+    clientRef.current.clearAuth();
+    setIsSignedIn(false);
+    setUser(null);
+    setOrg(null);
+    if (typeof window !== "undefined" && config.afterSignOutUrl) {
+      window.location.href = config.afterSignOutUrl;
+    }
+  }, [config.afterSignOutUrl]);
+  const switchOrg = useCallback(async (orgId) => {
+    try {
+      const data = await clientRef.current.fetchApi(`/user/orgs/${orgId}/switch`, { method: "POST" });
+      if (data.accessToken) localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
+      if (data.refreshToken) localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
+      const orgData = data.org;
+      localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(orgData));
+      setOrg(orgData);
+      window.dispatchEvent(new CustomEvent("githat:auth-changed", {
+        detail: { user, org: orgData, signedIn: true }
+      }));
+    } catch (e) {
+      console.error("Org switch failed:", e);
+    }
+  }, [user]);
+  const value = useMemo(() => ({
+    user,
+    org,
+    isSignedIn,
+    isLoading,
+    authError,
+    config,
+    signIn,
+    signUp,
+    signOut,
+    switchOrg
+  }), [user, org, isSignedIn, isLoading, authError, config, signIn, signUp, signOut, switchOrg]);
+  return /* @__PURE__ */ jsx(GitHatContext.Provider, { value, children });
+}
+
+// src/hooks.ts
+import { useContext, useMemo as useMemo2 } from "react";
+function useAuth() {
+  const ctx = useContext(GitHatContext);
+  if (!ctx) throw new Error("useAuth must be used within a <GitHatProvider>");
+  return ctx;
+}
+function useGitHat() {
+  const ctx = useAuth();
+  const client = useMemo2(
+    () => createClient(ctx.config.apiUrl, ctx.config.publishableKey),
+    [ctx.config.apiUrl, ctx.config.publishableKey]
+  );
+  return {
+    fetch: client.fetchApi,
+    getUserOrgs: () => client.fetchApi("/user/orgs"),
+    verifyMCP: (domain) => client.fetchApi(`/verify/mcp/${domain}`),
+    verifyAgent: (wallet) => client.fetchApi(`/verify/agent/${wallet}`)
+  };
+}
+
+// src/components/SignInForm.tsx
+import { useState as useState2 } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function SignInForm({ onSuccess, signUpUrl, forgotPasswordUrl }) {
+  const { signIn, config } = useAuth();
+  const [email, setEmail] = useState2("");
+  const [password, setPassword] = useState2("");
+  const [error, setError] = useState2("");
+  const [loading, setLoading] = useState2(false);
+  const emailValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!emailValid) {
+      setError("Please enter a valid email address");
+      return;
+    }
+    setError("");
+    setLoading(true);
+    try {
+      await signIn(email, password);
+      if (onSuccess) {
+        onSuccess();
+      } else if (typeof window !== "undefined") {
+        const params = new URLSearchParams(window.location.search);
+        window.location.href = params.get("redirect_url") || config.afterSignInUrl;
+      }
+    } catch (err) {
+      setError(err.message || "Sign in failed");
+    } finally {
+      setLoading(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "githat-form-container", children: [
+    /* @__PURE__ */ jsxs("div", { className: "githat-form-header", children: [
+      /* @__PURE__ */ jsx2("h2", { className: "githat-form-title", children: "Sign in" }),
+      /* @__PURE__ */ jsx2("p", { className: "githat-form-subtitle", children: "Welcome back to GitHat" })
+    ] }),
+    error && /* @__PURE__ */ jsx2("div", { className: "githat-alert githat-alert-error", role: "alert", "aria-live": "polite", children: error }),
+    /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, className: "githat-form", "aria-label": "Sign in form", children: [
+      /* @__PURE__ */ jsxs("div", { className: "githat-field", children: [
+        /* @__PURE__ */ jsx2("label", { className: "githat-label", htmlFor: "githat-signin-email", children: "Email" }),
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            id: "githat-signin-email",
+            className: "githat-input",
+            type: "email",
+            value: email,
+            onChange: (e) => setEmail(e.target.value),
+            placeholder: "you@example.com",
+            autoComplete: "email",
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "githat-field", children: [
+        /* @__PURE__ */ jsx2("label", { className: "githat-label", htmlFor: "githat-signin-password", children: "Password" }),
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            id: "githat-signin-password",
+            className: "githat-input",
+            type: "password",
+            value: password,
+            onChange: (e) => setPassword(e.target.value),
+            placeholder: "Enter your password",
+            autoComplete: "current-password",
+            required: true
+          }
+        )
+      ] }),
+      forgotPasswordUrl && /* @__PURE__ */ jsx2("a", { href: forgotPasswordUrl, className: "githat-link githat-forgot-link", children: "Forgot password?" }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "submit",
+          className: "githat-button githat-button-primary",
+          disabled: loading || !email || !password || email.length > 0 && !emailValid,
+          children: loading ? "Signing in..." : "Sign in"
+        }
+      )
+    ] }),
+    signUpUrl && /* @__PURE__ */ jsxs("p", { className: "githat-form-footer", children: [
+      "Don't have an account? ",
+      /* @__PURE__ */ jsx2("a", { href: signUpUrl, className: "githat-link", children: "Sign up" })
+    ] }),
+    /* @__PURE__ */ jsxs("p", { className: "githat-powered-by", children: [
+      "Secured by ",
+      /* @__PURE__ */ jsx2("strong", { children: "GitHat" })
+    ] })
+  ] });
+}
+
+// src/components/SignUpForm.tsx
+import { useState as useState3 } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function SignUpForm({ onSuccess, signInUrl }) {
+  const { signUp, config } = useAuth();
+  const [name, setName] = useState3("");
+  const [email, setEmail] = useState3("");
+  const [password, setPassword] = useState3("");
+  const [error, setError] = useState3("");
+  const [loading, setLoading] = useState3(false);
+  const emailValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+  const passwordValid = password.length >= 8 && /[A-Z]/.test(password) && /[a-z]/.test(password) && /\d/.test(password);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!emailValid) {
+      setError("Please enter a valid email address");
+      return;
+    }
+    if (!passwordValid) {
+      setError("Password must be 8+ characters with uppercase, lowercase, number, and special character");
+      return;
+    }
+    setError("");
+    setLoading(true);
+    try {
+      const result = await signUp({ email, password, name });
+      if (onSuccess) {
+        onSuccess(result);
+      } else if (typeof window !== "undefined") {
+        window.location.href = config.afterSignInUrl;
+      }
+    } catch (err) {
+      setError(err.message || "Sign up failed");
+    } finally {
+      setLoading(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: "githat-form-container", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "githat-form-header", children: [
+      /* @__PURE__ */ jsx3("h2", { className: "githat-form-title", children: "Create an account" }),
+      /* @__PURE__ */ jsx3("p", { className: "githat-form-subtitle", children: "Get started with GitHat" })
+    ] }),
+    error && /* @__PURE__ */ jsx3("div", { className: "githat-alert githat-alert-error", role: "alert", "aria-live": "polite", children: error }),
+    /* @__PURE__ */ jsxs2("form", { onSubmit: handleSubmit, className: "githat-form", "aria-label": "Sign up form", children: [
+      /* @__PURE__ */ jsxs2("div", { className: "githat-field", children: [
+        /* @__PURE__ */ jsx3("label", { className: "githat-label", htmlFor: "githat-signup-name", children: "Full name" }),
+        /* @__PURE__ */ jsx3(
+          "input",
+          {
+            id: "githat-signup-name",
+            className: "githat-input",
+            type: "text",
+            value: name,
+            onChange: (e) => setName(e.target.value),
+            placeholder: "Your name",
+            autoComplete: "name",
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs2("div", { className: "githat-field", children: [
+        /* @__PURE__ */ jsx3("label", { className: "githat-label", htmlFor: "githat-signup-email", children: "Email" }),
+        /* @__PURE__ */ jsx3(
+          "input",
+          {
+            id: "githat-signup-email",
+            className: "githat-input",
+            type: "email",
+            value: email,
+            onChange: (e) => setEmail(e.target.value),
+            placeholder: "you@example.com",
+            autoComplete: "email",
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs2("div", { className: "githat-field", children: [
+        /* @__PURE__ */ jsx3("label", { className: "githat-label", htmlFor: "githat-signup-password", children: "Password" }),
+        /* @__PURE__ */ jsx3(
+          "input",
+          {
+            id: "githat-signup-password",
+            className: "githat-input",
+            type: "password",
+            value: password,
+            onChange: (e) => setPassword(e.target.value),
+            placeholder: "8+ characters",
+            autoComplete: "new-password",
+            required: true
+          }
+        ),
+        password && !passwordValid && /* @__PURE__ */ jsx3("p", { className: "githat-field-error", children: "Must be 8+ characters with uppercase, lowercase, and number" })
+      ] }),
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "submit",
+          className: "githat-button githat-button-primary",
+          disabled: loading || !email || !password || !name || !emailValid,
+          children: loading ? "Creating account..." : "Sign up"
+        }
+      )
+    ] }),
+    signInUrl && /* @__PURE__ */ jsxs2("p", { className: "githat-form-footer", children: [
+      "Already have an account? ",
+      /* @__PURE__ */ jsx3("a", { href: signInUrl, className: "githat-link", children: "Sign in" })
+    ] }),
+    /* @__PURE__ */ jsxs2("p", { className: "githat-powered-by", children: [
+      "Secured by ",
+      /* @__PURE__ */ jsx3("strong", { children: "GitHat" })
+    ] })
+  ] });
+}
+
+// src/components/SignInButton.tsx
+import { useContext as useContext2 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function SignInButton({ className, children, href }) {
+  const ctx = useContext2(GitHatContext);
+  const url = href || ctx?.config.signInUrl || "/sign-in";
+  return /* @__PURE__ */ jsx4("a", { href: url, className: className || "githat-button githat-button-primary", "aria-label": "Sign in", children: children || "Sign in" });
+}
+
+// src/components/SignUpButton.tsx
+import { useContext as useContext3 } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function SignUpButton({ className, children, href }) {
+  const ctx = useContext3(GitHatContext);
+  const url = href || ctx?.config.signUpUrl || "/sign-up";
+  return /* @__PURE__ */ jsx5("a", { href: url, className: className || "githat-button githat-button-outline", "aria-label": "Sign up", children: children || "Sign up" });
+}
+
+// src/components/UserButton.tsx
+import { useState as useState4, useRef as useRef2, useEffect as useEffect2 } from "react";
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function UserButton() {
+  const { user, org, isSignedIn, signOut } = useAuth();
+  const [open, setOpen] = useState4(false);
+  const ref = useRef2(null);
+  useEffect2(() => {
+    const handleClickOutside = (e) => {
+      if (ref.current && !ref.current.contains(e.target)) setOpen(false);
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, []);
+  if (!isSignedIn || !user) return null;
+  const initials = user.name ? user.name.split(" ").map((n) => n[0]).join("").toUpperCase().slice(0, 2) : user.email[0].toUpperCase();
+  return /* @__PURE__ */ jsxs3("div", { className: "githat-user-button", ref, children: [
+    /* @__PURE__ */ jsx6("button", { className: "githat-avatar-trigger", onClick: () => setOpen(!open), "aria-label": "User menu", "aria-expanded": open, "aria-haspopup": "true", children: user.avatarUrl ? /* @__PURE__ */ jsx6("img", { src: user.avatarUrl, alt: user.name || "User avatar", className: "githat-avatar-img" }) : /* @__PURE__ */ jsx6("span", { className: "githat-avatar-initials", children: initials }) }),
+    open && /* @__PURE__ */ jsxs3("div", { className: "githat-dropdown", role: "menu", children: [
+      /* @__PURE__ */ jsxs3("div", { className: "githat-dropdown-header", children: [
+        /* @__PURE__ */ jsx6("p", { className: "githat-dropdown-name", children: user.name }),
+        /* @__PURE__ */ jsx6("p", { className: "githat-dropdown-email", children: user.email }),
+        org && /* @__PURE__ */ jsx6("p", { className: "githat-dropdown-org", children: org.name })
+      ] }),
+      /* @__PURE__ */ jsx6("div", { className: "githat-dropdown-divider" }),
+      /* @__PURE__ */ jsx6("button", { className: "githat-dropdown-item", role: "menuitem", onClick: () => {
+        signOut();
+        setOpen(false);
+      }, children: "Sign out" })
+    ] })
+  ] });
+}
+
+// src/components/OrgSwitcher.tsx
+import { useState as useState5, useEffect as useEffect3, useRef as useRef3 } from "react";
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+function OrgSwitcher() {
+  const { org, isSignedIn, switchOrg } = useAuth();
+  const githat = useGitHat();
+  const [orgs, setOrgs] = useState5([]);
+  const [orgsLoading, setOrgsLoading] = useState5(false);
+  const [open, setOpen] = useState5(false);
+  const ref = useRef3(null);
+  useEffect3(() => {
+    if (isSignedIn) {
+      setOrgsLoading(true);
+      githat.getUserOrgs().then((data) => setOrgs(data.orgs || [])).catch(() => {
+      }).finally(() => setOrgsLoading(false));
+    }
+  }, [isSignedIn]);
+  useEffect3(() => {
+    const handleClickOutside = (e) => {
+      if (ref.current && !ref.current.contains(e.target)) setOpen(false);
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, []);
+  if (!isSignedIn || !org || orgs.length < 2 && !orgsLoading) return null;
+  return /* @__PURE__ */ jsxs4("div", { className: "githat-org-switcher", ref, children: [
+    /* @__PURE__ */ jsxs4("button", { className: "githat-org-trigger", onClick: () => setOpen(!open), "aria-label": "Switch organization", "aria-expanded": open, "aria-haspopup": "true", children: [
+      /* @__PURE__ */ jsx7("span", { className: "githat-org-name", children: org.name }),
+      /* @__PURE__ */ jsx7("span", { className: "githat-chevron", children: open ? "\u25B2" : "\u25BC" })
+    ] }),
+    open && /* @__PURE__ */ jsx7("div", { className: "githat-dropdown", role: "menu", children: orgsLoading ? /* @__PURE__ */ jsx7("div", { className: "githat-dropdown-item", "aria-busy": "true", children: "Loading..." }) : orgs.map((o) => /* @__PURE__ */ jsxs4(
+      "button",
+      {
+        className: `githat-dropdown-item ${o.id === org.id ? "githat-dropdown-item-active" : ""}`,
+        role: "menuitem",
+        "aria-current": o.id === org.id ? "true" : void 0,
+        onClick: () => {
+          switchOrg(o.id);
+          setOpen(false);
+        },
+        children: [
+          o.name,
+          o.id === org.id && /* @__PURE__ */ jsx7("span", { className: "githat-check", children: "\u2713" })
+        ]
+      },
+      o.id
+    )) })
+  ] });
+}
+
+// src/components/VerifiedBadge.tsx
+import { useState as useState6, useEffect as useEffect4, useRef as useRef4 } from "react";
+import { jsxs as jsxs5 } from "react/jsx-runtime";
+var CACHE_TTL = 5 * 60 * 1e3;
+var cache = /* @__PURE__ */ new Map();
+function VerifiedBadge({ type, identifier, label }) {
+  const githat = useGitHat();
+  const [verified, setVerified] = useState6(null);
+  const mounted = useRef4(true);
+  useEffect4(() => {
+    mounted.current = true;
+    const key = `${type}:${identifier}`;
+    const cached = cache.get(key);
+    if (cached && Date.now() - cached.ts < CACHE_TTL) {
+      setVerified(cached.verified);
+      return;
+    }
+    const verify = type === "mcp" ? githat.verifyMCP : githat.verifyAgent;
+    verify(identifier).then((data) => {
+      if (mounted.current) {
+        setVerified(data.verified);
+        cache.set(key, { verified: data.verified, ts: Date.now() });
+      }
+    }).catch(() => {
+      if (mounted.current) setVerified(false);
+    });
+    return () => {
+      mounted.current = false;
+    };
+  }, [type, identifier]);
+  if (verified === null) return null;
+  return /* @__PURE__ */ jsxs5("span", { className: `githat-badge ${verified ? "githat-badge-verified" : "githat-badge-unverified"}`, children: [
+    verified ? "\u2713" : "\u2717",
+    " ",
+    label || (verified ? "Verified" : "Unverified")
+  ] });
+}
+
+// src/components/ProtectedRoute.tsx
+import { Fragment, jsx as jsx8 } from "react/jsx-runtime";
+function ProtectedRoute({ children, fallback }) {
+  const { isSignedIn, isLoading, config } = useAuth();
+  if (isLoading) {
+    return /* @__PURE__ */ jsx8(Fragment, { children: fallback || /* @__PURE__ */ jsx8("div", { className: "githat-loading", children: "Loading..." }) });
+  }
+  if (!isSignedIn) {
+    if (typeof window !== "undefined") {
+      window.location.href = config.signInUrl;
+    }
+    return null;
+  }
+  return /* @__PURE__ */ jsx8(Fragment, { children });
+}
+export {
+  GitHatProvider,
+  OrgSwitcher,
+  ProtectedRoute,
+  SignInButton,
+  SignInForm,
+  SignUpButton,
+  SignUpForm,
+  UserButton,
+  VerifiedBadge,
+  useAuth,
+  useGitHat
+};
+//# sourceMappingURL=index.mjs.map