@bodhiapp/bodhi-js-react-core 0.0.11

package/dist/bodhi-react-core.esm.js

@@ -0,0 +1,473 @@
+import { jsxs as F, jsx as H } from "react/jsx-runtime";
+import { Logger as B, BodhiClientUserPrefsManager as G, createStoragePrefixWithBasePath as K, detectBrowser as V, detectOS as W, getServerUrl as j, isDirectServerReady as Y, isExtensionServerReady as q, OS_CONFIGS as X, BROWSER_CONFIGS as J, OnboardingModal as Z, BACKEND_SERVER_NOT_CONNECTED as P, isExtensionState as Q, INITIAL_AUTH_STATE as $, NOOP_STATE_CALLBACK as ee, isWebUIClient as te } from "@bodhiapp/bodhi-js-core";
+import { createApiError as Ae, createOperationError as Oe, isApiResultError as Le, isApiResultOperationError as he, isApiResultSuccess as we, isAuthError as xe, isAuthLoading as Ie, isAuthenticated as _e, isClientReady as Re, isDirectState as De, isExtensionState as Me, isOperationError as Ne, isWebUIClient as Te } from "@bodhiapp/bodhi-js-core";
+import { useMemo as _, useRef as T, useCallback as d, useEffect as b, createContext as re, useState as N, useContext as ne } from "react";
+const m = {
+  // Modal lifecycle
+  MODAL_READY: "modal:ready",
+  MODAL_REFRESH: "modal:refresh",
+  MODAL_CLOSE: "modal:close",
+  MODAL_COMPLETE: "modal:complete",
+  // LNA actions
+  MODAL_LNA_CONNECT: "modal:lna:connect",
+  MODAL_LNA_SKIP: "modal:lna:skip",
+  // Server confirmation
+  MODAL_CONFIRM_SERVER_INSTALL: "modal:confirm-server-install",
+  // Connection selection
+  MODAL_SELECT_CONNECTION: "modal:select-connection"
+};
+function se({
+  client: e,
+  modalHtmlPath: o,
+  hideSetup: w,
+  onSetupReady: x,
+  setupState: R,
+  basePath: g = "/",
+  logLevel: A = "warn"
+}) {
+  const p = R !== "ready", E = _(() => new B("SetupModalProcessor", A), [A]), u = T(null), a = _(
+    () => new G(K(g, "bodhijs:")),
+    [g]
+  ), f = T(null), v = d(
+    (t) => t === "direct" ? "lna" : t === "extension" ? "extension" : null,
+    []
+  ), y = d((t) => t.extension === "ready" ? {
+    status: "ready",
+    version: "unknown",
+    // TODO: have ExtensionState also get extension version
+    id: t.extensionId
+  } : t.extension === "not-found" ? {
+    status: "not-installed",
+    error: { message: "Extension not found", code: "ext-not-installed" }
+  } : {
+    status: "unreachable",
+    error: { message: "Client not initialized", code: "ext-connection-failed" }
+  }, []), O = d((t) => {
+    if (t.server.status === "pending-extension-ready")
+      return {
+        status: "pending-extension-ready",
+        error: { message: "Extension not ready", code: "server-pending-ext-ready" }
+      };
+    const r = t.server;
+    switch (r.status) {
+      case "ready":
+        return { status: "ready", version: r.version || "unknown" };
+      case "setup":
+        return {
+          status: "setup",
+          version: r.version || "unknown",
+          error: {
+            message: r.error?.message || "Setup required",
+            code: "server-in-setup-status"
+          }
+        };
+      case "resource-admin":
+        return {
+          status: "resource-admin",
+          version: r.version || "unknown",
+          error: {
+            message: r.error?.message || "Resource admin required",
+            code: "server-in-admin-status"
+          }
+        };
+      case "error":
+        return {
+          status: "error",
+          error: {
+            message: r.error?.message || "Unknown error",
+            code: "server-unexpected-error"
+          }
+        };
+      case "not-reachable":
+        return {
+          status: "unreachable",
+          error: {
+            message: r.error?.message || "Server not reachable",
+            code: "server-conn-refused"
+          }
+        };
+      default:
+        return {
+          status: "unreachable",
+          error: {
+            message: "Unknown server status",
+            code: "server-unexpected-error"
+          }
+        };
+    }
+  }, []), C = d((t) => {
+    if (t.server.status === "not-connected")
+      return { status: "pending-lna-ready" };
+    const r = t.server;
+    switch (r.status) {
+      case "ready":
+        return { status: "ready", version: r.version || "unknown" };
+      case "setup":
+        return { status: "setup", version: r.version || "unknown" };
+      case "resource-admin":
+        return { status: "resource-admin", version: r.version || "unknown" };
+      case "error":
+      case "not-reachable":
+        return {
+          status: "error",
+          error: { message: r.error?.message || "Connection error" }
+        };
+      default:
+        return {
+          status: "error",
+          error: { message: "Unknown server status" }
+        };
+    }
+  }, []), L = d(
+    (t, r) => {
+      if (t.server.status !== "pending-extension-ready") {
+        const s = t.server.status;
+        if (s === "ready" || s === "setup" || s === "resource-admin")
+          return !0;
+      }
+      if (r.server.status !== "not-connected") {
+        const s = r.server.status;
+        if (s === "ready" || s === "setup" || s === "resource-admin")
+          return !0;
+      }
+      return !1;
+    },
+    []
+  ), h = d(
+    (t, r, s) => {
+      if (r === "skipped")
+        return { status: "skipped", serverUrl: s };
+      if (t.server.status !== "not-connected") {
+        const c = t.server;
+        return c.status === "ready" || c.status === "setup" || c.status === "resource-admin" ? { status: "granted", serverUrl: s } : {
+          status: "unreachable",
+          serverUrl: s,
+          error: {
+            message: c.error?.message || "Server unreachable",
+            code: "lna-unreachable"
+          }
+        };
+      }
+      return r === "granted" ? { status: "granted", serverUrl: s } : { status: "prompt", serverUrl: s };
+    },
+    []
+  ), S = d(
+    async (t = !1) => {
+      const r = V().type, s = W().type;
+      let c = await e.getExtensionState();
+      (c.extension === "not-initialized" || t) && (c = await e.testExtensionConnectivity());
+      let n = await e.getDirectState();
+      const i = a.getDirectStatus();
+      i === "granted" && (n.server.status === "not-connected" || t) && (n = await e.testDirectConnectivity());
+      const M = j(n) || "http://localhost:1135", I = h(n, i, M);
+      return e.getConnectionMode() === null && (Y(n) ? await e.setConnectionMode("direct") : q(c) && await e.setConnectionMode("extension")), a.isServerInstallConfirmed() || L(c, n) && a.setServerInstallConfirmed(!0), {
+        extension: y(c),
+        server: O(c),
+        lna: I,
+        lnaServer: C(n),
+        env: { browser: r, os: s },
+        browsers: J,
+        os: X,
+        userConfirmations: { serverInstall: a.isServerInstallConfirmed() },
+        selectedConnection: v(e.getConnectionMode())
+      };
+    },
+    [
+      e,
+      a,
+      y,
+      O,
+      C,
+      v,
+      h,
+      L
+    ]
+  ), l = d(() => {
+    if (!f.current)
+      throw new Error("Cannot get state: currentStateRef is null");
+    return {
+      ...f.current,
+      // Override userConfirmations from storage (in case updated outside buildSetupState)
+      userConfirmations: {
+        serverInstall: a.isServerInstallConfirmed()
+      },
+      // Override selectedConnection from client (in case changed via handler)
+      selectedConnection: v(e.getConnectionMode())
+    };
+  }, [a, e, v]), D = _(
+    () => ({
+      [m.MODAL_READY]: async () => (E.info("MODAL_READY: building initial state"), { setupState: l() }),
+      [m.MODAL_REFRESH]: async () => {
+        E.info("MODAL_REFRESH: refreshing state");
+        const t = await S(!0);
+        f.current = t;
+        const r = l();
+        return E.info(`MODAL_REFRESH: state refreshed
+`, JSON.stringify(r, null, 2)), u.current?.updateState(l()), { setupState: r };
+      },
+      [m.MODAL_LNA_CONNECT]: async (t) => {
+        const r = t.payload.serverUrl;
+        console.log("[SetupModalProcessor] LNA connect:", r);
+        const s = await e.testDirectConnectivity(r);
+        if (s.server.status !== "not-connected") {
+          const n = s.server.status;
+          if (n === "ready" || n === "setup" || n === "resource-admin") {
+            a.setDirectStatus("granted"), e.getConnectionMode() === null && await e.setConnectionMode("direct");
+            const i = await S();
+            return f.current = i, u.current?.updateState(l()), { success: !0 };
+          }
+        }
+        const c = await S();
+        return f.current = c, u.current?.updateState(l()), { success: !1 };
+      },
+      [m.MODAL_LNA_SKIP]: async () => {
+        a.setDirectStatus("skipped");
+        const t = await S();
+        return f.current = t, u.current?.updateState(l()), { success: !0 };
+      },
+      [m.MODAL_CLOSE]: () => {
+        w();
+      },
+      [m.MODAL_COMPLETE]: () => {
+        w();
+      },
+      [m.MODAL_CONFIRM_SERVER_INSTALL]: (t) => (a.setServerInstallConfirmed(t.payload.confirmed), u.current?.updateState(l()), { success: !0 }),
+      [m.MODAL_SELECT_CONNECTION]: async (t) => {
+        const s = t.payload.connection === "lna" ? "direct" : "extension";
+        return await e.setConnectionMode(s), u.current?.updateState(l()), { success: !0 };
+      }
+    }),
+    [E, e, a, S, l, C, w]
+  );
+  return b(() => (u.current = new Z({ modalHtmlPath: o, handlers: D }), () => {
+    u.current?.destroy(), u.current = null;
+  }), [o, D]), b(() => {
+    p && u.current ? S(!0).then((t) => {
+      f.current = t, u.current?.show(t), x?.();
+    }).catch((t) => {
+      console.error("[SetupModalProcessor] buildSetupState failed:", t);
+    }) : !p && u.current && u.current.destroy();
+  }, [p, S, x]), null;
+}
+const oe = {
+  status: "not-initialized",
+  mode: null,
+  extensionId: null,
+  url: null,
+  server: P,
+  error: null
+}, ae = {
+  status: "initializing",
+  mode: null,
+  extensionId: null,
+  url: null,
+  server: P,
+  error: null
+};
+function ie(e) {
+  return e.status === "not-initialized";
+}
+function ue(e) {
+  return e.status === "initializing";
+}
+function ce(e) {
+  return e.status !== "not-initialized" && e.status !== "initializing";
+}
+function U(e) {
+  return e.status === "ready";
+}
+function de(e) {
+  return U(e) && e.server.status === "ready";
+}
+function le(e) {
+  return Q(e) ? {
+    status: e.extension === "not-initialized" ? "initializing" : e.extension === "not-found" ? "extension-not-found" : "ready",
+    mode: "extension",
+    extensionId: e.extensionId,
+    url: null,
+    server: e.server,
+    error: e.server.error
+  } : {
+    status: e.url === null ? "direct-not-connected" : "ready",
+    mode: "direct",
+    extensionId: null,
+    url: e.url,
+    server: e.server,
+    error: e.server.error
+  };
+}
+const ve = {
+  isNotInitialized: ie,
+  isInitializing: ue,
+  isInitialized: ce,
+  isReady: U,
+  isOverallReady: de
+}, z = re(null);
+z.displayName = "BodhiContext";
+function me({
+  children: e,
+  client: o,
+  modalHtmlPath: w,
+  handleCallback: x = !0,
+  callbackPath: R = "/callback",
+  basePath: g = "/",
+  logLevel: A = "warn"
+}) {
+  const p = _(() => new B("BodhiProvider", A), [A]), E = T(!1), u = T(!1), [a, f] = N(oe), [v, y] = N($), [O, C] = N(!1), [L, h] = N("ready");
+  b(() => {
+    const n = (i) => {
+      switch (i.type) {
+        case "client-state":
+          f(le(i.state));
+          break;
+        case "auth-state":
+          y(i.state), C(!1);
+          break;
+      }
+    };
+    return o.setStateCallback(n), () => {
+      o.setStateCallback(ee);
+    };
+  }, [o]);
+  const S = d(async () => {
+    h("loading");
+  }, []), l = d(() => {
+    h("ready");
+  }, []), D = d(() => {
+    h("loaded");
+  }, []), t = d(
+    async (n) => {
+      f(ae);
+      try {
+        await o.init(n || {});
+      } catch (i) {
+        p.error("Init failed:", i);
+      }
+    },
+    [o, p]
+  );
+  b(() => {
+    if (u.current) return;
+    u.current = !0, (async () => {
+      if (await t(), !x) return;
+      const i = new URL(window.location.href);
+      if (i.pathname !== R) return;
+      const k = i.searchParams.get("code"), M = i.searchParams.get("state");
+      !k || !M || E.current || (E.current = !0, te(o) && (C(!0), o.handleOAuthCallback(k, M).then(() => {
+        window.history.replaceState({}, "", g);
+      }).catch((I) => {
+        p.error("OAuth callback failed:", I), y({
+          status: "error",
+          user: null,
+          accessToken: null,
+          error: {
+            message: I instanceof Error ? I.message : "OAuth callback failed",
+            code: "OAUTH_CALLBACK_FAILED"
+          }
+        }), C(!1), window.history.replaceState({}, "", g);
+      })));
+    })();
+  }, [t, o, x, R, g]);
+  const r = d(async () => {
+    C(!0);
+    try {
+      await o.login();
+    } catch (n) {
+      y({
+        status: "error",
+        user: null,
+        accessToken: null,
+        error: {
+          message: n instanceof Error ? n.message : "Login failed",
+          code: "LOGIN_FAILED"
+        }
+      }), C(!1);
+    }
+  }, [o]), s = d(async () => {
+    try {
+      await o.logout();
+    } catch (n) {
+      y({
+        status: "error",
+        user: null,
+        accessToken: null,
+        error: {
+          message: n instanceof Error ? n.message : "Logout failed",
+          code: "LOGOUT_FAILED"
+        }
+      });
+    }
+  }, [o]), c = _(() => {
+    const n = a.status === "ready", i = a.server.status === "ready";
+    return {
+      client: o,
+      clientState: a,
+      auth: v,
+      isAuthLoading: O,
+      login: r,
+      logout: s,
+      showSetup: S,
+      hideSetup: l,
+      setupState: L,
+      // Computed auth properties
+      isAuthenticated: v.status === "authenticated",
+      canLogin: n && !O,
+      // Computed connection properties
+      isReady: n,
+      isServerReady: i,
+      isOverallReady: n && i,
+      isInitializing: a.status === "initializing",
+      isExtension: a.mode === "extension",
+      isDirect: a.mode === "direct"
+    };
+  }, [o, a, v, O, L, r, s, S, l]);
+  return /* @__PURE__ */ F(z.Provider, { value: c, children: [
+    /* @__PURE__ */ H(
+      se,
+      {
+        client: o,
+        modalHtmlPath: w,
+        hideSetup: l,
+        onSetupReady: D,
+        setupState: L,
+        basePath: g,
+        logLevel: A
+      }
+    ),
+    e
+  ] });
+}
+function ge() {
+  const e = ne(z);
+  if (!e) throw new Error("useBodhi must be used within BodhiProvider");
+  return e;
+}
+const pe = "production";
+export {
+  me as BodhiProvider,
+  z as BodhiReactContext,
+  ve as ClientCtxState,
+  ae as INITIALIZING_CLIENT_CONTEXT_STATE,
+  oe as INITIAL_CLIENT_CONTEXT_STATE,
+  pe as REACT_CORE_BUILD_MODE,
+  le as clientStateToContextState,
+  Ae as createApiError,
+  Oe as createOperationError,
+  Le as isApiResultError,
+  he as isApiResultOperationError,
+  we as isApiResultSuccess,
+  xe as isAuthError,
+  Ie as isAuthLoading,
+  _e as isAuthenticated,
+  ce as isClientCtxInitialized,
+  ue as isClientCtxInitializing,
+  ie as isClientCtxNotInitialized,
+  U as isClientCtxReady,
+  Re as isClientReady,
+  De as isDirectState,
+  Me as isExtensionState,
+  Ne as isOperationError,
+  de as isOverallReady,
+  Te as isWebUIClient,
+  ge as useBodhi
+};

package/dist/setup-modal/src/types/extension.d.ts

@@ -0,0 +1,24 @@
+export type ExtensionErrorCode = 'ext-not-installed' | 'ext-connection-failed' | 'ext-unsupported-version';
+export declare const EXT_NOT_INSTALLED: ExtensionErrorCode;
+export declare const EXT_CONNECTION_FAILED: ExtensionErrorCode;
+export declare const EXT_UNSUPPORTED_VERSION: ExtensionErrorCode;
+export interface ExtensionStateReady {
+    /** Current extension status */
+    status: 'ready';
+    /** Extension version */
+    version: string;
+    /** Extension ID (always present when ready) */
+    id: string;
+}
+export interface ExtensionStateNotReady {
+    /** Current extension status */
+    status: 'unreachable' | 'not-installed' | 'unsupported';
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ExtensionErrorCode;
+    };
+}
+export type ExtensionState = ExtensionStateReady | ExtensionStateNotReady;

package/dist/setup-modal/src/types/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Consolidated types for setup-modal
+ *
+ * This folder contains all domain and protocol types organized by domain.
+ * It is designed to be independent and copyable to other packages.
+ */
+export type { BrowserType, OSType, EnvState, SupportedBrowser, NotSupportedBrowser, Browser, SupportedOS, NotSupportedOS, OS } from './platform';
+export type { ExtensionErrorCode, ExtensionStateReady, ExtensionStateNotReady, ExtensionState } from './extension';
+export { EXT_NOT_INSTALLED, EXT_CONNECTION_FAILED, EXT_UNSUPPORTED_VERSION } from './extension';
+export type { ServerErrorCode, ServerStateReady, ServerStateReachable, ServerStatePending, ServerStateUnreachable, ServerStateError, ServerState } from './server';
+export { SERVER_PENDING_EXT_READY, SERVER_CONN_REFUSED, SERVER_CONN_TIMEOUT, SERVER_NOT_FOUND, SERVER_NETWORK_UNREACHABLE, SERVER_SERVICE_UNAVAILABLE, SERVER_UNEXPECTED_ERROR, SERVER_IN_SETUP_STATUS, SERVER_IN_ADMIN_STATUS, } from './server';
+export type { LnaErrorCode, LnaStatePrompt, LnaStateSkipped, LnaStateGranted, LnaStateUnreachable, LnaStateDenied, LnaStateUnsupported, LnaState, LnaServerStatePending, LnaServerStateReady, LnaServerStateSetup, LnaServerStateResourceAdmin, LnaServerStateError, LnaServerState, } from './lna';
+export { LNA_UNREACHABLE, LNA_PERMISSION_DENIED } from './lna';
+export { SetupStep, DEFAULT_USER_CONFIRMATIONS, DEFAULT_SETUP_STATE } from './state';
+export type { SelectedConnection, UserConfirmations, SetupState } from './state';
+export type { RequestId, MessageKind, RequestMessage, ResponseMessage, ErrorMessage, EventMessage, ProtocolMessage } from './protocol';
+export { isRequestMessage, isResponseMessage, isErrorMessage, isEventMessage } from './protocol';
+export type { MessageTypeRegistry, MessageType, RequestPayload, ResponsePayload, RequestHandlers } from './message-types';
+export { MSG, isMessageType } from './message-types';
+export { isExtensionStateReady, isExtensionStateNotReady, isServerStateReady, isServerStateReachable, isServerStatePending, isServerStateUnreachable, isServerStateError, isLnaStatePrompt, isLnaStateSkipped, isLnaStateGranted, isLnaStateUnreachable, isLnaStateDenied, isLnaStateUnsupported, isLnaServerStatePending, isLnaServerStateReady, isLnaServerStateSetup, isLnaServerStateResourceAdmin, isLnaServerStateError, isSupportedBrowser, isNotSupportedBrowser, isSupportedOS, isNotSupportedOS, } from './type-guards';

