@bodhiapp/bodhi-js 0.0.1 → 0.0.3

package/dist/bodhi-web.esm.js

@@ -1,57 +1,37 @@
-import { DirectClientBase, STORAGE_PREFIXES, generateCodeVerifier, generateCodeChallenge, isApiResultOperationError, isApiResultSuccess, createStorageKeys, EXTENSION_STATE_NOT_INITIALIZED, Logger, createOAuthEndpoints, NOOP_STATE_CALLBACK, EXTENSION_STATE_NOT_FOUND, PENDING_EXTENSION_READY, BACKEND_SERVER_NOT_REACHABLE, extractUserInfo, refreshAccessToken, createOperationError, backendServerNotReady, SERVER_ERROR_CODES, createApiError, BaseFacadeClient } from "@bodhiapp/bodhi-js-core";
-class DirectWebClient extends DirectClientBase {
-  constructor(config, onStateChange) {
-    super({ ...config, storagePrefix: STORAGE_PREFIXES.DIRECT }, "DirectWebClient", onStateChange);
-    this.redirectUri = config.redirectUri;
+import { DirectClientBase as C, STORAGE_PREFIXES as f, generateCodeVerifier as g, generateCodeChallenge as y, isApiResultOperationError as T, isApiResultSuccess as E, createStorageKeys as x, EXTENSION_STATE_NOT_INITIALIZED as _, Logger as R, createOAuthEndpoints as A, NOOP_STATE_CALLBACK as k, EXTENSION_STATE_NOT_FOUND as v, PENDING_EXTENSION_READY as O, BACKEND_SERVER_NOT_REACHABLE as d, extractUserInfo as I, refreshAccessToken as b, createOperationError as u, backendServerNotReady as S, SERVER_ERROR_CODES as P, createApiError as U, BaseFacadeClient as N } from "@bodhiapp/bodhi-js-core";
+class L extends C {
+  constructor(e, t) {
+    super({ ...e, storagePrefix: f.DIRECT }, "DirectWebClient", t), this.redirectUri = e.redirectUri;
   }
   // ============================================================================
   // Authentication (Browser Redirect OAuth)
   // ============================================================================
   async login() {
-    const existingAuth = await this.getAuthState();
-    if (existingAuth.isLoggedIn) {
-      return existingAuth;
-    }
-    const resourceScope = await this.requestResourceAccess();
-    const fullScope = `openid profile email roles ${this.userScope} ${resourceScope}`;
-    const codeVerifier = generateCodeVerifier();
-    const codeChallenge = await generateCodeChallenge(codeVerifier);
-    const state = generateCodeVerifier();
-    localStorage.setItem(this.storageKeys.CODE_VERIFIER, codeVerifier);
-    localStorage.setItem(this.storageKeys.STATE, state);
-    const authUrl = new URL(this.authEndpoints.authorize);
-    authUrl.searchParams.set("client_id", this.authClientId);
-    authUrl.searchParams.set("response_type", "code");
-    authUrl.searchParams.set("redirect_uri", this.redirectUri);
-    authUrl.searchParams.set("scope", fullScope);
-    authUrl.searchParams.set("code_challenge", codeChallenge);
-    authUrl.searchParams.set("code_challenge_method", "S256");
-    authUrl.searchParams.set("state", state);
-    window.location.href = authUrl.toString();
-    throw new Error("Redirect initiated");
-  }
-  async handleOAuthCallback(code, state) {
-    const storedState = localStorage.getItem(this.storageKeys.STATE);
-    if (!storedState || storedState !== state) {
+    const e = await this.getAuthState();
+    if (e.isLoggedIn)
+      return e;
+    const t = await this.requestResourceAccess(), r = `openid profile email roles ${this.userScope} ${t}`, s = g(), i = await y(s), o = g();
+    localStorage.setItem(this.storageKeys.CODE_VERIFIER, s), localStorage.setItem(this.storageKeys.STATE, o);
+    const a = new URL(this.authEndpoints.authorize);
+    throw a.searchParams.set("client_id", this.authClientId), a.searchParams.set("response_type", "code"), a.searchParams.set("redirect_uri", this.redirectUri), a.searchParams.set("scope", r), a.searchParams.set("code_challenge", i), a.searchParams.set("code_challenge_method", "S256"), a.searchParams.set("state", o), window.location.href = a.toString(), new Error("Redirect initiated");
+  }
+  async handleOAuthCallback(e, t) {
+    const r = localStorage.getItem(this.storageKeys.STATE);
+    if (!r || r !== t)
       throw new Error("Invalid state parameter - possible CSRF attack");
-    }
-    await this.exchangeCodeForTokens(code);
-    localStorage.removeItem(this.storageKeys.CODE_VERIFIER);
-    localStorage.removeItem(this.storageKeys.STATE);
-    const authState = await this.getAuthState();
-    if (!authState.isLoggedIn) {
+    await this.exchangeCodeForTokens(e), localStorage.removeItem(this.storageKeys.CODE_VERIFIER), localStorage.removeItem(this.storageKeys.STATE);
+    const s = await this.getAuthState();
+    if (!s.isLoggedIn)
       throw new Error("Login failed");
-    }
-    const result = authState;
-    this.setAuthState(result);
-    return result;
+    const i = s;
+    return this.setAuthState(i), i;
   }
   async logout() {
-    const refreshToken = localStorage.getItem(this.storageKeys.REFRESH_TOKEN);
-    if (refreshToken) {
+    const e = localStorage.getItem(this.storageKeys.REFRESH_TOKEN);
+    if (e)
       try {
-        const params = new URLSearchParams({
-          token: refreshToken,
+        const r = new URLSearchParams({
+          token: e,
           client_id: this.authClientId,
           token_type_hint: "refresh_token"
         });
@@ -60,126 +40,102 @@ class DirectWebClient extends DirectClientBase {
           headers: {
             "Content-Type": "application/x-www-form-urlencoded"
           },
-          body: params
+          body: r
         });
-      } catch (error) {
-        this.logger.warn("Token revocation failed:", error);
+      } catch (r) {
+        this.logger.warn("Token revocation failed:", r);
       }
-    }
-    localStorage.removeItem(this.storageKeys.ACCESS_TOKEN);
-    localStorage.removeItem(this.storageKeys.REFRESH_TOKEN);
-    localStorage.removeItem(this.storageKeys.EXPIRES_AT);
-    localStorage.removeItem(this.storageKeys.RESOURCE_SCOPE);
-    const result = {
-      isLoggedIn: false
+    localStorage.removeItem(this.storageKeys.ACCESS_TOKEN), localStorage.removeItem(this.storageKeys.REFRESH_TOKEN), localStorage.removeItem(this.storageKeys.EXPIRES_AT), localStorage.removeItem(this.storageKeys.RESOURCE_SCOPE);
+    const t = {
+      isLoggedIn: !1
     };
-    this.setAuthState(result);
-    return result;
+    return this.setAuthState(t), t;
   }
   // ============================================================================
   // OAuth Helper Methods
   // ============================================================================
   async requestResourceAccess() {
-    const response = await this.sendApiRequest(
+    const e = await this.sendApiRequest(
       "POST",
       "/bodhi/v1/apps/request-access",
       { app_client_id: this.authClientId },
       {},
-      false
+      !1
     );
-    if (isApiResultOperationError(response)) {
+    if (T(e))
       throw new Error("Failed to get resource access scope from server");
-    }
-    if (!isApiResultSuccess(response)) {
+    if (!E(e))
       throw new Error("Failed to get resource access scope from server: API error");
-    }
-    const scope = response.body.scope;
-    localStorage.setItem(this.storageKeys.RESOURCE_SCOPE, scope);
-    return scope;
+    const t = e.body.scope;
+    return localStorage.setItem(this.storageKeys.RESOURCE_SCOPE, t), t;
   }
-  async exchangeCodeForTokens(code) {
-    const codeVerifier = localStorage.getItem(this.storageKeys.CODE_VERIFIER);
-    if (!codeVerifier) {
+  async exchangeCodeForTokens(e) {
+    const t = localStorage.getItem(this.storageKeys.CODE_VERIFIER);
+    if (!t)
       throw new Error("Code verifier not found");
-    }
-    const response = await fetch(this.authEndpoints.token, {
+    const r = await fetch(this.authEndpoints.token, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
       body: new URLSearchParams({
         grant_type: "authorization_code",
-        code,
+        code: e,
         redirect_uri: this.redirectUri,
         client_id: this.authClientId,
-        code_verifier: codeVerifier
+        code_verifier: t
       })
     });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Token exchange failed: ${response.status} ${errorText}`);
-    }
-    const tokens = await response.json();
-    localStorage.setItem(this.storageKeys.ACCESS_TOKEN, tokens.access_token);
-    if (tokens.refresh_token) {
-      localStorage.setItem(this.storageKeys.REFRESH_TOKEN, tokens.refresh_token);
+    if (!r.ok) {
+      const i = await r.text();
+      throw new Error(`Token exchange failed: ${r.status} ${i}`);
     }
-    if (tokens.expires_in) {
-      const expiresAt = Date.now() + tokens.expires_in * 1e3;
-      localStorage.setItem(this.storageKeys.EXPIRES_AT, expiresAt.toString());
+    const s = await r.json();
+    if (localStorage.setItem(this.storageKeys.ACCESS_TOKEN, s.access_token), s.refresh_token && localStorage.setItem(this.storageKeys.REFRESH_TOKEN, s.refresh_token), s.expires_in) {
+      const i = Date.now() + s.expires_in * 1e3;
+      localStorage.setItem(this.storageKeys.EXPIRES_AT, i.toString());
     }
   }
   // ============================================================================
   // Storage Implementation (localStorage)
   // ============================================================================
-  async _storageGet(key) {
-    return localStorage.getItem(key);
+  async _storageGet(e) {
+    return localStorage.getItem(e);
   }
-  async _storageSet(items) {
-    Object.entries(items).forEach(([key, value]) => {
-      localStorage.setItem(key, String(value));
+  async _storageSet(e) {
+    Object.entries(e).forEach(([t, r]) => {
+      localStorage.setItem(t, String(r));
     });
   }
-  async _storageRemove(keys) {
-    keys.forEach((key) => localStorage.removeItem(key));
+  async _storageRemove(e) {
+    e.forEach((t) => localStorage.removeItem(t));
   }
   _getRedirectUri() {
     return this.redirectUri;
   }
 }
-const POLL_INTERVAL = 500;
-const POLL_TIMEOUT = 5e3;
-const STORAGE_KEYS = createStorageKeys(STORAGE_PREFIXES.WEB);
-class WindowBodhiextClient {
-  constructor(authClientId, config, onStateChange) {
-    this.state = EXTENSION_STATE_NOT_INITIALIZED;
-    this.bodhiext = null;
-    this.refreshPromise = null;
-    this.logger = new Logger("WindowBodhiextClient", config.logLevel);
-    this.authClientId = authClientId;
-    this.config = config;
-    this.authEndpoints = createOAuthEndpoints(this.config.authServerUrl);
-    this.onStateChange = onStateChange ?? NOOP_STATE_CALLBACK;
+const K = 500, F = 5e3, n = x(f.WEB);
+class D {
+  constructor(e, t, r) {
+    this.state = _, this.bodhiext = null, this.refreshPromise = null, this.logger = new R("WindowBodhiextClient", t.logLevel), this.authClientId = e, this.config = t, this.authEndpoints = A(this.config.authServerUrl), this.onStateChange = r ?? k;
   }
   /**
    * Set client state and notify callback
    */
-  setState(newState) {
-    this.state = newState;
-    this.logger.info(`{state: ${JSON.stringify(newState)}} - Setting client state`);
-    this.onStateChange({ type: "client-state", state: newState });
+  setState(e) {
+    this.state = e, this.logger.info(`{state: ${JSON.stringify(e)}} - Setting client state`), this.onStateChange({ type: "client-state", state: e });
   }
   /**
    * Set auth state and notify callback
    */
-  setAuthState(authState) {
-    this.onStateChange({ type: "auth-state", state: authState });
+  setAuthState(e) {
+    this.onStateChange({ type: "auth-state", state: e });
   }
   /**
    * Set or update the state change callback
    */
-  setStateCallback(callback) {
-    this.onStateChange = callback;
+  setStateCallback(e) {
+    this.onStateChange = e;
   }
   // ============================================================================
   // Extension Communication
@@ -189,68 +145,58 @@ class WindowBodhiextClient {
    * @throws Error if client not initialized
    */
   ensureBodhiext() {
-    if (!this.bodhiext && window.bodhiext) {
-      this.logger.info("Acquiring window.bodhiext reference");
-      this.bodhiext = window.bodhiext;
-    }
-    if (!this.bodhiext) {
+    if (!this.bodhiext && window.bodhiext && (this.logger.info("Acquiring window.bodhiext reference"), this.bodhiext = window.bodhiext), !this.bodhiext)
       throw new Error("Client not initialized");
-    }
   }
   /**
    * Send extension request via window.bodhiext.sendExtRequest
    */
-  async sendExtRequest(action, params) {
-    this.ensureBodhiext();
-    return this.bodhiext.sendExtRequest(action, params);
+  async sendExtRequest(e, t) {
+    return this.ensureBodhiext(), this.bodhiext.sendExtRequest(e, t);
   }
   /**
    * Send API message via window.bodhiext.sendApiRequest
    * Converts ApiResponse to ApiResponseResult
    */
-  async sendApiRequest(method, endpoint, body, headers, authenticated) {
+  async sendApiRequest(e, t, r, s, i) {
     try {
       this.ensureBodhiext();
-    } catch (err) {
+    } catch (o) {
       return {
         error: {
-          message: err instanceof Error ? err.message : String(err),
+          message: o instanceof Error ? o.message : String(o),
           type: "extension_error"
         }
       };
     }
     try {
-      let requestHeaders = headers || {};
-      if (authenticated) {
-        const accessToken = await this._getAccessTokenRaw();
-        if (!accessToken) {
+      let o = s || {};
+      if (i) {
+        const h = await this._getAccessTokenRaw();
+        if (!h)
           return {
             error: {
               message: "Not authenticated. Please log in first.",
               type: "extension_error"
             }
           };
-        }
-        requestHeaders = {
-          ...requestHeaders,
-          Authorization: `Bearer ${accessToken}`
+        o = {
+          ...o,
+          Authorization: `Bearer ${h}`
         };
       }
-      const response = await this.bodhiext.sendApiRequest(
-        method,
-        endpoint,
-        body,
-        requestHeaders
+      return await this.bodhiext.sendApiRequest(
+        e,
+        t,
+        r,
+        o
       );
-      return response;
-    } catch (e) {
-      const errorObj = e == null ? void 0 : e.error;
-      const message = (errorObj == null ? void 0 : errorObj.message) ?? (e instanceof Error ? e.message : String(e));
-      const errorType = (errorObj == null ? void 0 : errorObj.type) || "extension_error";
+    } catch (o) {
+      const a = o == null ? void 0 : o.error, h = (a == null ? void 0 : a.message) ?? (o instanceof Error ? o.message : String(o)), c = (a == null ? void 0 : a.type) || "extension_error";
       return {
         error: {
-          message,
-          type: errorType
+          message: h,
+          type: c
         }
       };
     }
@@ -274,61 +220,47 @@ class WindowBodhiextClient {
    * Note: Web mode uses stateless discovery (always polls for window.bodhiext)
    * No extensionId storage/restoration needed - window.bodhiext handle is ephemeral
    */
-  async init(params = {}) {
-    var _a, _b, _c, _d;
-    if (!params.testConnection && !params.selectedConnection) {
-      this.logger.info("No testConnection or selectedConnection, returning not-initialized state");
-      return EXTENSION_STATE_NOT_INITIALIZED;
-    }
-    if (this.bodhiext && !params.testConnection) {
-      this.logger.debug("Already have bodhiext handle, skipping polling");
-      return this.state;
-    }
+  async init(e = {}) {
+    var s, i, o, a;
+    if (!e.testConnection && !e.selectedConnection)
+      return this.logger.info("No testConnection or selectedConnection, returning not-initialized state"), _;
+    if (this.bodhiext && !e.testConnection)
+      return this.logger.debug("Already have bodhiext handle, skipping polling"), this.state;
     if (!this.bodhiext) {
-      const timeoutMs = params.timeoutMs ?? ((_b = (_a = this.config.initParams) == null ? void 0 : _a.extension) == null ? void 0 : _b.timeoutMs) ?? POLL_TIMEOUT;
-      const intervalMs = params.intervalMs ?? ((_d = (_c = this.config.initParams) == null ? void 0 : _c.extension) == null ? void 0 : _d.intervalMs) ?? POLL_INTERVAL;
-      const startTime = Date.now();
-      const found = await new Promise((resolve) => {
-        const check = () => {
+      const h = e.timeoutMs ?? ((i = (s = this.config.initParams) == null ? void 0 : s.extension) == null ? void 0 : i.timeoutMs) ?? F, c = e.intervalMs ?? ((a = (o = this.config.initParams) == null ? void 0 : o.extension) == null ? void 0 : a.intervalMs) ?? K, l = Date.now();
+      if (!await new Promise((p) => {
+        const w = () => {
           if (window.bodhiext) {
-            this.bodhiext = window.bodhiext;
-            resolve(true);
+            this.bodhiext = window.bodhiext, p(!0);
             return;
           }
-          if (Date.now() - startTime >= timeoutMs) {
-            resolve(false);
+          if (Date.now() - l >= h) {
+            p(!1);
             return;
           }
-          setTimeout(check, intervalMs);
+          setTimeout(w, c);
         };
-        check();
-      });
-      if (!found) {
-        this.logger.warn(`Extension discovery timed out`);
-        this.setState(EXTENSION_STATE_NOT_FOUND);
-        return this.state;
-      }
+        w();
+      }))
+        return this.logger.warn("Extension discovery timed out"), this.setState(v), this.state;
     }
-    const extensionId = await this.bodhiext.getExtensionId();
-    this.logger.info(`Extension discovered: ${extensionId}`);
-    const state = {
+    const t = await this.bodhiext.getExtensionId();
+    this.logger.info(`Extension discovered: ${t}`);
+    const r = {
       type: "extension",
       extension: "ready",
-      extensionId,
-      server: PENDING_EXTENSION_READY
+      extensionId: t,
+      server: O
     };
-    if (params.testConnection) {
+    if (e.testConnection)
       try {
-        const serverState = await this.getServerState();
-        this.setState({ ...state, server: serverState });
-        this.logger.info(`Server connectivity tested: ${serverState.status}`);
-      } catch (error) {
-        this.logger.error(`Failed to get server state:`, error);
-        this.setState({ ...state, server: BACKEND_SERVER_NOT_REACHABLE });
+        const h = await this.getServerState();
+        this.setState({ ...r, server: h }), this.logger.info(`Server connectivity tested: ${h.status}`);
+      } catch (h) {
+        this.logger.error("Failed to get server state:", h), this.setState({ ...r, server: d });
       }
-    } else {
-      this.setState(state);
-    }
+    else
+      this.setState(r);
     return this.state;
   }
   // ============================================================================
@@ -340,45 +272,35 @@ class WindowBodhiextClient {
    */
   async requestResourceAccess() {
     this.ensureBodhiext();
-    const response = await this.bodhiext.sendApiRequest("POST", "/bodhi/v1/apps/request-access", {
+    const e = await this.bodhiext.sendApiRequest("POST", "/bodhi/v1/apps/request-access", {
       app_client_id: this.authClientId
     });
-    if (!isApiResultSuccess(response)) {
+    if (!E(e))
       throw new Error("Failed to get resource access scope: API error");
-    }
-    const scope = response.body.scope;
-    localStorage.setItem(STORAGE_KEYS.RESOURCE_SCOPE, scope);
-    return scope;
+    const t = e.body.scope;
+    return localStorage.setItem(n.RESOURCE_SCOPE, t), t;
   }
   /**
    * Login via browser redirect OAuth2 + PKCE flow
    * @returns AuthLoggedIn (though in practice, this redirects and never returns)
    */
   async login() {
-    const existingAuth = await this.getAuthState();
-    if (existingAuth.isLoggedIn) {
-      return existingAuth;
-    }
+    const e = await this.getAuthState();
+    if (e.isLoggedIn)
+      return e;
     this.ensureBodhiext();
-    const resourceScope = await this.requestResourceAccess();
-    const codeVerifier = generateCodeVerifier();
-    const codeChallenge = await generateCodeChallenge(codeVerifier);
-    const state = generateCodeVerifier();
-    localStorage.setItem(STORAGE_KEYS.CODE_VERIFIER, codeVerifier);
-    localStorage.setItem(STORAGE_KEYS.STATE, state);
-    const scopes = ["openid", "profile", "email", "roles", this.config.userScope, resourceScope];
-    const params = new URLSearchParams({
+    const t = await this.requestResourceAccess(), r = g(), s = await y(r), i = g();
+    localStorage.setItem(n.CODE_VERIFIER, r), localStorage.setItem(n.STATE, i);
+    const o = ["openid", "profile", "email", "roles", this.config.userScope, t], a = new URLSearchParams({
       response_type: "code",
       client_id: this.authClientId,
       redirect_uri: this.config.redirectUri,
-      scope: scopes.join(" "),
-      state,
-      code_challenge: codeChallenge,
+      scope: o.join(" "),
+      state: i,
+      code_challenge: s,
       code_challenge_method: "S256"
-    });
-    const authUrl = `${this.authEndpoints.authorize}?${params}`;
-    window.location.href = authUrl;
-    return new Promise(() => {
+    }), h = `${this.authEndpoints.authorize}?${a}`;
+    return window.location.href = h, new Promise(() => {
     });
   }
   /**
@@ -386,58 +308,46 @@ class WindowBodhiextClient {
    * Should be called from callback page with extracted URL params
    * @returns AuthLoggedIn with login state and user info
    */
-  async handleOAuthCallback(code, state) {
-    const storedState = localStorage.getItem(STORAGE_KEYS.STATE);
-    if (!storedState || storedState !== state) {
+  async handleOAuthCallback(e, t) {
+    const r = localStorage.getItem(n.STATE);
+    if (!r || r !== t)
       throw new Error("Invalid state parameter - possible CSRF attack");
-    }
-    await this.exchangeCodeForTokens(code);
-    localStorage.removeItem(STORAGE_KEYS.CODE_VERIFIER);
-    localStorage.removeItem(STORAGE_KEYS.STATE);
-    const authState = await this.getAuthState();
-    if (!authState.isLoggedIn) {
+    await this.exchangeCodeForTokens(e), localStorage.removeItem(n.CODE_VERIFIER), localStorage.removeItem(n.STATE);
+    const s = await this.getAuthState();
+    if (!s.isLoggedIn)
       throw new Error("Login failed");
-    }
-    this.setAuthState(authState);
-    return authState;
+    return this.setAuthState(s), s;
   }
   /**
    * Exchange authorization code for tokens
    */
-  async exchangeCodeForTokens(code) {
-    const codeVerifier = localStorage.getItem(STORAGE_KEYS.CODE_VERIFIER);
-    if (!codeVerifier) {
+  async exchangeCodeForTokens(e) {
+    const t = localStorage.getItem(n.CODE_VERIFIER);
+    if (!t)
       throw new Error("Code verifier not found");
-    }
-    const params = new URLSearchParams({
+    const r = new URLSearchParams({
       grant_type: "authorization_code",
       client_id: this.authClientId,
-      code,
+      code: e,
       redirect_uri: this.config.redirectUri,
-      code_verifier: codeVerifier
-    });
-    const response = await fetch(this.authEndpoints.token, {
+      code_verifier: t
+    }), s = await fetch(this.authEndpoints.token, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: params
+      body: r
     });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Token exchange failed: ${response.status} ${errorText}`);
+    if (!s.ok) {
+      const o = await s.text();
+      throw new Error(`Token exchange failed: ${s.status} ${o}`);
     }
-    const tokenData = await response.json();
-    if (!tokenData.access_token) {
+    const i = await s.json();
+    if (!i.access_token)
       throw new Error("No access token received");
-    }
-    localStorage.setItem(STORAGE_KEYS.ACCESS_TOKEN, tokenData.access_token);
-    if (tokenData.refresh_token) {
-      localStorage.setItem(STORAGE_KEYS.REFRESH_TOKEN, tokenData.refresh_token);
-    }
-    if (tokenData.expires_in) {
-      const expiresAt = Date.now() + tokenData.expires_in * 1e3;
-      localStorage.setItem(STORAGE_KEYS.EXPIRES_AT, expiresAt.toString());
+    if (localStorage.setItem(n.ACCESS_TOKEN, i.access_token), i.refresh_token && localStorage.setItem(n.REFRESH_TOKEN, i.refresh_token), i.expires_in) {
+      const o = Date.now() + i.expires_in * 1e3;
+      localStorage.setItem(n.EXPIRES_AT, o.toString());
     }
   }
   /**
@@ -445,11 +355,11 @@ class WindowBodhiextClient {
    * @returns AuthLoggedOut with logged out state
    */
   async logout() {
-    const refreshToken = localStorage.getItem(STORAGE_KEYS.REFRESH_TOKEN);
-    if (refreshToken) {
+    const e = localStorage.getItem(n.REFRESH_TOKEN);
+    if (e)
       try {
-        const params = new URLSearchParams({
-          token: refreshToken,
+        const r = new URLSearchParams({
+          token: e,
           client_id: this.authClientId,
           token_type_hint: "refresh_token"
         });
@@ -458,38 +368,28 @@ class WindowBodhiextClient {
           headers: {
             "Content-Type": "application/x-www-form-urlencoded"
           },
-          body: params
+          body: r
         });
-      } catch (error) {
-        this.logger.warn("Token revocation failed:", error);
+      } catch (r) {
+        this.logger.warn("Token revocation failed:", r);
       }
-    }
-    localStorage.removeItem(STORAGE_KEYS.ACCESS_TOKEN);
-    localStorage.removeItem(STORAGE_KEYS.REFRESH_TOKEN);
-    localStorage.removeItem(STORAGE_KEYS.EXPIRES_AT);
-    localStorage.removeItem(STORAGE_KEYS.CODE_VERIFIER);
-    localStorage.removeItem(STORAGE_KEYS.STATE);
-    localStorage.removeItem(STORAGE_KEYS.RESOURCE_SCOPE);
-    const result = {
-      isLoggedIn: false
+    localStorage.removeItem(n.ACCESS_TOKEN), localStorage.removeItem(n.REFRESH_TOKEN), localStorage.removeItem(n.EXPIRES_AT), localStorage.removeItem(n.CODE_VERIFIER), localStorage.removeItem(n.STATE), localStorage.removeItem(n.RESOURCE_SCOPE);
+    const t = {
+      isLoggedIn: !1
     };
-    this.setAuthState(result);
-    return result;
+    return this.setAuthState(t), t;
   }
   /**
    * Get current authentication state
    */
   async getAuthState() {
-    const accessToken = await this._getAccessTokenRaw();
-    if (!accessToken) {
-      return { isLoggedIn: false };
-    }
+    const e = await this._getAccessTokenRaw();
+    if (!e)
+      return { isLoggedIn: !1 };
     try {
-      const userInfo = extractUserInfo(accessToken);
-      return { isLoggedIn: true, userInfo, accessToken };
-    } catch (error) {
-      this.logger.error("Failed to parse token:", error);
-      return { isLoggedIn: false };
+      return { isLoggedIn: !0, userInfo: I(e), accessToken: e };
+    } catch (t) {
+      return this.logger.error("Failed to parse token:", t), { isLoggedIn: !1 };
     }
   }
   /**
@@ -497,33 +397,26 @@ class WindowBodhiextClient {
    * Returns null if not logged in or token expired
    */
   async _getAccessTokenRaw() {
-    const accessToken = localStorage.getItem(STORAGE_KEYS.ACCESS_TOKEN);
-    const expiresAt = localStorage.getItem(STORAGE_KEYS.EXPIRES_AT);
-    if (!accessToken) {
+    const e = localStorage.getItem(n.ACCESS_TOKEN), t = localStorage.getItem(n.EXPIRES_AT);
+    if (!e)
       return null;
-    }
-    if (expiresAt) {
-      const expirationTime = parseInt(expiresAt, 10);
-      if (Date.now() >= expirationTime - 5 * 1e3) {
-        const refreshToken = localStorage.getItem(STORAGE_KEYS.REFRESH_TOKEN);
-        if (refreshToken) {
-          return this._tryRefreshToken(refreshToken);
-        }
-        return null;
+    if (t) {
+      const r = parseInt(t, 10);
+      if (Date.now() >= r - 5 * 1e3) {
+        const s = localStorage.getItem(n.REFRESH_TOKEN);
+        return s ? this._tryRefreshToken(s) : null;
       }
     }
-    return accessToken;
+    return e;
   }
   /**
    * Try to refresh access token using refresh token
    * Race condition prevention: Returns existing promise if refresh already in progress
    */
-  async _tryRefreshToken(refreshToken) {
-    if (this.refreshPromise) {
-      this.logger.debug("Refresh already in progress, returning existing promise");
-      return this.refreshPromise;
-    }
-    this.refreshPromise = this._doRefreshToken(refreshToken);
+  async _tryRefreshToken(e) {
+    if (this.refreshPromise)
+      return this.logger.debug("Refresh already in progress, returning existing promise"), this.refreshPromise;
+    this.refreshPromise = this._doRefreshToken(e);
     try {
       return await this.refreshPromise;
     } finally {
@@ -533,30 +426,27 @@ class WindowBodhiextClient {
   /**
    * Perform the actual token refresh
    */
-  async _doRefreshToken(refreshToken) {
+  async _doRefreshToken(e) {
     this.logger.debug("Refreshing access token");
     try {
-      const tokens = await refreshAccessToken(
+      const t = await b(
         this.authEndpoints.token,
-        refreshToken,
+        e,
         this.authClientId
       );
-      if (tokens) {
-        this._storeRefreshedTokens(tokens);
-        const userInfo = extractUserInfo(tokens.access_token);
-        this.setAuthState({
-          isLoggedIn: true,
-          userInfo,
-          accessToken: tokens.access_token
-        });
-        this.logger.info("Token refreshed successfully");
-        return tokens.access_token;
+      if (t) {
+        this._storeRefreshedTokens(t);
+        const r = I(t.access_token);
+        return this.setAuthState({
+          isLoggedIn: !0,
+          userInfo: r,
+          accessToken: t.access_token
+        }), this.logger.info("Token refreshed successfully"), t.access_token;
       }
-    } catch (error) {
-      this.logger.warn("Token refresh failed:", error);
+    } catch (t) {
+      this.logger.warn("Token refresh failed:", t);
     }
-    this.logger.warn("Token refresh failed, keeping tokens for manual retry");
-    throw createOperationError(
+    throw this.logger.warn("Token refresh failed, keeping tokens for manual retry"), u(
       "Access token expired and unable to refresh. Try logging out and logging in again.",
       "token_refresh_failed"
     );
@@ -564,13 +454,9 @@ class WindowBodhiextClient {
   /**
    * Store refreshed tokens
    */
-  _storeRefreshedTokens(tokens) {
-    const expiresAt = Date.now() + tokens.expires_in * 1e3;
-    localStorage.setItem(STORAGE_KEYS.ACCESS_TOKEN, tokens.access_token);
-    localStorage.setItem(STORAGE_KEYS.EXPIRES_AT, String(expiresAt));
-    if (tokens.refresh_token) {
-      localStorage.setItem(STORAGE_KEYS.REFRESH_TOKEN, tokens.refresh_token);
-    }
+  _storeRefreshedTokens(e) {
+    const t = Date.now() + e.expires_in * 1e3;
+    localStorage.setItem(n.ACCESS_TOKEN, e.access_token), localStorage.setItem(n.EXPIRES_AT, String(t)), e.refresh_token && localStorage.setItem(n.REFRESH_TOKEN, e.refresh_token);
   }
   /**
    * Ping API
@@ -587,7 +473,7 @@ class WindowBodhiextClient {
       "/v1/models",
       void 0,
       void 0,
-      true
+      !0
     );
   }
   /**
@@ -595,88 +481,80 @@ class WindowBodhiextClient {
    * Calls /bodhi/v1/info and returns structured server state
    */
   async getServerState() {
-    const result = await this.sendApiRequest("GET", "/bodhi/v1/info");
-    if (isApiResultOperationError(result)) {
-      return BACKEND_SERVER_NOT_REACHABLE;
-    }
-    if (!isApiResultSuccess(result)) {
-      return BACKEND_SERVER_NOT_REACHABLE;
-    }
-    const body = result.body;
-    switch (body.status) {
+    const e = await this.sendApiRequest("GET", "/bodhi/v1/info");
+    if (T(e))
+      return d;
+    if (!E(e))
+      return d;
+    const t = e.body;
+    switch (t.status) {
       case "ready":
-        return { status: "ready", version: body.version || "unknown" };
+        return { status: "ready", version: t.version || "unknown" };
       case "setup":
-        return backendServerNotReady("setup", body.version || "unknown");
+        return S("setup", t.version || "unknown");
       case "resource-admin":
-        return backendServerNotReady("resource-admin", body.version || "unknown");
+        return S("resource-admin", t.version || "unknown");
       case "error":
-        return backendServerNotReady(
+        return S(
           "error",
-          body.version || "unknown",
-          body.error ? { message: body.error.message, type: body.error.type } : SERVER_ERROR_CODES.SERVER_NOT_READY
+          t.version || "unknown",
+          t.error ? { message: t.error.message, type: t.error.type } : P.SERVER_NOT_READY
         );
       default:
-        return BACKEND_SERVER_NOT_REACHABLE;
+        return d;
     }
   }
   /**
    * Generic streaming via window.bodhiext.sendStreamRequest
    * Wraps ReadableStream as AsyncGenerator
    */
-  async *stream(method, endpoint, body, headers, authenticated = true) {
+  async *stream(e, t, r, s, i = !0) {
     this.ensureBodhiext();
-    let requestHeaders = headers || {};
-    if (authenticated) {
-      const accessToken = await this._getAccessTokenRaw();
-      if (!accessToken) {
+    let o = s || {};
+    if (i) {
+      const c = await this._getAccessTokenRaw();
+      if (!c)
         throw new Error("Not authenticated. Please log in first.");
-      }
-      requestHeaders = {
-        ...requestHeaders,
-        Authorization: `Bearer ${accessToken}`
+      o = {
+        ...o,
+        Authorization: `Bearer ${c}`
       };
     }
-    const stream = this.bodhiext.sendStreamRequest(method, endpoint, body, requestHeaders);
-    const reader = stream.getReader();
+    const h = this.bodhiext.sendStreamRequest(e, t, r, o).getReader();
     try {
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done || (value == null ? void 0 : value.done)) {
+      for (; ; ) {
+        const { value: c, done: l } = await h.read();
+        if (l || c != null && c.done)
           break;
-        }
-        yield value.body;
+        yield c.body;
       }
-    } catch (err) {
-      if (err instanceof Error) {
-        if ("response" in err) {
-          const apiErr = err;
-          throw createApiError(err.message, apiErr.response.status, apiErr.response.body);
+    } catch (c) {
+      if (c instanceof Error) {
+        if ("response" in c) {
+          const l = c;
+          throw U(c.message, l.response.status, l.response.body);
         }
-        if ("error" in err) {
-          throw createOperationError(err.message, "extension_error");
-        }
-        throw createOperationError(err.message, "extension_error");
+        throw "error" in c ? u(c.message, "extension_error") : u(c.message, "extension_error");
       }
-      throw err;
+      throw c;
     } finally {
-      reader.releaseLock();
+      h.releaseLock();
     }
   }
   /**
    * Chat streaming
    */
-  async *streamChat(model, prompt, authenticated = true) {
+  async *streamChat(e, t, r = !0) {
     yield* this.stream(
       "POST",
       "/v1/chat/completions",
       {
-        model,
-        messages: [{ role: "user", content: prompt }],
-        stream: true
+        model: e,
+        messages: [{ role: "user", content: t }],
+        stream: !0
       },
       void 0,
-      authenticated
+      r
     );
   }
   /**
@@ -703,47 +581,43 @@ class WindowBodhiextClient {
     };
   }
 }
-class WebUIClient extends BaseFacadeClient {
-  constructor(authClientId, config, onStateChange, storagePrefix) {
-    const normalizedConfig = {
-      redirectUri: config.redirectUri,
-      authServerUrl: config.authServerUrl || "https://id.getbodhi.app/realms/bodhi",
-      userScope: config.userScope || "scope_user_user",
-      logLevel: config.logLevel || "warn",
-      initParams: config.initParams
+class V extends N {
+  constructor(e, t, r, s) {
+    const i = {
+      redirectUri: t.redirectUri,
+      authServerUrl: t.authServerUrl || "https://id.getbodhi.app/realms/bodhi",
+      userScope: t.userScope || "scope_user_user",
+      logLevel: t.logLevel || "warn",
+      initParams: t.initParams
     };
-    super(authClientId, normalizedConfig, onStateChange, storagePrefix);
+    super(e, i, r, s);
   }
-  createLogger(config) {
-    return new Logger("WebUIClient", config.logLevel);
+  createLogger(e) {
+    return new R("WebUIClient", e.logLevel);
   }
-  createExtClient(config, onStateChange) {
-    return new WindowBodhiextClient(this.authClientId, config, onStateChange);
+  createExtClient(e, t) {
+    return new D(this.authClientId, e, t);
   }
-  createDirectClient(authClientId, config, onStateChange) {
-    return new DirectWebClient(
+  createDirectClient(e, t, r) {
+    return new L(
       {
-        authClientId,
-        authServerUrl: config.authServerUrl,
-        redirectUri: config.redirectUri,
-        userScope: config.userScope,
-        logLevel: config.logLevel,
-        storagePrefix: STORAGE_PREFIXES.WEB
+        authClientId: e,
+        authServerUrl: t.authServerUrl,
+        redirectUri: t.redirectUri,
+        userScope: t.userScope,
+        logLevel: t.logLevel,
+        storagePrefix: f.WEB
       },
-      onStateChange
+      r
     );
   }
   // ============================================================================
   // Web-specific OAuth Callback
   // ============================================================================
-  async handleOAuthCallback(code, state) {
-    if (this.connectionMode === "direct") {
-      return this.directClient.handleOAuthCallback(code, state);
-    }
-    return this.extClient.handleOAuthCallback(code, state);
+  async handleOAuthCallback(e, t) {
+    return this.connectionMode === "direct" ? this.directClient.handleOAuthCallback(e, t) : this.extClient.handleOAuthCallback(e, t);
   }
 }
 export {
-  WebUIClient
+  V as WebUIClient
 };
-//# sourceMappingURL=bodhi-web.esm.js.map