@bodhiapp/bodhi-js 0.0.2 → 0.0.4

package/dist/bodhi-web.esm.js

@@ -1,57 +1,38 @@
-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 x, createStoragePrefixWithBasePath as w, STORAGE_PREFIXES as u, generateCodeVerifier as g, generateCodeChallenge as I, isApiResultOperationError as T, isApiResultSuccess as f, createStorageKeys as R, EXTENSION_STATE_NOT_INITIALIZED as y, Logger as C, createOAuthEndpoints as A, NOOP_STATE_CALLBACK as k, EXTENSION_STATE_NOT_FOUND as v, PENDING_EXTENSION_READY as b, BACKEND_SERVER_NOT_REACHABLE as d, extractUserInfo as _, refreshAccessToken as P, createOperationError as S, backendServerNotReady as E, SERVER_ERROR_CODES as O, createApiError as K, BaseFacadeClient as U } from "@bodhiapp/bodhi-js-core";
+class L extends x {
+  constructor(e, t) {
+    const s = e.basePath || "/", r = w(s, u.DIRECT);
+    super({ ...e, storagePrefix: r }, "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(), s = `openid profile email roles ${this.userScope} ${t}`, r = g(), i = await I(r), o = g();
+    localStorage.setItem(this.storageKeys.CODE_VERIFIER, r), 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", s), 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 s = localStorage.getItem(this.storageKeys.STATE);
+    if (!s || s !== 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 r = await this.getAuthState();
+    if (!r.isLoggedIn)
       throw new Error("Login failed");
-    }
-    const result = authState;
-    this.setAuthState(result);
-    return result;
+    const i = r;
+    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 s = new URLSearchParams({
+          token: e,
           client_id: this.authClientId,
           token_type_hint: "refresh_token"
         });
@@ -60,126 +41,107 @@ class DirectWebClient extends DirectClientBase {
           headers: {
             "Content-Type": "application/x-www-form-urlencoded"
           },
-          body: params
+          body: s
         });
-      } catch (error) {
-        this.logger.warn("Token revocation failed:", error);
+      } catch (s) {
+        this.logger.warn("Token revocation failed:", s);
       }
-    }
-    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 (!f(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 s = 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 (!s.ok) {
+      const i = await s.text();
+      throw new Error(`Token exchange failed: ${s.status} ${i}`);
     }
-    if (tokens.expires_in) {
-      const expiresAt = Date.now() + tokens.expires_in * 1e3;
-      localStorage.setItem(this.storageKeys.EXPIRES_AT, expiresAt.toString());
+    const r = await s.json();
+    if (localStorage.setItem(this.storageKeys.ACCESS_TOKEN, r.access_token), r.refresh_token && localStorage.setItem(this.storageKeys.REFRESH_TOKEN, r.refresh_token), r.expires_in) {
+      const i = Date.now() + r.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, s]) => {
+      localStorage.setItem(t, String(s));
     });
   }
