@burtson-labs/bandit-engine 2.0.99 → 2.0.101

package/dist/{chunk-H3BYFEIE.mjs → chunk-43MLINPL.mjs}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-KCI46M23.mjs";
 
 // src/store/aiProviderStore.ts
-import { create } from "zustand";
+import { create as create2 } from "zustand";
 
 // src/services/ai-provider/providers/ollama.provider.ts
 import { map as map2 } from "rxjs";
@@ -1020,6 +1020,131 @@ import { map as map12 } from "rxjs";
 // src/services/gateway/gateway.service.ts
 import axios, { AxiosHeaders } from "axios";
 import { catchError as catchError2, from as from5, lastValueFrom as lastValueFrom2, map as map6, Observable as Observable6, of as of2, shareReplay as shareReplay2, timeout as timeout2 } from "rxjs";
+
+// src/store/authenticationStore.ts
+import { create } from "zustand";
+var TOKEN_KEY = "authToken";
+var validToken = null;
+var user = null;
+var rawToken = localStorage.getItem(TOKEN_KEY);
+if (rawToken) {
+  try {
+    const base64Url = rawToken.split(".")[1];
+    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonPayload = decodeURIComponent(
+      atob(base64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
+    );
+    const decoded = JSON.parse(jsonPayload);
+    if (decoded.exp * 1e3 > Date.now()) {
+      validToken = rawToken;
+      user = decoded;
+    }
+  } catch {
+    validToken = null;
+    user = null;
+  }
+}
+var useAuthenticationStore = create((set) => ({
+  token: validToken,
+  user,
+  authError: null,
+  setToken: (token) => {
+    if (token) {
+      try {
+        const base64Url = token.split(".")[1];
+        const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+        const jsonPayload = decodeURIComponent(
+          atob(base64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
+        );
+        const user2 = JSON.parse(jsonPayload);
+        localStorage.setItem(TOKEN_KEY, token);
+        set({ token, authError: null, user: user2 });
+      } catch {
+        set({ token: null, authError: "Invalid token", user: null });
+      }
+    } else {
+      set({ token: null, authError: null, user: null });
+    }
+  },
+  clearToken: () => {
+    localStorage.removeItem(TOKEN_KEY);
+    set({ token: null, authError: null, user: null });
+  }
+}));
+var readPersistedToken = () => {
+  try {
+    const raw = localStorage.getItem(TOKEN_KEY);
+    if (!raw) return null;
+    const base64 = raw.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
+    const json = decodeURIComponent(
+      atob(base64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
+    );
+    const decoded = JSON.parse(json);
+    return decoded.exp * 1e3 > Date.now() ? raw : null;
+  } catch {
+    return null;
+  }
+};
+
+// src/services/auth/authenticationService.ts
+var TOKEN_KEY2 = "authToken";
+var AUTH_TOKEN_CHANGED_EVENT = "bandit:auth-token-changed";
+function emitAuthTokenChanged(token) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.dispatchEvent(new CustomEvent(AUTH_TOKEN_CHANGED_EVENT, {
+    detail: { token }
+  }));
+}
+var AuthenticationService = class {
+  getToken() {
+    const token = localStorage.getItem(TOKEN_KEY2);
+    return token;
+  }
+  setToken(token) {
+    localStorage.setItem(TOKEN_KEY2, token);
+    useAuthenticationStore.getState().setToken(token);
+    emitAuthTokenChanged(token);
+  }
+  clearToken() {
+    localStorage.removeItem(TOKEN_KEY2);
+    useAuthenticationStore.getState().clearToken();
+    emitAuthTokenChanged(null);
+  }
+  isAuthenticated() {
+    const token = useAuthenticationStore.getState().token;
+    return !!token && !this.isTokenExpired(token);
+  }
+  isTokenExpired(token) {
+    try {
+      if (!token) return true;
+      const decoded = this.parseJwtClaims(token);
+      if (!decoded) return true;
+      return decoded.exp * 1e3 < Date.now();
+    } catch {
+      return true;
+    }
+  }
+  parseJwtClaims(token) {
+    try {
+      const base64Url = token.split(".")[1];
+      const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+      const jsonPayload = decodeURIComponent(
+        atob(base64).split("").map((c) => {
+          return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
+        }).join("")
+      );
+      return JSON.parse(jsonPayload);
+    } catch (error) {
+      debugLogger.error("Failed to parse JWT claims:", { error });
+      return null;
+    }
+  }
+};
+var authenticationService = new AuthenticationService();
+
+// src/services/gateway/gateway.service.ts
 var GatewayService = class {
   constructor(_baseUrl, _tokenFactory, _feedbackEmail) {
     this._baseUrl = _baseUrl;
@@ -1060,7 +1185,10 @@ var GatewayService = class {
     });
     instance.interceptors.response.use(
       (response) => response,
-      (error) => Promise.reject(this._normalizeAxiosError(error))
+      (error) => {
+        this._handleAuthFailure(error);
+        return Promise.reject(this._normalizeAxiosError(error));
+      }
     );
     return instance;
   }
@@ -1081,6 +1209,24 @@ var GatewayService = class {
     }
     return new Error(error.message);
   }
+  _handleAuthFailure(error) {
+    const status = error.response?.status;
+    if (status !== 401 && status !== 403) {
+      return;
+    }
+    const data = error.response?.data;
+    const code = data?.code;
+    if (code !== "FORCE_RELOGIN" && code !== "ACCOUNT_LOCKED") {
+      return;
+    }
+    try {
+      authenticationService.clearToken();
+    } catch {
+    }
+    if (typeof window !== "undefined" && typeof window.dispatchEvent === "function") {
+      window.dispatchEvent(new CustomEvent("auth:force-relogin", { detail: { code } }));
+    }
+  }
   _createHttpError(message, response) {
     return Object.assign(new Error(message), { response });
   }
@@ -1448,15 +1594,15 @@ var GatewayService = class {
     );
   }
   _getHeaders() {
-    const rawToken = this._tokenFactory();
+    const rawToken2 = this._tokenFactory();
     const headers = {
       "Content-Type": "application/json"
     };
-    if (!rawToken) {
+    if (!rawToken2) {
       debugLogger.warn("GatewayService: No token found, skipping Authorization header");
       return headers;
     }
-    const token = rawToken.trim();
+    const token = rawToken2.trim();
     if (token === "") {
       debugLogger.warn("GatewayService: Token factory returned empty string");
       return headers;
@@ -2928,7 +3074,7 @@ var AIProviderFactory = class {
 };
 
 // src/store/aiProviderStore.ts
-var useAIProviderStore = create((set, get) => ({
+var useAIProviderStore = create2((set, get) => ({
   provider: null,
   config: null,
   setProvider: (provider, config) => set({ provider, config }),
@@ -2954,8 +3100,12 @@ var useAIProviderStore = create((set, get) => ({
 }));
 
 export {
+  useAuthenticationStore,
+  readPersistedToken,
+  AUTH_TOKEN_CHANGED_EVENT,
+  authenticationService,
   GatewayService,
   AIProviderFactory,
   useAIProviderStore
 };
-//# sourceMappingURL=chunk-H3BYFEIE.mjs.map
+//# sourceMappingURL=chunk-43MLINPL.mjs.map