npm - aegis-auth-navchetna - Versions diffs - 1.0.0 - Mend

aegis-auth-navchetna 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,383 @@
+# Aegis Auth - JavaScript SDK
+**Aegis Auth is a unified identity management system providing memory-safe Rust-based authentication. Consolidation of disparate identity providers into a single canonical source.**
+*Aegis Auth by Navchetna Technologies.*
+*Securing the future of decentralized identity.*
+*© 2026 Standard Core v3.*
+---
+Official JavaScript SDK for the Aegis Authentication System. Supports traditional authentication, WebAuthn/Passkeys, MFA, and more.
+## Installation
+### Via CDN
+```html
+<script src="https://cdn.jsdelivr.net/npm/aegis-auth-navchetna@latest/aegis-sdk.min.js"></script>
+```
+### Via npm
+```bash
+npm install aegis-auth-navchetna
+```
+### Via yarn
+```bash
+yarn add aegis-auth-navchetna
+```
+## Quick Start
+### CDN Usage
+```html
+<!DOCTYPE html>
+<html>
+<head>
+    <script src="https://cdn.jsdelivr.net/npm/@aegis/auth-sdk@latest/aegis-sdk.min.js"></script>
+</head>
+<body>
+    <script>
+        const aegis = Aegis.create({
+            apiKey: 'your-api-key-here'
+        });
+        // Login example
+        aegis.login('user@example.com', 'password')
+            .then(response => {
+                console.log('Logged in:', response.user);
+            })
+            .catch(error => {
+                console.error('Login failed:', error);
+            });
+    </script>
+</body>
+</html>
+```
+### ES6 Module Usage
+```javascript
+import Aegis from 'aegis-auth-navchetna';
+const aegis = Aegis.create({
+    apiKey: 'your-api-key-here',
+    baseURL: 'https://your-aegis-instance.com' // Optional
+});
+```
+### CommonJS Usage
+```javascript
+const Aegis = require('aegis-auth-navchetna');
+const aegis = Aegis.create({
+    apiKey: 'your-api-key-here'
+});
+```
+## Configuration
+```javascript
+const aegis = Aegis.create({
+    apiKey: 'your-api-key-here',           // Required: Your project API key
+    baseURL: 'https://your-instance.com'   // Optional: Custom Aegis instance URL
+});
+```
+## Authentication Methods
+### Email/Password Authentication
+#### Login
+```javascript
+try {
+    const response = await aegis.login('user@example.com', 'password');
+    console.log('User:', response.user);
+    console.log('Access Token:', response.access_token);
+} catch (error) {
+    console.error('Login failed:', error.message);
+}
+```
+#### Register
+```javascript
+try {
+    const response = await aegis.register({
+        email: 'user@example.com',
+        password: 'securePassword123',
+        first_name: 'John',
+        last_name: 'Doe'
+    });
+    console.log('Registration successful:', response);
+} catch (error) {
+    console.error('Registration failed:', error.message);
+}
+```
+#### Logout
+```javascript
+await aegis.logout();
+```
+### WebAuthn/Passkeys
+#### Check WebAuthn Support
+```javascript
+if (aegis.isWebAuthnSupported()) {
+    console.log('WebAuthn is supported');
+} else {
+    console.log('WebAuthn is not supported');
+}
+```
+#### Register WebAuthn Credential
+```javascript
+try {
+    const response = await aegis.startWebAuthnRegistration();
+    console.log('WebAuthn credential registered:', response);
+} catch (error) {
+    console.error('WebAuthn registration failed:', error.message);
+}
+```
+#### Login with WebAuthn
+```javascript
+try {
+    const response = await aegis.startWebAuthnLogin();
+    console.log('WebAuthn login successful:', response.user);
+} catch (error) {
+    console.error('WebAuthn login failed:', error.message);
+}
+```
+### Multi-Factor Authentication (MFA)
+#### Enable MFA
+```javascript
+try {
+    const response = await aegis.enableMFA();
+    console.log('QR Code:', response.qr_code);
+    console.log('Secret:', response.secret);
+    console.log('Backup Codes:', response.backup_codes);
+} catch (error) {
+    console.error('MFA enable failed:', error.message);
+}
+```
+#### Verify MFA Code
+```javascript
+try {
+    const response = await aegis.verifyMFA('123456');
+    console.log('MFA verified:', response);
+} catch (error) {
+    console.error('MFA verification failed:', error.message);
+}
+```
+#### Disable MFA
+```javascript
+try {
+    await aegis.disableMFA('123456');
+    console.log('MFA disabled');
+} catch (error) {
+    console.error('MFA disable failed:', error.message);
+}
+```
+### Password Reset
+#### Request Password Reset
+```javascript
+try {
+    await aegis.forgotPassword('user@example.com');
+    console.log('Password reset email sent');
+} catch (error) {
+    console.error('Password reset request failed:', error.message);
+}
+```
+#### Reset Password
+```javascript
+try {
+    await aegis.resetPassword('reset-token', 'newPassword123');
+    console.log('Password reset successful');
+} catch (error) {
+    console.error('Password reset failed:', error.message);
+}
+```
+## User Profile Management
+### Get User Profile
+```javascript
+try {
+    const profile = await aegis.getProfile();
+    console.log('User profile:', profile);
+} catch (error) {
+    console.error('Failed to get profile:', error.message);
+}
+```
+### Update User Profile
+```javascript
+try {
+    const response = await aegis.updateProfile({
+        first_name: 'Jane',
+        last_name: 'Smith',
+        phone: '+1234567890'
+    });
+    console.log('Profile updated:', response);
+} catch (error) {
+    console.error('Profile update failed:', error.message);
+}
+```
+## Token Management
+### Check Authentication Status
+```javascript
+if (aegis.isAuthenticated()) {
+    console.log('User is authenticated');
+    console.log('Current user:', aegis.getUser());
+} else {
+    console.log('User is not authenticated');
+}
+```
+### Get Access Token
+```javascript
+const token = aegis.getAccessToken();
+if (token) {
+    console.log('Access token:', token);
+}
+```
+### Manual Token Refresh
+```javascript
+try {
+    const response = await aegis.refreshAccessToken();
+    console.log('Token refreshed:', response);
+} catch (error) {
+    console.error('Token refresh failed:', error.message);
+}
+```
+## Event Handling
+The SDK emits events for various authentication states:
+```javascript
+// Listen for login events
+aegis.on('login', (user) => {
+    console.log('User logged in:', user);
+});
+// Listen for logout events
+aegis.on('logout', () => {
+    console.log('User logged out');
+});
+// Listen for token refresh events
+aegis.on('tokenRefresh', (user) => {
+    console.log('Token refreshed for user:', user);
+});
+// Listen for error events
+aegis.on('error', (errorData) => {
+    console.error('SDK Error:', errorData.error);
+    console.error('Endpoint:', errorData.endpoint);
+});
+```
+## Advanced Usage
+### Custom Request Headers
+```javascript
+const response = await aegis.request('/custom/endpoint', {
+    method: 'POST',
+    headers: {
+        'Custom-Header': 'value'
+    },
+    body: { data: 'example' }
+});
+```
+### Skip Authentication for Public Endpoints
+```javascript
+const response = await aegis.request('/public/endpoint', {
+    skipAuth: true
+});
+```
+## Error Handling
+The SDK throws descriptive errors that you can catch and handle:
+```javascript
+try {
+    await aegis.login('user@example.com', 'wrongpassword');
+} catch (error) {
+    if (error.message.includes('Invalid credentials')) {
+        // Handle invalid credentials
+        console.log('Please check your email and password');
+    } else if (error.message.includes('Network')) {
+        // Handle network errors
+        console.log('Please check your internet connection');
+    } else {
+        // Handle other errors
+        console.log('An unexpected error occurred');
+    }
+}
+```
+## Browser Compatibility
+- Chrome 67+
+- Firefox 60+
+- Safari 13+
+- Edge 79+
+WebAuthn features require HTTPS in production.
+## TypeScript Support
+The SDK includes TypeScript definitions:
+```typescript
+import Aegis, { AegisConfig, User, AuthResponse } from 'aegis-auth-navchetna';
+const config: AegisConfig = {
+    apiKey: 'your-api-key'
+};
+const aegis = Aegis.create(config);
+aegis.login('user@example.com', 'password')
+    .then((response: AuthResponse) => {
+        const user: User = response.user;
+        console.log('Logged in user:', user);
+    });
+```
+## Security Best Practices
+1. **Never expose your API key** in client-side code in production
+2. **Use HTTPS** in production environments
+3. **Implement proper error handling** to avoid exposing sensitive information
+4. **Store tokens securely** - the SDK uses localStorage by default
+5. **Implement logout functionality** to clear tokens when users sign out
+## Support
+- Documentation: [https://docs.aegis.com](https://docs.aegis.com)
+- Issues: [https://github.com/navchetna/aegis-auth-sdk/issues](https://github.com/navchetna/aegis-auth-sdk/issues)
+- Email: support@navchetna.com
+---
+**Aegis Auth by Navchetna Technologies**
+*Securing the future of decentralized identity*
+© 2026 Standard Core v3
+## License
+MIT License - see LICENSE file for details.

package/aegis-sdk.d.ts ADDED Viewed

@@ -0,0 +1,133 @@
+export interface AegisConfig {
+  apiKey: string;
+  baseURL?: string;
+}
+export interface User {
+  id: string;
+  email: string;
+  first_name?: string;
+  last_name?: string;
+  role?: string;
+  organization_id?: string;
+  permissions?: string[];
+}
+export interface AuthResponse {
+  access_token: string;
+  refresh_token: string;
+  expires_in: number;
+  token_type: string;
+  user: User;
+}
+export interface RegisterData {
+  email: string;
+  password: string;
+  first_name?: string;
+  last_name?: string;
+}
+export interface ProfileData {
+  first_name?: string;
+  last_name?: string;
+  phone?: string;
+}
+export interface WebAuthnCredential {
+  id: string;
+  rawId: number[];
+  response: {
+    attestationObject: number[];
+    clientDataJSON: number[];
+  };
+  type: string;
+}
+export interface WebAuthnAssertion {
+  id: string;
+  rawId: number[];
+  response: {
+    authenticatorData: number[];
+    clientDataJSON: number[];
+    signature: number[];
+    userHandle: number[] | null;
+  };
+  type: string;
+}
+export interface MFAResponse {
+  qr_code?: string;
+  secret?: string;
+  backup_codes?: string[];
+}
+export type EventType = 'login' | 'logout' | 'tokenRefresh' | 'error';
+export interface ErrorEvent {
+  error: Error;
+  endpoint?: string;
+  type?: string;
+}
+export class AegisSDK {
+  constructor(config: AegisConfig);
+  // Event handling
+  on(event: EventType, callback: (data: any) => void): void;
+  emit(event: EventType, data: any): void;
+  // HTTP requests
+  request(endpoint: string, options?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: any;
+    skipAuth?: boolean;
+    fetchOptions?: RequestInit;
+  }): Promise<any>;
+  // Authentication
+  login(email: string, password: string): Promise<AuthResponse>;
+  register(userData: RegisterData): Promise<any>;
+  logout(): Promise<void>;
+  refreshAccessToken(): Promise<AuthResponse>;
+  // WebAuthn
+  startWebAuthnRegistration(): Promise<any>;
+  completeWebAuthnRegistration(credential: PublicKeyCredential): Promise<any>;
+  startWebAuthnLogin(): Promise<AuthResponse>;
+  completeWebAuthnLogin(assertion: PublicKeyCredential): Promise<AuthResponse>;
+  // MFA
+  enableMFA(): Promise<MFAResponse>;
+  verifyMFA(code: string): Promise<any>;
+  disableMFA(code: string): Promise<any>;
+  // Password reset
+  forgotPassword(email: string): Promise<any>;
+  resetPassword(token: string, newPassword: string): Promise<any>;
+  // Profile
+  getProfile(): Promise<User>;
+  updateProfile(profileData: ProfileData): Promise<any>;
+  // Token management
+  setTokens(authData: AuthResponse): void;
+  clearTokens(): void;
+  loadTokensFromStorage(): boolean;
+  setupTokenRefresh(): void;
+  // Utility methods
+  isAuthenticated(): boolean;
+  getUser(): User | null;
+  getAccessToken(): string | null;
+  isWebAuthnSupported(): boolean;
+}
+export interface AegisFactory {
+  create(config: AegisConfig): AegisSDK;
+  AegisSDK: typeof AegisSDK;
+}
+declare const Aegis: AegisFactory;
+export default Aegis;

package/aegis-sdk.js ADDED Viewed

@@ -0,0 +1,404 @@
+/**
+ * Aegis Authentication SDK
+ * Client-side JavaScript SDK for Aegis Authentication System
+ * Version: 1.0.0
+ */
+(function(global, factory) {
+    if (typeof exports === 'object' && typeof module !== 'undefined') {
+        module.exports = factory();
+    } else if (typeof define === 'function' && define.amd) {
+        define(factory);
+    } else {
+        global.Aegis = factory();
+    }
+}(typeof self !== 'undefined' ? self : this, function() {
+    'use strict';
+    class AegisSDK {
+        constructor(config) {
+            this.apiKey = config.apiKey;
+            this.baseURL = config.baseURL || 'https://05card1j5b.execute-api.ap-south-1.amazonaws.com/prod';
+            this.accessToken = null;
+            this.refreshToken = null;
+            this.user = null;
+            this.tokenExpiry = null;
+            // Event listeners
+            this.listeners = {
+                login: [],
+                logout: [],
+                tokenRefresh: [],
+                error: []
+            };
+            // Auto-refresh token setup
+            this.refreshInterval = null;
+            this.setupTokenRefresh();
+        }
+        // Event handling
+        on(event, callback) {
+            if (this.listeners[event]) {
+                this.listeners[event].push(callback);
+            }
+        }
+        emit(event, data) {
+            if (this.listeners[event]) {
+                this.listeners[event].forEach(callback => callback(data));
+            }
+        }
+        // HTTP request helper
+        async request(endpoint, options = {}) {
+            const url = `${this.baseURL}${endpoint}`;
+            const headers = {
+                'Content-Type': 'application/json',
+                ...options.headers
+            };
+            if (this.apiKey) {
+                headers['X-API-Key'] = this.apiKey;
+            }
+            if (this.accessToken && !options.skipAuth) {
+                headers['Authorization'] = `Bearer ${this.accessToken}`;
+            }
+            try {
+                const response = await fetch(url, {
+                    method: options.method || 'GET',
+                    headers,
+                    body: options.body ? JSON.stringify(options.body) : undefined,
+                    ...options.fetchOptions
+                });
+                const data = await response.json();
+                if (!response.ok) {
+                    throw new Error(data.message || `HTTP ${response.status}`);
+                }
+                return data;
+            } catch (error) {
+                this.emit('error', { error, endpoint });
+                throw error;
+            }
+        }
+        // Authentication methods
+        async login(email, password) {
+            try {
+                const response = await this.request('/auth/login', {
+                    method: 'POST',
+                    body: { email, password },
+                    skipAuth: true
+                });
+                this.setTokens(response.data);
+                this.emit('login', this.user);
+                return response.data;
+            } catch (error) {
+                throw new Error(`Login failed: ${error.message}`);
+            }
+        }
+        async register(userData) {
+            try {
+                const response = await this.request('/auth/register', {
+                    method: 'POST',
+                    body: userData,
+                    skipAuth: true
+                });
+                return response.data;
+            } catch (error) {
+                throw new Error(`Registration failed: ${error.message}`);
+            }
+        }
+        async logout() {
+            try {
+                if (this.accessToken) {
+                    await this.request('/auth/logout', {
+                        method: 'POST'
+                    });
+                }
+            } catch (error) {
+                console.warn('Logout request failed:', error.message);
+            } finally {
+                this.clearTokens();
+                this.emit('logout');
+            }
+        }
+        async refreshAccessToken() {
+            if (!this.refreshToken) {
+                throw new Error('No refresh token available');
+            }
+            try {
+                const response = await this.request('/auth/refresh', {
+                    method: 'POST',
+                    body: { refresh_token: this.refreshToken },
+                    skipAuth: true
+                });
+                this.setTokens(response.data);
+                this.emit('tokenRefresh', this.user);
+                return response.data;
+            } catch (error) {
+                this.clearTokens();
+                throw new Error(`Token refresh failed: ${error.message}`);
+            }
+        }
+        // WebAuthn methods
+        async startWebAuthnRegistration() {
+            try {
+                const response = await this.request('/auth/webauthn/register/start', {
+                    method: 'POST'
+                });
+                const credential = await navigator.credentials.create({
+                    publicKey: response.data.options
+                });
+                return await this.completeWebAuthnRegistration(credential);
+            } catch (error) {
+                throw new Error(`WebAuthn registration failed: ${error.message}`);
+            }
+        }
+        async completeWebAuthnRegistration(credential) {
+            const credentialData = {
+                id: credential.id,
+                rawId: Array.from(new Uint8Array(credential.rawId)),
+                response: {
+                    attestationObject: Array.from(new Uint8Array(credential.response.attestationObject)),
+                    clientDataJSON: Array.from(new Uint8Array(credential.response.clientDataJSON))
+                },
+                type: credential.type
+            };
+            return await this.request('/auth/webauthn/register/complete', {
+                method: 'POST',
+                body: { credential: credentialData }
+            });
+        }
+        async startWebAuthnLogin() {
+            try {
+                const response = await this.request('/auth/webauthn/login/start', {
+                    method: 'POST',
+                    skipAuth: true
+                });
+                const assertion = await navigator.credentials.get({
+                    publicKey: response.data.options
+                });
+                return await this.completeWebAuthnLogin(assertion);
+            } catch (error) {
+                throw new Error(`WebAuthn login failed: ${error.message}`);
+            }
+        }
+        async completeWebAuthnLogin(assertion) {
+            const assertionData = {
+                id: assertion.id,
+                rawId: Array.from(new Uint8Array(assertion.rawId)),
+                response: {
+                    authenticatorData: Array.from(new Uint8Array(assertion.response.authenticatorData)),
+                    clientDataJSON: Array.from(new Uint8Array(assertion.response.clientDataJSON)),
+                    signature: Array.from(new Uint8Array(assertion.response.signature)),
+                    userHandle: assertion.response.userHandle ? Array.from(new Uint8Array(assertion.response.userHandle)) : null
+                },
+                type: assertion.type
+            };
+            const response = await this.request('/auth/webauthn/login/complete', {
+                method: 'POST',
+                body: { assertion: assertionData },
+                skipAuth: true
+            });
+            this.setTokens(response.data);
+            this.emit('login', this.user);
+            return response.data;
+        }
+        // MFA methods
+        async enableMFA() {
+            return await this.request('/auth/mfa/enable', {
+                method: 'POST'
+            });
+        }
+        async verifyMFA(code) {
+            return await this.request('/auth/mfa/verify', {
+                method: 'POST',
+                body: { code }
+            });
+        }
+        async disableMFA(code) {
+            return await this.request('/auth/mfa/disable', {
+                method: 'POST',
+                body: { code }
+            });
+        }
+        // Password reset
+        async forgotPassword(email) {
+            return await this.request('/auth/forgot-password', {
+                method: 'POST',
+                body: { email },
+                skipAuth: true
+            });
+        }
+        async resetPassword(token, newPassword) {
+            return await this.request('/auth/reset-password', {
+                method: 'POST',
+                body: { token, new_password: newPassword },
+                skipAuth: true
+            });
+        }
+        // User profile
+        async getProfile() {
+            return await this.request('/auth/profile');
+        }
+        async updateProfile(profileData) {
+            return await this.request('/auth/profile', {
+                method: 'PATCH',
+                body: profileData
+            });
+        }
+        // Token management
+        setTokens(authData) {
+            this.accessToken = authData.access_token;
+            this.refreshToken = authData.refresh_token;
+            this.user = authData.user;
+            this.tokenExpiry = Date.now() + (authData.expires_in * 1000);
+            // Store in localStorage
+            if (typeof localStorage !== 'undefined') {
+                localStorage.setItem('aegis_access_token', this.accessToken);
+                localStorage.setItem('aegis_refresh_token', this.refreshToken);
+                localStorage.setItem('aegis_user', JSON.stringify(this.user));
+                localStorage.setItem('aegis_token_expiry', this.tokenExpiry.toString());
+            }
+            this.setupTokenRefresh();
+        }
+        clearTokens() {
+            this.accessToken = null;
+            this.refreshToken = null;
+            this.user = null;
+            this.tokenExpiry = null;
+            if (this.refreshInterval) {
+                clearInterval(this.refreshInterval);
+                this.refreshInterval = null;
+            }
+            // Clear from localStorage
+            if (typeof localStorage !== 'undefined') {
+                localStorage.removeItem('aegis_access_token');
+                localStorage.removeItem('aegis_refresh_token');
+                localStorage.removeItem('aegis_user');
+                localStorage.removeItem('aegis_token_expiry');
+            }
+        }
+        loadTokensFromStorage() {
+            if (typeof localStorage === 'undefined') return false;
+            const accessToken = localStorage.getItem('aegis_access_token');
+            const refreshToken = localStorage.getItem('aegis_refresh_token');
+            const user = localStorage.getItem('aegis_user');
+            const tokenExpiry = localStorage.getItem('aegis_token_expiry');
+            if (accessToken && refreshToken && user && tokenExpiry) {
+                this.accessToken = accessToken;
+                this.refreshToken = refreshToken;
+                this.user = JSON.parse(user);
+                this.tokenExpiry = parseInt(tokenExpiry);
+                // Check if token is expired
+                if (Date.now() >= this.tokenExpiry) {
+                    this.clearTokens();
+                    return false;
+                }
+                this.setupTokenRefresh();
+                return true;
+            }
+            return false;
+        }
+        setupTokenRefresh() {
+            if (this.refreshInterval) {
+                clearInterval(this.refreshInterval);
+            }
+            if (this.tokenExpiry) {
+                const refreshTime = this.tokenExpiry - Date.now() - 60000; // Refresh 1 minute before expiry
+                if (refreshTime > 0) {
+                    this.refreshInterval = setTimeout(async () => {
+                        try {
+                            await this.refreshAccessToken();
+                        } catch (error) {
+                            this.emit('error', { error, type: 'token_refresh' });
+                        }
+                    }, refreshTime);
+                }
+            }
+        }
+        // Utility methods
+        isAuthenticated() {
+            return !!(this.accessToken && this.tokenExpiry && Date.now() < this.tokenExpiry);
+        }
+        getUser() {
+            return this.user;
+        }
+        getAccessToken() {
+            return this.accessToken;
+        }
+        // WebAuthn support check
+        isWebAuthnSupported() {
+            return !!(navigator.credentials && navigator.credentials.create && navigator.credentials.get);
+        }
+    }
+    // Factory function
+    function createAegisSDK(config) {
+        if (!config || !config.apiKey) {
+            throw new Error('Aegis SDK requires an API key');
+        }
+        const sdk = new AegisSDK(config);
+        // Try to load existing tokens
+        sdk.loadTokensFromStorage();
+        return sdk;
+    }
+    // Export
+    return {
+        create: createAegisSDK,
+        AegisSDK
+    };
+}));

package/aegis-sdk.min.js ADDED Viewed

@@ -0,0 +1 @@

+ !function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.Aegis=t()}("undefined"!=typeof self?self:this,function(){"use strict";class e{constructor(e){this.apiKey=e.apiKey,this.baseURL=e.baseURL||"https://05card1j5b.execute-api.ap-south-1.amazonaws.com/prod",this.accessToken=null,this.refreshToken=null,this.user=null,this.tokenExpiry=null,this.listeners={login:[],logout:[],tokenRefresh:[],error:[]},this.refreshInterval=null,this.setupTokenRefresh()}on(e,t){this.listeners[e]&&this.listeners[e].push(t)}emit(e,t){this.listeners[e]&&this.listeners[e].forEach(e=>e(t))}async request(e,t={}){const n=`${this.baseURL}${e}`,s={"Content-Type":"application/json",...t.headers};this.apiKey&&(s["X-API-Key"]=this.apiKey),this.accessToken&&!t.skipAuth&&(s.Authorization=`Bearer ${this.accessToken}`);try{const e=await fetch(n,{method:t.method||"GET",headers:s,body:t.body?JSON.stringify(t.body):void 0,...t.fetchOptions}),r=await e.json();if(!e.ok)throw new Error(r.message||`HTTP ${e.status}`);return r}catch(t){throw this.emit("error",{error:t,endpoint:e}),t}}async login(e,t){try{const n=await this.request("/auth/login",{method:"POST",body:{email:e,password:t},skipAuth:!0});return this.setTokens(n.data),this.emit("login",this.user),n.data}catch(e){throw new Error(`Login failed: ${e.message}`)}}async register(e){try{return(await this.request("/auth/register",{method:"POST",body:e,skipAuth:!0})).data}catch(e){throw new Error(`Registration failed: ${e.message}`)}}async logout(){try{this.accessToken&&await this.request("/auth/logout",{method:"POST"})}catch(e){console.warn("Logout request failed:",e.message)}finally{this.clearTokens(),this.emit("logout")}}async refreshAccessToken(){if(!this.refreshToken)throw new Error("No refresh token available");try{const e=await this.request("/auth/refresh",{method:"POST",body:{refresh_token:this.refreshToken},skipAuth:!0});return this.setTokens(e.data),this.emit("tokenRefresh",this.user),e.data}catch(e){throw this.clearTokens(),new Error(`Token refresh failed: ${e.message}`)}}async startWebAuthnRegistration(){try{const e=await this.request("/auth/webauthn/register/start",{method:"POST"}),t=await navigator.credentials.create({publicKey:e.data.options});return await this.completeWebAuthnRegistration(t)}catch(e){throw new Error(`WebAuthn registration failed: ${e.message}`)}}async completeWebAuthnRegistration(e){const t={id:e.id,rawId:Array.from(new Uint8Array(e.rawId)),response:{attestationObject:Array.from(new Uint8Array(e.response.attestationObject)),clientDataJSON:Array.from(new Uint8Array(e.response.clientDataJSON))},type:e.type};return await this.request("/auth/webauthn/register/complete",{method:"POST",body:{credential:t}})}async startWebAuthnLogin(){try{const e=await this.request("/auth/webauthn/login/start",{method:"POST",skipAuth:!0}),t=await navigator.credentials.get({publicKey:e.data.options});return await this.completeWebAuthnLogin(t)}catch(e){throw new Error(`WebAuthn login failed: ${e.message}`)}}async completeWebAuthnLogin(e){const t={id:e.id,rawId:Array.from(new Uint8Array(e.rawId)),response:{authenticatorData:Array.from(new Uint8Array(e.response.authenticatorData)),clientDataJSON:Array.from(new Uint8Array(e.response.clientDataJSON)),signature:Array.from(new Uint8Array(e.response.signature)),userHandle:e.response.userHandle?Array.from(new Uint8Array(e.response.userHandle)):null},type:e.type},n=await this.request("/auth/webauthn/login/complete",{method:"POST",body:{assertion:t},skipAuth:!0});return this.setTokens(n.data),this.emit("login",this.user),n.data}async enableMFA(){return await this.request("/auth/mfa/enable",{method:"POST"})}async verifyMFA(e){return await this.request("/auth/mfa/verify",{method:"POST",body:{code:e}})}async disableMFA(e){return await this.request("/auth/mfa/disable",{method:"POST",body:{code:e}})}async forgotPassword(e){return await this.request("/auth/forgot-password",{method:"POST",body:{email:e},skipAuth:!0})}async resetPassword(e,t){return await this.request("/auth/reset-password",{method:"POST",body:{token:e,new_password:t},skipAuth:!0})}async getProfile(){return await this.request("/auth/profile")}async updateProfile(e){return await this.request("/auth/profile",{method:"PATCH",body:e})}setTokens(e){this.accessToken=e.access_token,this.refreshToken=e.refresh_token,this.user=e.user,this.tokenExpiry=Date.now()+1e3*e.expires_in,"undefined"!=typeof localStorage&&(localStorage.setItem("aegis_access_token",this.accessToken),localStorage.setItem("aegis_refresh_token",this.refreshToken),localStorage.setItem("aegis_user",JSON.stringify(this.user)),localStorage.setItem("aegis_token_expiry",this.tokenExpiry.toString())),this.setupTokenRefresh()}clearTokens(){this.accessToken=null,this.refreshToken=null,this.user=null,this.tokenExpiry=null,this.refreshInterval&&(clearInterval(this.refreshInterval),this.refreshInterval=null),"undefined"!=typeof localStorage&&(localStorage.removeItem("aegis_access_token"),localStorage.removeItem("aegis_refresh_token"),localStorage.removeItem("aegis_user"),localStorage.removeItem("aegis_token_expiry"))}loadTokensFromStorage(){if("undefined"==typeof localStorage)return!1;const e=localStorage.getItem("aegis_access_token"),t=localStorage.getItem("aegis_refresh_token"),n=localStorage.getItem("aegis_user"),s=localStorage.getItem("aegis_token_expiry");return!!(e&&t&&n&&s)&&(this.accessToken=e,this.refreshToken=t,this.user=JSON.parse(n),this.tokenExpiry=parseInt(s),!(Date.now()>=this.tokenExpiry)||(this.clearTokens(),!1)&&(this.setupTokenRefresh(),!0))}setupTokenRefresh(){this.refreshInterval&&clearInterval(this.refreshInterval),this.tokenExpiry&&(e=>{e>0&&(this.refreshInterval=setTimeout(async()=>{try{await this.refreshAccessToken()}catch(e){this.emit("error",{error:e,type:"token_refresh"})}},e))})(this.tokenExpiry-Date.now()-6e4)}isAuthenticated(){return!!(this.accessToken&&this.tokenExpiry&&Date.now()<this.tokenExpiry)}getUser(){return this.user}getAccessToken(){return this.accessToken}isWebAuthnSupported(){return!!(navigator.credentials&&navigator.credentials.create&&navigator.credentials.get)}}return{create:function(t){if(!t||!t.apiKey)throw new Error("Aegis SDK requires an API key");const n=new e(t);return n.loadTokensFromStorage(),n},AegisSDK:e}});