package/dist/setup-modal/src/types/lna.d.ts

@@ -0,0 +1,56 @@
+export type LnaErrorCode = 'lna-unreachable' | 'lna-permission-denied';
+export declare const LNA_UNREACHABLE: LnaErrorCode;
+export declare const LNA_PERMISSION_DENIED: LnaErrorCode;
+export interface LnaStatePrompt {
+    status: 'prompt';
+    serverUrl?: string;
+}
+export interface LnaStateSkipped {
+    status: 'skipped';
+    serverUrl?: string;
+}
+export interface LnaStateGranted {
+    status: 'granted';
+    serverUrl: string;
+}
+export interface LnaStateUnreachable {
+    status: 'unreachable';
+    serverUrl: string;
+    error: {
+        message: string;
+        code: LnaErrorCode;
+    };
+}
+export interface LnaStateDenied {
+    status: 'denied';
+    error: {
+        message: string;
+        code: LnaErrorCode;
+    };
+}
+export interface LnaStateUnsupported {
+    status: 'unsupported';
+}
+export type LnaState = LnaStatePrompt | LnaStateSkipped | LnaStateGranted | LnaStateUnreachable | LnaStateDenied | LnaStateUnsupported;
+export interface LnaServerStatePending {
+    status: 'pending-lna-ready';
+}
+export interface LnaServerStateReady {
+    status: 'ready';
+    version: string;
+}
+export interface LnaServerStateSetup {
+    status: 'setup';
+    version: string;
+}
+export interface LnaServerStateResourceAdmin {
+    status: 'resource-admin';
+    version: string;
+}
+export interface LnaServerStateError {
+    status: 'error';
+    error: {
+        message: string;
+    };
+}
+export type LnaServerState = LnaServerStatePending | LnaServerStateReady | LnaServerStateSetup | LnaServerStateResourceAdmin | LnaServerStateError;