Where agent teams gather. Cross-platform team chat where AI agents are first-class teammates — with cloud or bring-your-own (Claude Code / Codex) brains.
TypeScript
feat(auth): sign in with GitLab, including self-managed instances
Xialie Zhuangc76a270c9110
diff --git a/.env.example b/.env.exampleindex 21b981e..30c794c 100644--- a/.env.example+++ b/.env.example@@ -108,6 +108,15 @@ R2_URL_SIGNING_SECRET=# GOOGLE_CLIENT_SECRET=# GITHUB_CLIENT_ID=# GITHUB_CLIENT_SECRET=+# GITLAB_CLIENT_ID=+# GITLAB_CLIENT_SECRET=+# Which GitLab to sign in against. Defaults to gitlab.com; point it at a+# self-managed instance to use that one instead. Redirect URI to register in+# GitLab: <CUMORA_PUBLIC_ORIGIN>/api/auth/callback/gitlab, scope `read_user`.+# Whatever you set here is TRUSTED to attest its users' email ownership, the+# same trust Google and GitHub get — a verified email is what lets sign-in+# link to an existing account.+# GITLAB_BASE_URL=https://gitlab.com## Publicly reachable origin of THIS server — used to build the OAuth# redirect_uri handed to providers. For local dev with a tunnel, set thisdiff --git a/server/src/__tests__/oauth-gitlab-profile.test.ts b/server/src/__tests__/oauth-gitlab-profile.test.tsnew file mode 100644index 0000000..9ca94c6--- /dev/null+++ b/server/src/__tests__/oauth-gitlab-profile.test.ts@@ -0,0 +1,116 @@+/**+ * GitLab sign-in profile normalization.+ *+ * `NormalizedProfile.email` feeds `findOrCreateUserByProfile`'s cross-provider+ * auto-link, which attaches a new identity to an EXISTING account purely by+ * matching the address. So the address has to be one the provider attests to,+ * not merely one it reports — otherwise sign-in becomes an account-takeover+ * primitive. Google gates on `email_verified`, GitHub on the address being+ * `verified`; GitLab's equivalent is `confirmed_at`.+ *+ * These pin every refusal path, because the failure direction that matters is+ * "refuse the login", never "link to someone else's account".+ *+ * Run: node --import tsx --test server/src/__tests__/oauth-gitlab-profile.test.ts+ */+import { test, afterEach, after } from 'node:test'+import assert from 'node:assert/strict'+import { fetchProfile } from '../oauth.js'+import { pool } from '../db/pool.js'++const SAVED_FETCH = globalThis.fetch++interface GitLabUser {+ id: number+ username: string+ name?: string | null+ email?: string | null+ state?: string | null+ confirmed_at?: string | null+ avatar_url?: string | null+}++function mockGitLab(user: GitLabUser, base = 'https://gitlab.com') {+ globalThis.fetch = (async (url: string | URL | Request) => {+ const href = typeof url === 'string' ? url : url instanceof URL ? url.href : url.url+ if (href === `${base}/api/v4/user`) return new Response(JSON.stringify(user), { status: 200 })+ throw new Error(`unexpected fetch: ${href}`)+ }) as typeof fetch+}++afterEach(() => { globalThis.fetch = SAVED_FETCH })++after(async () => {+ // oauth.ts opens a pool + redis at module load; close them so the runner exits.+ try { await pool.end() } catch { /* ignore */ }+ try {+ const { redis, sub } = await import('../redis.js')+ redis.disconnect()+ sub.disconnect()+ } catch { /* ignore */ }+})++const CONFIRMED: GitLabUser = {+ id: 42,+ username: 'yuluo',+ name: 'Yu Luo',+ email: '[email protected]',+ state: 'active',+ confirmed_at: '2026-05-23T09:05:22Z',+ avatar_url: 'https://gitlab.com/uploads/-/system/user/avatar/42/avatar.png',+}++test('a confirmed, active account normalizes', async () => {+ mockGitLab(CONFIRMED)+ const p = await fetchProfile('gitlab', 'tok')+ assert.equal(p.providerId, '42')+ assert.equal(p.email, '[email protected]')+ assert.equal(p.displayName, 'Yu Luo')+ assert.equal(p.avatarUrl, CONFIRMED.avatar_url)+})++test('the email is lowercased, like the other providers', async () => {+ mockGitLab({ ...CONFIRMED, email: '[email protected]' })+ const p = await fetchProfile('gitlab', 'tok')+ assert.equal(p.email, '[email protected]')+})++test('an unconfirmed email is refused', async () => {+ // A self-managed instance can disable user confirmation entirely, which+ // leaves confirmed_at null on an otherwise ordinary account. Trusting that+ // address would let anyone who can create an account there claim any+ // existing Cumora account by email.+ mockGitLab({ ...CONFIRMED, confirmed_at: null })+ await assert.rejects(() => fetchProfile('gitlab', 'tok'), /no confirmed email/)+})++test('a non-active account is refused even when confirmed', async () => {+ // Blocked / deactivated users can still be holding a live token.+ mockGitLab({ ...CONFIRMED, state: 'blocked' })+ await assert.rejects(() => fetchProfile('gitlab', 'tok'), /not active/)+})++test('an account that exposes no email is refused', async () => {+ mockGitLab({ ...CONFIRMED, email: null })+ await assert.rejects(() => fetchProfile('gitlab', 'tok'), /no email/)+})++test('the username stands in when the display name is empty', async () => {+ mockGitLab({ ...CONFIRMED, name: ' ' })+ const p = await fetchProfile('gitlab', 'tok')+ assert.equal(p.displayName, 'yuluo')+})++test('a self-managed instance is read from GITLAB_BASE_URL', async () => {+ // The whole point of the issue: sign in against your own GitLab.+ const { env } = await import('../env.js')+ const saved = env.GITLAB_BASE_URL+ ;(env as { GITLAB_BASE_URL: string }).GITLAB_BASE_URL = 'https://gitlab.example.com'+ try {+ mockGitLab(CONFIRMED, 'https://gitlab.example.com')+ const p = await fetchProfile('gitlab', 'tok')+ assert.equal(p.email, '[email protected]')+ } finally {+ ;(env as { GITLAB_BASE_URL: string }).GITLAB_BASE_URL = saved+ }+})diff --git a/server/src/api/router.ts b/server/src/api/router.tsindex cf9ede6..9989663 100644--- a/server/src/api/router.ts+++ b/server/src/api/router.ts@@ -19,7 +19,7 @@ import {} from '../auth.js'import { joinAllHands, onboardStarterAgents, seedMemberDms } from '../onboardCompany.js'import {- type Provider, providerEnabled, createState, consumeState,+ type Provider, providerEnabled, createState, consumeState, isWebOAuthProvider, WEB_OAUTH_PROVIDERS,authorizeUrl, handleCallback, errorUrl, returnUrlAllowed,} from '../oauth.js'import { adminRouter } from './admin-router.js'@@ -651,9 +651,17 @@ api.get('/metrics', async (req, res) => {* `?return=<url>` is the post-callback redirect target. Must startsWith* one of CUMORA_AUTH_RETURN_ALLOWLIST entries; otherwise rejected so we* can't be turned into an open redirect. Omit to use AUTH_DONE_URL. */+/** Which browser sign-in providers this deployment actually has credentials+ * for. The sign-in screens use it to avoid offering a button that can only+ * 503 — GitLab is opt-in (and points at whichever instance the operator+ * configured), so most deployments will not have it. */+api.get('/auth/providers', safe(async (_req, res) => {+ res.json({ providers: [...WEB_OAUTH_PROVIDERS].filter((p) => providerEnabled(p as Provider)) })+}))+api.get('/auth/start/:provider', safe(async (req, res) => {const provider = req.params.provider as Provider- if (provider !== 'google' && provider !== 'github') {+ if (!isWebOAuthProvider(provider)) {res.status(404).json({ error: 'unknown provider' }); return}if (!providerEnabled(provider)) {@@ -682,7 +690,7 @@ api.get('/auth/start/:provider', safe(async (req, res) => {* On failure we 302 to the same target with `#error=...`. */api.get('/auth/callback/:provider', safe(async (req, res) => {const provider = req.params.provider as Provider- if (provider !== 'google' && provider !== 'github') {+ if (!isWebOAuthProvider(provider)) {res.status(404).json({ error: 'unknown provider' }); return}const code = typeof req.query.code === 'string' ? req.query.code : ''diff --git a/server/src/db/migrate.ts b/server/src/db/migrate.tsindex a20f6aa..c094357 100644--- a/server/src/db/migrate.ts+++ b/server/src/db/migrate.ts@@ -808,7 +808,7 @@ CREATE INDEX IF NOT EXISTS idx_audit_events_kind ON audit_events(kind, create-- provider gave us at link time — used for cross-provider lookup AND so we-- can audit changes if a provider later returns a different email.CREATE TABLE IF NOT EXISTS user_identities (- provider TEXT NOT NULL, -- 'google' | 'github'+ provider TEXT NOT NULL, -- 'google' | 'github' | 'gitlab' | 'apple'provider_id TEXT NOT NULL, -- sub (Google) / numeric id (GitHub)user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,email_lower TEXT NOT NULL,diff --git a/server/src/env.ts b/server/src/env.tsindex 8f0686b..b30b98f 100644--- a/server/src/env.ts+++ b/server/src/env.ts@@ -271,6 +271,14 @@ export const env = {GOOGLE_CLIENT_SECRET: process.env.GOOGLE_CLIENT_SECRET ?? '',GITHUB_CLIENT_ID: process.env.GITHUB_CLIENT_ID ?? '',GITHUB_CLIENT_SECRET: process.env.GITHUB_CLIENT_SECRET ?? '',+ GITLAB_CLIENT_ID: process.env.GITLAB_CLIENT_ID ?? '',+ GITLAB_CLIENT_SECRET: process.env.GITLAB_CLIENT_SECRET ?? '',+ /** Which GitLab to talk to. Defaults to gitlab.com; point it at a+ * self-managed instance (https://gitlab.example.com) to sign in against+ * that one instead. Whatever you set here is TRUSTED to attest its users'+ * email ownership — the same trust Google and GitHub get — because a+ * verified email is what lets sign-in link to an existing account. */+ GITLAB_BASE_URL: (process.env.GITLAB_BASE_URL ?? 'https://gitlab.com').replace(/\/+$/, ''),/** Public origin this server is reachable at. Used to construct the* per-provider redirect_uri that we hand to Google / GitHub at flow* start. Defaults to http://localhost:5181 for local dev. In proddiff --git a/server/src/oauth.ts b/server/src/oauth.tsindex 1387180..d5443f6 100644--- a/server/src/oauth.ts+++ b/server/src/oauth.ts@@ -41,7 +41,20 @@ import { storage } from './storage.js'import { provisionUser as provisionSub2apiUser, sub2apiConfigured } from './sub2api.js'import { isWaitlistEnabled, enqueueWaitlist, isAllowlistedAdmin } from './admin.js'-export type Provider = 'google' | 'github' | 'apple'+export type Provider = 'google' | 'github' | 'gitlab' | 'apple'++/** Providers reachable through the BROWSER redirect flow (/auth/start/:provider+ * → /auth/callback/:provider). Apple is deliberately absent: it signs in+ * natively through /auth/apple/native and never goes through these routes.+ *+ * One set rather than a `!== 'google' && !== 'github'` chain at each gate —+ * those have to be found and widened by hand for every new provider, and a+ * missed one fails as a 404 on a button the UI already renders. */+export const WEB_OAUTH_PROVIDERS: ReadonlySet<string> = new Set(['google', 'github', 'gitlab'])++export function isWebOAuthProvider(p: string): p is Provider {+ return WEB_OAUTH_PROVIDERS.has(p)+}interface ProviderConfig {authorizeUrl: string@@ -61,6 +74,22 @@ function providerConfig(p: Provider): ProviderConfig {clientId: env.GOOGLE_CLIENT_ID,clientSecret: env.GOOGLE_CLIENT_SECRET,}+ if (p === 'gitlab') {+ // Endpoints are derived from GITLAB_BASE_URL so a self-managed instance+ // works with the same code path as gitlab.com. `read_user` is the scope+ // that grants the `/api/v4/user` profile read we need — deliberately the+ // narrowest one: `api` would hand us write access to the user's repos for+ // no reason.+ const base = env.GITLAB_BASE_URL+ return {+ authorizeUrl: `${base}/oauth/authorize`,+ tokenUrl: `${base}/oauth/token`,+ userInfoUrl: `${base}/api/v4/user`,+ scope: 'read_user',+ clientId: env.GITLAB_CLIENT_ID,+ clientSecret: env.GITLAB_CLIENT_SECRET,+ }+ }return {authorizeUrl: 'https://github.com/login/oauth/authorize',tokenUrl: 'https://github.com/login/oauth/access_token',@@ -128,7 +157,7 @@ export async function consumeState(state: string): Promise<StateData | null> {if (!v) return nulltry {const parsed = JSON.parse(v) as StateData- if (parsed.provider !== 'google' && parsed.provider !== 'github') return null+ if (!isWebOAuthProvider(parsed.provider)) return nullreturn parsed} catch {return null@@ -184,6 +213,18 @@ async function exchangeCode(p: Provider, code: string): Promise<string> {interface GoogleProfile { sub: string; email?: string; email_verified?: boolean; name?: string; picture?: string }interface GitHubProfile { id: number; login: string; name?: string | null; email?: string | null; avatar_url?: string }+/** GitLab `GET /api/v4/user` (the authenticated user). `confirmed_at` is the+ * field that attests the address: GitLab sets it when the user completes email+ * confirmation, and leaves it null otherwise. */+interface GitLabProfile {+ id: number+ username: string+ name?: string | null+ email?: string | null+ state?: string | null+ confirmed_at?: string | null+ avatar_url?: string | null+}interface GitHubEmail { email: string; primary: boolean; verified: boolean }export async function fetchProfile(p: Provider, accessToken: string): Promise<NormalizedProfile> {@@ -200,6 +241,33 @@ export async function fetchProfile(p: Provider, accessToken: string): Promise<NoavatarUrl: g.picture ?? null,}}+ if (p === 'gitlab') {+ const r = await fetch(cfg.userInfoUrl, {+ headers: { authorization: `Bearer ${accessToken}`, accept: 'application/json' },+ })+ if (!r.ok) throw new Error(`gitlab user ${r.status}`)+ const g = await r.json() as GitLabProfile+ // The email must be ATTESTED, not merely present. NormalizedProfile.email+ // feeds findOrCreateUserByProfile's cross-provider auto-link, which links a+ // new identity onto an existing account purely by matching address — so an+ // unattested address here would be an account-takeover primitive, not a+ // cosmetic gap. Google gates on email_verified and GitHub on the address+ // being `verified`; GitLab's equivalent is confirmed_at.+ //+ // Both checks are required. A self-managed instance can be configured with+ // user confirmation disabled, in which case confirmed_at stays null even+ // for an active account — refuse rather than trust it. `state` catches+ // accounts that are blocked/deactivated but still hold a live token.+ if (g.state !== 'active') throw new Error('gitlab account is not active')+ if (!g.confirmed_at) throw new Error('gitlab account has no confirmed email')+ if (!g.email) throw new Error('gitlab account exposes no email to read_user')+ return {+ providerId: String(g.id),+ email: g.email.toLowerCase(),+ displayName: (g.name && g.name.trim()) || g.username,+ avatarUrl: g.avatar_url ?? null,+ }+ }// GitHub: /user doesn't expose email when the user hides it. Hit /user/emails// and prefer `primary && verified`. A GitHub account can have its primary// email unverified while a secondary address is verified (e.g. mid-waydiff --git a/src/api/client.ts b/src/api/client.tsindex 0baf035..e560204 100644--- a/src/api/client.ts+++ b/src/api/client.ts@@ -765,7 +765,7 @@ export const api = {* `window.location.assign(api.authStartUrl('google'))` rather than* fetch — the browser needs to do the actual navigation so the* callback can land back on AUTH_DONE_URL with the session token. */- authStartUrl: (provider: 'google' | 'github', opts?: { inviteToken?: string | null; returnUrl?: string | null }) => {+ authStartUrl: (provider: 'google' | 'github' | 'gitlab', opts?: { inviteToken?: string | null; returnUrl?: string | null }) => {const params = new URLSearchParams()if (opts?.returnUrl) params.set('return', opts.returnUrl)if (opts?.inviteToken) params.set('invite', opts.inviteToken)@@ -1236,6 +1236,9 @@ export const api = {http<ApiConveneSession | null>(`/conversations/${encodeURIComponent(conversationId)}/convene`),getConveneTranscript: (sessionId: string) =>http<ApiConveneTranscript[]>(`/convene/${encodeURIComponent(sessionId)}/transcript`),+ /** Browser sign-in providers this deployment has credentials for. Used to+ * avoid rendering a button that can only 503. */+ authProviders: () => http<{ providers: string[] }>('/auth/providers'),getPreferences: () => http<Record<string, unknown>>('/me/preferences'),putPreferences: (prefs: Record<string, unknown>) =>http<{ ok: boolean }>('/me/preferences', { method: 'PUT', body: JSON.stringify(prefs) }),diff --git a/src/components/AuthScreen.tsx b/src/components/AuthScreen.tsxindex 9553bcc..ebb1024 100644--- a/src/components/AuthScreen.tsx+++ b/src/components/AuthScreen.tsx@@ -33,13 +33,25 @@ const PRESET_LABEL_KEY: Record<string, MessageKey> = {export function AuthScreen() {const t = useT()- const [busy, setBusy] = useState<'google' | 'github' | 'apple' | null>(null)+ const [busy, setBusy] = useState<'google' | 'github' | 'gitlab' | 'apple' | null>(null)+ // GitLab is opt-in and can point at a self-managed instance, so most+ // deployments have no credentials for it — ask the server rather than+ // offering a button that can only 503.+ const [gitlabEnabled, setGitlabEnabled] = useState(false)const [err, setErr] = useState<string | null>(null)const [picker, setPicker] = useState(false)// AuthGate strips a successful fragment after consuming it. A failure// fragment looks like `#token=&companyId=&error=...` — surface that// so the user knows the previous attempt didn't take.+ useEffect(() => {+ let cancelled = false+ void api.authProviders()+ .then((r) => { if (!cancelled) setGitlabEnabled(r.providers.includes('gitlab')) })+ .catch(() => { /* older server or offline — leave the button hidden */ })+ return () => { cancelled = true }+ }, [])+useEffect(() => {const params = new URLSearchParams(location.hash.replace(/^#/, ''))const error = params.get('error')@@ -93,7 +105,7 @@ export function AuthScreen() {}}- function go(provider: 'google' | 'github') {+ function go(provider: 'google' | 'github' | 'gitlab') {setBusy(provider); setErr(null)if (isElectron && window.cumora?.auth) {// Open the user's real browser (Safari / Chrome) so they see the@@ -223,6 +235,17 @@ export function AuthScreen() {<GitHubMark />{busy === 'github' ? t('auth.redirecting') : t('auth.continueWithGithub')}</button>+ {gitlabEnabled && (+ <button+ type="button"+ onClick={() => go('gitlab')}+ disabled={busy !== null}+ className="h-11 rounded-[10px] bg-[#fc6d26] hover:bg-[#e24329] text-white transition-colors flex items-center justify-center gap-3 text-[14px] font-medium disabled:opacity-60"+ >+ <GitLabMark />+ {busy === 'gitlab' ? t('auth.redirecting') : t('auth.continueWithGitlab')}+ </button>+ )}</div>{err && (<div className="text-[12px] text-red-600 text-center max-w-full break-words">@@ -329,6 +352,14 @@ function GoogleMark() {)}+function GitLabMark() {+ return (+ <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">+ <path d="M12 21.4 8.7 11.2H15.3L12 21.4zM3.6 11.2 2.3 15.3a.9.9 0 0 0 .33 1L12 21.4 3.6 11.2zM3.6 11.2h5.1L6.5 4.4a.45.45 0 0 0-.86 0L3.6 11.2zM20.4 11.2l1.3 4.1a.9.9 0 0 1-.33 1L12 21.4l8.4-10.2zM20.4 11.2h-5.1l2.2-6.8a.45.45 0 0 1 .86 0l2.04 6.8z" />+ </svg>+ )+}+function GitHubMark() {return (<svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden>diff --git a/src/locales/en.ts b/src/locales/en.tsindex db041ce..c0a2dc0 100644--- a/src/locales/en.ts+++ b/src/locales/en.ts@@ -62,6 +62,7 @@ export const en = {'auth.continueWithApple': 'Continue with Apple','auth.continueWithGoogle': 'Continue with Google','auth.continueWithGithub': 'Continue with GitHub',+ 'auth.continueWithGitlab': 'Continue with GitLab','auth.signInToAccept': 'Sign in to accept this invite',// Local email + password — self-hosted servers with no OAuth provider.// ─── web landing (app.cumora.ai) ──────────────────────────────────diff --git a/src/locales/zh-CN.ts b/src/locales/zh-CN.tsindex e17046e..bbd1159 100644--- a/src/locales/zh-CN.ts+++ b/src/locales/zh-CN.ts@@ -68,6 +68,7 @@ export const zhCN: Partial<Record<keyof typeof en, string>> = {'auth.continueWithApple': '使用 Apple 继续','auth.continueWithGoogle': '使用 Google 继续','auth.continueWithGithub': '使用 GitHub 继续',+ 'auth.continueWithGitlab': '使用 GitLab 继续','auth.signInToAccept': '登录以接受这份邀请',// ─── 网页落地页(app.cumora.ai)───────────────────────────────────'web.desktopApp': 'Cumora 是一个桌面应用',diff --git a/src/web/WebShell.tsx b/src/web/WebShell.tsxindex d57415d..83a51b3 100644--- a/src/web/WebShell.tsx+++ b/src/web/WebShell.tsx@@ -109,17 +109,28 @@ function WebHandoff() {* or as a suspended verdict (→ SuspendedScreen, also App.tsx). */function WebLanding() {const t = useT()- const [busy, setBusy] = useState<'google' | 'github' | null>(null)+ const [busy, setBusy] = useState<'google' | 'github' | 'gitlab' | null>(null)const [err, setErr] = useState<string | null>(null)+ // Same gating as AuthScreen: GitLab is opt-in, so only offer it when this+ // deployment actually has credentials for it.+ const [gitlabEnabled, setGitlabEnabled] = useState(false)const approvedEntry = new URLSearchParams(location.search).has('approved')+ useEffect(() => {+ let cancelled = false+ void api.authProviders()+ .then((r) => { if (!cancelled) setGitlabEnabled(r.providers.includes('gitlab')) })+ .catch(() => { /* older server or offline — leave the button hidden */ })+ return () => { cancelled = true }+ }, [])+useEffect(() => {const params = new URLSearchParams(location.hash.replace(/^#/, ''))const error = params.get('error')if (error) setErr(decodeURIComponent(error))}, [])- const go = (provider: 'google' | 'github') => {+ const go = (provider: 'google' | 'github' | 'gitlab') => {setBusy(provider); setErr(null)const returnUrl = `${location.origin}${location.pathname}`location.assign(api.authStartUrl(provider, { returnUrl }))@@ -157,6 +168,17 @@ function WebLanding() {<GitHubMark />{busy === 'github' ? t('auth.redirecting') : t('auth.continueWithGithub')}</button>+ {gitlabEnabled && (+ <button+ type="button"+ onClick={() => go('gitlab')}+ disabled={busy !== null}+ className="h-11 rounded-[10px] bg-[#fc6d26] hover:bg-[#e24329] text-white transition-colors flex items-center justify-center gap-3 text-[14px] disabled:opacity-60"+ >+ <GitLabMark />+ {busy === 'gitlab' ? t('auth.redirecting') : t('auth.continueWithGitlab')}+ </button>+ )}</div>{err && (<div className="text-[12px] text-red-600 text-center max-w-full break-words">@@ -201,6 +223,14 @@ function GoogleMark() {)}+function GitLabMark() {+ return (+ <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">+ <path d="M12 21.4 8.7 11.2H15.3L12 21.4zM3.6 11.2 2.3 15.3a.9.9 0 0 0 .33 1L12 21.4 3.6 11.2zM3.6 11.2h5.1L6.5 4.4a.45.45 0 0 0-.86 0L3.6 11.2zM20.4 11.2l1.3 4.1a.9.9 0 0 1-.33 1L12 21.4l8.4-10.2zM20.4 11.2h-5.1l2.2-6.8a.45.45 0 0 1 .86 0l2.04 6.8z" />+ </svg>+ )+}+function GitHubMark() {return (<svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden>