@seaverseai/auth-sdk 0.1.2

package/dist/index.js

@@ -0,0 +1,2534 @@
+import axios from 'axios';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+
+/**
+ * 生成UUID的跨平台函数
+ * 支持 Node.js 和浏览器环境
+ */
+function generateUUID() {
+    // Node.js 环境
+    if (typeof globalThis !== 'undefined' && globalThis.crypto?.randomUUID) {
+        return globalThis.crypto.randomUUID();
+    }
+    // 浏览器环境 - crypto.randomUUID (现代浏览器)
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    // 浏览器环境 - crypto.getRandomValues (备用方案)
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (crypto.getRandomValues(new Uint8Array(1))[0] % 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    // Fallback - 使用 Math.random() (不推荐用于生产环境)
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * 内置Hook集合
+ */
+class BuiltInHooks {
+    /**
+     * 创建日志记录Hook
+     */
+    static createLoggerHook(options) {
+        const logLevel = options?.logLevel || 'info';
+        const logRequestBody = options?.logRequestBody ?? false;
+        const logResponseBody = options?.logResponseBody ?? false;
+        const logHeaders = options?.logHeaders ?? false;
+        return {
+            type: 'beforeRequest',
+            name: 'logger',
+            priority: 100,
+            handler: async (context) => {
+                const { operationId, config } = context;
+                console.log(`[${logLevel.toUpperCase()}] ${config.method?.toUpperCase()} ${config.url}`);
+                console.log(`Operation ID: ${operationId}`);
+                if (logHeaders && config.headers) {
+                    console.log('Headers:', JSON.stringify(config.headers, null, 2));
+                }
+                if (logRequestBody && config.data) {
+                    console.log('Request Body:', JSON.stringify(config.data, null, 2));
+                }
+                // 添加afterResponse日志
+                if (context.response) {
+                    console.log(`Response Status: ${context.response.status}`);
+                    if (logResponseBody && context.response.data) {
+                        console.log('Response Body:', JSON.stringify(context.response.data, null, 2));
+                    }
+                }
+            },
+        };
+    }
+    /**
+     * 创建请求ID Hook
+     */
+    static createRequestIdHook() {
+        return {
+            type: 'beforeRequest',
+            name: 'request-id',
+            priority: 10,
+            handler: async (context) => {
+                const requestId = generateUUID();
+                context.config.headers = {
+                    ...context.config.headers,
+                    'X-Request-ID': requestId,
+                };
+                context.metadata = context.metadata || {};
+                context.metadata.requestId = requestId;
+            },
+        };
+    }
+    /**
+     * 创建速率限制Hook
+     */
+    static createRateLimitHook(options) {
+        const requestsPerSecond = options?.requestsPerSecond;
+        // TODO: 实现基于分钟的速率限制
+        // const requestsPerMinute = options?.requestsPerMinute;
+        // 简单的令牌桶实现
+        let tokens = requestsPerSecond || 10;
+        let lastRefill = Date.now();
+        const refillTokens = () => {
+            const now = Date.now();
+            const timePassed = now - lastRefill;
+            if (requestsPerSecond && timePassed >= 1000) {
+                tokens = Math.min(requestsPerSecond, tokens + requestsPerSecond);
+                lastRefill = now;
+            }
+        };
+        return {
+            type: 'beforeRequest',
+            name: 'rate-limit',
+            priority: 5,
+            handler: async (_context) => {
+                refillTokens();
+                if (tokens <= 0) {
+                    const waitTime = 1000 - (Date.now() - lastRefill);
+                    if (waitTime > 0) {
+                        await new Promise((resolve) => setTimeout(resolve, waitTime));
+                        refillTokens();
+                    }
+                }
+                tokens--;
+            },
+        };
+    }
+    /**
+     * 创建缓存Hook（简化版）
+     */
+    static createCacheHook(options) {
+        const cache = new Map();
+        // TODO: 实现缓存过期逻辑
+        // const ttl = options?.ttl || 60000; // 默认60秒
+        const methods = options?.methods || ['GET'];
+        return {
+            type: 'beforeRequest',
+            name: 'cache',
+            priority: 20,
+            handler: async (context) => {
+                const method = context.config.method?.toUpperCase();
+                if (!method || !methods.includes(method)) {
+                    return;
+                }
+                const cacheKey = `${method}:${context.config.url}:${JSON.stringify(context.config.params)}`;
+                const cached = cache.get(cacheKey);
+                if (cached && Date.now() < cached.expiresAt) {
+                    // 从缓存返回（这里需要特殊处理，通常在拦截器中实现）
+                    context.metadata = context.metadata || {};
+                    context.metadata.cacheHit = true;
+                }
+                else {
+                    // 缓存miss，需要在afterResponse中缓存结果
+                    context.metadata = context.metadata || {};
+                    context.metadata.cacheKey = cacheKey;
+                }
+            },
+        };
+    }
+    /**
+     * 创建性能监控Hook
+     */
+    static createMetricsHook(options) {
+        const collector = options?.collector || ((metrics) => {
+            console.log('Metrics:', metrics);
+        });
+        return {
+            type: 'beforeRequest',
+            name: 'metrics',
+            priority: 1,
+            handler: async (context) => {
+                context.metadata = context.metadata || {};
+                context.metadata.startTime = Date.now();
+                // 在afterResponse或onError中计算duration
+                if (context.response) {
+                    const duration = Date.now() - context.metadata.startTime;
+                    const metrics = {
+                        operationId: context.operationId,
+                        method: context.config.method?.toUpperCase() || 'UNKNOWN',
+                        path: context.config.url || '',
+                        statusCode: context.response.status,
+                        duration,
+                        timestamp: Date.now(),
+                    };
+                    collector(metrics);
+                }
+                else if (context.error) {
+                    const duration = Date.now() - context.metadata.startTime;
+                    const metrics = {
+                        operationId: context.operationId,
+                        method: context.config.method?.toUpperCase() || 'UNKNOWN',
+                        path: context.config.url || '',
+                        duration,
+                        timestamp: Date.now(),
+                        error: context.error.message,
+                    };
+                    collector(metrics);
+                }
+            },
+        };
+    }
+    /**
+     * 创建重试Hook（需要在interceptor中实现真正的重试逻辑）
+     */
+    static createRetryHook(maxRetries = 3, retryDelay = 1000) {
+        return {
+            type: 'onRetry',
+            name: 'retry',
+            priority: 1,
+            handler: async (context) => {
+                const retryCount = context.retryCount || 0;
+                console.log(`Retrying request (${retryCount}/${maxRetries})...`);
+                if (retryCount > 0) {
+                    // 指数退避
+                    const delay = retryDelay * Math.pow(2, retryCount - 1);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            },
+        };
+    }
+}
+
+/**
+ * Hook管理器
+ */
+class HookManager {
+    constructor(options) {
+        this.hooks = new Map();
+        // 初始化hook类型映射
+        this.hooks.set('beforeRequest', []);
+        this.hooks.set('afterResponse', []);
+        this.hooks.set('onError', []);
+        this.hooks.set('onRetry', []);
+        // 注册用户自定义hooks
+        if (options?.hooks) {
+            for (const hook of options.hooks) {
+                this.register(hook);
+            }
+        }
+        // 注册内置hooks
+        if (options?.enableBuiltInHooks) {
+            this.registerBuiltInHooks(options);
+        }
+    }
+    /**
+     * 注册hook
+     */
+    register(hook) {
+        const hooks = this.hooks.get(hook.type) || [];
+        hooks.push(hook);
+        // 按优先级排序（优先级数字越小越优先）
+        hooks.sort((a, b) => a.priority - b.priority);
+        this.hooks.set(hook.type, hooks);
+    }
+    /**
+     * 注销hook
+     */
+    unregister(type, name) {
+        const hooks = this.hooks.get(type) || [];
+        const filtered = hooks.filter((h) => h.name !== name);
+        this.hooks.set(type, filtered);
+    }
+    /**
+     * 执行beforeRequest hooks
+     */
+    async executeBeforeRequest(context) {
+        await this.executeHooks('beforeRequest', context);
+    }
+    /**
+     * 执行afterResponse hooks
+     */
+    async executeAfterResponse(context) {
+        await this.executeHooks('afterResponse', context);
+    }
+    /**
+     * 执行onError hooks
+     */
+    async executeOnError(context) {
+        await this.executeHooks('onError', context);
+    }
+    /**
+     * 执行onRetry hooks
+     */
+    async executeOnRetry(context) {
+        await this.executeHooks('onRetry', context);
+    }
+    /**
+     * 执行指定类型的hooks
+     */
+    async executeHooks(type, context) {
+        const hooks = this.hooks.get(type) || [];
+        for (const hook of hooks) {
+            // 检查过滤条件
+            if (!this.shouldExecuteHook(hook, context)) {
+                continue;
+            }
+            try {
+                await hook.handler(context);
+            }
+            catch (error) {
+                // Hook执行失败不应阻断请求
+                console.error(`Hook ${hook.name} failed:`, error);
+            }
+        }
+    }
+    /**
+     * 检查是否应该执行hook
+     */
+    shouldExecuteHook(hook, context) {
+        if (!hook.filter) {
+            return true;
+        }
+        const filter = hook.filter;
+        // 检查operationId过滤
+        if (filter.operationIds && filter.operationIds.length > 0) {
+            if (!filter.operationIds.includes(context.operationId)) {
+                return false;
+            }
+        }
+        // 检查method过滤
+        if (filter.methods && filter.methods.length > 0) {
+            const method = context.config.method?.toUpperCase();
+            if (!method || !filter.methods.includes(method)) {
+                return false;
+            }
+        }
+        // 检查path pattern过滤
+        if (filter.pathPatterns && filter.pathPatterns.length > 0) {
+            const url = context.config.url || '';
+            const matched = filter.pathPatterns.some((pattern) => pattern.test(url));
+            if (!matched) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * 注册内置hooks
+     */
+    registerBuiltInHooks(options) {
+        const { enableBuiltInHooks } = options;
+        if (enableBuiltInHooks?.logger) {
+            this.register(BuiltInHooks.createLoggerHook(options.loggerOptions));
+        }
+        if (enableBuiltInHooks?.requestId) {
+            this.register(BuiltInHooks.createRequestIdHook());
+        }
+        if (enableBuiltInHooks?.retry) {
+            // Retry hook需要特殊处理，通常在axios interceptor中实现
+            console.warn('Retry hook should be implemented in axios interceptor');
+        }
+        if (enableBuiltInHooks?.rateLimit) {
+            this.register(BuiltInHooks.createRateLimitHook(options.rateLimitOptions));
+        }
+        if (enableBuiltInHooks?.cache) {
+            // Cache hook需要特殊处理
+            console.warn('Cache hook requires special implementation');
+        }
+        if (enableBuiltInHooks?.metrics) {
+            this.register(BuiltInHooks.createMetricsHook(options.metricsOptions));
+        }
+    }
+    /**
+     * 获取所有注册的hooks
+     */
+    getAllHooks() {
+        return new Map(this.hooks);
+    }
+    /**
+     * 获取指定类型的hooks
+     */
+    getHooks(type) {
+        return this.hooks.get(type) || [];
+    }
+    /**
+     * 清除所有hooks
+     */
+    clear() {
+        this.hooks.clear();
+        this.hooks.set('beforeRequest', []);
+        this.hooks.set('afterResponse', []);
+        this.hooks.set('onError', []);
+        this.hooks.set('onRetry', []);
+    }
+}
+
+/**
+ * HTTP客户端，集成认证和Hook系统
+ */
+class HttpClient {
+    constructor(options) {
+        this.auth = options.auth;
+        this.hookManager = new HookManager(options.hooks);
+        this.retryOptions = {
+            maxRetries: 3,
+            retryDelay: 1000,
+            retryStatusCodes: [408, 429, 500, 502, 503, 504],
+            ...options.retryOptions,
+        };
+        // 创建axios实例
+        this.client = axios.create({
+            baseURL: options.baseURL,
+            timeout: options.timeout || 30000,
+            headers: options.headers,
+        });
+        // 设置拦截器
+        this.setupInterceptors();
+    }
+    /**
+     * 设置请求和响应拦截器
+     */
+    setupInterceptors() {
+        // 请求拦截器
+        this.client.interceptors.request.use(async (config) => {
+            const operationId = config.headers?.['X-Operation-Id'] || 'unknown';
+            // 添加认证信息
+            if (this.auth) {
+                config = await this.auth.attachCredentials(config);
+            }
+            // 执行beforeRequest hooks
+            const hookContext = {
+                operationId,
+                config,
+                metadata: {},
+            };
+            await this.hookManager.executeBeforeRequest(hookContext);
+            return hookContext.config;
+        }, (error) => {
+            return Promise.reject(error);
+        });
+        // 响应拦截器
+        this.client.interceptors.response.use(async (response) => {
+            const operationId = response.config.headers?.['X-Operation-Id'] || 'unknown';
+            // 执行afterResponse hooks
+            const hookContext = {
+                operationId,
+                config: response.config,
+                response,
+                metadata: {},
+            };
+            await this.hookManager.executeAfterResponse(hookContext);
+            return hookContext.response || response;
+        }, async (error) => {
+            const operationId = error.config?.headers?.['X-Operation-Id'] || 'unknown';
+            // 执行onError hooks
+            const hookContext = {
+                operationId,
+                config: error.config,
+                error,
+                metadata: {},
+            };
+            await this.hookManager.executeOnError(hookContext);
+            // 重试逻辑
+            const shouldRetry = this.shouldRetryRequest(error);
+            const retryCount = error.config?._retryCount || 0;
+            if (shouldRetry && retryCount < this.retryOptions.maxRetries) {
+                // 执行onRetry hooks
+                hookContext.retryCount = retryCount;
+                await this.hookManager.executeOnRetry(hookContext);
+                // 计算退避延迟
+                const delay = this.retryOptions.retryDelay * Math.pow(2, retryCount);
+                await this.delay(delay);
+                // 更新重试计数
+                const config = error.config;
+                config._retryCount = retryCount + 1;
+                // 重新发起请求
+                return this.client.request(config);
+            }
+            return Promise.reject(hookContext.error || error);
+        });
+    }
+    /**
+     * 判断是否应该重试
+     */
+    shouldRetryRequest(error) {
+        // 自定义重试判断
+        if (this.retryOptions.shouldRetry) {
+            return this.retryOptions.shouldRetry(error);
+        }
+        // 没有响应或网络错误
+        if (!error.response) {
+            return true;
+        }
+        // 根据状态码判断
+        const statusCode = error.response.status;
+        return this.retryOptions.retryStatusCodes?.includes(statusCode) || false;
+    }
+    /**
+     * 延迟函数
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * 发起请求
+     */
+    async request(config) {
+        return this.client.request(config);
+    }
+    /**
+     * GET请求
+     */
+    async get(url, config) {
+        return this.client.get(url, config);
+    }
+    /**
+     * POST请求
+     */
+    async post(url, data, config) {
+        return this.client.post(url, data, config);
+    }
+    /**
+     * PUT请求
+     */
+    async put(url, data, config) {
+        return this.client.put(url, data, config);
+    }
+    /**
+     * DELETE请求
+     */
+    async delete(url, config) {
+        return this.client.delete(url, config);
+    }
+    /**
+     * PATCH请求
+     */
+    async patch(url, data, config) {
+        return this.client.patch(url, data, config);
+    }
+    /**
+     * 获取底层axios实例
+     */
+    getAxiosInstance() {
+        return this.client;
+    }
+}
+
+/**
+ * 认证提供者抽象基类
+ */
+class AuthProvider {
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+    /**
+     * 获取当前凭证
+     */
+    getCredentials() {
+        return this.credentials;
+    }
+    /**
+     * 更新凭证
+     */
+    updateCredentials(credentials) {
+        this.credentials = { ...this.credentials, ...credentials };
+    }
+}
+
+/**
+ * API Key认证提供者
+ */
+class ApiKeyProvider extends AuthProvider {
+    constructor(credentials) {
+        super(credentials);
+        this.credentials = credentials;
+    }
+    async attachCredentials(config) {
+        const newConfig = { ...config };
+        if (this.credentials.location === 'header') {
+            // 添加到Header
+            newConfig.headers = {
+                ...newConfig.headers,
+                [this.credentials.name]: this.credentials.apiKey,
+            };
+        }
+        else if (this.credentials.location === 'query') {
+            // 添加到Query参数
+            newConfig.params = {
+                ...newConfig.params,
+                [this.credentials.name]: this.credentials.apiKey,
+            };
+        }
+        return newConfig;
+    }
+    async refreshCredentials() {
+        // API Key通常不需要刷新
+        return Promise.resolve();
+    }
+    async isValid() {
+        return Boolean(this.credentials.apiKey);
+    }
+}
+
+/**
+ * OAuth2认证提供者
+ */
+class OAuth2Provider extends AuthProvider {
+    constructor(credentials) {
+        super(credentials);
+        this.credentials = credentials;
+    }
+    async attachCredentials(config) {
+        // 确保有有效的access token
+        if (!(await this.isValid())) {
+            await this.refreshCredentials();
+        }
+        const newConfig = { ...config };
+        newConfig.headers = {
+            ...newConfig.headers,
+            Authorization: `Bearer ${this.credentials.accessToken}`,
+        };
+        return newConfig;
+    }
+    async refreshCredentials() {
+        try {
+            const params = new URLSearchParams();
+            params.append('client_id', this.credentials.clientId);
+            params.append('client_secret', this.credentials.clientSecret);
+            if (this.credentials.refreshToken) {
+                // 使用refresh token刷新
+                params.append('grant_type', 'refresh_token');
+                params.append('refresh_token', this.credentials.refreshToken);
+            }
+            else {
+                // 使用client credentials流程
+                params.append('grant_type', 'client_credentials');
+                if (this.credentials.scope) {
+                    params.append('scope', this.credentials.scope);
+                }
+            }
+            const response = await axios.post(this.credentials.tokenUrl, params, {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+            });
+            const tokenData = response.data;
+            // 更新凭证
+            this.credentials.accessToken = tokenData.access_token;
+            if (tokenData.refresh_token) {
+                this.credentials.refreshToken = tokenData.refresh_token;
+            }
+            if (tokenData.expires_in) {
+                this.credentials.expiresAt = Date.now() + tokenData.expires_in * 1000;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to refresh OAuth2 token: ${error}`);
+        }
+    }
+    async isValid() {
+        if (!this.credentials.accessToken) {
+            return false;
+        }
+        if (this.credentials.expiresAt) {
+            // 提前5分钟刷新
+            const bufferTime = 5 * 60 * 1000;
+            return Date.now() < this.credentials.expiresAt - bufferTime;
+        }
+        return true;
+    }
+}
+
+/**
+ * JWT认证提供者
+ */
+class JWTProvider extends AuthProvider {
+    constructor(credentials) {
+        super(credentials);
+        this.credentials = credentials;
+    }
+    async attachCredentials(config) {
+        const newConfig = { ...config };
+        const headerName = this.credentials.headerName || 'Authorization';
+        const token = this.credentials.token;
+        newConfig.headers = {
+            ...newConfig.headers,
+            [headerName]: headerName === 'Authorization' ? `Bearer ${token}` : token,
+        };
+        return newConfig;
+    }
+    async refreshCredentials() {
+        // JWT通常由外部系统管理，这里不实现刷新逻辑
+        return Promise.resolve();
+    }
+    async isValid() {
+        if (!this.credentials.token) {
+            return false;
+        }
+        // 可以在这里添加JWT过期检查
+        try {
+            const parts = this.credentials.token.split('.');
+            if (parts.length !== 3) {
+                return false;
+            }
+            const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
+            if (payload.exp) {
+                // 检查是否过期（提前1分钟）
+                return Date.now() < payload.exp * 1000 - 60000;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+/**
+ * Basic认证提供者
+ */
+class BasicAuthProvider extends AuthProvider {
+    constructor(credentials) {
+        super(credentials);
+        this.credentials = credentials;
+    }
+    async attachCredentials(config) {
+        const newConfig = { ...config };
+        const token = Buffer.from(`${this.credentials.username}:${this.credentials.password}`).toString('base64');
+        newConfig.headers = {
+            ...newConfig.headers,
+            Authorization: `Basic ${token}`,
+        };
+        return newConfig;
+    }
+    async refreshCredentials() {
+        // Basic Auth不需要刷新
+        return Promise.resolve();
+    }
+    async isValid() {
+        return Boolean(this.credentials.username && this.credentials.password);
+    }
+}
+
+/**
+ * 自定义认证提供者
+ */
+class CustomAuthProvider extends AuthProvider {
+    constructor(credentials) {
+        super(credentials);
+        this.credentials = credentials;
+    }
+    async attachCredentials(config) {
+        return this.credentials.handler(config);
+    }
+    async refreshCredentials() {
+        // 自定义认证由用户实现
+        return Promise.resolve();
+    }
+    async isValid() {
+        // 自定义认证默认认为总是有效
+        return true;
+    }
+}
+
+/**
+ * 配置管理器
+ */
+class ConfigManager {
+    constructor(configDir) {
+        this.configDir = configDir || path.join(os.homedir(), '.openapi-sdk');
+        this.configPath = path.join(this.configDir, 'config.json');
+    }
+    /**
+     * 保存认证配置
+     */
+    async saveAuth(profileName, authConfig) {
+        await this.ensureConfigDir();
+        const config = await this.loadConfig();
+        config.profiles[profileName] = authConfig;
+        await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    /**
+     * 加载认证配置
+     */
+    async loadAuth(profileName) {
+        const config = await this.loadConfig();
+        const authConfig = config.profiles[profileName];
+        if (!authConfig) {
+            throw new Error(`Profile '${profileName}' not found`);
+        }
+        return authConfig;
+    }
+    /**
+     * 列出所有profile
+     */
+    async listProfiles() {
+        const config = await this.loadConfig();
+        return Object.keys(config.profiles);
+    }
+    /**
+     * 删除profile
+     */
+    async removeProfile(profileName) {
+        const config = await this.loadConfig();
+        delete config.profiles[profileName];
+        await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    /**
+     * 从文件加载配置
+     */
+    async loadFromFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to load config from ${filePath}: ${error}`);
+        }
+    }
+    /**
+     * 保存配置到文件
+     */
+    async saveToFile(filePath, authConfig) {
+        try {
+            await fs.writeFile(filePath, JSON.stringify(authConfig, null, 2), 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to save config to ${filePath}: ${error}`);
+        }
+    }
+    /**
+     * 加载完整配置文件
+     */
+    async loadConfig() {
+        try {
+            const content = await fs.readFile(this.configPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // 文件不存在，返回默认配置
+                return { profiles: {} };
+            }
+            throw error;
+        }
+    }
+    /**
+     * 确保配置目录存在
+     */
+    async ensureConfigDir() {
+        try {
+            await fs.mkdir(this.configDir, { recursive: true });
+        }
+        catch (error) {
+            // 忽略错误，可能目录已存在
+        }
+    }
+    /**
+     * 获取配置目录路径
+     */
+    getConfigDir() {
+        return this.configDir;
+    }
+    /**
+     * 获取配置文件路径
+     */
+    getConfigPath() {
+        return this.configPath;
+    }
+}
+
+/**
+ * 跨平台环境配置工具
+ * 支持 Node.js 和浏览器环境
+ */
+/**
+ * 全局配置存储（用于浏览器环境）
+ */
+const globalConfig = {};
+/**
+ * 获取环境变量或配置值
+ * 优先级：globalConfig > process.env (仅 Node.js)
+ */
+function getEnvConfig(key) {
+    // 优先使用全局配置
+    if (globalConfig[key] !== undefined) {
+        return globalConfig[key];
+    }
+    // Node.js 环境
+    if (typeof process !== 'undefined' && process.env) {
+        return process.env[key];
+    }
+    return undefined;
+}
+
+/**
+ * 认证提供者工厂
+ */
+class AuthFactory {
+    /**
+     * 根据配置创建认证提供者
+     */
+    static create(config) {
+        return this.createFromCredentials(config.credentials);
+    }
+    /**
+     * 根据凭证创建认证提供者
+     */
+    static createFromCredentials(credentials) {
+        switch (credentials.type) {
+            case 'apiKey':
+                return new ApiKeyProvider(credentials);
+            case 'oauth2':
+                return new OAuth2Provider(credentials);
+            case 'jwt':
+                return new JWTProvider(credentials);
+            case 'basic':
+                return new BasicAuthProvider(credentials);
+            case 'custom':
+                return new CustomAuthProvider(credentials);
+            default:
+                throw new Error(`Unsupported auth type: ${credentials.type}`);
+        }
+    }
+    /**
+     * 从环境变量创建认证提供者
+     */
+    static fromEnv() {
+        const authType = getEnvConfig('AUTH_TYPE');
+        if (!authType) {
+            throw new Error('AUTH_TYPE environment variable is not set');
+        }
+        let credentials;
+        switch (authType) {
+            case 'apiKey': {
+                const apiKey = getEnvConfig('API_KEY');
+                const location = getEnvConfig('API_KEY_LOCATION') || 'header';
+                const name = getEnvConfig('API_KEY_NAME') || 'X-API-Key';
+                if (!apiKey) {
+                    throw new Error('API_KEY environment variable is required for apiKey auth');
+                }
+                credentials = {
+                    type: 'apiKey',
+                    apiKey,
+                    location,
+                    name,
+                };
+                break;
+            }
+            case 'oauth2': {
+                const clientId = getEnvConfig('OAUTH_CLIENT_ID');
+                const clientSecret = getEnvConfig('OAUTH_CLIENT_SECRET');
+                const tokenUrl = getEnvConfig('OAUTH_TOKEN_URL');
+                const accessToken = getEnvConfig('ACCESS_TOKEN');
+                const refreshToken = getEnvConfig('REFRESH_TOKEN');
+                const scope = getEnvConfig('OAUTH_SCOPE');
+                if (!clientId || !clientSecret || !tokenUrl) {
+                    throw new Error('OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET, and OAUTH_TOKEN_URL are required for oauth2 auth');
+                }
+                credentials = {
+                    type: 'oauth2',
+                    clientId,
+                    clientSecret,
+                    tokenUrl,
+                    accessToken,
+                    refreshToken,
+                    scope,
+                };
+                break;
+            }
+            case 'jwt': {
+                const token = getEnvConfig('JWT_TOKEN');
+                const headerName = getEnvConfig('JWT_HEADER_NAME');
+                if (!token) {
+                    throw new Error('JWT_TOKEN environment variable is required for jwt auth');
+                }
+                credentials = {
+                    type: 'jwt',
+                    token,
+                    headerName,
+                };
+                break;
+            }
+            case 'basic': {
+                const username = getEnvConfig('BASIC_USERNAME');
+                const password = getEnvConfig('BASIC_PASSWORD');
+                if (!username || !password) {
+                    throw new Error('BASIC_USERNAME and BASIC_PASSWORD are required for basic auth');
+                }
+                credentials = {
+                    type: 'basic',
+                    username,
+                    password,
+                };
+                break;
+            }
+            default:
+                throw new Error(`Unsupported AUTH_TYPE: ${authType}`);
+        }
+        return this.createFromCredentials(credentials);
+    }
+    /**
+     * 从配置文件创建认证提供者
+     */
+    static async fromFile(path) {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadFromFile(path);
+        return this.create(config);
+    }
+    /**
+     * 从profile创建认证提供者
+     */
+    static async fromProfile(profileName = 'default') {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadAuth(profileName);
+        return this.create(config);
+    }
+}
+
+/**
+ * Environment Configuration for SeaVerse SDK
+ * 环境配置模块 - 支持多环境部署
+ */
+/**
+ * 预定义的环境配置
+ *
+ * 使用说明：
+ * - production: 正式生产环境
+ * - staging: 预发布环境（当前默认）
+ * - development: 开发测试环境
+ * - local: 本地开发环境
+ */
+const ENVIRONMENT_CONFIGS = {
+    production: {
+        name: 'production',
+        baseURL: 'https://api.seaverse.com',
+        wsURL: 'wss://api.seaverse.com',
+        isProduction: true,
+    },
+    staging: {
+        name: 'staging',
+        baseURL: 'https://account-hub.sg.seaverse.dev',
+        wsURL: 'wss://account-hub.sg.seaverse.dev',
+        isProduction: false,
+    },
+    development: {
+        name: 'development',
+        baseURL: 'https://api-dev.seaverse.dev',
+        wsURL: 'wss://api-dev.seaverse.dev',
+        isProduction: false,
+    },
+    local: {
+        name: 'local',
+        baseURL: 'http://localhost:8001',
+        wsURL: 'ws://localhost:8000',
+        isProduction: false,
+    },
+};
+/**
+ * 根据当前运行环境自动检测应该使用的环境配置
+ *
+ * 检测规则：
+ * 1. localhost/127.0.0.1 → local
+ * 2. 包含 -dev 或 .dev → development
+ * 3. 包含 staging → staging
+ * 4. 其他 → production (默认)
+ *
+ * @returns 检测到的环境类型
+ */
+function detectEnvironment() {
+    // Node.js 环境或非浏览器环境，默认返回 staging（安全起见）
+    if (typeof window === 'undefined' || typeof window.location === 'undefined') {
+        return 'staging';
+    }
+    const hostname = window.location.hostname.toLowerCase();
+    // 本地开发环境
+    if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '0.0.0.0') {
+        return 'local';
+    }
+    // 开发环境 (包含 -dev 或 .dev)
+    if (hostname.includes('-dev.') || hostname.includes('.dev') || hostname.endsWith('.dev')) {
+        return 'development';
+    }
+    // Staging 环境
+    if (hostname.includes('-staging.') || hostname.includes('staging.')) {
+        return 'staging';
+    }
+    // 默认使用 production
+    return 'production';
+}
+/**
+ * 获取环境配置
+ *
+ * @param env 环境类型，如果不提供则自动检测
+ * @returns 环境配置对象
+ */
+function getEnvironmentConfig(env) {
+    const targetEnv = env || detectEnvironment();
+    return ENVIRONMENT_CONFIGS[targetEnv];
+}
+/**
+ * 解析用户配置，返回最终的 baseURL
+ *
+ * 优先级：
+ * 1. 显式传入的 baseURL（最高优先级）
+ * 2. environment 参数指定的环境
+ * 3. 自动检测环境（最低优先级）
+ *
+ * @param options 用户配置选项
+ * @returns 最终使用的 baseURL
+ */
+function resolveBaseURL(options) {
+    // 优先级 1: 显式传入的 baseURL
+    if (options.baseURL) {
+        return options.baseURL;
+    }
+    // 优先级 2: environment 参数
+    if (options.environment) {
+        return ENVIRONMENT_CONFIGS[options.environment].baseURL;
+    }
+    // 优先级 3: 自动检测
+    const detectedEnv = detectEnvironment();
+    return ENVIRONMENT_CONFIGS[detectedEnv].baseURL;
+}
+
+/**
+ * Type definitions for SeaVerse Dispatcher API
+ * Generated from auth.yaml OpenAPI specification
+ */
+
+var models = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
+/**
+ * SeaVerse Backend API Client
+ * SeaVerse Dispatcher API - 云原生 AI Agent 平台的统一网关服务
+ *
+ * @version 2.0.0
+ *
+ * @example
+ * // 方式 1: 自动检测环境（推荐本地开发）
+ * const client = new SeaVerseBackendAPIClient();
+ *
+ * @example
+ * // 方式 2: 指定环境（推荐生产部署）
+ * const client = new SeaVerseBackendAPIClient({
+ *   environment: 'production',
+ * });
+ *
+ * @example
+ * // 方式 3: 自定义 URL（特殊需求）
+ * const client = new SeaVerseBackendAPIClient({
+ *   baseURL: 'https://custom-api.example.com',
+ * });
+ */
+class SeaVerseBackendAPIClient {
+    constructor(options = {}) {
+        // 使用智能配置解析，支持三种优先级：
+        // 1. 显式 baseURL（最高）
+        // 2. environment 参数
+        // 3. 自动检测（默认）
+        const finalBaseURL = resolveBaseURL({
+            baseURL: options.baseURL,
+            environment: options.environment,
+        });
+        const httpOptions = {
+            baseURL: finalBaseURL,
+            timeout: options.timeout,
+            headers: options.headers,
+            auth: options.auth || this.getDefaultAuth(),
+            hooks: options.hooks || this.getDefaultHooks(),
+        };
+        this.httpClient = new HttpClient(httpOptions);
+    }
+    /**
+     * Get default authentication configuration
+     */
+    getDefaultAuth() {
+        const token = getEnvConfig('JWT_TOKEN');
+        if (!token)
+            return undefined;
+        return AuthFactory.create({
+            type: 'jwt',
+            credentials: {
+                type: 'jwt',
+                token,
+            },
+        });
+    }
+    /**
+     * Get default hooks configuration
+     */
+    getDefaultHooks() {
+        return {
+            hooks: [
+                BuiltInHooks.createLoggerHook({
+                    logLevel: 'info',
+                    logRequestBody: true,
+                    logResponseBody: true,
+                }),
+                BuiltInHooks.createRequestIdHook(),
+            ],
+        };
+    }
+    // ============================================================================
+    // Authentication & OAuth APIs
+    // ============================================================================
+    /**
+     * Health check
+     * Check if the service is healthy
+     */
+    async getHealth(options) {
+        const config = {
+            method: 'GET',
+            url: `/health`,
+            headers: {
+                'X-Operation-Id': 'getHealth',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * User registration
+     * Register a new user with email verification
+     */
+    async register(data, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/register`,
+            data,
+            headers: {
+                'X-Operation-Id': 'register',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * User login
+     * Login with email and password
+     */
+    async login(data, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/login`,
+            data,
+            headers: {
+                'X-Operation-Id': 'login',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Get current user
+     * Get the authenticated user's information
+     */
+    async getCurrentUser(options) {
+        const config = {
+            method: 'GET',
+            url: `/api/auth/me`,
+            headers: {
+                'X-Operation-Id': 'getCurrentUser',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * User logout
+     * Logout the current user
+     */
+    async logout(options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/logout`,
+            headers: {
+                'X-Operation-Id': 'logout',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Request password reset
+     * Send password reset email
+     */
+    async forgotPassword(data, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/forgot-password`,
+            data,
+            headers: {
+                'X-Operation-Id': 'forgotPassword',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Reset password
+     * Reset password with token from email
+     */
+    async resetPassword(data, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/reset-password`,
+            data,
+            headers: {
+                'X-Operation-Id': 'resetPassword',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Get api-service token
+     * Generate token for accessing api-service from sandbox
+     */
+    async getApiServiceToken(options) {
+        const config = {
+            method: 'GET',
+            url: `/api/auth/api-service-token`,
+            headers: {
+                'X-Operation-Id': 'getApiServiceToken',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    // ============================================================================
+    // OAuth APIs
+    // ============================================================================
+    /**
+     * Exchange Google code for token
+     * Exchange Google authorization code for JWT token (for app)
+     */
+    async googleCodeToToken(data, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/google/code2token`,
+            data,
+            headers: {
+                'X-Operation-Id': 'googleCodeToToken',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Unlink Google account
+     * Unlink the user's Google account
+     */
+    async unlinkGoogle(options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/google/unlink`,
+            headers: {
+                'X-Operation-Id': 'unlinkGoogle',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Exchange Discord code for token
+     */
+    async discordCodeToToken(data, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/discord/code2token`,
+            data,
+            headers: {
+                'X-Operation-Id': 'discordCodeToToken',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Unlink Discord account
+     */
+    async unlinkDiscord(options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/discord/unlink`,
+            headers: {
+                'X-Operation-Id': 'unlinkDiscord',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Exchange GitHub code for token
+     */
+    async githubCodeToToken(data, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/github/code2token`,
+            data,
+            headers: {
+                'X-Operation-Id': 'githubCodeToToken',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Unlink GitHub account
+     */
+    async unlinkGithub(options) {
+        const config = {
+            method: 'POST',
+            url: `/api/auth/github/unlink`,
+            headers: {
+                'X-Operation-Id': 'unlinkGithub',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    // ============================================================================
+    // Container APIs
+    // ============================================================================
+    /**
+     * List all containers
+     */
+    async listContainers(options) {
+        const config = {
+            method: 'GET',
+            url: `/api/containers`,
+            headers: {
+                'X-Operation-Id': 'listContainers',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Register a container
+     * Internal service call to register a new container
+     */
+    async registerContainer(data, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/containers`,
+            data,
+            headers: {
+                'X-Operation-Id': 'registerContainer',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Get container by ID
+     */
+    async getContainer(id, options) {
+        const config = {
+            method: 'GET',
+            url: `/api/containers/${id}`,
+            headers: {
+                'X-Operation-Id': 'getContainer',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Unregister a container
+     * Internal service call to unregister a container
+     */
+    async unregisterContainer(id, options) {
+        const config = {
+            method: 'DELETE',
+            url: `/api/containers/${id}`,
+            headers: {
+                'X-Operation-Id': 'unregisterContainer',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Get container statistics
+     */
+    async getContainerStats(options) {
+        const config = {
+            method: 'GET',
+            url: `/api/containers/stats`,
+            headers: {
+                'X-Operation-Id': 'getContainerStats',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Container heartbeat
+     * Internal service call to update container heartbeat
+     */
+    async containerHeartbeat(id, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/containers/${id}/heartbeat`,
+            headers: {
+                'X-Operation-Id': 'containerHeartbeat',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    // ============================================================================
+    // Conversation APIs
+    // ============================================================================
+    /**
+     * Get conversation status
+     * Query conversation streaming status from Redis
+     */
+    async getConversationStatus(conversationId, options) {
+        const config = {
+            method: 'GET',
+            url: `/api/conversations/${conversationId}/status`,
+            headers: {
+                'X-Operation-Id': 'getConversationStatus',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    // ============================================================================
+    // Skills Marketplace APIs
+    // ============================================================================
+    /**
+     * List marketplace skills
+     */
+    async listMarketplaceSkills(params, options) {
+        const config = {
+            method: 'GET',
+            url: `/api/marketplace/skills`,
+            params,
+            headers: {
+                'X-Operation-Id': 'listMarketplaceSkills',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Get skill details
+     */
+    async getMarketplaceSkill(skillId, options) {
+        const config = {
+            method: 'GET',
+            url: `/api/marketplace/skills/${skillId}`,
+            headers: {
+                'X-Operation-Id': 'getMarketplaceSkill',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Install skill from marketplace
+     */
+    async installSkill(skillId, options) {
+        const config = {
+            method: 'POST',
+            url: `/api/marketplace/skills/${skillId}/download`,
+            headers: {
+                'X-Operation-Id': 'installSkill',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * List user installed skills
+     */
+    async listUserSkills(options) {
+        const config = {
+            method: 'GET',
+            url: `/api/user/skills`,
+            headers: {
+                'X-Operation-Id': 'listUserSkills',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    /**
+     * Uninstall skill
+     */
+    async uninstallSkill(localName, options) {
+        const config = {
+            method: 'DELETE',
+            url: `/api/user/skills/${localName}`,
+            headers: {
+                'X-Operation-Id': 'uninstallSkill',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        await this.httpClient.request(config);
+    }
+    // ============================================================================
+    // Speech Service APIs
+    // ============================================================================
+    /**
+     * Get Azure Speech token
+     * Get temporary token for Azure Speech Service
+     */
+    async getSpeechToken(options) {
+        const config = {
+            method: 'GET',
+            url: `/api/speech/token`,
+            headers: {
+                'X-Operation-Id': 'getSpeechToken',
+                ...options?.headers,
+            },
+            ...options,
+        };
+        const response = await this.httpClient.request(config);
+        return response.data;
+    }
+    // ============================================================================
+    // Deprecated/Legacy Methods (for backward compatibility)
+    // ============================================================================
+    /**
+     * @deprecated Use register() instead
+     */
+    async postapiauthregister(data, options) {
+        return this.register(data, options);
+    }
+    /**
+     * @deprecated Use login() instead
+     */
+    async postapiauthlogin(data, options) {
+        return this.login(data, options);
+    }
+    /**
+     * @deprecated Use getHealth() instead
+     */
+    async gethealth(options) {
+        return this.getHealth(options);
+    }
+    /**
+     * @deprecated Use listContainers() instead
+     */
+    async getapicontainers(options) {
+        return this.listContainers(options);
+    }
+}
+
+class AuthModal {
+    constructor(options) {
+        this.modal = null;
+        this.currentView = 'login';
+        this.client = options.client;
+        this.options = options;
+    }
+    /**
+     * Show the authentication modal
+     */
+    show(initialView = 'login') {
+        this.currentView = initialView;
+        if (!this.modal) {
+            this.createModal();
+        }
+        this.modal.classList.remove('hidden');
+        this.switchView(initialView);
+    }
+    /**
+     * Hide the authentication modal
+     */
+    hide() {
+        if (this.modal) {
+            this.modal.classList.add('hidden');
+        }
+    }
+    /**
+     * Destroy the modal and remove from DOM
+     */
+    destroy() {
+        if (this.modal) {
+            this.modal.remove();
+            this.modal = null;
+        }
+    }
+    createModal() {
+        const theme = this.options.theme || 'dark';
+        // Create modal container
+        this.modal = document.createElement('div');
+        this.modal.id = 'authModal';
+        this.modal.className = `auth-modal auth-modal-${theme}`;
+        // Create backdrop
+        const backdrop = document.createElement('div');
+        backdrop.className = 'auth-modal-backdrop';
+        this.modal.appendChild(backdrop);
+        // Create content container
+        const content = document.createElement('div');
+        content.className = 'auth-modal-content';
+        this.modal.appendChild(content);
+        // Create left panel (branding)
+        const leftPanel = this.createLeftPanel();
+        content.appendChild(leftPanel);
+        // Create right panel (forms)
+        const rightPanel = this.createRightPanel();
+        content.appendChild(rightPanel);
+        // Append to body
+        document.body.appendChild(this.modal);
+        // Bind event listeners
+        this.bindEventListeners();
+    }
+    createLeftPanel() {
+        const leftPanel = document.createElement('div');
+        leftPanel.className = 'auth-modal-left';
+        // Logo
+        const logo = document.createElement('div');
+        logo.className = 'auth-modal-logo';
+        const logoText = document.createElement('span');
+        logoText.className = 'logo-text';
+        logoText.textContent = 'SeaVerse';
+        logo.appendChild(logoText);
+        leftPanel.appendChild(logo);
+        // Decoration
+        const decoration = document.createElement('div');
+        decoration.className = 'auth-modal-decoration';
+        const orb1 = document.createElement('div');
+        orb1.className = 'glow-orb glow-orb-1';
+        const orb2 = document.createElement('div');
+        orb2.className = 'glow-orb glow-orb-2';
+        decoration.appendChild(orb1);
+        decoration.appendChild(orb2);
+        leftPanel.appendChild(decoration);
+        // Branding
+        const branding = document.createElement('div');
+        branding.className = 'auth-modal-branding';
+        const brandingTitle = document.createElement('h2');
+        brandingTitle.className = 'branding-title';
+        brandingTitle.textContent = 'Get Started with Us';
+        const brandingSubtitle = document.createElement('p');
+        brandingSubtitle.className = 'branding-subtitle';
+        brandingSubtitle.textContent = "Every conversation changes this place. You're not just using Infinity. You're creating it.";
+        branding.appendChild(brandingTitle);
+        branding.appendChild(brandingSubtitle);
+        leftPanel.appendChild(branding);
+        return leftPanel;
+    }
+    createRightPanel() {
+        const rightPanel = document.createElement('div');
+        rightPanel.className = 'auth-modal-right';
+        // Close button
+        const closeBtn = document.createElement('button');
+        closeBtn.className = 'auth-modal-close';
+        closeBtn.setAttribute('aria-label', 'Close modal');
+        closeBtn.innerHTML = '<svg width="24" height="24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>';
+        rightPanel.appendChild(closeBtn);
+        // Login form
+        const loginForm = this.createLoginForm();
+        rightPanel.appendChild(loginForm);
+        // Signup form
+        const signupForm = this.createSignupForm();
+        rightPanel.appendChild(signupForm);
+        // Forgot password form
+        const forgotForm = this.createForgotPasswordForm();
+        rightPanel.appendChild(forgotForm);
+        // Success message
+        const successMessage = this.createSuccessMessage();
+        rightPanel.appendChild(successMessage);
+        return rightPanel;
+    }
+    createLoginForm() {
+        const container = document.createElement('div');
+        container.id = 'loginForm';
+        container.className = 'auth-form-view';
+        // Header
+        const header = document.createElement('div');
+        header.className = 'auth-form-header';
+        const title = document.createElement('h2');
+        title.className = 'auth-form-title';
+        title.textContent = 'Welcome back.';
+        const subtitle = document.createElement('p');
+        subtitle.className = 'auth-form-subtitle';
+        subtitle.textContent = "Don't have an account? ";
+        const signupLink = document.createElement('a');
+        signupLink.href = '#';
+        signupLink.id = 'showSignup';
+        signupLink.className = 'link-primary';
+        signupLink.textContent = 'Sign up';
+        subtitle.appendChild(signupLink);
+        header.appendChild(title);
+        header.appendChild(subtitle);
+        container.appendChild(header);
+        // Form
+        const form = document.createElement('form');
+        form.id = 'loginFormElement';
+        form.className = 'auth-form';
+        // Email field
+        const emailGroup = this.createFormGroup('loginEmail', 'Email', 'email', 'Email');
+        form.appendChild(emailGroup);
+        // Password field with forgot link
+        const passwordGroup = document.createElement('div');
+        passwordGroup.className = 'form-group';
+        const groupHeader = document.createElement('div');
+        groupHeader.className = 'form-group-header';
+        const passwordLabel = document.createElement('label');
+        passwordLabel.htmlFor = 'loginPassword';
+        passwordLabel.className = 'form-label';
+        passwordLabel.textContent = 'Password';
+        const forgotLink = document.createElement('a');
+        forgotLink.href = '#';
+        forgotLink.id = 'forgotPasswordLink';
+        forgotLink.className = 'forgot-password-link';
+        forgotLink.textContent = 'Forgot Password?';
+        groupHeader.appendChild(passwordLabel);
+        groupHeader.appendChild(forgotLink);
+        passwordGroup.appendChild(groupHeader);
+        const passwordInputWrapper = this.createPasswordInput('loginPassword', 'Password');
+        passwordGroup.appendChild(passwordInputWrapper);
+        form.appendChild(passwordGroup);
+        // Submit button
+        const submitBtn = document.createElement('button');
+        submitBtn.type = 'submit';
+        submitBtn.id = 'loginButton';
+        submitBtn.className = 'btn-auth-primary';
+        const btnText = document.createElement('span');
+        btnText.className = 'btn-text';
+        btnText.textContent = 'Sign In';
+        const btnLoader = document.createElement('span');
+        btnLoader.className = 'btn-loader hidden';
+        btnLoader.innerHTML = '<svg class="spinner" viewBox="0 0 24 24"><circle class="spinner-track" cx="12" cy="12" r="10"></circle><circle class="spinner-circle" cx="12" cy="12" r="10"></circle></svg>';
+        submitBtn.appendChild(btnText);
+        submitBtn.appendChild(btnLoader);
+        form.appendChild(submitBtn);
+        // Divider
+        const divider = document.createElement('div');
+        divider.className = 'divider';
+        divider.textContent = 'OR SIGN IN WITH';
+        form.appendChild(divider);
+        // Social buttons grid (Google + GitHub)
+        const socialGrid = document.createElement('div');
+        socialGrid.className = 'social-buttons-grid';
+        // Google button
+        const googleBtn = this.createSocialButton('google', 'Google', 'login');
+        socialGrid.appendChild(googleBtn);
+        // GitHub button
+        const githubBtn = this.createSocialButton('github', 'Github', 'login');
+        socialGrid.appendChild(githubBtn);
+        form.appendChild(socialGrid);
+        // Discord button (full width)
+        const discordBtn = this.createSocialButton('discord', 'Discord', 'login', true);
+        form.appendChild(discordBtn);
+        container.appendChild(form);
+        return container;
+    }
+    createSignupForm() {
+        const container = document.createElement('div');
+        container.id = 'signupForm';
+        container.className = 'auth-form-view hidden';
+        // Header
+        const header = document.createElement('div');
+        header.className = 'auth-form-header';
+        const title = document.createElement('h2');
+        title.className = 'auth-form-title';
+        title.textContent = 'Create an account.';
+        const subtitle = document.createElement('p');
+        subtitle.className = 'auth-form-subtitle';
+        subtitle.textContent = 'Already have an account? ';
+        const loginLink = document.createElement('a');
+        loginLink.href = '#';
+        loginLink.id = 'showLogin';
+        loginLink.className = 'link-primary';
+        loginLink.textContent = 'Sign in';
+        subtitle.appendChild(loginLink);
+        header.appendChild(title);
+        header.appendChild(subtitle);
+        container.appendChild(header);
+        // Form
+        const form = document.createElement('form');
+        form.id = 'signupFormElement';
+        form.className = 'auth-form';
+        // Email field
+        const emailGroup = this.createFormGroup('signupEmail', 'Email', 'email', 'Email');
+        form.appendChild(emailGroup);
+        // Password field
+        const passwordGroup = document.createElement('div');
+        passwordGroup.className = 'form-group';
+        const passwordLabel = document.createElement('label');
+        passwordLabel.htmlFor = 'signupPassword';
+        passwordLabel.className = 'form-label';
+        passwordLabel.textContent = 'Password';
+        passwordGroup.appendChild(passwordLabel);
+        const passwordInputWrapper = this.createPasswordInput('signupPassword', 'Password');
+        passwordGroup.appendChild(passwordInputWrapper);
+        const strengthText = document.createElement('p');
+        strengthText.className = 'strength-text';
+        strengthText.textContent = 'Use 8+ characters with mix of letters, numbers & symbols';
+        passwordGroup.appendChild(strengthText);
+        form.appendChild(passwordGroup);
+        // Confirm password field
+        const confirmGroup = document.createElement('div');
+        confirmGroup.className = 'form-group';
+        const confirmLabel = document.createElement('label');
+        confirmLabel.htmlFor = 'signupPasswordConfirm';
+        confirmLabel.className = 'form-label';
+        confirmLabel.textContent = 'Confirm Password';
+        confirmGroup.appendChild(confirmLabel);
+        const confirmInputWrapper = this.createPasswordInput('signupPasswordConfirm', 'Confirm Password');
+        confirmGroup.appendChild(confirmInputWrapper);
+        form.appendChild(confirmGroup);
+        // Submit button
+        const submitBtn = document.createElement('button');
+        submitBtn.type = 'submit';
+        submitBtn.id = 'signupButton';
+        submitBtn.className = 'btn-auth-primary';
+        const btnText = document.createElement('span');
+        btnText.className = 'btn-text';
+        btnText.textContent = 'Sign Up';
+        const btnLoader = document.createElement('span');
+        btnLoader.className = 'btn-loader hidden';
+        btnLoader.innerHTML = '<svg class="spinner" viewBox="0 0 24 24"><circle class="spinner-track" cx="12" cy="12" r="10"></circle><circle class="spinner-circle" cx="12" cy="12" r="10"></circle></svg>';
+        submitBtn.appendChild(btnText);
+        submitBtn.appendChild(btnLoader);
+        form.appendChild(submitBtn);
+        // Divider
+        const divider = document.createElement('div');
+        divider.className = 'divider';
+        divider.textContent = 'OR SIGN UP WITH';
+        form.appendChild(divider);
+        // Social buttons grid (Google + GitHub)
+        const socialGrid = document.createElement('div');
+        socialGrid.className = 'social-buttons-grid';
+        // Google button
+        const googleBtn = this.createSocialButton('google', 'Google', 'signup');
+        socialGrid.appendChild(googleBtn);
+        // GitHub button
+        const githubBtn = this.createSocialButton('github', 'Github', 'signup');
+        socialGrid.appendChild(githubBtn);
+        form.appendChild(socialGrid);
+        // Discord button (full width)
+        const discordBtn = this.createSocialButton('discord', 'Discord', 'signup', true);
+        form.appendChild(discordBtn);
+        container.appendChild(form);
+        return container;
+    }
+    createForgotPasswordForm() {
+        const container = document.createElement('div');
+        container.id = 'forgotPasswordForm';
+        container.className = 'auth-form-view hidden';
+        // Icon
+        const icon = document.createElement('div');
+        icon.className = 'forgot-password-icon';
+        icon.innerHTML = '<div class="icon-glow"></div><svg class="icon-lock" width="56" height="56" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="11" width="18" height="11" rx="2" ry="2"/><path class="lock-shackle" d="M7 11V7a5 5 0 0 1 10 0v4"/><circle class="lock-keyhole" cx="12" cy="16" r="1.5"/></svg>';
+        container.appendChild(icon);
+        // Header
+        const header = document.createElement('div');
+        header.className = 'auth-form-header';
+        const title = document.createElement('h2');
+        title.className = 'auth-form-title';
+        title.textContent = 'Reset Password';
+        const subtitle = document.createElement('p');
+        subtitle.className = 'auth-form-subtitle';
+        subtitle.textContent = "We'll send a magic link to your inbox";
+        header.appendChild(title);
+        header.appendChild(subtitle);
+        container.appendChild(header);
+        // Form
+        const form = document.createElement('form');
+        form.id = 'forgotPasswordFormElement';
+        form.className = 'auth-form';
+        const emailGroup = this.createFormGroup('resetEmail', 'Email Address', 'email', 'Enter your email');
+        form.appendChild(emailGroup);
+        const submitBtn = document.createElement('button');
+        submitBtn.type = 'submit';
+        submitBtn.id = 'resetButton';
+        submitBtn.className = 'btn-auth-primary btn-forgot-password';
+        submitBtn.innerHTML = '<span class="btn-text">Send Reset Link</span><svg class="btn-arrow" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12h14M12 5l7 7-7 7"/></svg>';
+        form.appendChild(submitBtn);
+        container.appendChild(form);
+        // Footer
+        const footer = document.createElement('div');
+        footer.className = 'auth-footer forgot-footer';
+        const backLink = document.createElement('a');
+        backLink.href = '#';
+        backLink.id = 'backToLogin';
+        backLink.className = 'back-to-login';
+        backLink.innerHTML = '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M19 12H5M12 19l-7-7 7-7"/></svg><span>Back to Sign In</span>';
+        footer.appendChild(backLink);
+        container.appendChild(footer);
+        return container;
+    }
+    createSuccessMessage() {
+        const container = document.createElement('div');
+        container.id = 'authMessage';
+        container.className = 'auth-form-view hidden';
+        const content = document.createElement('div');
+        content.className = 'auth-message-content';
+        const icon = document.createElement('div');
+        icon.className = 'message-icon';
+        icon.innerHTML = '<svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><polyline points="22 4 12 14.01 9 11.01"/></svg>';
+        content.appendChild(icon);
+        const title = document.createElement('h3');
+        title.id = 'messageTitle';
+        title.className = 'message-title';
+        title.textContent = 'Success!';
+        content.appendChild(title);
+        const text = document.createElement('p');
+        text.id = 'messageText';
+        text.className = 'message-text';
+        text.textContent = 'Operation completed successfully.';
+        content.appendChild(text);
+        const button = document.createElement('button');
+        button.id = 'messageButton';
+        button.className = 'btn-auth-primary';
+        button.textContent = 'Continue';
+        content.appendChild(button);
+        container.appendChild(content);
+        return container;
+    }
+    createFormGroup(id, label, type, placeholder) {
+        const group = document.createElement('div');
+        group.className = 'form-group';
+        const labelEl = document.createElement('label');
+        labelEl.htmlFor = id;
+        labelEl.className = 'form-label';
+        labelEl.textContent = label;
+        group.appendChild(labelEl);
+        const input = document.createElement('input');
+        input.type = type;
+        input.id = id;
+        input.className = 'form-input';
+        input.placeholder = placeholder;
+        input.required = true;
+        group.appendChild(input);
+        return group;
+    }
+    createPasswordInput(id, placeholder) {
+        const wrapper = document.createElement('div');
+        wrapper.className = 'input-with-icon';
+        const input = document.createElement('input');
+        input.type = 'password';
+        input.id = id;
+        input.className = 'form-input';
+        input.placeholder = placeholder;
+        input.required = true;
+        wrapper.appendChild(input);
+        const toggleBtn = document.createElement('button');
+        toggleBtn.type = 'button';
+        toggleBtn.className = 'input-icon-btn toggle-password';
+        toggleBtn.dataset.target = id;
+        toggleBtn.innerHTML = '<svg class="icon-eye" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"></path><circle cx="12" cy="12" r="3"></circle></svg><svg class="icon-eye-off hidden" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M17.94 17.94A10.07 10.07 0 0 1 12 20c-7 0-11-8-11-8a18.45 18.45 0 0 1 5.06-5.94M9.9 4.24A9.12 9.12 0 0 1 12 4c7 0 11 8 11 8a18.5 18.5 0 0 1-2.16 3.19m-6.72-1.07a3 3 0 1 1-4.24-4.24"></path><line x1="1" y1="1" x2="23" y2="23"></line></svg>';
+        wrapper.appendChild(toggleBtn);
+        return wrapper;
+    }
+    createSocialButton(provider, label, mode, fullWidth = false) {
+        const button = document.createElement('button');
+        button.type = 'button';
+        button.className = fullWidth ? 'btn-social btn-social-full' : 'btn-social';
+        button.id = `${provider}${mode === 'login' ? 'SignIn' : 'SignUp'}Modal`;
+        // SVG icons for each provider
+        const icons = {
+            google: `<svg width="20" height="20" viewBox="0 0 24 24">
+        <path fill="#4285F4" d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z"/>
+        <path fill="#34A853" d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"/>
+        <path fill="#FBBC05" d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"/>
+        <path fill="#EA4335" d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"/>
+      </svg>`,
+            github: `<svg width="20" height="20" viewBox="0 0 24 24" fill="currentColor">
+        <path d="M12 2C6.477 2 2 6.477 2 12c0 4.42 2.865 8.17 6.839 9.49.5.092.682-.217.682-.482 0-.237-.008-.866-.013-1.7-2.782.603-3.369-1.34-3.369-1.34-.454-1.156-1.11-1.463-1.11-1.463-.908-.62.069-.608.069-.608 1.003.07 1.531 1.03 1.531 1.03.892 1.529 2.341 1.087 2.91.831.092-.646.35-1.086.636-1.336-2.22-.253-4.555-1.11-4.555-4.943 0-1.091.39-1.984 1.029-2.683-.103-.253-.446-1.27.098-2.647 0 0 .84-.269 2.75 1.025A9.578 9.578 0 0 1 12 6.836c.85.004 1.705.114 2.504.336 1.909-1.294 2.747-1.025 2.747-1.025.546 1.377.203 2.394.1 2.647.64.699 1.028 1.592 1.028 2.683 0 3.842-2.339 4.687-4.566 4.935.359.309.678.919.678 1.852 0 1.336-.012 2.415-.012 2.743 0 .267.18.578.688.48C19.138 20.167 22 16.418 22 12c0-5.523-4.477-10-10-10z"/>
+      </svg>`,
+            discord: `<svg width="20" height="20" viewBox="0 0 24 24" fill="#5865F2">
+        <path d="M20.317 4.37a19.791 19.791 0 0 0-4.885-1.515a.074.074 0 0 0-.079.037c-.21.375-.444.864-.608 1.25a18.27 18.27 0 0 0-5.487 0a12.64 12.64 0 0 0-.617-1.25a.077.077 0 0 0-.079-.037A19.736 19.736 0 0 0 3.677 4.37a.07.07 0 0 0-.032.027C.533 9.046-.32 13.58.099 18.057a.082.082 0 0 0 .031.057a19.9 19.9 0 0 0 5.993 3.03a.078.078 0 0 0 .084-.028a14.09 14.09 0 0 0 1.226-1.994a.076.076 0 0 0-.041-.106a13.107 13.107 0 0 1-1.872-.892a.077.077 0 0 1-.008-.128a10.2 10.2 0 0 0 .372-.292a.074.074 0 0 1 .077-.01c3.928 1.793 8.18 1.793 12.062 0a.074.074 0 0 1 .078.01c.12.098.246.198.373.292a.077.077 0 0 1-.006.127a12.299 12.299 0 0 1-1.873.892a.077.077 0 0 0-.041.107c.36.698.772 1.362 1.225 1.993a.076.076 0 0 0 .084.028a19.839 19.839 0 0 0 6.002-3.03a.077.077 0 0 0 .032-.054c.5-5.177-.838-9.674-3.549-13.66a.061.061 0 0 0-.031-.03zM8.02 15.33c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.956-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.956 2.418-2.157 2.418zm7.975 0c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.955-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.946 2.418-2.157 2.418z"/>
+      </svg>`
+        };
+        button.innerHTML = icons[provider];
+        const span = document.createElement('span');
+        span.textContent = label;
+        button.appendChild(span);
+        return button;
+    }
+    bindEventListeners() {
+        if (!this.modal)
+            return;
+        // Close button
+        const closeBtn = this.modal.querySelector('.auth-modal-close');
+        closeBtn?.addEventListener('click', () => this.hide());
+        // Backdrop click to close
+        const backdrop = this.modal.querySelector('.auth-modal-backdrop');
+        backdrop?.addEventListener('click', () => this.hide());
+        // View switching
+        const showSignup = this.modal.querySelector('#showSignup');
+        showSignup?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.switchView('signup');
+        });
+        const showLogin = this.modal.querySelector('#showLogin');
+        showLogin?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.switchView('login');
+        });
+        const forgotPasswordLink = this.modal.querySelector('#forgotPasswordLink');
+        forgotPasswordLink?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.switchView('forgot');
+        });
+        const backToLogin = this.modal.querySelector('#backToLogin');
+        backToLogin?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.switchView('login');
+        });
+        // Password toggle
+        const passwordToggles = this.modal.querySelectorAll('.toggle-password');
+        passwordToggles.forEach((toggle) => {
+            toggle.addEventListener('click', (e) => {
+                e.preventDefault();
+                const target = toggle.dataset.target;
+                if (target) {
+                    const input = this.modal.querySelector(`#${target}`);
+                    const iconEye = toggle.querySelector('.icon-eye');
+                    const iconEyeOff = toggle.querySelector('.icon-eye-off');
+                    if (input.type === 'password') {
+                        input.type = 'text';
+                        iconEye?.classList.add('hidden');
+                        iconEyeOff?.classList.remove('hidden');
+                    }
+                    else {
+                        input.type = 'password';
+                        iconEye?.classList.remove('hidden');
+                        iconEyeOff?.classList.add('hidden');
+                    }
+                }
+            });
+        });
+        // Form submissions
+        const loginForm = this.modal.querySelector('#loginFormElement');
+        loginForm?.addEventListener('submit', (e) => this.handleLogin(e));
+        const signupForm = this.modal.querySelector('#signupFormElement');
+        signupForm?.addEventListener('submit', (e) => this.handleSignup(e));
+        const forgotForm = this.modal.querySelector('#forgotPasswordFormElement');
+        forgotForm?.addEventListener('submit', (e) => this.handleForgotPassword(e));
+        // OAuth social login buttons
+        this.bindSocialLoginButtons();
+    }
+    /**
+     * Bind click events to social login buttons
+     */
+    bindSocialLoginButtons() {
+        if (!this.modal)
+            return;
+        // Google login buttons
+        const googleSignInBtn = this.modal.querySelector('#googleSignInModal');
+        googleSignInBtn?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.startOAuthFlow('google');
+        });
+        const googleSignUpBtn = this.modal.querySelector('#googleSignUpModal');
+        googleSignUpBtn?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.startOAuthFlow('google');
+        });
+        // Discord login buttons
+        const discordSignInBtn = this.modal.querySelector('#discordSignInModal');
+        discordSignInBtn?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.startOAuthFlow('discord');
+        });
+        const discordSignUpBtn = this.modal.querySelector('#discordSignUpModal');
+        discordSignUpBtn?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.startOAuthFlow('discord');
+        });
+        // GitHub login buttons
+        const githubSignInBtn = this.modal.querySelector('#githubSignInModal');
+        githubSignInBtn?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.startOAuthFlow('github');
+        });
+        const githubSignUpBtn = this.modal.querySelector('#githubSignUpModal');
+        githubSignUpBtn?.addEventListener('click', (e) => {
+            e.preventDefault();
+            this.startOAuthFlow('github');
+        });
+    }
+    switchView(view) {
+        if (!this.modal)
+            return;
+        const views = ['loginForm', 'signupForm', 'forgotPasswordForm', 'authMessage'];
+        views.forEach((viewId) => {
+            const element = this.modal.querySelector(`#${viewId}`);
+            element?.classList.add('hidden');
+        });
+        const viewMap = {
+            login: 'loginForm',
+            signup: 'signupForm',
+            forgot: 'forgotPasswordForm',
+            message: 'authMessage',
+        };
+        const targetView = this.modal.querySelector(`#${viewMap[view]}`);
+        targetView?.classList.remove('hidden');
+        this.currentView = view;
+    }
+    async handleLogin(e) {
+        e.preventDefault();
+        const emailInput = this.modal?.querySelector('#loginEmail');
+        const passwordInput = this.modal?.querySelector('#loginPassword');
+        const submitBtn = this.modal?.querySelector('#loginButton');
+        const btnText = submitBtn?.querySelector('.btn-text');
+        const btnLoader = submitBtn?.querySelector('.btn-loader');
+        if (!emailInput || !passwordInput || !submitBtn)
+            return;
+        const email = emailInput.value;
+        const password = passwordInput.value;
+        try {
+            // Show loading state
+            submitBtn.disabled = true;
+            btnText?.classList.add('hidden');
+            btnLoader?.classList.remove('hidden');
+            // Call login API using new typed method
+            const response = await this.client.login({
+                email,
+                password,
+            });
+            // Handle success
+            if (response.token) {
+                if (this.options.onLoginSuccess) {
+                    this.options.onLoginSuccess(response.token, response.user);
+                }
+                this.showMessage('Login Successful', 'Welcome back!');
+            }
+            else {
+                throw new Error('Invalid response from server');
+            }
+        }
+        catch (error) {
+            // Handle error
+            const errorMessage = error instanceof Error ? error.message : 'Login failed';
+            this.showError(errorMessage);
+            if (this.options.onError) {
+                this.options.onError(error);
+            }
+        }
+        finally {
+            // Reset loading state
+            submitBtn.disabled = false;
+            btnText?.classList.remove('hidden');
+            btnLoader?.classList.add('hidden');
+        }
+    }
+    async handleSignup(e) {
+        e.preventDefault();
+        const emailInput = this.modal?.querySelector('#signupEmail');
+        const passwordInput = this.modal?.querySelector('#signupPassword');
+        const passwordConfirmInput = this.modal?.querySelector('#signupPasswordConfirm');
+        const submitBtn = this.modal?.querySelector('#signupButton');
+        const btnText = submitBtn?.querySelector('.btn-text');
+        const btnLoader = submitBtn?.querySelector('.btn-loader');
+        if (!emailInput || !passwordInput || !passwordConfirmInput || !submitBtn)
+            return;
+        const email = emailInput.value;
+        const password = passwordInput.value;
+        const passwordConfirm = passwordConfirmInput.value;
+        // Validate passwords match
+        if (password !== passwordConfirm) {
+            this.showError('Passwords do not match');
+            return;
+        }
+        try {
+            // Show loading state
+            submitBtn.disabled = true;
+            btnText?.classList.add('hidden');
+            btnLoader?.classList.remove('hidden');
+            // Call signup API using new typed method
+            const response = await this.client.register({
+                email,
+                password,
+            });
+            // Handle success - Note: register returns different response format
+            if (response.success) {
+                // After successful registration, perform login to get token
+                const loginResponse = await this.client.login({ email, password });
+                if (loginResponse.token) {
+                    if (this.options.onSignupSuccess) {
+                        this.options.onSignupSuccess(loginResponse.token, loginResponse.user);
+                    }
+                    this.showMessage('Account Created', response.message || 'Your account has been created successfully!');
+                }
+            }
+            else {
+                throw new Error('Registration failed');
+            }
+        }
+        catch (error) {
+            // Handle error
+            const errorMessage = error instanceof Error ? error.message : 'Signup failed';
+            this.showError(errorMessage);
+            if (this.options.onError) {
+                this.options.onError(error);
+            }
+        }
+        finally {
+            // Reset loading state
+            submitBtn.disabled = false;
+            btnText?.classList.remove('hidden');
+            btnLoader?.classList.add('hidden');
+        }
+    }
+    async handleForgotPassword(e) {
+        e.preventDefault();
+        const emailInput = this.modal?.querySelector('#resetEmail');
+        const submitBtn = this.modal?.querySelector('#resetButton');
+        if (!emailInput || !submitBtn)
+            return;
+        const email = emailInput.value;
+        try {
+            // Show loading state
+            submitBtn.disabled = true;
+            // TODO: Call forgot password API when available
+            // await this.client.postapiauthforgotpassword({ email });
+            // Show success message
+            this.showMessage('Reset Link Sent', `We've sent a password reset link to ${email}`);
+        }
+        catch (error) {
+            // Handle error
+            const errorMessage = error instanceof Error ? error.message : 'Failed to send reset link';
+            this.showError(errorMessage);
+            if (this.options.onError) {
+                this.options.onError(error);
+            }
+        }
+        finally {
+            // Reset loading state
+            submitBtn.disabled = false;
+        }
+    }
+    showMessage(title, message) {
+        if (!this.modal)
+            return;
+        const messageTitle = this.modal.querySelector('#messageTitle');
+        const messageText = this.modal.querySelector('#messageText');
+        const messageButton = this.modal.querySelector('#messageButton');
+        if (messageTitle)
+            messageTitle.textContent = title;
+        if (messageText)
+            messageText.textContent = message;
+        messageButton?.addEventListener('click', () => {
+            this.hide();
+        }, { once: true });
+        this.switchView('message');
+    }
+    showError(message) {
+        // Simple error display - you can enhance this
+        alert(message);
+    }
+    // ============================================================================
+    // OAuth Methods
+    // ============================================================================
+    /**
+     * Start OAuth flow for a given provider
+     */
+    startOAuthFlow(provider) {
+        const config = this.options.oauthConfig?.[provider];
+        if (!config) {
+            this.showError(`${provider} OAuth is not configured`);
+            return;
+        }
+        // Store the current state (to verify callback)
+        const state = this.generateRandomState();
+        sessionStorage.setItem('oauth_state', state);
+        sessionStorage.setItem('oauth_provider', provider);
+        // Build authorization URL
+        const authUrl = this.buildAuthUrl(provider, config, state);
+        // Redirect to OAuth provider
+        window.location.href = authUrl;
+    }
+    /**
+     * Generate random state for CSRF protection
+     */
+    generateRandomState() {
+        const array = new Uint8Array(32);
+        crypto.getRandomValues(array);
+        return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
+    }
+    /**
+     * Build authorization URL for each provider
+     */
+    buildAuthUrl(provider, config, state) {
+        const params = new URLSearchParams({
+            client_id: config.clientId,
+            redirect_uri: config.redirectUri,
+            state,
+            response_type: 'code',
+        });
+        // Provider-specific configurations
+        switch (provider) {
+            case 'google':
+                params.append('scope', config.scope || 'openid email profile');
+                params.append('access_type', 'offline');
+                params.append('prompt', 'consent');
+                return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+            case 'discord':
+                params.append('scope', config.scope || 'identify email');
+                return `https://discord.com/api/oauth2/authorize?${params.toString()}`;
+            case 'github':
+                params.append('scope', config.scope || 'read:user user:email');
+                return `https://github.com/login/oauth/authorize?${params.toString()}`;
+            default:
+                throw new Error(`Unknown provider: ${provider}`);
+        }
+    }
+    /**
+     * Handle OAuth callback
+     * Call this method from your redirect page with the code and state from URL
+     */
+    async handleOAuthCallback(code, state) {
+        try {
+            // Verify state
+            const storedState = sessionStorage.getItem('oauth_state');
+            const provider = sessionStorage.getItem('oauth_provider');
+            if (!storedState || storedState !== state) {
+                throw new Error('Invalid state parameter - possible CSRF attack');
+            }
+            if (!provider) {
+                throw new Error('No provider stored in session');
+            }
+            // Clear stored state
+            sessionStorage.removeItem('oauth_state');
+            sessionStorage.removeItem('oauth_provider');
+            // Exchange code for token using the appropriate SDK method
+            let response;
+            switch (provider) {
+                case 'google':
+                    response = await this.client.googleCodeToToken({ code });
+                    break;
+                case 'discord':
+                    response = await this.client.discordCodeToToken({ code });
+                    break;
+                case 'github':
+                    response = await this.client.githubCodeToToken({ code });
+                    break;
+                default:
+                    throw new Error(`Unknown provider: ${provider}`);
+            }
+            // Handle success
+            if (response.token) {
+                if (this.options.onLoginSuccess) {
+                    this.options.onLoginSuccess(response.token, response.user);
+                }
+                return {
+                    success: true,
+                    token: response.token,
+                    user: response.user,
+                };
+            }
+            else {
+                throw new Error('No token received from server');
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error('OAuth authentication failed');
+            if (this.options.onError) {
+                this.options.onError(err);
+            }
+            return {
+                success: false,
+                error: err,
+            };
+        }
+    }
+    /**
+     * Check if current page is an OAuth callback and handle it automatically
+     */
+    static async handleOAuthCallbackFromUrl(client, options) {
+        const urlParams = new URLSearchParams(window.location.search);
+        const code = urlParams.get('code');
+        const state = urlParams.get('state');
+        if (!code || !state) {
+            return null; // Not an OAuth callback
+        }
+        const modal = new AuthModal({
+            client,
+            ...options,
+        });
+        return await modal.handleOAuthCallback(code, state);
+    }
+}
+/**
+ * Create and show auth modal
+ */
+function createAuthModal(options) {
+    return new AuthModal(options);
+}
+
+export { AuthFactory, AuthModal, AuthProvider, BuiltInHooks, ENVIRONMENT_CONFIGS, SeaVerseBackendAPIClient, createAuthModal, detectEnvironment, getEnvironmentConfig, models };
+//# sourceMappingURL=index.js.map