@meshagent/meshagent-ts-auth 0.35.6

package/dist/browser/mauth-response.d.ts

@@ -0,0 +1,15 @@
+import { Meshagent } from "@meshagent/meshagent";
+import { MeshagentAuth } from "./meshagent-auth";
+import type { StorageLike } from "./storage";
+export declare function getAuthorizationCode(): string | null;
+export declare function normalizedExpiresIn(expiresIn: unknown): number | null;
+export declare function getMeshagentClient(auth: MeshagentAuth, serverUrl: URL | string): Meshagent;
+export interface MAuthResponseProps {
+    serverUrl: string | URL;
+    callbackUrl: string | URL;
+    oauthClientId: string;
+    authorizationCode?: string;
+    storage?: StorageLike;
+    auth?: MeshagentAuth;
+}
+export declare function exchangeToken(props: MAuthResponseProps, signal?: AbortSignal): Promise<void>;

package/dist/browser/meshagent-auth.d.ts

@@ -0,0 +1,40 @@
+import type { StorageLike } from "./storage";
+export type MeshagentUser = Record<string, unknown>;
+export interface MeshagentAuthSnapshot {
+    accessToken: string | null;
+    refreshToken: string | null;
+    expiration: Date | null;
+    user: MeshagentUser | null;
+}
+export interface MeshagentAuthSession {
+    accessToken: string | null;
+    refreshToken: string | null;
+    expiresIn: number | null | undefined;
+}
+type MeshagentAuthListener = () => void;
+export declare class MeshagentAuth {
+    static current: MeshagentAuth;
+    private readonly storage;
+    private readonly listeners;
+    private snapshot;
+    constructor(storage?: StorageLike);
+    subscribe(listener: MeshagentAuthListener): () => void;
+    getSnapshot(): MeshagentAuthSnapshot;
+    setSession(session: MeshagentAuthSession): void;
+    setUser(user: MeshagentUser | null): void;
+    getUser(): MeshagentUser | null;
+    signOut(): void;
+    isLoggedIn(): boolean;
+    get expiration(): Date | null;
+    isExpired(): boolean;
+    getAccessToken(): string | null;
+    getRefreshToken(): string | null;
+    setAccessToken(token: string | null): void;
+    setRefreshToken(refreshToken: string | null): void;
+    setExpiresIn(expiresIn: number | null | undefined): void;
+    private writeValue;
+    private publish;
+    private isEqual;
+}
+export declare const meshagentAuth: MeshagentAuth;
+export {};

package/dist/browser/oauth-session-manager.d.ts

@@ -0,0 +1,22 @@
+import { MeshagentAuth } from "./meshagent-auth";
+export interface OAuthSessionManagerOptions {
+    serverUrl: string | URL;
+    clientId: string;
+    clientSecret?: string;
+    refreshSkew?: number;
+    minValidFor?: number;
+    auth?: MeshagentAuth;
+}
+export declare class OAuthSessionManager {
+    readonly serverUrl: URL;
+    readonly clientId: string;
+    readonly clientSecret?: string;
+    readonly refreshSkew: number;
+    readonly minValidFor: number;
+    private readonly auth;
+    constructor({ serverUrl, clientId, clientSecret, refreshSkew, minValidFor, auth, }: OAuthSessionManagerOptions);
+    get isLoggedIn(): boolean;
+    getValidAccessTokenOrThrow(): Promise<string>;
+    isAccessTokenValidEnough(): boolean;
+    refreshOrThrow(): Promise<void>;
+}

package/dist/browser/pkce-generator.d.ts

