Spaces:
Running
Running
Download js/hf-auth.js from ereniko/LocalWebAgent: direct link, hf CLI and curl.
- Browser
- Download file 9.7 kB
-
https://huggingface.co/spaces/ereniko/LocalWebAgent/resolve/main/js/hf-auth.js
- Command line
-
hf download hf://spaces/ereniko/LocalWebAgent/js/hf-auth.js
-
curl -L -o hf-auth.js https://huggingface.co/spaces/ereniko/LocalWebAgent/resolve/main/js/hf-auth.js
9.7 kB
| // "Sign in with Hugging Face": OAuth 2.0 authorization code flow with PKCE, entirely in the | |
| // browser (no backend, no client secret). The token it returns calls Hugging Face Inference | |
| // Providers on the user's own account (scope "inference-api"). | |
| // | |
| // The sign-in runs in a popup so the app (and its running Linux VM) never reloads. The popup | |
| // lands on oauth.html, which exchanges the code for a token and hands the session back over | |
| // a BroadcastChannel: the app is cross-origin isolated (COOP), so the popup has no opener. | |
| import { HF_OAUTH_CLIENT_ID } from "./config.js"; | |
| const HF = "https://huggingface.co"; | |
| export const HF_SCOPES = "openid profile inference-api"; | |
| const PENDING = "lwa-hf-oauth-pending"; // localStorage: what the callback needs to finish | |
| const CHANNEL = "lwa-hf-oauth"; | |
| const SESSION = (id) => `lwa-hf-session:${id}`; | |
| /** The OAuth app's client ID: from config.js, or the one Hugging Face injects into Spaces with hf_oauth. */ | |
| export function hfClientId() { | |
| return HF_OAUTH_CLIENT_ID || globalThis.huggingface?.variables?.OAUTH_CLIENT_ID || ""; | |
| } | |
| export const hfSignInAvailable = () => !!hfClientId(); | |
| /** | |
| * True inside an iframe, e.g. the Space page on huggingface.co. There the browser keeps | |
| * this app's storage separate from the same app in its own tab (storage partitioning), | |
| * and isolation cuts the popup's link back, so the sign-in popup can't hand its result to | |
| * the embedded app. Sign-in is then offered in the app's own tab instead. | |
| */ | |
| export function embedded() { | |
| try { return window.top !== window.self; } catch { return true; } | |
| } | |
| export const standaloneUrl = () => new URL("./", document.baseURI).href; | |
| export const hfRedirectUri = () => new URL("oauth.html", document.baseURI).href; | |
| const b64url = (bytes) => btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""); | |
| const random = (n) => b64url(crypto.getRandomValues(new Uint8Array(n))); | |
| async function tokenRequest(params) { | |
| let res; | |
| try { | |
| res = await fetch(`${HF}/oauth/token`, { | |
| method: "POST", | |
| headers: { "Content-Type": "application/x-www-form-urlencoded" }, | |
| body: new URLSearchParams(params), | |
| }); | |
| } catch (err) { throw new Error(`Couldn't reach Hugging Face (${err.message})`); } | |
| const j = await res.json().catch(() => ({})); | |
| if (!res.ok || !j.access_token) throw new Error(j.error_description || j.error || `Sign-in failed (HTTP ${res.status})`); | |
| return j; | |
| } | |
| async function userInfo(accessToken) { | |
| try { | |
| const res = await fetch(`${HF}/oauth/userinfo`, { headers: { Authorization: `Bearer ${accessToken}` } }); | |
| const u = await res.json(); | |
| return { name: u.name || u.preferred_username || "", username: u.preferred_username || "", avatarUrl: u.picture || "" }; | |
| } catch { return { name: "", username: "", avatarUrl: "" }; } | |
| } | |
| const toSession = (t, user, prev = {}) => ({ | |
| accessToken: t.access_token, | |
| refreshToken: t.refresh_token ?? prev.refreshToken ?? null, | |
| expiresAt: t.expires_in ? Date.now() + t.expires_in * 1000 : null, | |
| user: user ?? prev.user ?? null, | |
| clientId: prev.clientId ?? hfClientId(), | |
| }); | |
| let cancelPending = null; | |
| // Messages between the app and the oauth.html popup go over a BroadcastChannel, with | |
| // localStorage "storage" events as a backup (both same-origin only). The popup only | |
| // forwards the code; the app, which holds the PKCE verifier in memory, does the token | |
| // exchange. So a callback page that loads twice, or late, can't break the sign-in. | |
| const MSG_KEY = "lwa-hf-oauth-msg"; | |
| function postMsg(msg) { | |
| try { const ch = new BroadcastChannel(CHANNEL); ch.postMessage(msg); ch.close(); } catch {} | |
| try { localStorage.setItem(MSG_KEY, JSON.stringify({ ...msg, nonce: Math.random() })); } catch {} | |
| } | |
| function onMsg(handler) { | |
| let ch = null; | |
| try { ch = new BroadcastChannel(CHANNEL); ch.onmessage = ({ data }) => handler(data); } catch {} | |
| const onStorage = (e) => { if (e.key === MSG_KEY && e.newValue) { try { handler(JSON.parse(e.newValue)); } catch {} } }; | |
| addEventListener("storage", onStorage); | |
| return () => { ch?.close(); removeEventListener("storage", onStorage); }; | |
| } | |
| /** | |
| * Opens the Hugging Face sign-in popup. Resolves with a session | |
| * { accessToken, refreshToken, expiresAt, user: { name, username, avatarUrl } }. | |
| * Must be called from a click (popups are otherwise blocked). | |
| */ | |
| export async function signInWithHuggingFace() { | |
| const clientId = hfClientId(); | |
| if (!clientId) throw new Error("Sign in with Hugging Face isn't set up for this app yet. Use an access token instead."); | |
| cancelPending?.(); | |
| try { localStorage.removeItem(PENDING); } catch {} // from older versions | |
| const verifier = random(48); | |
| const challenge = b64url(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)))); | |
| const state = random(16); | |
| const redirectUri = hfRedirectUri(); | |
| const url = new URL(`${HF}/oauth/authorize`); | |
| for (const [k, v] of Object.entries({ | |
| client_id: clientId, redirect_uri: redirectUri, response_type: "code", scope: HF_SCOPES, | |
| state, code_challenge: challenge, code_challenge_method: "S256", | |
| })) url.searchParams.set(k, v); | |
| const w = 520, hgt = 720; | |
| const popup = window.open(url.href, "lwa-hf-signin", | |
| `popup,width=${w},height=${hgt},left=${Math.round(screenX + (outerWidth - w) / 2)},top=${Math.round(screenY + (outerHeight - hgt) / 2)}`); | |
| if (!popup) throw new Error("Your browser blocked the sign-in window. Allow pop-ups for this site and try again."); | |
| return new Promise((resolve, reject) => { | |
| let result = null; // the finished session, kept to answer repeated callbacks | |
| let exchanging = false; | |
| const stop = onMsg(async (m) => { | |
| if (m?.type !== "code" || m.state !== state) return; | |
| if (result) return postMsg({ type: "ack", state, ok: true, name: result.user?.name ?? "" }); | |
| if (exchanging) return; // the same code again while we're already using it | |
| if (m.error) { | |
| postMsg({ type: "ack", state, ok: false, error: m.error }); | |
| return finish(reject, new Error(m.error)); | |
| } | |
| exchanging = true; | |
| try { | |
| const t = await tokenRequest({ grant_type: "authorization_code", code: m.code, redirect_uri: redirectUri, client_id: clientId, code_verifier: verifier }); | |
| result = toSession(t, await userInfo(t.access_token), { clientId }); | |
| postMsg({ type: "ack", state, ok: true, name: result.user?.name ?? "" }); | |
| finish(resolve, result, 15_000); // keep answering a reloaded callback for a while | |
| } catch (err) { | |
| postMsg({ type: "ack", state, ok: false, error: err.message }); | |
| finish(reject, err); | |
| } | |
| }); | |
| const timer = setTimeout(() => finish(reject, new Error("Sign-in timed out.")), 10 * 60 * 1000); | |
| let settled = false; | |
| function finish(fn, value, linger = 0) { | |
| if (settled) return; | |
| settled = true; | |
| clearTimeout(timer); | |
| cancelPending = null; | |
| setTimeout(stop, linger); | |
| fn(value); | |
| } | |
| cancelPending = () => finish(reject, Object.assign(new Error("Sign-in cancelled."), { cancelled: true })); | |
| }); | |
| } | |
| /** Stops waiting for a sign-in started with signInWithHuggingFace. */ | |
| export const cancelSignIn = () => cancelPending?.(); | |
| /** | |
| * Runs in oauth.html: forwards the code (or error) from the redirect to the app and waits | |
| * for its answer. Resolves with { ok, name } or rejects with the reason. | |
| */ | |
| export function completeSignIn() { | |
| const q = new URLSearchParams(location.search); | |
| const state = q.get("state"); | |
| const msg = { type: "code", state, code: q.get("code"), error: q.get("error") ? (q.get("error_description") || q.get("error")) : null }; | |
| if (!state || (!msg.code && !msg.error)) return Promise.reject(new Error("This page should be opened by Hugging Face after signing in. Start again from LocalWebAgent.")); | |
| return new Promise((resolve, reject) => { | |
| const stop = onMsg((m) => { | |
| if (m?.type !== "ack" || m.state !== state) return; | |
| clearInterval(resend); clearTimeout(giveUp); stop(); | |
| m.ok ? resolve(m) : reject(new Error(m.error || "Sign-in failed.")); | |
| }); | |
| postMsg(msg); | |
| const resend = setInterval(() => postMsg(msg), 1000); | |
| const giveUp = setTimeout(() => { | |
| clearInterval(resend); stop(); | |
| reject(new Error("LocalWebAgent didn't answer. Keep its tab open, then press Sign in with Hugging Face again.")); | |
| }, 20_000); | |
| }); | |
| } | |
| // ---------- stored sessions (one per saved API model that uses sign-in) ---------- | |
| export function loadSession(id) { | |
| try { return JSON.parse(localStorage.getItem(SESSION(id)) || "null"); } catch { return null; } | |
| } | |
| export function saveSession(id, session) { | |
| try { localStorage.setItem(SESSION(id), JSON.stringify(session)); } catch {} | |
| } | |
| export function deleteSession(id) { | |
| try { localStorage.removeItem(SESSION(id)); } catch {} | |
| } | |
| export const sessionExpired = (s) => !!s?.expiresAt && s.expiresAt < Date.now() + 30_000; | |
| /** | |
| * The session's access token, refreshed first if it is about to expire and Hugging Face | |
| * gave a refresh token. Throws when the user has to sign in again. | |
| */ | |
| export async function freshAccessToken(id) { | |
| const s = loadSession(id); | |
| if (!s?.accessToken) throw new Error("Not signed in to Hugging Face. Open the Model Manager and sign in."); | |
| if (!sessionExpired(s)) return s.accessToken; | |
| if (!s.refreshToken) throw new Error("Your Hugging Face sign-in has expired. Open the Model Manager and sign in again."); | |
| const t = await tokenRequest({ grant_type: "refresh_token", refresh_token: s.refreshToken, client_id: s.clientId || hfClientId() }); | |
| const next = toSession(t, null, s); | |
| saveSession(id, next); | |
| return next.accessToken; | |
| } | |