package/package.json ADDED Viewed

@@ -0,0 +1,50 @@
+{
+  "name": "aegis-auth-navchetna",
+  "version": "1.0.0",
+  "description": "Aegis Auth is a unified identity management system providing memory-safe Rust-based authentication. Consolidation of disparate identity providers into a single canonical source.",
+  "main": "aegis-sdk.js",
+  "types": "aegis-sdk.d.ts",
+  "files": [
+    "aegis-sdk.js",
+    "aegis-sdk.min.js",
+    "aegis-sdk.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npm run minify",
+    "minify": "terser aegis-sdk.js -o aegis-sdk.min.js -c -m",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "authentication",
+    "auth",
+    "webauthn",
+    "mfa",
+    "jwt",
+    "aegis",
+    "sdk",
+    "security",
+    "rust",
+    "identity",
+    "decentralized",
+    "navchetna"
+  ],
+  "author": "Navchetna Technologies",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/navchetna/aegis-auth-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/navchetna/aegis-auth-sdk/issues"
+  },
+  "homepage": "https://github.com/navchetna/aegis-auth-sdk#readme",
+  "devDependencies": {
+    "terser": "^5.16.0"
+  },
+  "browser": "aegis-sdk.min.js",
+  "cdn": "https://cdn.jsdelivr.net/npm/aegis-auth-navchetna@latest/aegis-sdk.min.js",
+  "publishConfig": {
+    "access": "public"
+  }
+}