@microcosmmoney/auth-core 1.0.0

package/dist/api-client.d.ts

@@ -0,0 +1,9 @@
+import { TokenManager } from './token-manager';
+export declare class ApiClient {
+    private tokenManager;
+    constructor(tokenManager: TokenManager);
+    fetch<T>(path: string, options?: RequestInit): Promise<T>;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body: unknown): Promise<T>;
+    patch<T>(path: string, body: unknown): Promise<T>;
+}

package/dist/api-client.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const OPEN_API_BASE = 'https://api.microcosm.money/v1';
+class ApiClient {
+    constructor(tokenManager) {
+        this.tokenManager = tokenManager;
+    }
+    async fetch(path, options = {}) {
+        const token = await this.tokenManager.getAccessToken();
+        const headers = {
+            'Accept': 'application/json',
+            ...(options.headers || {}),
+        };
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        if (options.body && !headers['Content-Type']) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const response = await fetch(`${OPEN_API_BASE}${path}`, {
+            ...options,
+            headers,
+        });
+        if (response.status === 429) {
+            const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
+            await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
+            return this.fetch(path, options);
+        }
+        const contentType = response.headers.get('content-type');
+        if (!contentType?.includes('application/json')) {
+            const text = await response.text();
+            throw new Error(`Non-JSON response from API: ${text.substring(0, 200)}`);
+        }
+        const data = await response.json();
+        if (!response.ok) {
+            throw new Error(data.detail || data.error?.message || data.message || `API error ${response.status}`);
+        }
+        return data;
+    }
+    async get(path) {
+        return this.fetch(path);
+    }
+    async post(path, body) {
+        return this.fetch(path, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    async patch(path, body) {
+        return this.fetch(path, {
+            method: 'PATCH',
+            body: JSON.stringify(body),
+        });
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/client.d.ts

@@ -0,0 +1,26 @@
+import { MicrocosmAuthConfig, User, LoginOptions } from './types';
+import { ApiClient } from './api-client';
+export declare class MicrocosmAuthClient {
+    private config;
+    private storage;
+    private tokenManager;
+    private apiClient;
+    private listeners;
+    constructor(config: MicrocosmAuthConfig);
+    login(options?: LoginOptions): void;
+    handleCallback(): Promise<User>;
+    logout(): Promise<void>;
+    getUser(): User | null;
+    setUser(user: User): void;
+    isAuthenticated(): boolean;
+    getAccessToken(): Promise<string | null>;
+    getApiClient(): ApiClient;
+    onAuthStateChange(callback: (user: User | null) => void): () => void;
+    private fetchUserProfile;
+    private mapProfileToUser;
+    private resolveRedirectUri;
+    private generateState;
+    private safeJson;
+    private notifyListeners;
+    private log;
+}

package/dist/client.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrocosmAuthClient = void 0;
+const token_manager_1 = require("./token-manager");
+const storage_1 = require("./storage");
+const api_client_1 = require("./api-client");
+const DEFAULT_CONFIG = {
+    scope: ['openid', 'profile', 'email'],
+    authEndpoint: 'https://microcosm.money',
+    tokenExchangeUri: '/api/auth/exchange',
+    profileUri: '/api/users/profile',
+    storage: 'localStorage',
+    autoRefresh: true,
+    refreshBuffer: 300,
+    debug: false,
+};
+class MicrocosmAuthClient {
+    constructor(config) {
+        this.listeners = new Set();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.storage = new storage_1.Storage(this.config.storage);
+        this.tokenManager = new token_manager_1.TokenManager(this.config, this.storage);
+        this.apiClient = new api_client_1.ApiClient(this.tokenManager);
+        if (this.config.autoRefresh && this.tokenManager.hasValidToken()) {
+            this.tokenManager.scheduleRefresh();
+        }
+        this.log('Initialized', { clientId: this.config.clientId });
+    }
+    login(options) {
+        const state = this.generateState();
+        this.storage.set(storage_1.STORAGE_KEYS.OAUTH_STATE, state);
+        const redirectUri = this.resolveRedirectUri();
+        const params = new URLSearchParams({
+            oauth: 'true',
+            response_type: 'code',
+            client_id: this.config.clientId,
+            redirect_uri: redirectUri,
+            scope: this.config.scope.join(' '),
+            state: state,
+        });
+        if (options?.prompt) {
+            params.set('prompt', options.prompt);
+        }
+        const authUrl = `${this.config.authEndpoint}/login?${params.toString()}`;
+        this.log('Redirecting to:', authUrl);
+        if (typeof window !== 'undefined') {
+            window.location.href = authUrl;
+        }
+    }
+    async handleCallback() {
+        if (typeof window === 'undefined') {
+            throw new Error('handleCallback must be called in browser');
+        }
+        const params = new URLSearchParams(window.location.search);
+        const code = params.get('code');
+        const state = params.get('state');
+        const error = params.get('error');
+        if (error) {
+            throw new Error(params.get('error_description') || error);
+        }
+        if (!code) {
+            throw new Error('Missing authorization code');
+        }
+        const savedState = this.storage.get(storage_1.STORAGE_KEYS.OAUTH_STATE);
+        if (state && savedState && state !== savedState) {
+            throw new Error('Invalid state parameter (possible CSRF)');
+        }
+        this.storage.remove(storage_1.STORAGE_KEYS.OAUTH_STATE);
+        this.log('Exchanging code for tokens...');
+        const tokenResponse = await fetch(this.config.tokenExchangeUri, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ code }),
+        });
+        if (!tokenResponse.ok) {
+            const errorData = await this.safeJson(tokenResponse);
+            throw new Error(errorData.error_description || errorData.error || 'Token exchange failed');
+        }
+        const tokenData = await tokenResponse.json();
+        const tokens = {
+            accessToken: tokenData.access_token,
+            refreshToken: tokenData.refresh_token,
+            expiresAt: Date.now() + (tokenData.expires_in || 3600) * 1000,
+        };
+        this.tokenManager.setTokens(tokens);
+        const user = await this.fetchUserProfile(tokens.accessToken);
+        this.storage.set(storage_1.STORAGE_KEYS.USER, JSON.stringify(user));
+        this.notifyListeners(user);
+        this.log('Login successful:', user.uid);
+        return user;
+    }
+    async logout() {
+        this.tokenManager.clear();
+        this.storage.remove(storage_1.STORAGE_KEYS.USER);
+        this.notifyListeners(null);
+        this.log('Logged out');
+    }
+    getUser() {
+        const userJson = this.storage.get(storage_1.STORAGE_KEYS.USER);
+        if (!userJson)
+            return null;
+        try {
+            return JSON.parse(userJson);
+        }
+        catch {
+            return null;
+        }
+    }
+    setUser(user) {
+        this.storage.set(storage_1.STORAGE_KEYS.USER, JSON.stringify(user));
+        this.notifyListeners(user);
+    }
+    isAuthenticated() {
+        return this.tokenManager.hasValidToken() && this.getUser() !== null;
+    }
+    async getAccessToken() {
+        return this.tokenManager.getAccessToken();
+    }
+    getApiClient() {
+        return this.apiClient;
+    }
+    onAuthStateChange(callback) {
+        this.listeners.add(callback);
+        return () => this.listeners.delete(callback);
+    }
+    async fetchUserProfile(accessToken) {
+        const response = await fetch(this.config.profileUri, {
+            headers: { Authorization: `Bearer ${accessToken}` },
+        });
+        if (!response.ok) {
+            this.log('Profile fetch failed, using minimal user');
+            return { uid: '', email: '', role: 'user' };
+        }
+        const data = await response.json();
+        const profile = data.user || data;
+        return this.mapProfileToUser(profile);
+    }
+    mapProfileToUser(profile) {
+        return {
+            uid: profile.uid,
+            email: profile.email || '',
+            displayName: profile.display_name || null,
+            avatarUrl: profile.avatar_url || null,
+            role: profile.role || 'user',
+            level: profile.level || undefined,
+            title: profile.title || null,
+            stationId: profile.station_id || null,
+            emailVerified: profile.email_verified,
+        };
+    }
+    resolveRedirectUri() {
+        const uri = this.config.redirectUri;
+        if (uri.startsWith('http'))
+            return uri;
+        if (typeof window !== 'undefined') {
+            return `${window.location.origin}${uri.startsWith('/') ? '' : '/'}${uri}`;
+        }
+        return uri;
+    }
+    generateState() {
+        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+            const array = new Uint8Array(32);
+            crypto.getRandomValues(array);
+            return Array.from(array, b => b.toString(16).padStart(2, '0')).join('');
+        }
+        return Math.random().toString(36).substring(2) + Date.now().toString(36);
+    }
+    async safeJson(response) {
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+            return response.json();
+        }
+        const text = await response.text();
+        return { error: 'Non-JSON Response', message: text.substring(0, 200) };
+    }
+    notifyListeners(user) {
+        this.listeners.forEach(callback => {
+            try {
+                callback(user);
+            }
+            catch (e) {
+                console.error('[MicrocosmAuth] Listener error:', e);
+            }
+        });
+    }
+    log(...args) {
+        if (this.config.debug) {
+            console.log('[MicrocosmAuth]', ...args);
+        }
+    }
+}
+exports.MicrocosmAuthClient = MicrocosmAuthClient;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { MicrocosmAuthClient } from './client';
+export { TokenManager } from './token-manager';
+export { Storage, STORAGE_KEYS } from './storage';
+export { ApiClient } from './api-client';
+export { MicrocosmAPI } from './open-api';
+export type { MicrocosmAPIConfig } from './open-api';
+export type { MicrocosmAuthConfig, ResolvedConfig, User, TokenData, AuthState, LoginOptions, TokenExchangeResponse, UserProfileResponse, ApiResponse, MCDBalance, MCCBalance, MCCPrice, } from './types';

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrocosmAPI = exports.ApiClient = exports.STORAGE_KEYS = exports.Storage = exports.TokenManager = exports.MicrocosmAuthClient = void 0;
+// AI-generated · AI-managed · AI-maintained
+var client_1 = require("./client");
+Object.defineProperty(exports, "MicrocosmAuthClient", { enumerable: true, get: function () { return client_1.MicrocosmAuthClient; } });
+var token_manager_1 = require("./token-manager");
+Object.defineProperty(exports, "TokenManager", { enumerable: true, get: function () { return token_manager_1.TokenManager; } });
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "Storage", { enumerable: true, get: function () { return storage_1.Storage; } });
+Object.defineProperty(exports, "STORAGE_KEYS", { enumerable: true, get: function () { return storage_1.STORAGE_KEYS; } });
+var api_client_1 = require("./api-client");
+Object.defineProperty(exports, "ApiClient", { enumerable: true, get: function () { return api_client_1.ApiClient; } });
+var open_api_1 = require("./open-api");
+Object.defineProperty(exports, "MicrocosmAPI", { enumerable: true, get: function () { return open_api_1.MicrocosmAPI; } });