@@ -0,0 +1,27 @@
+import type { StorageLike } from "./storage";
+export interface PkceCache {
+    saveVerifier(verifier: string): Promise<void>;
+    readVerifier(): Promise<string | null>;
+    clearVerifier(): Promise<void>;
+}
+export declare class LocalStoragePkceCache implements PkceCache {
+    private readonly storage;
+    constructor(storage?: StorageLike);
+    saveVerifier(verifier: string): Promise<void>;
+    readVerifier(): Promise<string | null>;
+    clearVerifier(): Promise<void>;
+}
+export interface PkcePair {
+    codeVerifier: string;
+    codeChallenge: string;
+}
+export declare class PkceGenerator {
+    static readonly minVerifierLength = 43;
+    static readonly maxVerifierLength = 128;
+    private readonly cryptoApi;
+    constructor(cryptoApi?: Crypto);
+    generate(verifierLength?: number): Promise<PkcePair>;
+    private validateLength;
+    private generateCodeVerifier;
+    private createCodeChallenge;
+}

package/dist/browser/storage.d.ts

@@ -0,0 +1,6 @@
+export interface StorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export declare function getDefaultStorage(): StorageLike;

package/dist/cjs/access-token-provider.d.ts

@@ -0,0 +1,9 @@
+import type { OAuthSessionManagerOptions } from "./oauth-session-manager";
+export interface AccessTokenProvider {
+    getToken(): Promise<string>;
+}
+export declare class RefreshAccessTokenProvider implements AccessTokenProvider {
+    private readonly session;
+    constructor(options: OAuthSessionManagerOptions);
+    getToken(): Promise<string>;
+}

