import { useAuth, useMCD } from '@microcosm/auth-react'
const { user, login } = useAuth()
const { balance } = useMCD()

npm install @microcosm/auth-react

// app/providers.tsx
import { MicrocosmAuthProvider } from '@microcosm/auth-react'

export function Providers({ children }) {
  return (
    <MicrocosmAuthProvider
      clientId="doublehelix"
      redirectUri="/auth/callback"
    >
      {children}
    </MicrocosmAuthProvider>
  )
}

// app/page.tsx
import { useAuth } from '@microcosm/auth-react'

export default function HomePage() {
  const { user, isLoading, login, logout } = useAuth()

  if (isLoading) return <div>Loading...</div>

  if (!user) {
    return <button onClick={login}>登录</button>
  }

  return (
    <div>
      <p>欢迎, {user.email}</p>
      <button onClick={logout}>登出</button>
    </div>
  )
}

// app/auth/callback/page.tsx
import { AuthCallback } from '@microcosm/auth-react'

export default function CallbackPage() {
  return <AuthCallback redirectTo="/dashboard" />
}

import { withAuth } from '@microcosm/auth-react'

function DashboardPage() {
  const { user } = useAuth()
  return <div>Dashboard for {user.email}</div>
}

// 自动重定向未登录用户到登录页
export default withAuth(DashboardPage)

import { useAuth } from '@microcosm/auth-react'

function MyComponent() {
  const { getAccessToken } = useAuth()

  const fetchData = async () => {
    const token = await getAccessToken() // 自动处理刷新
    const res = await fetch('/api/data', {
      headers: { Authorization: `Bearer ${token}` }
    })
    return res.json()
  }
}

import { useAuth, useMCD, useMCC } from '@microcosm/auth-react'

function AssetPage() {
  // 方式一: 使用封装好的 Hooks
  const { balance: mcdBalance, loading: mcdLoading } = useMCD()
  const { balance: mccBalance, loading: mccLoading } = useMCC()

  // 方式二: 直接调用 Open API
  const { getAccessToken } = useAuth()

  const fetchMCDBalance = async () => {
    const token = await getAccessToken()
    const res = await fetch('https://api.microcosm.money/v1/mcd/balance', {
      headers: { Authorization: `Bearer ${token}` }
    })
    return res.json()
  }

  return (
    <div>
      <p>MCC 余额: {mccBalance?.total_balance}</p>
      <p>MCD 积分: {mcdBalance?.total_balance}</p>
    </div>
  )
}

import { useAuth, useProfile } from '@microcosm/auth-react'

function ProfilePage() {
  // 方式一: 使用封装好的 Hook
  const { profile, updateProfile, uploadAvatar, loading } = useProfile()

  const handleUpdateName = async (newName: string) => {
    await updateProfile({ display_name: newName })
    // 更新后所有项目（Double Helix、Event Horizon）立即生效
  }

  const handleUploadAvatar = async (file: File) => {
    await uploadAvatar(file)
  }

  // 方式二: 直接调用 Open API
  const { getAccessToken } = useAuth()

  const updateDisplayName = async (displayName: string) => {
    const token = await getAccessToken()
    const res = await fetch('https://api.microcosm.money/v1/users/me/profile', {
      method: 'PATCH',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ display_name: displayName })
    })
    return res.json()
  }

  const uploadAvatarFile = async (file: File) => {
    const token = await getAccessToken()
    const formData = new FormData()
    formData.append('avatar', file)

    const res = await fetch('https://api.microcosm.money/v1/users/me/avatar', {
      method: 'POST',
      headers: { Authorization: `Bearer ${token}` },
      body: formData
    })
    return res.json()
  }

  return (
    <div>
      <p>当前昵称: {profile?.display_name}</p>
      <input
        type="text"
        placeholder="新昵称 (1-50字符)"
        onChange={(e) => handleUpdateName(e.target.value)}
      />
      <input
        type="file"
        accept="image/jpeg,image/png,image/gif,image/webp"
        onChange={(e) => e.target.files?.[0] && handleUploadAvatar(e.target.files[0])}
      />
    </div>
  )
}

import { useAuth } from '@microcosm/auth-react'

function MyComponent() {
  const { getAccessToken } = useAuth()

  const fetchWithRetry = async (url: string) => {
    const token = await getAccessToken()
    const res = await fetch(url, {
      headers: { Authorization: `Bearer ${token}` }
    })

    // 检查速率限制
    const remaining = res.headers.get('X-RateLimit-Remaining')
    const reset = res.headers.get('X-RateLimit-Reset')

    if (res.status === 429) {
      const retryAfter = parseInt(res.headers.get('Retry-After') || '60')
      console.log(`Rate limited. Retry after ${retryAfter}s`)
      await new Promise(resolve => setTimeout(resolve, retryAfter * 1000))
      return fetchWithRetry(url) // 重试
    }

    return res.json()
  }
}