package/dist/open-api.d.ts

@@ -0,0 +1,75 @@
+export interface MicrocosmAPIConfig {
+    baseUrl?: string;
+    timeout?: number;
+}
+interface ApiRes<T> {
+    success: boolean;
+    data: T;
+}
+export declare class MicrocosmAPI {
+    private base;
+    constructor(config?: MicrocosmAPIConfig);
+    readonly mcc: {
+        getPrice: () => Promise<ApiRes<any>>;
+        getStats: () => Promise<ApiRes<any>>;
+        getBalance: (token: string) => Promise<ApiRes<any>>;
+        getHolders: () => Promise<ApiRes<any>>;
+        getMiningHistory: (days?: number) => Promise<ApiRes<any>>;
+    };
+    readonly mcd: {
+        getBalance: (token: string) => Promise<ApiRes<any>>;
+        getStats: () => Promise<ApiRes<any>>;
+    };
+    readonly reincarnation: {
+        getPool: () => Promise<ApiRes<any>>;
+        getBuybackPrice: () => Promise<ApiRes<any>>;
+    };
+    readonly mining: {
+        getRecords: (token: string, params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<ApiRes<any>>;
+        getStats: (token: string) => Promise<ApiRes<any>>;
+    };
+    readonly users: {
+        getProfile: (token: string) => Promise<ApiRes<any>>;
+        getLevel: (token: string) => Promise<ApiRes<any>>;
+    };
+    readonly dashboard: {
+        getMarket: () => Promise<ApiRes<any>>;
+        getPlatform: () => Promise<ApiRes<any>>;
+        getUserSummary: (wallet: string) => Promise<ApiRes<any>>;
+    };
+    readonly territory: {
+        getCollection: () => Promise<ApiRes<any>>;
+        getNft: (mint: string) => Promise<ApiRes<any>>;
+        getUserNfts: (wallet: string) => Promise<ApiRes<any>>;
+    };
+    readonly auctions: {
+        getConfig: () => Promise<ApiRes<any>>;
+        getActive: () => Promise<ApiRes<any>>;
+        getDetails: (id: number) => Promise<ApiRes<any>>;
+        getBids: (id: number) => Promise<ApiRes<any>>;
+    };
+    readonly techTree: {
+        getConfig: () => Promise<ApiRes<any>>;
+        getUser: (token: string) => Promise<ApiRes<any>>;
+        getBonus: (token: string) => Promise<ApiRes<any>>;
+        unlock: (token: string, nodeId: string) => Promise<ApiRes<any>>;
+        upgrade: (token: string, nodeId: string) => Promise<ApiRes<any>>;
+    };
+    readonly fragment: {
+        getConfig: () => Promise<ApiRes<any>>;
+        getVaults: () => Promise<ApiRes<any>>;
+        getVault: (id: number) => Promise<ApiRes<any>>;
+    };
+    readonly lending: {
+        getPool: () => Promise<ApiRes<any>>;
+        getStats: () => Promise<ApiRes<any>>;
+        getPosition: (wallet: string) => Promise<ApiRes<any>>;
+    };
+    readonly organizations: {
+        getList: (token: string) => Promise<ApiRes<any>>;
+    };
+}
+export {};

package/dist/open-api.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrocosmAPI = void 0;
+// AI-generated · AI-managed · AI-maintained
+const DEFAULT_BASE = 'https://api.microcosm.money/v1';
+async function request(baseUrl, path, token) {
+    const headers = { 'Accept': 'application/json' };
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    const res = await fetch(`${baseUrl}${path}`, { headers });
+    if (res.status === 429) {
+        const retry = parseInt(res.headers.get('Retry-After') || '60');
+        await new Promise(r => setTimeout(r, retry * 1000));
+        return request(baseUrl, path, token);
+    }
+    const data = await res.json();
+    if (!res.ok)
+        throw new Error(data.detail || `API error ${res.status}`);
+    return data;
+}
+async function postRequest(baseUrl, path, body, token) {
+    const headers = {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+    };
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    const res = await fetch(`${baseUrl}${path}`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    if (!res.ok)
+        throw new Error(data.detail || `API error ${res.status}`);
+    return data;
+}
+class MicrocosmAPI {
+    constructor(config) {
+        this.mcc = {
+            getPrice: () => request(this.base, '/mcc/price'),
+            getStats: () => request(this.base, '/mcc/stats'),
+            getBalance: (token) => request(this.base, '/mcc/balance', token),
+            getHolders: () => request(this.base, '/reincarnation/holders'),
+            getMiningHistory: (days = 30) => request(this.base, `/reincarnation/mining-history?days=${days}`),
+        };
+        this.mcd = {
+            getBalance: (token) => request(this.base, '/mcd/balance', token),
+            getStats: () => request(this.base, '/mcd/stats'),
+        };
+        this.reincarnation = {
+            getPool: () => request(this.base, '/reincarnation/pool'),
+            getBuybackPrice: () => request(this.base, '/reincarnation/buyback-price'),
+        };
+        this.mining = {
+            getRecords: (token, params) => {
+                const qs = params ? `?limit=${params.limit || 20}&offset=${params.offset || 0}` : '';
+                return request(this.base, `/mining/records${qs}`, token);
+            },
+            getStats: (token) => request(this.base, '/mining/stats', token),
+        };
+        this.users = {
+            getProfile: (token) => request(this.base, '/users/me', token),
+            getLevel: (token) => request(this.base, '/users/me/level', token),
+        };
+        this.dashboard = {
+            getMarket: () => request(this.base, '/dashboard/market'),
+            getPlatform: () => request(this.base, '/dashboard/platform'),
+            getUserSummary: (wallet) => request(this.base, `/dashboard/user/${wallet}`),
+        };
+        this.territory = {
+            getCollection: () => request(this.base, '/territory/collection'),
+            getNft: (mint) => request(this.base, `/territory/nft/${mint}`),
+            getUserNfts: (wallet) => request(this.base, `/territory/nfts/${wallet}`),
+        };
+        this.auctions = {
+            getConfig: () => request(this.base, '/auction-solana/config'),
+            getActive: () => request(this.base, '/auction-solana/active'),
+            getDetails: (id) => request(this.base, `/auction-solana/auction/${id}`),
+            getBids: (id) => request(this.base, `/auction-solana/auction/${id}/bids`),
+        };
+        this.techTree = {
+            getConfig: () => request(this.base, '/tech-tree/config'),
+            getUser: (token) => request(this.base, '/tech-tree/user', token),
+            getBonus: (token) => request(this.base, '/tech-tree/bonus', token),
+            unlock: (token, nodeId) => postRequest(this.base, '/tech-tree/unlock', { node_id: nodeId }, token),
+            upgrade: (token, nodeId) => postRequest(this.base, '/tech-tree/upgrade', { node_id: nodeId }, token),
+        };
+        this.fragment = {
+            getConfig: () => request(this.base, '/fragment/config'),
+            getVaults: () => request(this.base, '/fragment/vaults'),
+            getVault: (id) => request(this.base, `/fragment/vault/${id}`),
+        };
+        this.lending = {
+            getPool: () => request(this.base, '/lending/pool'),
+            getStats: () => request(this.base, '/lending/stats'),
+            getPosition: (wallet) => request(this.base, `/lending/position/${wallet}`),
+        };
+        this.organizations = {
+            getList: (token) => request(this.base, '/organizations', token),
+        };
+        this.base = (config?.baseUrl || DEFAULT_BASE).replace(/\/$/, '');
+    }
+}
+exports.MicrocosmAPI = MicrocosmAPI;

package/dist/storage.d.ts

@@ -0,0 +1,17 @@
+export declare class Storage {
+    private type;
+    private memoryStore;
+    constructor(type?: 'localStorage' | 'sessionStorage' | 'memory');
+    private prefixKey;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+    clear(): void;
+}
+export declare const STORAGE_KEYS: {
+    readonly ACCESS_TOKEN: "access_token";
+    readonly REFRESH_TOKEN: "refresh_token";
+    readonly EXPIRES_AT: "token_expires_at";
+    readonly USER: "user";
+    readonly OAUTH_STATE: "oauth_state";
+};

package/dist/storage.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STORAGE_KEYS = exports.Storage = void 0;
+// AI-generated · AI-managed · AI-maintained
+const KEY_PREFIX = 'mc_';
+class Storage {
+    constructor(type = 'localStorage') {
+        this.memoryStore = new Map();
+        this.type = type;
+    }
+    prefixKey(key) {
+        return key.startsWith(KEY_PREFIX) ? key : `${KEY_PREFIX}${key}`;
+    }
+    get(key) {
+        const prefixed = this.prefixKey(key);
+        try {
+            if (this.type === 'memory') {
+                return this.memoryStore.get(prefixed) ?? null;
+            }
+            if (typeof window === 'undefined')
+                return null;
+            const store = this.type === 'localStorage' ? window.localStorage : window.sessionStorage;
+            return store.getItem(prefixed);
+        }
+        catch {
+            return this.memoryStore.get(prefixed) ?? null;
+        }
+    }
+    set(key, value) {
+        const prefixed = this.prefixKey(key);
+        try {
+            if (this.type === 'memory') {
+                this.memoryStore.set(prefixed, value);
+                return;
+            }
+            if (typeof window === 'undefined') {
+                this.memoryStore.set(prefixed, value);
+                return;
+            }
+            const store = this.type === 'localStorage' ? window.localStorage : window.sessionStorage;
+            store.setItem(prefixed, value);
+        }
+        catch {
+            this.memoryStore.set(prefixed, value);
+        }
+    }
+    remove(key) {
+        const prefixed = this.prefixKey(key);
+        try {
+            this.memoryStore.delete(prefixed);
+            if (this.type !== 'memory' && typeof window !== 'undefined') {
+                const store = this.type === 'localStorage' ? window.localStorage : window.sessionStorage;
+                store.removeItem(prefixed);
+            }
+        }
+        catch {
+            this.memoryStore.delete(prefixed);
+        }
+    }
+    clear() {
+        const keysToRemove = [];
+        try {
+            if (this.type !== 'memory' && typeof window !== 'undefined') {
+                const store = this.type === 'localStorage' ? window.localStorage : window.sessionStorage;
+                for (let i = 0; i < store.length; i++) {
+                    const key = store.key(i);
+                    if (key?.startsWith(KEY_PREFIX)) {
+                        keysToRemove.push(key);
+                    }
+                }
+                keysToRemove.forEach(k => store.removeItem(k));
+            }
+        }
+        catch {
+        }
+        this.memoryStore.clear();
+    }
+}
+exports.Storage = Storage;
+exports.STORAGE_KEYS = {
+    ACCESS_TOKEN: 'access_token',
+    REFRESH_TOKEN: 'refresh_token',
+    EXPIRES_AT: 'token_expires_at',
+    USER: 'user',
+    OAUTH_STATE: 'oauth_state',
+};

package/dist/token-manager.d.ts

@@ -0,0 +1,18 @@
+import { ResolvedConfig, TokenData } from './types';
+import { Storage } from './storage';
+export declare class TokenManager {
+    private config;
+    private storage;
+    private refreshTimer;
+    private refreshPromise;
+    constructor(config: ResolvedConfig, storage: Storage);
+    setTokens(data: TokenData): void;
+    getAccessToken(): Promise<string | null>;
+    getRawAccessToken(): string | null;
+    hasValidToken(): boolean;
+    isExpired(): boolean;
+    clear(): void;
+    scheduleRefresh(): void;
+    private refreshToken;
+    private doRefresh;
+}

package/dist/token-manager.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenManager = void 0;
+const storage_1 = require("./storage");
+class TokenManager {
+    constructor(config, storage) {
+        this.refreshTimer = null;
+        this.refreshPromise = null;
+        this.config = config;
+        this.storage = storage;
+    }
+    setTokens(data) {
+        this.storage.set(storage_1.STORAGE_KEYS.ACCESS_TOKEN, data.accessToken);
+        this.storage.set(storage_1.STORAGE_KEYS.REFRESH_TOKEN, data.refreshToken);
+        this.storage.set(storage_1.STORAGE_KEYS.EXPIRES_AT, data.expiresAt.toString());
+        if (this.config.autoRefresh) {
+            this.scheduleRefresh();
+        }
+    }
+    async getAccessToken() {
+        const accessToken = this.storage.get(storage_1.STORAGE_KEYS.ACCESS_TOKEN);
+        const expiresAt = parseInt(this.storage.get(storage_1.STORAGE_KEYS.EXPIRES_AT) || '0', 10);
+        if (!accessToken)
+            return null;
+        const bufferMs = this.config.refreshBuffer * 1000;
+        if (expiresAt - Date.now() < bufferMs) {
+            return this.refreshToken();
+        }
+        return accessToken;
+    }
+    getRawAccessToken() {
+        return this.storage.get(storage_1.STORAGE_KEYS.ACCESS_TOKEN);
+    }
+    hasValidToken() {
+        return !!this.storage.get(storage_1.STORAGE_KEYS.REFRESH_TOKEN);
+    }
+    isExpired() {
+        const expiresAt = parseInt(this.storage.get(storage_1.STORAGE_KEYS.EXPIRES_AT) || '0', 10);
+        return Date.now() >= expiresAt;
+    }
+    clear() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        this.storage.remove(storage_1.STORAGE_KEYS.ACCESS_TOKEN);
+        this.storage.remove(storage_1.STORAGE_KEYS.REFRESH_TOKEN);
+        this.storage.remove(storage_1.STORAGE_KEYS.EXPIRES_AT);
+    }
+    scheduleRefresh() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+        }
+        const expiresAt = parseInt(this.storage.get(storage_1.STORAGE_KEYS.EXPIRES_AT) || '0', 10);
+        const bufferMs = this.config.refreshBuffer * 1000;
+        const delay = Math.max(0, expiresAt - Date.now() - bufferMs);
+        if (delay > 0 && delay < 86400000) {
+            this.refreshTimer = setTimeout(() => this.refreshToken(), delay);
+        }
+    }
+    async refreshToken() {
+        if (this.refreshPromise) {
+            return this.refreshPromise;
+        }
+        this.refreshPromise = this.doRefresh();
+        try {
+            return await this.refreshPromise;
+        }
+        finally {
+            this.refreshPromise = null;
+        }
+    }
+    async doRefresh() {
+        const refreshToken = this.storage.get(storage_1.STORAGE_KEYS.REFRESH_TOKEN);
+        if (!refreshToken)
+            return null;
+        try {
+            const response = await fetch(this.config.tokenExchangeUri, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    grant_type: 'refresh_token',
+                    refresh_token: refreshToken,
+                }),
+            });
+            if (!response.ok) {
+                this.clear();
+                return null;
+            }
+            const contentType = response.headers.get('content-type');
+            if (!contentType?.includes('application/json')) {
+                this.clear();
+                return null;
+            }
+            const data = await response.json();
+            if (!data.access_token) {
+                this.clear();
+                return null;
+            }
+            this.setTokens({
+                accessToken: data.access_token,
+                refreshToken: data.refresh_token || refreshToken,
+                expiresAt: Date.now() + (data.expires_in || 3600) * 1000,
+            });
+            return data.access_token;
+        }
+        catch (error) {
+            console.error('[MicrocosmAuth] Token refresh failed:', error);
+            return null;
+        }
+    }
+}
+exports.TokenManager = TokenManager;