package/dist/cjs/access-token-provider.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshAccessTokenProvider = void 0;
+const oauth_session_manager_1 = require("./oauth-session-manager");
+class RefreshAccessTokenProvider {
+    constructor(options) {
+        Object.defineProperty(this, "session", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.session = new oauth_session_manager_1.OAuthSessionManager(options);
+    }
+    getToken() {
+        return this.session.getValidAccessTokenOrThrow();
+    }
+}
+exports.RefreshAccessTokenProvider = RefreshAccessTokenProvider;

package/dist/cjs/browser-global.d.ts

@@ -0,0 +1,7 @@
+import type * as MeshagentAuthModule from "./index";
+declare global {
+    interface Window {
+        maAuth: typeof MeshagentAuthModule;
+    }
+}
+export {};

package/dist/cjs/browser-global.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/ensure-login.d.ts

@@ -0,0 +1,6 @@
+export declare function ensureLogin({ oauthClientId, serverUrl, callbackUrl, provider, }: {
+    oauthClientId: string;
+    serverUrl?: string;
+    callbackUrl?: string;
+    provider?: string;
+}): Promise<void>;

package/dist/cjs/ensure-login.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureLogin = ensureLogin;
+const pkce_generator_1 = require("./pkce-generator");
+const mauth_response_1 = require("./mauth-response");
+const meshagent_auth_1 = require("./meshagent-auth");
+const storage_1 = require("./storage");
+const DEFAULT_SERVER_URL = "https://api.meshagent.com";
+const CALLBACK_URL_KEY = "ma:callback_url";
+const CALLBACK_SOURCE_QUERY_PARAM = "ma_origin";
+const CALLBACK_SOURCE_QUERY_VALUE = "meshagent_auth";
+function getCurrentUrl() {
+    if (typeof window === "undefined") {
+        throw new Error("ensureLogin requires a browser environment");
+    }
+    return new URL(window.location.href);
+}
+function clearMeshagentAuthQueryParams(url) {
+    url.searchParams.delete("code");
+    url.searchParams.delete("state");
+    url.searchParams.delete("error");
+    url.searchParams.delete("error_description");
+    url.searchParams.delete("error_uri");
+    url.searchParams.delete(CALLBACK_SOURCE_QUERY_PARAM);
+}
+function hasMeshagentCallbackMarker(url) {
+    return url.searchParams.get(CALLBACK_SOURCE_QUERY_PARAM) === CALLBACK_SOURCE_QUERY_VALUE;
+}
+function isMeshagentCallbackUrl(callbackUrl) {
+    const currentUrl = getCurrentUrl();
+    if (!currentUrl.searchParams.has("code")) {
+        return false;
+    }
+    if (!callbackUrl) {
+        return hasMeshagentCallbackMarker(currentUrl);
+    }
+    const expectedCallbackUrl = new URL(callbackUrl, currentUrl);
+    clearMeshagentAuthQueryParams(currentUrl);
+    clearMeshagentAuthQueryParams(expectedCallbackUrl);
+    return currentUrl.toString() === expectedCallbackUrl.toString();
+}
+function getRedirectCallbackUrl(callbackUrl) {
+    if (callbackUrl) {
+        return callbackUrl;
+    }
+    const currentUrl = getCurrentUrl();
+    clearMeshagentAuthQueryParams(currentUrl);
+    currentUrl.searchParams.set(CALLBACK_SOURCE_QUERY_PARAM, CALLBACK_SOURCE_QUERY_VALUE);
+    return currentUrl.toString();
+}
+function getExchangeCallbackUrl(callbackUrl, storage) {
+    if (callbackUrl) {
+        return callbackUrl;
+    }
+    const storedCallbackUrl = storage.getItem(CALLBACK_URL_KEY);
+    if (storedCallbackUrl) {
+        return storedCallbackUrl;
+    }
+    return getRedirectCallbackUrl(undefined);
+}
+function saveCallbackUrl(storage, callbackUrl) {
+    storage.setItem(CALLBACK_URL_KEY, callbackUrl);
+}
+function clearCallbackUrl(storage) {
+    storage.removeItem(CALLBACK_URL_KEY);
+}
+function replaceCurrentUrlWithoutAuthParams() {
+    if (typeof window === "undefined" || typeof window.history.replaceState !== "function") {
+        return;
+    }
+    const currentUrl = getCurrentUrl();
+    clearMeshagentAuthQueryParams(currentUrl);
+    window.history.replaceState(window.history.state, "", currentUrl.toString());
+}
+async function ensureLogin({ oauthClientId, serverUrl, callbackUrl, provider, }) {
+    const serverBaseUrl = serverUrl ?? DEFAULT_SERVER_URL;
+    const storage = (0, storage_1.getDefaultStorage)();
+    const cache = new pkce_generator_1.LocalStoragePkceCache(storage);
+    const authorizationCode = isMeshagentCallbackUrl(callbackUrl)
+        ? (0, mauth_response_1.getAuthorizationCode)()
+        : null;
+    if (authorizationCode) {
+        const exchangeCallbackUrl = getExchangeCallbackUrl(callbackUrl, storage);
+        await (0, mauth_response_1.exchangeToken)({
+            oauthClientId,
+            serverUrl: serverBaseUrl,
+            callbackUrl: exchangeCallbackUrl,
+            authorizationCode,
+            storage,
+            auth: meshagent_auth_1.MeshagentAuth.current,
+        });
+        await cache.clearVerifier();
+        clearCallbackUrl(storage);
+        replaceCurrentUrlWithoutAuthParams();
+        return;
+    }
+    if (meshagent_auth_1.MeshagentAuth.current.isLoggedIn()) {
+        return;
+    }
+    const redirectCallbackUrl = getRedirectCallbackUrl(callbackUrl);
+    const generator = new pkce_generator_1.PkceGenerator();
+    const pkce = await generator.generate();
+    await cache.saveVerifier(pkce.codeVerifier);
+    saveCallbackUrl(storage, redirectCallbackUrl);
+    const query = new URLSearchParams({
+        scope: "email",
+        client_id: oauthClientId,
+        code_challenge: pkce.codeChallenge,
+        response_type: "code",
+        redirect_uri: redirectCallbackUrl,
+        prompt: "select_account",
+    });
+    if (provider) {
+        query.set("provider", provider);
+    }
+    const authorizeUrl = new URL(`/oauth/authorize?${query.toString()}`, serverBaseUrl);
+    window.location.assign(authorizeUrl.toString());
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./access-token-provider";
+export * from "./ensure-login";
+export * from "./mauth-response";
+export * from "./meshagent-auth";
+export * from "./oauth-session-manager";
+export * from "./pkce-generator";
+export * from "./storage";

package/dist/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./access-token-provider"), exports);
+__exportStar(require("./ensure-login"), exports);
+__exportStar(require("./mauth-response"), exports);
+__exportStar(require("./meshagent-auth"), exports);
+__exportStar(require("./oauth-session-manager"), exports);
+__exportStar(require("./pkce-generator"), exports);
+__exportStar(require("./storage"), exports);

package/dist/cjs/mauth-response.d.ts

@@ -0,0 +1,15 @@
+import { Meshagent } from "@meshagent/meshagent";
+import { MeshagentAuth } from "./meshagent-auth";
+import type { StorageLike } from "./storage";
+export declare function getAuthorizationCode(): string | null;
+export declare function normalizedExpiresIn(expiresIn: unknown): number | null;
+export declare function getMeshagentClient(auth: MeshagentAuth, serverUrl: URL | string): Meshagent;
+export interface MAuthResponseProps {
+    serverUrl: string | URL;
+    callbackUrl: string | URL;
+    oauthClientId: string;
+    authorizationCode?: string;
+    storage?: StorageLike;
+    auth?: MeshagentAuth;
+}
+export declare function exchangeToken(props: MAuthResponseProps, signal?: AbortSignal): Promise<void>;

package/dist/cjs/mauth-response.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthorizationCode = getAuthorizationCode;
+exports.normalizedExpiresIn = normalizedExpiresIn;
+exports.getMeshagentClient = getMeshagentClient;
+exports.exchangeToken = exchangeToken;
+const meshagent_1 = require("@meshagent/meshagent");
+const meshagent_auth_1 = require("./meshagent-auth");
+const pkce_generator_1 = require("./pkce-generator");
+const storage_1 = require("./storage");
+function toUrl(value) {
+    return value instanceof URL ? value : new URL(value);
+}
+function getAuthorizationCode() {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    const url = new URL(window.location.href);
+    return url.searchParams.get("code");
+}
+function normalizedExpiresIn(expiresIn) {
+    if (typeof expiresIn === "number" && Number.isFinite(expiresIn)) {
+        return expiresIn;
+    }
+    if (typeof expiresIn === "string") {
+        if (expiresIn.trim() === "") {
+            return null;
+        }
+        const val = Number(expiresIn);
+        if (Number.isFinite(val)) {
+            return val;
+        }
+    }
+    return null;
+}
+function getMeshagentClient(auth, serverUrl) {
+    const token = auth.getAccessToken();
+    const baseUrl = serverUrl.toString();
+    if (!token) {
+        throw Error("No access token - you are not logged in");
+    }
+    return new meshagent_1.Meshagent({ baseUrl, token });
+}
+async function exchangeToken(props, signal) {
+    const serverUrl = toUrl(props.serverUrl);
+    const callbackUrl = toUrl(props.callbackUrl);
+    const authorizationCode = props.authorizationCode ?? getAuthorizationCode();
+    const storage = props.storage ?? (0, storage_1.getDefaultStorage)();
+    const auth = props.auth ?? meshagent_auth_1.MeshagentAuth.current;
+    const cache = new pkce_generator_1.LocalStoragePkceCache(storage);
+    if (!authorizationCode) {
+        throw new Error("Missing authorization code");
+    }
+    const codeVerifier = await cache.readVerifier();
+    if (!codeVerifier) {
+        throw new Error("Missing PKCE code verifier");
+    }
+    const response = await fetch(new URL("/oauth/token", serverUrl), {
+        method: "POST",
+        signal,
+        headers: {
+            "content-type": "application/json",
+            "accept": "application/json",
+        },
+        body: JSON.stringify({
+            "client_id": props.oauthClientId,
+            "code_verifier": codeVerifier,
+            "code": authorizationCode,
+            "grant_type": "authorization_code",
+            "redirect_uri": callbackUrl.toString(),
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Token exchange failed: ${response.status} ${await response.text()}`);
+    }
+    const data = await response.json();
+    const accessToken = data["access_token"];
+    const refreshToken = data["refresh_token"];
+    const expiresIn = data["expires_in"];
+    if (typeof accessToken !== "string" || accessToken.length === 0) {
+        throw new Error("Token exchange response missing access token");
+    }
+    auth.setAccessToken(accessToken);
+    if (typeof refreshToken !== "string" || refreshToken.length === 0) {
+        throw new Error("Token exchange response missing refresh token");
+    }
+    auth.setRefreshToken(refreshToken);
+    const client = getMeshagentClient(auth, serverUrl);
+    const me = await client.getUserProfile("me");
+    if (me) {
+        auth.setUser(me);
+    }
+    auth.setExpiresIn(normalizedExpiresIn(expiresIn));
+}

package/dist/cjs/meshagent-auth.d.ts

@@ -0,0 +1,40 @@
+import type { StorageLike } from "./storage";
+export type MeshagentUser = Record<string, unknown>;
+export interface MeshagentAuthSnapshot {
+    accessToken: string | null;
+    refreshToken: string | null;
+    expiration: Date | null;
+    user: MeshagentUser | null;
+}
+export interface MeshagentAuthSession {
+    accessToken: string | null;
+    refreshToken: string | null;
+    expiresIn: number | null | undefined;
+}
+type MeshagentAuthListener = () => void;
+export declare class MeshagentAuth {
+    static current: MeshagentAuth;
+    private readonly storage;
+    private readonly listeners;
+    private snapshot;
+    constructor(storage?: StorageLike);
+    subscribe(listener: MeshagentAuthListener): () => void;
+    getSnapshot(): MeshagentAuthSnapshot;
+    setSession(session: MeshagentAuthSession): void;
+    setUser(user: MeshagentUser | null): void;
+    getUser(): MeshagentUser | null;
+    signOut(): void;
+    isLoggedIn(): boolean;
+    get expiration(): Date | null;
+    isExpired(): boolean;
+    getAccessToken(): string | null;
+    getRefreshToken(): string | null;
+    setAccessToken(token: string | null): void;
+    setRefreshToken(refreshToken: string | null): void;
+    setExpiresIn(expiresIn: number | null | undefined): void;
+    private writeValue;
+    private publish;
+    private isEqual;
+}
+export declare const meshagentAuth: MeshagentAuth;
+export {};

package/dist/cjs/meshagent-auth.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meshagentAuth = exports.MeshagentAuth = void 0;
+const storage_1 = require("./storage");
+const ACCESS_TOKEN_KEY = "ma:access_token";
+const REFRESH_TOKEN_KEY = "ma:refresh_token";
+const EXPIRATION_KEY = "ma:expiration";
+function parseExpiration(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function buildExpiration(expiresIn) {
+    if (expiresIn == null || !Number.isFinite(expiresIn)) {
+        return null;
+    }
+    return new Date(Date.now() + expiresIn * 1000);
+}
+function sameDate(left, right) {
+    if (left === right) {
+        return true;
+    }
+    if (!left || !right) {
+        return false;
+    }
+    return left.getTime() === right.getTime();
+}
+class MeshagentAuth {
+    constructor(storage = (0, storage_1.getDefaultStorage)()) {
+        Object.defineProperty(this, "storage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "snapshot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.storage = storage;
+        this.snapshot = {
+            accessToken: this.storage.getItem(ACCESS_TOKEN_KEY),
+            refreshToken: this.storage.getItem(REFRESH_TOKEN_KEY),
+            expiration: parseExpiration(this.storage.getItem(EXPIRATION_KEY)),
+            user: null,
+        };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    setSession(session) {
+        this.writeValue(ACCESS_TOKEN_KEY, session.accessToken);
+        this.writeValue(REFRESH_TOKEN_KEY, session.refreshToken);
+        const expiration = buildExpiration(session.expiresIn);
+        if (expiration) {
+            this.storage.setItem(EXPIRATION_KEY, expiration.toISOString());
+        }
+        else {
+            this.storage.removeItem(EXPIRATION_KEY);
+        }
+        this.publish({
+            ...this.snapshot,
+            accessToken: session.accessToken,
+            refreshToken: session.refreshToken,
+            expiration,
+        });
+    }
+    setUser(user) {
+        this.publish({
+            ...this.snapshot,
+            user,
+        });
+    }
+    getUser() {
+        return this.snapshot.user;
+    }
+    signOut() {
+        this.writeValue(ACCESS_TOKEN_KEY, null);
+        this.writeValue(REFRESH_TOKEN_KEY, null);
+        this.storage.removeItem(EXPIRATION_KEY);
+        this.publish({
+            accessToken: null,
+            refreshToken: null,
+            expiration: null,
+            user: null,
+        });
+    }
+    isLoggedIn() {
+        return this.snapshot.accessToken !== null;
+    }
+    get expiration() {
+        return this.snapshot.expiration;
+    }
+    isExpired() {
+        const expiration = this.expiration;
+        return expiration ? expiration.getTime() <= Date.now() : false;
+    }
+    getAccessToken() {
+        return this.snapshot.accessToken;
+    }
+    getRefreshToken() {
+        return this.snapshot.refreshToken;
+    }
+    setAccessToken(token) {
+        this.writeValue(ACCESS_TOKEN_KEY, token);
+        this.publish({
+            ...this.snapshot,
+            accessToken: token,
+        });
+    }
+    setRefreshToken(refreshToken) {
+        this.writeValue(REFRESH_TOKEN_KEY, refreshToken);
+        this.publish({
+            ...this.snapshot,
+            refreshToken,
+        });
+    }
+    setExpiresIn(expiresIn) {
+        const expiration = buildExpiration(expiresIn);
+        if (expiration) {
+            this.storage.setItem(EXPIRATION_KEY, expiration.toISOString());
+        }
+        else {
+            this.storage.removeItem(EXPIRATION_KEY);
+        }
+        this.publish({
+            ...this.snapshot,
+            expiration,
+        });
+    }
+    writeValue(key, value) {
+        if (!value) {
+            this.storage.removeItem(key);
+            return;
+        }
+        this.storage.setItem(key, value);
+    }
+    publish(nextSnapshot) {
+        if (this.isEqual(nextSnapshot)) {
+            return;
+        }
+        this.snapshot = nextSnapshot;
+        for (const listener of this.listeners) {
+            listener();
+        }
+    }
+    isEqual(nextSnapshot) {
+        return this.snapshot.accessToken === nextSnapshot.accessToken
+            && this.snapshot.refreshToken === nextSnapshot.refreshToken
+            && sameDate(this.snapshot.expiration, nextSnapshot.expiration)
+            && this.snapshot.user === nextSnapshot.user;
+    }
+}
+exports.MeshagentAuth = MeshagentAuth;
+Object.defineProperty(MeshagentAuth, "current", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new MeshagentAuth()
+});
+exports.meshagentAuth = MeshagentAuth.current;

package/dist/cjs/oauth-session-manager.d.ts

@@ -0,0 +1,22 @@
+import { MeshagentAuth } from "./meshagent-auth";
+export interface OAuthSessionManagerOptions {
+    serverUrl: string | URL;
+    clientId: string;
+    clientSecret?: string;
+    refreshSkew?: number;
+    minValidFor?: number;
+    auth?: MeshagentAuth;
+}
+export declare class OAuthSessionManager {
+    readonly serverUrl: URL;
+    readonly clientId: string;
+    readonly clientSecret?: string;
+    readonly refreshSkew: number;
+    readonly minValidFor: number;
+    private readonly auth;
+    constructor({ serverUrl, clientId, clientSecret, refreshSkew, minValidFor, auth, }: OAuthSessionManagerOptions);
+    get isLoggedIn(): boolean;
+    getValidAccessTokenOrThrow(): Promise<string>;
+    isAccessTokenValidEnough(): boolean;
+    refreshOrThrow(): Promise<void>;
+}