import { useAuth, RequireRole } from '@microcosm/auth-react'

function AdminPage() {
  return (
    <RequireRole roles={['admin']} fallback={<div>无权限</div>}>
      <AdminDashboard />
    </RequireRole>
  )
}

pip install microcosm-auth

from flask import Flask
from microcosm_auth import MicrocosmAuth, require_auth

app = Flask(__name__)

# 一行配置
auth = MicrocosmAuth(
    client_id="doublehelix",
    client_secret="sk_xxx"  # 从环境变量读取
)

# 保护路由 - 装饰器方式
@app.route('/api/protected')
@auth.require_auth
def protected_route():
    user = auth.current_user  # 自动注入
    return {"message": f"Hello {user.email}"}

# 保护路由 - 角色限制
@app.route('/api/admin')
@auth.require_role('admin')
def admin_route():
    return {"message": "Admin only"}

# 手动验证 token
@app.route('/api/manual')
def manual_route():
    token = request.headers.get('Authorization', '').replace('Bearer ', '')
    user = auth.verify_token(token)
    if not user:
        return {"error": "Unauthorized"}, 401
    return {"user": user.to_dict()}

from fastapi import FastAPI, Depends
from microcosm_auth.fastapi import MicrocosmAuth, get_current_user, User

app = FastAPI()
auth = MicrocosmAuth(client_id="doublehelix", client_secret="sk_xxx")

@app.get('/api/protected')
async def protected_route(user: User = Depends(get_current_user)):
    return {"message": f"Hello {user.email}"}

const express = require('express')
const { MicrocosmAuth } = require('@microcosm/auth-node')

const app = express()
const auth = new MicrocosmAuth({
  clientId: 'doublehelix',
  clientSecret: process.env.MICROCOSM_CLIENT_SECRET
})

// 中间件方式
app.get('/api/protected', auth.requireAuth(), (req, res) => {
  res.json({ message: `Hello ${req.user.email}` })
})

// 角色限制
app.get('/api/admin', auth.requireRole('admin'), (req, res) => {
  res.json({ message: 'Admin only' })
})

package main

import (
    "github.com/microcosm/auth-go"
    "net/http"
)

func main() {
    auth := microcosm.NewAuth(microcosm.Config{
        ClientID:     "doublehelix",
        ClientSecret: os.Getenv("MICROCOSM_CLIENT_SECRET"),
    })

    http.Handle("/api/protected", auth.RequireAuth(protectedHandler))
    http.ListenAndServe(":8080", nil)
}

func protectedHandler(w http.ResponseWriter, r *http.Request) {
    user := microcosm.GetUser(r.Context())
    json.NewEncoder(w).Encode(map[string]string{
        "message": "Hello " + user.Email,
    })
}

interface ApiResponse<T> {
  success: boolean
  data: T | null
  error: string | null       // 简要错误描述
  message?: string | null    // 详细错误信息 (可选)
}

{
  "success": true,
  "data": {
    "uid": "abc123",
    "email": "user@example.com",
    "role": "user"
  },
  "error": null
}

{
  "success": false,
  "data": null,
  "error": {
    "code": "invalid_token",
    "message": "The access token has expired"
  }
}

// 核心配置
interface MicrocosmAuthConfig {
  clientId: string
  redirectUri: string
  scope?: string[]           // 默认 ['openid', 'profile', 'email']
  authEndpoint?: string      // 默认 'https://microcosm.money'
  usePKCE?: boolean          // 默认 true
  storage?: 'localStorage' | 'sessionStorage' | 'cookie'
  autoRefresh?: boolean      // 默认 true
  refreshBuffer?: number     // Token 过期前多少秒刷新，默认 300
}

// 用户对象
interface User {
  uid: string
  email: string
  displayName?: string
  role: 'admin' | 'user' | 'agent'                                    // 系统角色
  level: 'recruit' | 'prospect' | 'miner'                             // 用户级别
  title?: 'commander' | 'pioneer' | 'warden' | 'admiral' | null       // 职级头衔（基于 NFT）
  stationId?: number                                                  // 所属 Station ID（Miner 才有）
  avatarUrl?: string
  emailVerified?: boolean
}

