Owner-authorized recovery of accumulated source changes.
Includes accepted work and in-progress changes; NOT a release or acceptance.
Parent baseline 1b6db09bd1. Runtime data, build caches and local credentials excluded.
363 lines
11 KiB
JavaScript
363 lines
11 KiB
JavaScript
(function() {
|
|
var STORAGE_KEY = 'crank_user';
|
|
var sessionCache = null;
|
|
var sessionPromise = null;
|
|
var csrfRefreshPromise = null;
|
|
var csrfTokenFallback = '';
|
|
var sessionEpoch = 0;
|
|
function tKey(key) {
|
|
return typeof t === 'function' ? t(key) : key;
|
|
}
|
|
function tfKey(key, vars) {
|
|
return typeof tf === 'function' ? tf(key, vars) : key;
|
|
}
|
|
function roleLabel(role) {
|
|
var normalized = String(role || 'viewer').toLowerCase();
|
|
if (normalized === 'operator') return tKey('workspace_setup.role.operator');
|
|
if (normalized === 'owner') return tKey('workspace_setup.role.owner');
|
|
if (normalized === 'admin') return tKey('workspace_setup.role.admin');
|
|
if (normalized === 'viewer') return tKey('workspace_setup.role.viewer');
|
|
return normalized.replace(/^\w/, function(char) { return char.toUpperCase(); });
|
|
}
|
|
|
|
function currentWorkspaceLabel() {
|
|
if (window.getCurrentWorkspace) {
|
|
var workspace = window.getCurrentWorkspace();
|
|
if (workspace && workspace.name) {
|
|
return workspace.name;
|
|
}
|
|
}
|
|
try {
|
|
return localStorage.getItem('crank_workspace_slug') || tKey('settings.nav.workspace');
|
|
} catch (_error) {
|
|
return tKey('settings.nav.workspace');
|
|
}
|
|
}
|
|
|
|
function isLoginPage() {
|
|
return /\/(?:html\/login\.html|login)\/?$/.test(window.location.pathname);
|
|
}
|
|
|
|
function loginUrl() {
|
|
return (window.CrankRoutes && window.CrankRoutes.login) || '/login';
|
|
}
|
|
|
|
function homeUrl() {
|
|
return (window.CrankRoutes && window.CrankRoutes.home) || '/';
|
|
}
|
|
|
|
function clearUserMirror() {
|
|
sessionEpoch += 1;
|
|
csrfRefreshPromise = null;
|
|
csrfTokenFallback = '';
|
|
sessionCache = null;
|
|
sessionPromise = null;
|
|
try {
|
|
localStorage.removeItem(STORAGE_KEY);
|
|
} catch (_error) {}
|
|
renderShellIdentity(null);
|
|
}
|
|
|
|
function primaryMembership(session) {
|
|
if (!(session && session.memberships && session.memberships.length)) {
|
|
return null;
|
|
}
|
|
if (session.current_workspace_id) {
|
|
var currentMembership = session.memberships.find(function(item) {
|
|
return item.workspace && item.workspace.id === session.current_workspace_id;
|
|
});
|
|
if (currentMembership) {
|
|
return currentMembership;
|
|
}
|
|
}
|
|
if (window.getCurrentWorkspace) {
|
|
var currentWorkspace = window.getCurrentWorkspace();
|
|
if (currentWorkspace) {
|
|
var matched = session.memberships.find(function(item) {
|
|
return item.workspace && item.workspace.id === currentWorkspace.id;
|
|
});
|
|
if (matched) {
|
|
return matched;
|
|
}
|
|
}
|
|
}
|
|
return session.memberships[0];
|
|
}
|
|
|
|
function initials(displayName, email) {
|
|
var source = safeIdentityText(displayName, 80, '') || safeIdentityText(email, 254, '') || 'Crank';
|
|
return source
|
|
.split(/\s+/)
|
|
.filter(Boolean)
|
|
.slice(0, 2)
|
|
.map(function(part) { return part.charAt(0).toUpperCase(); })
|
|
.join('') || 'CR';
|
|
}
|
|
|
|
function safeIdentityText(value, maxLength, fallback) {
|
|
var text = String(value || '')
|
|
.replace(/[\r\n\t]+/g, ' ')
|
|
.replace(/\s{2,}/g, ' ')
|
|
.trim();
|
|
if (!text || /<\s*(?:!doctype|html|head|body|nav|script)\b/i.test(text)) {
|
|
return fallback || '';
|
|
}
|
|
if (text.length > maxLength) {
|
|
return fallback || '';
|
|
}
|
|
return text;
|
|
}
|
|
|
|
function persistUserMirror(session) {
|
|
var membership = primaryMembership(session);
|
|
var user = {
|
|
id: session.user.id,
|
|
name: safeIdentityText(session.user.display_name, 80, 'Crank'),
|
|
email: safeIdentityText(session.user.email, 254, ''),
|
|
role: membership ? roleLabel(membership.role) : tKey('workspace_setup.role.viewer'),
|
|
workspace: membership ? membership.workspace.slug : '',
|
|
workspaceId: membership ? membership.workspace.id : '',
|
|
initials: initials(session.user.display_name, session.user.email),
|
|
};
|
|
|
|
try {
|
|
localStorage.setItem(STORAGE_KEY, JSON.stringify(user));
|
|
} catch (_error) {}
|
|
}
|
|
|
|
function mirroredUser() {
|
|
try {
|
|
return JSON.parse(localStorage.getItem(STORAGE_KEY));
|
|
} catch (_error) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function renderShellIdentity(session) {
|
|
var membership = primaryMembership(session);
|
|
var fallbackUser = mirroredUser();
|
|
var displayName = session && session.user
|
|
? (safeIdentityText(session.user.display_name, 80, '') || safeIdentityText(session.user.email, 254, '') || 'Crank')
|
|
: safeIdentityText(fallbackUser && fallbackUser.name, 80, 'Crank');
|
|
var email = session && session.user
|
|
? safeIdentityText(session.user.email, 254, '')
|
|
: safeIdentityText(fallbackUser && fallbackUser.email, 254, '');
|
|
var role = membership
|
|
? roleLabel(membership.role)
|
|
: (fallbackUser && fallbackUser.role) || tKey('workspace_setup.role.viewer');
|
|
var workspace = membership && membership.workspace
|
|
? (membership.workspace.display_name || membership.workspace.slug || membership.workspace.id)
|
|
: currentWorkspaceLabel();
|
|
var avatarValue = initials(displayName, email);
|
|
|
|
document.querySelectorAll('.nav-avatar').forEach(function(element) {
|
|
element.textContent = avatarValue;
|
|
});
|
|
document.querySelectorAll('.user-dropdown-name').forEach(function(element) {
|
|
element.textContent = displayName;
|
|
});
|
|
document.querySelectorAll('.user-dropdown-role').forEach(function(element) {
|
|
element.textContent = role + ' · ' + workspace;
|
|
});
|
|
if (window.CrankDiagnostics && typeof window.CrankDiagnostics.ensureShellTestIds === 'function') {
|
|
window.CrankDiagnostics.ensureShellTestIds();
|
|
}
|
|
}
|
|
|
|
function replaceSession(session) {
|
|
if (session && session.csrf_token) {
|
|
// Keep the fallback in sync: sessions rotated by the server (profile update,
|
|
// workspace switch) must not be replaced later by an older token.
|
|
csrfTokenFallback = session.csrf_token;
|
|
}
|
|
sessionCache = session;
|
|
persistUserMirror(session);
|
|
renderShellIdentity(session);
|
|
window.dispatchEvent(new CustomEvent('crank:sessionchange', { detail: session }));
|
|
return session;
|
|
}
|
|
|
|
function getCsrfToken() {
|
|
return sessionCache && sessionCache.csrf_token ? sessionCache.csrf_token : '';
|
|
}
|
|
|
|
function storeCsrfToken(token, epoch) {
|
|
if (!token || epoch !== sessionEpoch) {
|
|
return '';
|
|
}
|
|
csrfTokenFallback = token;
|
|
if (sessionCache) {
|
|
replaceSession(Object.assign({}, sessionCache, { csrf_token: token }));
|
|
}
|
|
return token;
|
|
}
|
|
|
|
// Single-flight rotation: parallel page loads, guards and mutations share one
|
|
// POST /api/auth/session/csrf and its token is always written back to the
|
|
// session cache, so the client can never keep a token the server already
|
|
// replaced with a later rotation.
|
|
function refreshCsrf() {
|
|
if (csrfRefreshPromise) {
|
|
return csrfRefreshPromise;
|
|
}
|
|
if (!(window.CrankApi && typeof window.CrankApi.refreshSessionCsrf === 'function')) {
|
|
return Promise.resolve('');
|
|
}
|
|
var epoch = sessionEpoch;
|
|
csrfRefreshPromise = window.CrankApi.refreshSessionCsrf()
|
|
.then(function(csrf) {
|
|
return storeCsrfToken(csrf && csrf.csrf_token ? csrf.csrf_token : '', epoch);
|
|
})
|
|
.finally(function() {
|
|
csrfRefreshPromise = null;
|
|
});
|
|
return csrfRefreshPromise;
|
|
}
|
|
|
|
// Token for a protected mutation: join a rotation that is already in flight,
|
|
// reuse the cached token, or rotate once.
|
|
function ensureCsrf() {
|
|
if (csrfRefreshPromise) {
|
|
return csrfRefreshPromise.then(getCsrfToken);
|
|
}
|
|
var token = getCsrfToken();
|
|
if (token) {
|
|
return Promise.resolve(token);
|
|
}
|
|
if (sessionPromise) {
|
|
return sessionPromise.then(ensureCsrf, function() { return ''; });
|
|
}
|
|
if (sessionCache) {
|
|
return refreshCsrf();
|
|
}
|
|
return Promise.resolve('');
|
|
}
|
|
|
|
async function fetchSession(force) {
|
|
if (!force && sessionCache) {
|
|
return sessionCache;
|
|
}
|
|
if (!force && sessionPromise) {
|
|
return sessionPromise;
|
|
}
|
|
|
|
var epoch = sessionEpoch;
|
|
sessionPromise = window.CrankApi.getSession()
|
|
.then(function(session) {
|
|
if (epoch !== sessionEpoch) {
|
|
return sessionCache;
|
|
}
|
|
if (session && !session.csrf_token && csrfTokenFallback) {
|
|
session.csrf_token = csrfTokenFallback;
|
|
}
|
|
replaceSession(session);
|
|
if (session && !session.csrf_token) {
|
|
return refreshCsrf().then(function() {
|
|
return sessionCache || session;
|
|
});
|
|
}
|
|
return session;
|
|
})
|
|
.catch(function(error) {
|
|
if (epoch === sessionEpoch) {
|
|
clearUserMirror();
|
|
}
|
|
throw error;
|
|
})
|
|
.finally(function() {
|
|
sessionPromise = null;
|
|
});
|
|
|
|
return sessionPromise;
|
|
}
|
|
|
|
async function guardProtectedPage() {
|
|
try {
|
|
return await fetchSession(false);
|
|
} catch (error) {
|
|
if (error && error.status === 401) {
|
|
window.location.replace(loginUrl());
|
|
return null;
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function guardLoginPage() {
|
|
try {
|
|
await fetchSession(false);
|
|
window.location.replace(homeUrl());
|
|
} catch (error) {
|
|
if (!error || error.status !== 401) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
async function login(email, password) {
|
|
var session = await window.CrankApi.login({
|
|
email: email,
|
|
password: password,
|
|
});
|
|
replaceSession(session);
|
|
window.location.href = homeUrl();
|
|
}
|
|
|
|
async function completeBootstrap(token, password) {
|
|
var session = await window.CrankApi.completeBootstrap({
|
|
token: token,
|
|
password: password,
|
|
});
|
|
replaceSession(session);
|
|
window.location.href = homeUrl();
|
|
}
|
|
|
|
async function logout() {
|
|
try {
|
|
await window.CrankApi.logout();
|
|
} finally {
|
|
clearUserMirror();
|
|
window.location.href = loginUrl();
|
|
}
|
|
}
|
|
|
|
function handleUnauthorized() {
|
|
if (isLoginPage()) {
|
|
clearUserMirror();
|
|
return;
|
|
}
|
|
clearUserMirror();
|
|
window.location.replace(loginUrl());
|
|
}
|
|
|
|
window.CrankAuth = {
|
|
fetchSession: fetchSession,
|
|
replaceSession: replaceSession,
|
|
getCachedSession: function() { return sessionCache; },
|
|
getCsrfToken: getCsrfToken,
|
|
ensureCsrf: ensureCsrf,
|
|
refreshCsrf: refreshCsrf,
|
|
renderShellIdentity: function() {
|
|
renderShellIdentity(sessionCache);
|
|
},
|
|
guardProtectedPage: guardProtectedPage,
|
|
guardLoginPage: guardLoginPage,
|
|
login: login,
|
|
completeBootstrap: completeBootstrap,
|
|
logout: logout,
|
|
handleUnauthorized: handleUnauthorized,
|
|
};
|
|
|
|
window.addEventListener('crank:workspacechange', function() {
|
|
renderShellIdentity(sessionCache);
|
|
});
|
|
|
|
window.addEventListener('crank:sessionchange', function(event) {
|
|
renderShellIdentity(event.detail || sessionCache);
|
|
});
|
|
|
|
document.addEventListener('DOMContentLoaded', function() {
|
|
renderShellIdentity(sessionCache);
|
|
});
|
|
}());
|