@adonis-agora/authkit-server 0.44.0 → 0.46.0

package/build/src/host/assets/webauthn.js

@@ -0,0 +1,2 @@
+function l(e){let t=new Uint8Array(e),r="";for(let n of t)r+=String.fromCharCode(n);return btoa(r).replace(/\+/g,"-").replace(/\//g,"_").replace(/=/g,"")}function h(e){let t=e.replace(/-/g,"+").replace(/_/g,"/"),r=(4-t.length%4)%4,i=t.padEnd(t.length+r,"="),n=atob(i),c=new ArrayBuffer(n.length),f=new Uint8Array(c);for(let a=0;a<n.length;a++)f[a]=n.charCodeAt(a);return c}function p(){return C.stubThis(globalThis?.PublicKeyCredential!==void 0&&typeof globalThis.PublicKeyCredential=="function")}var C={stubThis:e=>e};function R(e){let{id:t}=e;return{...e,id:h(t),transports:e.transports}}function w(e){return e==="localhost"||/^((xn--[a-z0-9-]+|[a-z0-9]+(-[a-z0-9]+)*)\.)+([a-z]{2,}|xn--[a-z0-9-]+)$/i.test(e)}var o=class extends Error{constructor({message:t,code:r,cause:i,name:n}){super(t,{cause:i}),Object.defineProperty(this,"code",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.name=n??i.name,this.code=r}};function I({error:e,options:t}){let{publicKey:r}=t;if(!r)throw Error("options was missing required publicKey property");if(e.name==="AbortError"){if(t.signal instanceof AbortSignal)return new o({message:"Registration ceremony was sent an abort signal",code:"ERROR_CEREMONY_ABORTED",cause:e})}else if(e.name==="ConstraintError"){if(r.authenticatorSelection?.requireResidentKey===!0)return new o({message:"Discoverable credentials were required but no available authenticator supported it",code:"ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT",cause:e});if(t.mediation==="conditional"&&r.authenticatorSelection?.userVerification==="required")return new o({message:"User verification was required during automatic registration but it could not be performed",code:"ERROR_AUTO_REGISTER_USER_VERIFICATION_FAILURE",cause:e});if(r.authenticatorSelection?.userVerification==="required")return new o({message:"User verification was required but no available authenticator supported it",code:"ERROR_AUTHENTICATOR_MISSING_USER_VERIFICATION_SUPPORT",cause:e})}else{if(e.name==="InvalidStateError")return new o({message:"The authenticator was previously registered",code:"ERROR_AUTHENTICATOR_PREVIOUSLY_REGISTERED",cause:e});if(e.name==="NotAllowedError")return new o({message:e.message,code:"ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY",cause:e});if(e.name==="NotSupportedError")return r.pubKeyCredParams.filter(n=>n.type==="public-key").length===0?new o({message:'No entry in pubKeyCredParams was of type "public-key"',code:"ERROR_MALFORMED_PUBKEYCREDPARAMS",cause:e}):new o({message:"No available authenticator supported any of the specified pubKeyCredParams algorithms",code:"ERROR_AUTHENTICATOR_NO_SUPPORTED_PUBKEYCREDPARAMS_ALG",cause:e});if(e.name==="SecurityError"){let i=globalThis.location.hostname;if(w(i)){if(r.rp.id!==i)return new o({message:`The RP ID "${r.rp.id}" is invalid for this domain`,code:"ERROR_INVALID_RP_ID",cause:e})}else return new o({message:`${globalThis.location.hostname} is an invalid domain`,code:"ERROR_INVALID_DOMAIN",cause:e})}else if(e.name==="TypeError"){if(r.user.id.byteLength<1||r.user.id.byteLength>64)return new o({message:"User ID was not between 1 and 64 characters",code:"ERROR_INVALID_USER_ID_LENGTH",cause:e})}else if(e.name==="UnknownError")return new o({message:"The authenticator was unable to process the specified options, or could not create a new credential",code:"ERROR_AUTHENTICATOR_GENERAL_ERROR",cause:e})}return e}var S=class{constructor(){Object.defineProperty(this,"controller",{enumerable:!0,configurable:!0,writable:!0,value:void 0})}createNewAbortSignal(){if(this.controller){let r=new Error("Cancelling existing WebAuthn API call for new one");r.name="AbortError",this.controller.abort(r)}let t=new AbortController;return this.controller=t,t.signal}cancelCeremony(){if(this.controller){let t=new Error("Manually cancelling existing WebAuthn API call");t.name="AbortError",this.controller.abort(t),this.controller=void 0}}},A=new S;var x=["cross-platform","platform"];function E(e){if(e&&!(x.indexOf(e)<0))return e}async function N(e){!e.optionsJSON&&e.challenge&&(console.warn("startRegistration() was not called correctly. It will try to continue with the provided options, but this call should be refactored to use the expected call structure instead. See https://simplewebauthn.dev/docs/packages/browser#typeerror-cannot-read-properties-of-undefined-reading-challenge for more information."),e={optionsJSON:e});let{optionsJSON:t,useAutoRegister:r=!1}=e;if(!p())throw new Error("WebAuthn is not supported in this browser");let i={...t,challenge:h(t.challenge),user:{...t.user,id:h(t.user.id)},excludeCredentials:t.excludeCredentials?.map(R)},n={};r&&(n.mediation="conditional"),n.publicKey=i,n.signal=A.createNewAbortSignal();let c;try{c=await navigator.credentials.create(n)}catch(u){throw I({error:u,options:n})}if(!c)throw new Error("Registration was not completed");let{id:f,rawId:a,response:s,type:y}=c,d;typeof s.getTransports=="function"&&(d=s.getTransports());let g;if(typeof s.getPublicKeyAlgorithm=="function")try{g=s.getPublicKeyAlgorithm()}catch(u){O("getPublicKeyAlgorithm()",u)}let b;if(typeof s.getPublicKey=="function")try{let u=s.getPublicKey();u!==null&&(b=l(u))}catch(u){O("getPublicKey()",u)}let m;if(typeof s.getAuthenticatorData=="function")try{m=l(s.getAuthenticatorData())}catch(u){O("getAuthenticatorData()",u)}return{id:f,rawId:l(a),response:{attestationObject:l(s.attestationObject),clientDataJSON:l(s.clientDataJSON),transports:d,publicKeyAlgorithm:g,publicKey:b,authenticatorData:m},type:y,clientExtensionResults:c.getClientExtensionResults(),authenticatorAttachment:E(c.authenticatorAttachment)}}function O(e,t){console.warn(`The browser extension that intercepted this WebAuthn API call incorrectly implemented ${e}. You should report this error to them.
+`,t)}function _(){if(!p())return T.stubThis(new Promise(t=>t(!1)));let e=globalThis.PublicKeyCredential;return e?.isConditionalMediationAvailable===void 0?T.stubThis(new Promise(t=>t(!1))):T.stubThis(e.isConditionalMediationAvailable())}var T={stubThis:e=>e};function P({error:e,options:t}){let{publicKey:r}=t;if(!r)throw Error("options was missing required publicKey property");if(e.name==="AbortError"){if(t.signal instanceof AbortSignal)return new o({message:"Authentication ceremony was sent an abort signal",code:"ERROR_CEREMONY_ABORTED",cause:e})}else{if(e.name==="NotAllowedError")return new o({message:e.message,code:"ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY",cause:e});if(e.name==="SecurityError"){let i=globalThis.location.hostname;if(w(i)){if(r.rpId!==i)return new o({message:`The RP ID "${r.rpId}" is invalid for this domain`,code:"ERROR_INVALID_RP_ID",cause:e})}else return new o({message:`${globalThis.location.hostname} is an invalid domain`,code:"ERROR_INVALID_DOMAIN",cause:e})}else if(e.name==="UnknownError")return new o({message:"The authenticator was unable to process the specified options, or could not create a new assertion signature",code:"ERROR_AUTHENTICATOR_GENERAL_ERROR",cause:e})}return e}async function D(e){!e.optionsJSON&&e.challenge&&(console.warn("startAuthentication() was not called correctly. It will try to continue with the provided options, but this call should be refactored to use the expected call structure instead. See https://simplewebauthn.dev/docs/packages/browser#typeerror-cannot-read-properties-of-undefined-reading-challenge for more information."),e={optionsJSON:e});let{optionsJSON:t,useBrowserAutofill:r=!1,verifyBrowserAutofillInput:i=!0}=e;if(!p())throw new Error("WebAuthn is not supported in this browser");let n;t.allowCredentials?.length!==0&&(n=t.allowCredentials?.map(R));let c={...t,challenge:h(t.challenge),allowCredentials:n},f={};if(r){if(!await _())throw Error("Browser does not support WebAuthn autofill");if(document.querySelectorAll("input[autocomplete$='webauthn']").length<1&&i)throw Error('No <input> with "webauthn" as the only or last value in its `autocomplete` attribute was detected');f.mediation="conditional",c.allowCredentials=[]}f.publicKey=c,f.signal=A.createNewAbortSignal();let a;try{a=await navigator.credentials.get(f)}catch(m){throw P({error:m,options:f})}if(!a)throw new Error("Authentication was not completed");let{id:s,rawId:y,response:d,type:g}=a,b;return d.userHandle&&(b=l(d.userHandle)),{id:s,rawId:l(y),response:{authenticatorData:l(d.authenticatorData),clientDataJSON:l(d.clientDataJSON),signature:l(d.signature),userHandle:b},type:g,clientExtensionResults:a.getClientExtensionResults(),authenticatorAttachment:E(a.authenticatorAttachment)}}function v(){return p()?PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable():new Promise(e=>e(!1))}export{A as WebAuthnAbortService,o as WebAuthnError,p as browserSupportsWebAuthn,_ as browserSupportsWebAuthnAutofill,v as platformAuthenticatorIsAvailable,D as startAuthentication,N as startRegistration};

package/build/src/host/avatar_storage.d.ts

@@ -20,6 +20,18 @@ type DriveService = any;
  * @internal
  */
 export declare function __setDriveLoaderForTests(fn: (() => Promise<DriveService | null>) | undefined): void;
+/**
+ * Módulo `@adonis-agora/media/single-file` resolvido de forma preguiçosa. Tipado
+ * como `any` de propósito: a lib NÃO depende do media em tempo de compilação
+ * (peer/opt-in). Expõe `storeSingleFile`/`removeSingleFile`/`isSingleFileStoreAvailable`.
+ */
+type MediaModule = any;
+/**
+ * Permite reapontar/limpar o loader do media (usado em testes). Espelha
+ * {@link __setDriveLoaderForTests}.
+ * @internal
+ */
+export declare function __setMediaLoaderForTests(fn: (() => Promise<MediaModule | null>) | undefined): void;
 /** Erro de validação do upload (mensagem já localizada no controller). */
 export declare class AvatarUploadError extends Error {
     reason: 'extname' | 'size';
@@ -29,7 +41,9 @@ export declare class AvatarUploadError extends Error {
 export interface UploadedAvatar {
     extname?: string | null;
     size?: number;
-    /** Caminho temporário (drive lê daqui para stream). */
+    /** MIME reportado pelo multipart (ex.: 'image/png'). Usado pelo backend media. */
+    type?: string | null;
+    /** Caminho temporário (drive lê daqui para stream; media lê os bytes daqui). */
     tmpPath?: string | null;
     /** Move o arquivo para um disk do drive (API v3+). */
     moveToDisk?: (key: string, options?: {
@@ -42,27 +56,39 @@ export interface UploadedAvatar {
  */
 export declare function isDriveAvailable(): Promise<boolean>;
 /**
- * Armazena o avatar no drive do host e retorna a URL pública.
+ * Indica se o upload de avatar está disponível para a config dada — i.e. se ALGUM
+ * backend configurado consegue armazenar (mesma lógica de seleção do
+ * {@link resolveUploader}: `'builtin'` → drive; `'media'` → media; `'auto'` →
+ * media OU drive). Usado pelas views/controllers para decidir mostrar o input de
+ * arquivo. Best-effort: nunca lança.
+ *
+ * Substitui o antigo gate por {@link isDriveAvailable}, que escondia o input num
+ * host media-only (media presente, drive ausente) mesmo com o media capaz de armazenar.
+ */
+export declare function isAvatarUploadSupported(cfg: ResolvedUploadsConfig): Promise<boolean>;
+/**
+ * Armazena o avatar no backend ativo (drive OU media) e retorna a URL pública.
  *
- * - Valida extensão (jpg/jpeg/png/webp) e tamanho (≤ maxSizeMb) — lança
+ * - Resolve o backend PRIMEIRO: se nenhum estiver disponível → retorna `null`
+ *   (degrada para o input de URL, feature off) SEM validar/lançar. Isso preserva o
+ *   comportamento histórico: um host sem backend nunca vê erro de validação.
+ * - Só quando há backend valida extensão (jpg/jpeg/png/webp) e tamanho
+ *   (≤ maxSizeMb) — COMPARTILHADO, antes de entregar ao backend; lança
  *   {@link AvatarUploadError} se inválido (o controller traduz/flasha).
- * - Usa o disk configurado em `uploads.avatars.disk` ou o disk DEFAULT do app.
- * - Se o drive estiver ausente/não-configurado → retorna `null` (degrada para URL).
+ * - Backend conforme `cfg.avatars.storage` (ver {@link resolveUploader}).
  *
- * Nunca lança por causa de drive ausente; só lança em validação.
+ * Nunca lança por causa de backend ausente; só lança em validação (com backend).
  */
-export declare function storeAvatar(_ctx: HttpContext, cfg: ResolvedUploadsConfig, file: UploadedAvatar, accountId: string, messages: {
+export declare function storeAvatar(ctx: HttpContext, cfg: ResolvedUploadsConfig, file: UploadedAvatar, accountId: string, messages: {
     extname: string;
     size: string;
 }): Promise<string | null>;
 /**
- * Deleta (best-effort, fail-safe) o avatar de uma conta no drive do host, a partir
- * da URL/key armazenada. Usado pela deleção de conta (LGPD): apaga o arquivo se
- * conseguirmos derivar a key dentro do diretório configurado.
+ * Deleta (best-effort, fail-safe) o avatar de uma conta no backend ativo. Usado
+ * pela deleção de conta (LGPD). O `accountId` é o owner — necessário para o backend
+ * media apagar por owner; o backend builtin deriva a key da `storedUrlOrKey`.
  *
- * NUNCA lança: drive ausente, key não reconhecida ou erro de I/O → no-op. A key é
- * derivada da `storedUrlOrKey` pegando o trecho a partir de `directory/` (cobre
- * tanto uma key relativa quanto uma URL pública que contenha o caminho).
+ * NUNCA lança: backend ausente, key não reconhecida ou erro de I/O → no-op.
  */
-export declare function deleteAvatar(cfg: ResolvedUploadsConfig, storedUrlOrKey: string | null | undefined): Promise<boolean>;
+export declare function deleteAvatar(cfg: ResolvedUploadsConfig, accountId: string | null | undefined, storedUrlOrKey: string | null | undefined): Promise<boolean>;
 export {};

package/build/src/host/avatar_storage.js

@@ -34,8 +34,43 @@ export function __setDriveLoaderForTests(fn) {
         driveServicePromise = undefined;
     }
 }
+let mediaModulePromise;
+/**
+ * Importa o helper single-file do `@adonis-agora/media` de forma preguiçosa e
+ * fail-safe. Espelha {@link loadDrive}: se o pacote não estiver instalado, resolve
+ * `null` (o specifier é indireto para não ser resolvido em build-time — peer opcional).
+ */
+async function loadMedia() {
+    if (!mediaModulePromise) {
+        const specifier = '@adonis-agora/media/single-file';
+        mediaModulePromise = import(__rewriteRelativeImportExtension(specifier))
+            .then((mod) => mod ?? null)
+            .catch(() => null);
+    }
+    return mediaModulePromise;
+}
+/**
+ * Permite reapontar/limpar o loader do media (usado em testes). Espelha
+ * {@link __setDriveLoaderForTests}.
+ * @internal
+ */
+export function __setMediaLoaderForTests(fn) {
+    if (fn) {
+        mediaModulePromise = fn();
+    }
+    else {
+        mediaModulePromise = undefined;
+    }
+}
 /** Extensões aceitas para o avatar (imagem raster comum). */
 const ALLOWED_EXTNAMES = ['jpg', 'jpeg', 'png', 'webp'];
+/** MIME por extensão validada — fallback quando o file de multipart não traz `type`. */
+const EXT_MIME = {
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    webp: 'image/webp',
+};
 /** Erro de validação do upload (mensagem já localizada no controller). */
 export class AvatarUploadError extends Error {
     reason;
@@ -76,91 +111,205 @@ function buildKey(cfg, accountId, ext) {
     return `${cfg.avatars.directory}/${accountId}-${random}.${ext}`;
 }
 /**
- * Armazena o avatar no drive do host e retorna a URL pública.
+ * Backend builtin: o `@adonisjs/drive` JÁ configurado no app. Comportamento
+ * BYTE-IDÊNTICO ao histórico (moveToDisk/putStream + getUrl; delete por key
+ * derivada do diretório).
+ */
+const builtinUploader = {
+    async store(_ctx, cfg, file, accountId, ext) {
+        const drive = await loadDrive();
+        if (!drive)
+            return null;
+        // Resolve o disk: o configurado, ou o DEFAULT do drive do app.
+        let disk;
+        try {
+            disk = cfg.avatars.disk ? drive.use(cfg.avatars.disk) : drive.use();
+        }
+        catch {
+            // disk inválido/não-configurado — degrada para URL.
+            return null;
+        }
+        if (!disk)
+            return null;
+        const key = buildKey(cfg, accountId || 'account', ext);
+        // API @adonisjs/drive v3+: o file de multipart move-se direto para o disk.
+        // `moveToDisk` lê do tmpPath e usa o disk informado (ou o default da config).
+        if (typeof file.moveToDisk === 'function') {
+            await file.moveToDisk(key, cfg.avatars.disk ? { disk: cfg.avatars.disk } : undefined);
+        }
+        else if (file.tmpPath) {
+            // Fallback: lê do tmpPath e escreve via putStream no disk resolvido.
+            const fs = await import('node:fs');
+            await disk.putStream(key, fs.createReadStream(file.tmpPath));
+        }
+        else {
+            return null;
+        }
+        try {
+            return await disk.getUrl(key);
+        }
+        catch {
+            // disk sem getUrl público — retorna a key como referência relativa.
+            return key;
+        }
+    },
+    async delete(cfg, _accountId, storedUrlOrKey) {
+        if (!storedUrlOrKey)
+            return false;
+        const drive = await loadDrive();
+        if (!drive)
+            return false;
+        // Deriva a key: trecho a partir de `<directory>/`. Se não bater, aborta (não
+        // arriscamos deletar algo fora do nosso diretório).
+        const dir = cfg.avatars.directory.replace(/\/+$/, '');
+        const marker = `${dir}/`;
+        const idx = storedUrlOrKey.indexOf(marker);
+        if (idx < 0)
+            return false;
+        // Remove querystring/fragment de uma URL pública.
+        const key = storedUrlOrKey.slice(idx).split(/[?#]/)[0];
+        let disk;
+        try {
+            disk = cfg.avatars.disk ? drive.use(cfg.avatars.disk) : drive.use();
+        }
+        catch {
+            return false;
+        }
+        if (!disk || typeof disk.delete !== 'function')
+            return false;
+        try {
+            await disk.delete(key);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+};
+/**
+ * Backend media: delega ao `@adonis-agora/media` (collection single-file). O
+ * lifecycle é keyed por owner (`ownerType`/`ownerId`) — o `single: true` da
+ * collection faz o replace de slot; a URL final é o que persistimos em `avatarUrl`.
+ */
+function makeMediaUploader(media) {
+    return {
+        async store(_ctx, cfg, file, accountId, ext) {
+            if (!file.tmpPath)
+                return null;
+            const fs = await import('node:fs/promises');
+            const contents = await fs.readFile(file.tmpPath);
+            const fileName = `avatar.${ext}`;
+            const mimeType = file.type ?? EXT_MIME[ext] ?? 'application/octet-stream';
+            const result = await media.storeSingleFile({
+                ownerType: cfg.avatars.ownerType,
+                ownerId: accountId,
+                collection: cfg.avatars.collection,
+                fileName,
+                mimeType,
+                contents,
+            });
+            return result?.url ?? null;
+        },
+        async delete(cfg, accountId, _storedUrlOrKey) {
+            // media apaga por owner (a key/URL não é usada — o lifecycle é do owner).
+            if (!accountId)
+                return false;
+            try {
+                await media.removeSingleFile({
+                    ownerType: cfg.avatars.ownerType,
+                    ownerId: accountId,
+                    collection: cfg.avatars.collection,
+                });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}
+/**
+ * Resolve o backend de avatar conforme `cfg.avatars.storage`:
+ * - `'builtin'` → sempre o drive (ou `null` se ausente).
+ * - `'media'`   → o media (ou `null` se ausente/indisponível — degrada gracioso).
+ * - `'auto'`    → media se disponível, senão o drive.
  *
- * - Valida extensão (jpg/jpeg/png/webp) e tamanho (≤ maxSizeMb) — lança
- *   {@link AvatarUploadError} se inválido (o controller traduz/flasha).
- * - Usa o disk configurado em `uploads.avatars.disk` ou o disk DEFAULT do app.
- * - Se o drive estiver ausente/não-configurado → retorna `null` (degrada para URL).
+ * "media disponível" = pacote presente E `isSingleFileStoreAvailable()` true (o
+ * MediaManager está bindado no container do app). Nunca lança.
+ */
+async function resolveUploader(cfg) {
+    const storage = cfg.avatars.storage;
+    if (storage === 'builtin') {
+        return (await loadDrive()) ? builtinUploader : null;
+    }
+    if (storage === 'media') {
+        const media = await loadMediaIfUsable();
+        return media ? makeMediaUploader(media) : null;
+    }
+    // 'auto' (default): media se disponível, senão builtin.
+    const media = await loadMediaIfUsable();
+    if (media)
+        return makeMediaUploader(media);
+    return (await loadDrive()) ? builtinUploader : null;
+}
+/**
+ * Indica se o upload de avatar está disponível para a config dada — i.e. se ALGUM
+ * backend configurado consegue armazenar (mesma lógica de seleção do
+ * {@link resolveUploader}: `'builtin'` → drive; `'media'` → media; `'auto'` →
+ * media OU drive). Usado pelas views/controllers para decidir mostrar o input de
+ * arquivo. Best-effort: nunca lança.
  *
- * Nunca lança por causa de drive ausente; só lança em validação.
+ * Substitui o antigo gate por {@link isDriveAvailable}, que escondia o input num
+ * host media-only (media presente, drive ausente) mesmo com o media capaz de armazenar.
  */
-export async function storeAvatar(_ctx, cfg, file, accountId, messages) {
-    const drive = await loadDrive();
-    if (!drive)
+export async function isAvatarUploadSupported(cfg) {
+    return (await resolveUploader(cfg)) !== null;
+}
+/**
+ * Carrega o módulo media só se ele estiver USÁVEL: pacote presente E
+ * `isSingleFileStoreAvailable()` resolve `true`. Best-effort — qualquer erro → null.
+ */
+async function loadMediaIfUsable() {
+    const media = await loadMedia();
+    if (!media)
         return null;
-    const ext = validate(file, cfg, messages);
-    // Resolve o disk: o configurado, ou o DEFAULT do drive do app.
-    let disk;
     try {
-        disk = cfg.avatars.disk ? drive.use(cfg.avatars.disk) : drive.use();
+        return (await media.isSingleFileStoreAvailable()) ? media : null;
     }
     catch {
-        // disk inválido/não-configurado — degrada para URL.
         return null;
     }
-    if (!disk)
-        return null;
-    const key = buildKey(cfg, accountId || 'account', ext);
-    // API @adonisjs/drive v3+: o file de multipart move-se direto para o disk.
-    // `moveToDisk` lê do tmpPath e usa o disk informado (ou o default da config).
-    if (typeof file.moveToDisk === 'function') {
-        await file.moveToDisk(key, cfg.avatars.disk ? { disk: cfg.avatars.disk } : undefined);
-    }
-    else if (file.tmpPath) {
-        // Fallback: lê do tmpPath e escreve via putStream no disk resolvido.
-        const fs = await import('node:fs');
-        await disk.putStream(key, fs.createReadStream(file.tmpPath));
-    }
-    else {
+}
+/**
+ * Armazena o avatar no backend ativo (drive OU media) e retorna a URL pública.
+ *
+ * - Resolve o backend PRIMEIRO: se nenhum estiver disponível → retorna `null`
+ *   (degrada para o input de URL, feature off) SEM validar/lançar. Isso preserva o
+ *   comportamento histórico: um host sem backend nunca vê erro de validação.
+ * - Só quando há backend valida extensão (jpg/jpeg/png/webp) e tamanho
+ *   (≤ maxSizeMb) — COMPARTILHADO, antes de entregar ao backend; lança
+ *   {@link AvatarUploadError} se inválido (o controller traduz/flasha).
+ * - Backend conforme `cfg.avatars.storage` (ver {@link resolveUploader}).
+ *
+ * Nunca lança por causa de backend ausente; só lança em validação (com backend).
+ */
+export async function storeAvatar(ctx, cfg, file, accountId, messages) {
+    const uploader = await resolveUploader(cfg);
+    if (!uploader)
         return null;
-    }
-    try {
-        return await disk.getUrl(key);
-    }
-    catch {
-        // disk sem getUrl público — retorna a key como referência relativa.
-        return key;
-    }
+    const ext = validate(file, cfg, messages);
+    return uploader.store(ctx, cfg, file, accountId, ext);
 }
 /**
- * Deleta (best-effort, fail-safe) o avatar de uma conta no drive do host, a partir
- * da URL/key armazenada. Usado pela deleção de conta (LGPD): apaga o arquivo se
- * conseguirmos derivar a key dentro do diretório configurado.
+ * Deleta (best-effort, fail-safe) o avatar de uma conta no backend ativo. Usado
+ * pela deleção de conta (LGPD). O `accountId` é o owner — necessário para o backend
+ * media apagar por owner; o backend builtin deriva a key da `storedUrlOrKey`.
  *
- * NUNCA lança: drive ausente, key não reconhecida ou erro de I/O → no-op. A key é
- * derivada da `storedUrlOrKey` pegando o trecho a partir de `directory/` (cobre
- * tanto uma key relativa quanto uma URL pública que contenha o caminho).
+ * NUNCA lança: backend ausente, key não reconhecida ou erro de I/O → no-op.
  */
-export async function deleteAvatar(cfg, storedUrlOrKey) {
-    if (!storedUrlOrKey)
-        return false;
-    const drive = await loadDrive();
-    if (!drive)
-        return false;
-    // Deriva a key: trecho a partir de `<directory>/`. Se não bater, aborta (não
-    // arriscamos deletar algo fora do nosso diretório).
-    const dir = cfg.avatars.directory.replace(/\/+$/, '');
-    const marker = `${dir}/`;
-    const idx = storedUrlOrKey.indexOf(marker);
-    if (idx < 0)
-        return false;
-    // Remove querystring/fragment de uma URL pública.
-    const key = storedUrlOrKey.slice(idx).split(/[?#]/)[0];
-    let disk;
-    try {
-        disk = cfg.avatars.disk ? drive.use(cfg.avatars.disk) : drive.use();
-    }
-    catch {
+export async function deleteAvatar(cfg, accountId, storedUrlOrKey) {
+    const uploader = await resolveUploader(cfg);
+    if (!uploader)
         return false;
-    }
-    if (!disk || typeof disk.delete !== 'function')
-        return false;
-    try {
-        await disk.delete(key);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return uploader.delete(cfg, accountId, storedUrlOrKey);
 }

package/build/src/host/controllers/account_confirm_controller.d.ts

@@ -1,24 +1,21 @@
 /**
  * Sudo mode — tela de confirmação de identidade (/account/confirm).
  *
- * GET  /account/confirm  → exibe o formulário de senha (e opção de passkey se disponível).
- * POST /account/confirm  → verifica a senha e, se correta, marca o sudo na sessão.
- * POST /account/confirm/passkey/options → gera as opções de autenticação.
- * POST /account/confirm/passkey         → verifica a resposta da passkey e marca o sudo.
+ * O GET lista os métodos DISPONÍVEIS para a conta (SPI `SudoMethod`); a
+ * verificação de cada um vive no próprio método, nas rotas que ele registra.
+ * Este controller não verifica credencial nem chama `markSudo`.
  *
  * A tela está atrás do `accountGuard` (requer sessão de conta ativa).
- * Após confirmação, redireciona para `return_to` (validado) ou para `/account/tokens`.
  */
 import '../augmentations.js';
 import type { HttpContext } from '@adonisjs/core/http';
+import { sudoContextFrom } from '../sudo/runtime.js';
+/**
+ * Reexport de compatibilidade. O construtor canônico do `SudoContext` vive em
+ * `sudo/runtime.ts` (é runtime do SPI, não detalhe da tela); este caminho
+ * antigo segue valendo para quem já o importava.
+ */
+export { sudoContextFrom };
 export default class AccountConfirmController {
-    show(ctx: HttpContext): Promise<any>;
-    confirm(ctx: HttpContext): Promise<void>;
-    passkeyOptions(ctx: HttpContext): Promise<any>;
-    passkeyConfirm(ctx: HttpContext): Promise<void>;
-    /**
-     * Verifica se a conta é "passwordless" (sem hash de senha definido).
-     * Fail-safe: retorna `false` quando não é possível determinar.
-     */
-    private isPasswordless;
+    show(ctx: HttpContext): Promise<unknown>;
 }