// 核心类
class MicrocosmAuthClient {
  constructor(config: MicrocosmAuthConfig)

  // 认证方法
  login(options?: { prompt?: 'login' | 'consent' }): void
  logout(): Promise<void>
  handleCallback(): Promise<User>

  // 状态方法
  getUser(): User | null
  isAuthenticated(): boolean
  getAccessToken(): Promise<string | null>  // 自动刷新

  // 事件监听
  onAuthStateChange(callback: (user: User | null) => void): () => void
}

class TokenManager {
  private refreshTimer: NodeJS.Timeout | null = null

  async getAccessToken(): Promise<string | null> {
    const token = this.getStoredToken()
    if (!token) return null

    // 检查是否需要刷新（提前 5 分钟）
    if (this.shouldRefresh(token)) {
      return this.refreshToken()
    }

    return token.accessToken
  }

  private shouldRefresh(token: TokenData): boolean {
    const bufferMs = this.config.refreshBuffer * 1000
    return token.expiresAt - Date.now() < bufferMs
  }

  private async refreshToken(): Promise<string> {
    // 防止并发刷新
    if (this.refreshPromise) {
      return this.refreshPromise
    }

    this.refreshPromise = this.doRefresh()
    try {
      return await this.refreshPromise
    } finally {
      this.refreshPromise = null
    }
  }
}

class PKCEManager {
  static async generateChallenge(): Promise<{
    codeVerifier: string
    codeChallenge: string
  }> {
    // 生成随机 code_verifier
    const codeVerifier = this.generateRandomString(64)

    // 计算 code_challenge = BASE64URL(SHA256(code_verifier))
    const encoder = new TextEncoder()
    const data = encoder.encode(codeVerifier)
    const digest = await crypto.subtle.digest('SHA-256', data)
    const codeChallenge = this.base64UrlEncode(digest)

    return { codeVerifier, codeChallenge }
  }
}

// 推荐的 fetchApi 内部逻辑
const safeJson = async (res: Response) => {
  const contentType = res.headers.get('content-type')
  if (contentType?.includes('application/json')) {
    return res.json()
  }
  // 如果非 JSON 响应，捕获为文本错误描述
  const text = await res.text()
  return { 
    success: false, 
    error: 'Non-JSON Response', 
    message: text.substring(0, 200) 
  }
}

npm install @microcosm/auth-react

pip install microcosm-auth

// app/providers.tsx
<MicrocosmAuthProvider clientId="your-client-id" redirectUri="/auth/callback">
  {children}
</MicrocosmAuthProvider>

# 从环境变量读取
auth = MicrocosmAuth(
    client_id=os.environ['MICROCOSM_CLIENT_ID'],
    client_secret=os.environ['MICROCOSM_CLIENT_SECRET']
)

// OAuth callback 中正确设置用户信息
const handleCallback = async () => {
  // 1. Token exchange
  const tokenData = await fetch("/api/auth/exchange", {
    method: "POST",
    body: JSON.stringify({ code }),
  }).then(res => res.json())

  // 2. 获取用户详细资料
  const profileRes = await fetch("/api/users/profile", {
    headers: { Authorization: `Bearer ${tokenData.access_token}` }
  })
  const profileData = await profileRes.json()

  // 3. 兼容解包 (API 可能返回 {user: {...}} 或 {...})
  const userData = profileData.user || profileData

  // 4. ⚠️ 必须传递 displayName 和 avatarUrl！
  authManager.setUser({
    uid: userData.uid,
    email: userData.email || "",
    role: userData.role || "user",
    displayName: userData.display_name || null,  // ← 必须
    avatarUrl: userData.avatar_url || null,       // ← 必须
    apiKeysConfigured: userData.api_keys_configured || false,
  })

  router.push("/dashboard")
}

// 1. 配置 SDK
const config = {
  clientId: "your-project-id",
  apiKey: "mc_live_xxxxx",
  apiSecret: "mc_secret_yyyyy",
  redirectUri: "/auth/callback"
}

// 2. 初始化 SDK
<MicrocosmAuthProvider {...config} />

// 3. MCD 消费场景 - 用户消费 MCD 会转到你注册的钱包
const { consumeMcd } = useMcd()
await consumeMcd({
  amount: 100,  // 消费 100 MCD
  memo: "购买商品"
})

// 1. 安装
npm install @microcosm/auth-react

// 2. 配置 (1 行)
<MicrocosmAuthProvider clientId="xxx" redirectUri="/auth/callback" />

// 3. 使用 (1 行)
const { user, login, logout } = useAuth()