package/dist/types.d.ts

@@ -0,0 +1,82 @@
+export interface MicrocosmAuthConfig {
+    clientId: string;
+    redirectUri: string;
+    scope?: string[];
+    authEndpoint?: string;
+    tokenExchangeUri?: string;
+    profileUri?: string;
+    storage?: 'localStorage' | 'sessionStorage' | 'memory';
+    autoRefresh?: boolean;
+    refreshBuffer?: number;
+    debug?: boolean;
+}
+export type ResolvedConfig = Required<MicrocosmAuthConfig>;
+export interface User {
+    uid: string;
+    email: string;
+    displayName?: string | null;
+    avatarUrl?: string | null;
+    role: 'admin' | 'user' | 'agent';
+    level?: 'recruit' | 'prospect' | 'miner';
+    title?: 'commander' | 'pioneer' | 'warden' | 'admiral' | null;
+    stationId?: number | null;
+    emailVerified?: boolean;
+}
+export interface TokenData {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+}
+export interface AuthState {
+    user: User | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: Error | null;
+}
+export interface LoginOptions {
+    prompt?: 'login' | 'consent';
+}
+export interface TokenExchangeResponse {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+    user_id?: string;
+}
+export interface UserProfileResponse {
+    uid: string;
+    email?: string;
+    display_name?: string | null;
+    avatar_url?: string | null;
+    role?: string;
+    level?: string;
+    title?: string | null;
+    station_id?: number | null;
+    email_verified?: boolean;
+    user?: UserProfileResponse;
+}
+export interface ApiResponse<T> {
+    success: boolean;
+    data: T | null;
+    error: string | null;
+    message?: string | null;
+}
+export interface MCDBalance {
+    total_balance: string;
+    available_balance: string;
+    frozen_balance: string;
+}
+export interface MCCBalance {
+    total_balance: number;
+    available_balance: number;
+    locked_balance: number;
+    on_chain_balance?: number;
+    wallet_address?: string;
+}
+export interface MCCPrice {
+    price: number;
+    price_change_24h?: number;
+    volume_24h?: number;
+    market_cap?: number;
+    source: string;
+    updated_at: string;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@microcosmmoney/auth-core",
+  "version": "1.0.0",
+  "description": "Microcosm OAuth 2.0 authentication core library",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "peerDependencies": {},
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MicrocosmMoney/Microcosm"
+  }
+}