-  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 N = 500, D = 5e3;
+R(u.WEB);
+function F(l = "/") {
+  const e = w(l, u.WEB);
+  return R(e);
+}
+class B {
+  constructor(e, t, s, r) {
+    this.state = y, this.bodhiext = null, this.refreshPromise = null, this.logger = new C("WindowBodhiextClient", t.logLevel), this.authClientId = e, this.config = t, this.authEndpoints = A(this.config.authServerUrl), this.onStateChange = s ?? k, this.storageKeys = F(r || "/");
   }
   /**
    * 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 +151,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, s, r, 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 = r || {};
+      if (i) {
+        const c = await this._getAccessTokenRaw();
+        if (!c)
           return {
             error: {
               message: "Not authenticated. Please log in first.",
               type: "extension_error"
             }
           };
-        }
-        requestHeaders = {
-          ...requestHeaders,
-          Authorization: `Bearer ${accessToken}`
+        o = {
+          ...o,
+          Authorization: `Bearer ${c}`
         };
       }
-      const response = await this.bodhiext.sendApiRequest(
-        method,
-        endpoint,
-        body,
-        requestHeaders
+      return await this.bodhiext.sendApiRequest(
+        e,
+        t,
+        s,
+        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, c = (a == null ? void 0 : a.message) ?? (o instanceof Error ? o.message : String(o)), n = (a == null ? void 0 : a.type) || "extension_error";
       return {
         error: {
-          message,
-          type: errorType
+          message: c,
+          type: n
         }
       };
     }
@@ -274,61 +226,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 r, i, o, a;
+    if (!e.testConnection && !e.selectedConnection)
+      return this.logger.info("No testConnection or selectedConnection, returning not-initialized state"), y;
+    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 c = e.timeoutMs ?? ((i = (r = this.config.initParams) == null ? void 0 : r.extension) == null ? void 0 : i.timeoutMs) ?? D, n = e.intervalMs ?? ((a = (o = this.config.initParams) == null ? void 0 : o.extension) == null ? void 0 : a.intervalMs) ?? N, h = Date.now();
+      if (!await new Promise((p) => {
+        const m = () => {
           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() - h >= c) {
+            p(!1);
             return;
           }
-          setTimeout(check, intervalMs);
+          setTimeout(m, n);
         };
-        check();
-      });
-      if (!found) {
-        this.logger.warn(`Extension discovery timed out`);
-        this.setState(EXTENSION_STATE_NOT_FOUND);
-        return this.state;
-      }
+        m();
+      }))
+        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 s = {
       type: "extension",
       extension: "ready",
-      extensionId,
-      server: PENDING_EXTENSION_READY
+      extensionId: t,
+      server: b
     };
-    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 c = await this.getServerState();
+        this.setState({ ...s, server: c }), this.logger.info(`Server connectivity tested: ${c.status}`);
+      } catch (c) {
+        this.logger.error("Failed to get server state:", c), this.setState({ ...s, server: d });
       }
-    } else {
-      this.setState(state);
-    }
+    else
+      this.setState(s);
     return this.state;
   }
   // ============================================================================
@@ -340,45 +278,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 (!f(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(this.storageKeys.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(), s = g(), r = await I(s), i = g();
+    localStorage.setItem(this.storageKeys.CODE_VERIFIER, s), localStorage.setItem(this.storageKeys.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: r,
       code_challenge_method: "S256"
-    });
-    const authUrl = `${this.authEndpoints.authorize}?${params}`;
-    window.location.href = authUrl;
-    return new Promise(() => {
+    }), c = `${this.authEndpoints.authorize}?${a}`;
+    return window.location.href = c, new Promise(() => {
     });
   }
   /**
@@ -386,58 +314,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 s = localStorage.getItem(this.storageKeys.STATE);
+    if (!s || s !== 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(this.storageKeys.CODE_VERIFIER), localStorage.removeItem(this.storageKeys.STATE);
+    const r = await this.getAuthState();
+    if (!r.isLoggedIn)
       throw new Error("Login failed");
-    }
-    this.setAuthState(authState);
-    return authState;
+    return this.setAuthState(r), r;
   }
   /**
    * 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(this.storageKeys.CODE_VERIFIER);
+    if (!t)
       throw new Error("Code verifier not found");
-    }
-    const params = new URLSearchParams({
+    const s = 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
+    }), r = await fetch(this.authEndpoints.token, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: params
+      body: s
     });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Token exchange failed: ${response.status} ${errorText}`);
+    if (!r.ok) {
+      const o = await r.text();
+      throw new Error(`Token exchange failed: ${r.status} ${o}`);
     }
-    const tokenData = await response.json();
-    if (!tokenData.access_token) {
+    const i = await r.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(this.storageKeys.ACCESS_TOKEN, i.access_token), i.refresh_token && localStorage.setItem(this.storageKeys.REFRESH_TOKEN, i.refresh_token), i.expires_in) {
+      const o = Date.now() + i.expires_in * 1e3;
+      localStorage.setItem(this.storageKeys.EXPIRES_AT, o.toString());
     }
   }
   /**
@@ -445,11 +361,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(this.storageKeys.REFRESH_TOKEN);
+    if (e)
       try {
-        const params = new URLSearchParams({
-          token: refreshToken,
+        const s = new URLSearchParams({
+          token: e,
           client_id: this.authClientId,
           token_type_hint: "refresh_token"
         });
@@ -458,38 +374,28 @@ class WindowBodhiextClient {
           headers: {
             "Content-Type": "application/x-www-form-urlencoded"
           },
-          body: params
+          body: s
         });
-      } catch (error) {
-        this.logger.warn("Token revocation failed:", error);
+      } catch (s) {
+        this.logger.warn("Token revocation failed:", s);
       }
-    }
-    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(this.storageKeys.ACCESS_TOKEN), localStorage.removeItem(this.storageKeys.REFRESH_TOKEN), localStorage.removeItem(this.storageKeys.EXPIRES_AT), localStorage.removeItem(this.storageKeys.CODE_VERIFIER), localStorage.removeItem(this.storageKeys.STATE), localStorage.removeItem(this.storageKeys.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: _(e), accessToken: e };
+    } catch (t) {
+      return this.logger.error("Failed to parse token:", t), { isLoggedIn: !1 };
     }
   }
   /**
@@ -497,33 +403,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(this.storageKeys.ACCESS_TOKEN), t = localStorage.getItem(this.storageKeys.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 s = parseInt(t, 10);
+      if (Date.now() >= s - 5 * 1e3) {
+        const r = localStorage.getItem(this.storageKeys.REFRESH_TOKEN);
+        return r ? this._tryRefreshToken(r) : 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 +432,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 P(
         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 s = _(t.access_token);
+        return this.setAuthState({
+          isLoggedIn: !0,
+          userInfo: s,
+          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"), S(
       "Access token expired and unable to refresh. Try logging out and logging in again.",
       "token_refresh_failed"
     );
@@ -564,13 +460,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(this.storageKeys.ACCESS_TOKEN, e.access_token), localStorage.setItem(this.storageKeys.EXPIRES_AT, String(t)), e.refresh_token && localStorage.setItem(this.storageKeys.REFRESH_TOKEN, e.refresh_token);
   }
   /**
    * Ping API
@@ -587,7 +479,7 @@ class WindowBodhiextClient {
       "/v1/models",
       void 0,
       void 0,
-      true
+      !0
     );
   }
   /**
@@ -595,88 +487,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 (!f(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 E("setup", t.version || "unknown");
       case "resource-admin":
-        return backendServerNotReady("resource-admin", body.version || "unknown");
+        return E("resource-admin", t.version || "unknown");
       case "error":
-        return backendServerNotReady(
+        return E(
           "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 } : O.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, s, r, i = !0) {
     this.ensureBodhiext();
-    let requestHeaders = headers || {};
-    if (authenticated) {
-      const accessToken = await this._getAccessTokenRaw();
-      if (!accessToken) {
+    let o = r || {};
+    if (i) {
+      const n = await this._getAccessTokenRaw();
+      if (!n)
         throw new Error("Not authenticated. Please log in first.");
-      }
-      requestHeaders = {
-        ...requestHeaders,
-        Authorization: `Bearer ${accessToken}`
+      o = {
+        ...o,
+        Authorization: `Bearer ${n}`
       };
     }
-    const stream = this.bodhiext.sendStreamRequest(method, endpoint, body, requestHeaders);
-    const reader = stream.getReader();
+    const c = this.bodhiext.sendStreamRequest(e, t, s, o).getReader();
     try {
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done || (value == null ? void 0 : value.done)) {
+      for (; ; ) {
+        const { value: n, done: h } = await c.read();
+        if (h || n != null && n.done)
           break;
-        }
-        yield value.body;
+        yield n.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 (n) {
+      if (n instanceof Error) {
+        if ("response" in n) {
+          const h = n;
+          throw K(n.message, h.response.status, h.response.body);
         }
-        if ("error" in err) {
-          throw createOperationError(err.message, "extension_error");
-        }
-        throw createOperationError(err.message, "extension_error");
+        throw "error" in n ? S(n.message, "extension_error") : S(n.message, "extension_error");
       }
-      throw err;
+      throw n;
     } finally {
-      reader.releaseLock();
+      c.releaseLock();
     }
   }
   /**
    * Chat streaming
    */
-  async *streamChat(model, prompt, authenticated = true) {
+  async *streamChat(e, t, s = !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
+      s
     );
   }
   /**
@@ -703,47 +587,47 @@ 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 W extends U {
+  constructor(e, t, s, r) {
+    const i = {
+      redirectUri: t.redirectUri,
+      authServerUrl: t.authServerUrl || "https://id.getbodhi.app/realms/bodhi",
+      userScope: t.userScope || "scope_user_user",
+      basePath: t.basePath || "/",
+      logLevel: t.logLevel || "warn",
+      initParams: t.initParams
     };
-    super(authClientId, normalizedConfig, onStateChange, storagePrefix);
+    super(e, i, s, r, t.basePath);
   }
-  createLogger(config) {
-    return new Logger("WebUIClient", config.logLevel);
+  createLogger(e) {
+    return new C("WebUIClient", e.logLevel);
   }
-  createExtClient(config, onStateChange) {
-    return new WindowBodhiextClient(this.authClientId, config, onStateChange);
+  createExtClient(e, t) {
+    return new B(this.authClientId, e, t, e.basePath);
   }
-  createDirectClient(authClientId, config, onStateChange) {
-    return new DirectWebClient(
+  createDirectClient(e, t, s) {
+    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: u.WEB,
+        basePath: t.basePath
       },
-      onStateChange
+      s
     );
   }
   // ============================================================================
   // 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);
   }
 }
+const $ = "production";
 export {
-  WebUIClient
+  $ as WEB_BUILD_MODE,
+  W as WebUIClient
 };
-//# sourceMappingURL=bodhi-web.esm.js.map