@yogesh0333/yogiway
Version:
YOGIWAY Format - Ultra-compact, nested-aware data format for LLM prompts. Handles deeply nested JSON efficiently, 10-15% more efficient than TOON.
266 lines • 8.57 kB
JavaScript
;
/**
* Authentication System for YOGIWAY Library
* Handles user login, registration, and token management
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.logout = logout;
exports.clearAuth = clearAuth;
exports.register = register;
exports.login = login;
exports.refreshToken = refreshToken;
exports.getAccessToken = getAccessToken;
exports.getCurrentUser = getCurrentUser;
exports.isAuthenticated = isAuthenticated;
exports.authenticatedFetch = authenticatedFetch;
// Auth server (deprecated - library is now free, auth is optional)
const AUTH_SERVER_URL = process.env.YOGIWAY_AUTH_SERVER || "";
const AUTH_STORAGE_KEY = "yogiway_auth_token";
const REFRESH_STORAGE_KEY = "yogiway_refresh_token";
const USER_STORAGE_KEY = "yogiway_user";
/**
* Store auth tokens securely
*/
function storeAuthTokens(accessToken, refreshToken, user) {
if (typeof window !== "undefined" && window.localStorage) {
// Browser environment
window.localStorage.setItem(AUTH_STORAGE_KEY, accessToken);
window.localStorage.setItem(REFRESH_STORAGE_KEY, refreshToken);
window.localStorage.setItem(USER_STORAGE_KEY, JSON.stringify(user));
}
else if (typeof require !== "undefined") {
// Node.js environment
try {
const fs = require("fs");
const path = require("path");
const os = require("os");
const authDir = path.join(os.homedir(), ".yogiway");
if (!fs.existsSync(authDir)) {
fs.mkdirSync(authDir, { recursive: true });
}
const authPath = path.join(authDir, "auth.json");
fs.writeFileSync(authPath, JSON.stringify({
access_token: accessToken,
refresh_token: refreshToken,
user,
}, null, 2));
}
catch (error) {
console.warn("Failed to store auth tokens:", error);
}
}
}
/**
* Get stored auth tokens
*/
function getStoredAuthTokens() {
if (typeof window !== "undefined" && window.localStorage) {
const accessToken = window.localStorage.getItem(AUTH_STORAGE_KEY);
const refreshToken = window.localStorage.getItem(REFRESH_STORAGE_KEY);
const userStr = window.localStorage.getItem(USER_STORAGE_KEY);
const user = userStr ? JSON.parse(userStr) : null;
return { accessToken, refreshToken, user };
}
else if (typeof require !== "undefined") {
try {
const fs = require("fs");
const path = require("path");
const os = require("os");
const authPath = path.join(os.homedir(), ".yogiway", "auth.json");
if (fs.existsSync(authPath)) {
const data = JSON.parse(fs.readFileSync(authPath, "utf8"));
return {
accessToken: data.access_token || null,
refreshToken: data.refresh_token || null,
user: data.user || null,
};
}
}
catch (error) {
// Ignore errors
}
}
return { accessToken: null, refreshToken: null, user: null };
}
/**
* Logout user (alias for clearAuth)
*/
function logout() {
clearAuth();
}
/**
* Clear stored auth tokens
*/
function clearAuth() {
if (typeof window !== "undefined" && window.localStorage) {
window.localStorage.removeItem(AUTH_STORAGE_KEY);
window.localStorage.removeItem(REFRESH_STORAGE_KEY);
window.localStorage.removeItem(USER_STORAGE_KEY);
}
else if (typeof require !== "undefined") {
try {
const fs = require("fs");
const path = require("path");
const os = require("os");
const authPath = path.join(os.homedir(), ".yogiway", "auth.json");
if (fs.existsSync(authPath)) {
fs.unlinkSync(authPath);
}
}
catch (error) {
// Ignore errors
}
}
}
/**
* Register a new user
*/
async function register(email, password) {
try {
const response = await fetch(`${AUTH_SERVER_URL}/register`, {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({ email, password }),
});
const data = (await response.json());
if (!response.ok || !data.success) {
throw new Error(data.error || "Registration failed");
}
// Store tokens
if (data.access_token && data.refresh_token && data.user) {
storeAuthTokens(data.access_token, data.refresh_token, data.user);
}
return data;
}
catch (error) {
throw new Error(`Registration failed: ${error instanceof Error ? error.message : "Unknown error"}`);
}
}
/**
* Login with email and password
*/
async function login(email, password) {
try {
const response = await fetch(`${AUTH_SERVER_URL}/login`, {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({ email, password }),
});
const data = (await response.json());
if (!response.ok || !data.success) {
throw new Error(data.error || "Login failed");
}
// Store tokens
if (data.access_token && data.refresh_token && data.user) {
storeAuthTokens(data.access_token, data.refresh_token, data.user);
}
return data;
}
catch (error) {
throw new Error(`Login failed: ${error instanceof Error ? error.message : "Unknown error"}`);
}
}
/**
* Refresh access token
*/
async function refreshToken() {
const { refreshToken } = getStoredAuthTokens();
if (!refreshToken) {
return null;
}
try {
const response = await fetch(`${AUTH_SERVER_URL}/refresh`, {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({ refresh_token: refreshToken }),
});
const data = (await response.json());
if (!response.ok || !data.success) {
// Clear invalid tokens
clearAuth();
return null;
}
// Update stored tokens
const { user } = getStoredAuthTokens();
if (data.access_token && data.refresh_token && user) {
storeAuthTokens(data.access_token, data.refresh_token, user);
}
return data.access_token || null;
}
catch (error) {
// Clear invalid tokens
clearAuth();
return null;
}
}
/**
* Get current access token (with auto-refresh if needed)
*/
async function getAccessToken() {
const { accessToken, refreshToken: storedRefreshToken } = getStoredAuthTokens();
if (!accessToken) {
return null;
}
// Check if token is expired (simple check - tokens expire after 1 hour)
// In production, you'd decode the JWT to check expiration
// For now, we'll try to use it and refresh if it fails
return accessToken;
}
/**
* Get current authenticated user
*/
function getCurrentUser() {
const { user } = getStoredAuthTokens();
return user;
}
/**
* Check if user is authenticated
*/
async function isAuthenticated() {
const token = await getAccessToken();
return token !== null;
}
/**
* Make authenticated API request
*/
async function authenticatedFetch(url, options = {}) {
let token = await getAccessToken();
// If no token, try to refresh
if (!token) {
token = await refreshToken();
}
if (!token) {
throw new Error("Not authenticated. Please login first.");
}
// Add authorization header
const headers = new Headers(options.headers || {});
headers.set("Authorization", `Bearer ${token}`);
headers.set("Content-Type", "application/json");
const response = await fetch(url, {
...options,
headers,
});
// If token expired, try to refresh and retry once
if (response.status === 401) {
const newToken = await refreshToken();
if (newToken) {
headers.set("Authorization", `Bearer ${newToken}`);
return fetch(url, {
...options,
headers,
});
}
else {
clearAuth();
throw new Error("Session expired. Please login again.");
}
}
return response;
}
//# sourceMappingURL=auth.js.map