LocalWebAgent / js /hf-auth.js
ereniko's picture
v0.8.2: Hugging Face sign-in from the embedded Space page, sturdier callback
5d3283b unverified
Raw History Blame Contribute Delete
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;
}