@adonis-agora/authkit-client 0.15.0 → 0.17.0

package/build/index.d.ts

@@ -16,6 +16,8 @@ export { default as BackchannelRevocationMiddleware } from './src/middleware/bac
 export { authkitClientGuard, AuthkitClientGuard } from './src/host/authkit_client_guard.js';
 export type { UnauthorizedAccessConstructor } from './src/host/authkit_client_guard.js';
 export { getAuthkit } from './src/host/request_authenticator.js';
+export { isAuthkitAdmin, authkitDashboardAuthorize, authkitDashboardMiddleware, } from './src/host/dashboard_guard.js';
+export type { DashboardGuardOptions } from './src/host/dashboard_guard.js';
 export { default as AuthkitContextMiddleware } from './src/middleware/authkit_context_middleware.js';
 export { lucidMirror } from './src/lucid_mirror.js';
 export type { LucidMirrorOptions } from './src/lucid_mirror.js';

package/build/index.js

@@ -9,6 +9,7 @@ export { lucidRevocationStore, DEFAULT_REVOCATION_TABLE, } from './src/revocatio
 export { default as BackchannelRevocationMiddleware } from './src/middleware/backchannel_revocation_middleware.js';
 export { authkitClientGuard, AuthkitClientGuard } from './src/host/authkit_client_guard.js';
 export { getAuthkit } from './src/host/request_authenticator.js';
+export { isAuthkitAdmin, authkitDashboardAuthorize, authkitDashboardMiddleware, } from './src/host/dashboard_guard.js';
 export { default as AuthkitContextMiddleware } from './src/middleware/authkit_context_middleware.js';
 export { lucidMirror } from './src/lucid_mirror.js';
 export { registerOidcClient } from './src/register_oidc_client.js';

package/build/providers/authkit_client_provider.d.ts

@@ -2,6 +2,7 @@ import type { HttpContext } from '@adonisjs/core/http';
 import type { ApplicationService } from '@adonisjs/core/types';
 import { Authenticator } from '../src/authenticator.js';
 import type { ResolvedClientConfig } from '../src/define_config.js';
+import type { TokenSet } from '../src/types.js';
 /** Deps injetáveis (relógio/fetch) para testar `maybeRefresh` sem rede/tempo real. */
 export interface RefreshDeps {
     now?: () => number;
@@ -23,6 +24,9 @@ export declare class AuthkitClientManager {
      * renovado — incluindo o refresh_token ROTACIONADO — de volta na sessão. Preserva
      * o id_token / refresh_token anteriores quando o IdP não os reemite.
      *
+     * Preserva TAMBÉM o `impersonationBinding`: renovar o token do alvo não muda a
+     * sessão, então não pode invalidar o vínculo e trancar o ator na impersonação.
+     *
      * Best-effort: qualquer falha (token revogado, IdP fora) é silenciosa — o resolver
      * lida com a sessão expirada no fluxo normal. Chamado pelo middleware por request.
      */
@@ -43,10 +47,64 @@ export declare class AuthkitClientManager {
      * do chamador (ex.: Bouncer) ANTES de chamar este método.
      */
     impersonate(ctx: HttpContext, requestedSubject: string): Promise<void>;
-    /** Encerra a impersonação restaurando o token set original. Retorna false se não havia impersonação. */
+    /**
+     * Encerra a impersonação restaurando o token set do ator — SE a sessão que pede
+     * ainda for aquela para a qual a credencial foi guardada.
+     *
+     * A credencial parqueada é um refresh token vivo; sem essa conferência o restore
+     * a entrega a quem estiver de posse do cookie jar depois (logout do ator + login
+     * de outra identidade). A prova é o `impersonationBinding`: um nonce escrito ao
+     * mesmo tempo dentro do token set ATIVO e do registro parqueado. Só `impersonate()`
+     * o escreve e só o `maybeRefresh` o propaga — qualquer troca de identidade
+     * reescreve o slot da sessão e o vínculo some.
+     *
+     * As conferências ÓBVIAS não servem, e é por isso que o vínculo existe:
+     *  - `sub === sub do ator`: durante uma impersonação legítima a sessão é a do
+     *    ALVO, então isso nunca é verdade — trancaria o ator dentro da impersonação;
+     *  - "o token parqueado é de um admin?": sempre verdade; o atacante não alega
+     *    ser o ator, ele pede a credencial do ator;
+     *  - gate por papel: o ator impersonando carrega os papéis do ALVO nesse momento.
+     *
+     * Recusa é FAIL-CLOSED: a credencial órfã é DESCARTADA (nunca devolvida) e o
+     * token set da sessão também cai — uma recusa não é uma tentativa a repetir, e
+     * ninguém fica preso impersonando.
+     *
+     * LIMITE HONESTO: quem controla o cookie jar DURANTE uma impersonação ativa é
+     * indistinguível do ator — é literalmente a mesma sessão, e o vínculo viaja nela.
+     * Isso é o modelo de sessão, não esta conferência. O que fecha é a janela em que
+     * a credencial sobrevive à sessão que a guardou.
+     *
+     * @returns `true` só quando o ator foi restaurado.
+     */
     stopImpersonating(ctx: HttpContext): Promise<boolean>;
-    /** Indica se a request corrente está impersonando (p/ exibir banner na UI). */
+    /**
+     * Indica se a request corrente está impersonando (p/ exibir banner na UI). Exige o
+     * mesmo vínculo do `stopImpersonating` — uma credencial órfã de outra sessão não
+     * faz o banner aparecer para quem não está impersonando ninguém.
+     */
     isImpersonating(ctx: HttpContext): boolean;
+    /**
+     * Encerra a sessão do AuthKit: remove o token set E qualquer credencial de
+     * impersonação parqueada. Todo caminho da lib que derruba a sessão passa por aqui
+     * — logout RP-initiated (`registerOidcClient`) e revogação back-channel.
+     *
+     * Existe porque um `session.forget(sessionKey)` solto deixava o refresh token do
+     * ATOR parqueado no browser depois de uma revogação central — o mecanismo que o
+     * operador usa justamente para matar a sessão.
+     */
+    endSession(ctx: HttpContext): void;
+    /**
+     * Instala o token set de um login recém-concluído, descartando o que sobrou da
+     * sessão anterior no mesmo cookie jar.
+     *
+     * O `stopImpersonating` já recusa uma credencial órfã — o token set novo nasce sem
+     * `impersonationBinding`, então o vínculo não fecha. Mas recusar é só não DEVOLVER:
+     * sem esta limpeza o refresh token do ator continua serializado no cookie de sessão
+     * de outra identidade até a sessão expirar. Não devolver e não guardar são coisas
+     * diferentes, e a segunda é a que mantém a invariante — a credencial parqueada nunca
+     * sobrevive à sessão que a parqueou.
+     */
+    startSession(ctx: HttpContext, tokenSet: TokenSet): void;
     createAuthenticator(ctx: HttpContext): Promise<Authenticator>;
 }
 declare module '@adonisjs/core/types' {

package/build/providers/authkit_client_provider.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { configProvider } from '@adonisjs/core';
 import { RuntimeException } from '@adonisjs/core/exceptions';
 import { Authenticator } from '../src/authenticator.js';
@@ -5,6 +6,17 @@ import { validateLogoutToken } from '../src/backchannel_logout.js';
 import { exchangeToken, refreshTokens } from '../src/oidc_login.js';
 /** Margem (ms) antes do `expiresAt` em que o access token é renovado proativamente. */
 const REFRESH_SKEW_MS = 60_000;
+/** Aceita só o formato COM vínculo; o formato legado (TokenSet cru) vira `null`. */
+function readParked(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const candidate = value;
+    if (typeof candidate.binding !== 'string' || !candidate.binding)
+        return null;
+    if (!candidate.tokenSet || typeof candidate.tokenSet !== 'object')
+        return null;
+    return candidate;
+}
 export class AuthkitClientManager {
     config;
     #resolverCache;
@@ -40,6 +52,9 @@ export class AuthkitClientManager {
      * renovado — incluindo o refresh_token ROTACIONADO — de volta na sessão. Preserva
      * o id_token / refresh_token anteriores quando o IdP não os reemite.
      *
+     * Preserva TAMBÉM o `impersonationBinding`: renovar o token do alvo não muda a
+     * sessão, então não pode invalidar o vínculo e trancar o ator na impersonação.
+     *
      * Best-effort: qualquer falha (token revogado, IdP fora) é silenciosa — o resolver
      * lida com a sessão expirada no fluxo normal. Chamado pelo middleware por request.
      */
@@ -68,6 +83,7 @@ export class AuthkitClientManager {
                 accessToken: next.accessToken,
                 refreshToken: next.refreshToken ?? tokenSet.refreshToken,
                 expiresAt: next.expiresAt,
+                impersonationBinding: tokenSet.impersonationBinding,
             });
         }
         catch {
@@ -140,24 +156,113 @@ export class AuthkitClientManager {
             requestedSubject,
             resilience: this.config.resilience,
         });
-        session.put(this.#impersonatorKey, current);
-        session.put(this.config.sessionKey, impersonated);
+        // Vínculo: o mesmo nonce nos dois lados. O lado ATIVO mora dentro do token set
+        // da sessão, o único slot que todo caminho de fim-de-sessão já limpa.
+        const binding = randomUUID();
+        session.put(this.#impersonatorKey, {
+            tokenSet: current,
+            binding,
+        });
+        session.put(this.config.sessionKey, { ...impersonated, impersonationBinding: binding });
     }
-    /** Encerra a impersonação restaurando o token set original. Retorna false se não havia impersonação. */
+    /**
+     * Encerra a impersonação restaurando o token set do ator — SE a sessão que pede
+     * ainda for aquela para a qual a credencial foi guardada.
+     *
+     * A credencial parqueada é um refresh token vivo; sem essa conferência o restore
+     * a entrega a quem estiver de posse do cookie jar depois (logout do ator + login
+     * de outra identidade). A prova é o `impersonationBinding`: um nonce escrito ao
+     * mesmo tempo dentro do token set ATIVO e do registro parqueado. Só `impersonate()`
+     * o escreve e só o `maybeRefresh` o propaga — qualquer troca de identidade
+     * reescreve o slot da sessão e o vínculo some.
+     *
+     * As conferências ÓBVIAS não servem, e é por isso que o vínculo existe:
+     *  - `sub === sub do ator`: durante uma impersonação legítima a sessão é a do
+     *    ALVO, então isso nunca é verdade — trancaria o ator dentro da impersonação;
+     *  - "o token parqueado é de um admin?": sempre verdade; o atacante não alega
+     *    ser o ator, ele pede a credencial do ator;
+     *  - gate por papel: o ator impersonando carrega os papéis do ALVO nesse momento.
+     *
+     * Recusa é FAIL-CLOSED: a credencial órfã é DESCARTADA (nunca devolvida) e o
+     * token set da sessão também cai — uma recusa não é uma tentativa a repetir, e
+     * ninguém fica preso impersonando.
+     *
+     * LIMITE HONESTO: quem controla o cookie jar DURANTE uma impersonação ativa é
+     * indistinguível do ator — é literalmente a mesma sessão, e o vínculo viaja nela.
+     * Isso é o modelo de sessão, não esta conferência. O que fecha é a janela em que
+     * a credencial sobrevive à sessão que a guardou.
+     *
+     * @returns `true` só quando o ator foi restaurado.
+     */
     async stopImpersonating(ctx) {
         const session = ctx.session;
         if (!session)
             return false;
-        const original = session.get(this.#impersonatorKey);
-        if (!original)
+        const raw = session.get(this.#impersonatorKey);
+        if (raw === undefined || raw === null)
+            return false;
+        const parked = readParked(raw);
+        const live = session.get(this.config.sessionKey);
+        // `parked === null` cobre o formato pré-0.15 (TokenSet cru, sem vínculo nenhum):
+        // é justamente a credencial que não dá pra atribuir. Recusada como qualquer outra.
+        if (!parked || !live?.impersonationBinding || live.impersonationBinding !== parked.binding) {
+            session.forget(this.#impersonatorKey);
+            session.forget(this.config.sessionKey);
             return false;
+        }
+        const { impersonationBinding: _binding, ...original } = parked.tokenSet;
         session.put(this.config.sessionKey, original);
         session.forget(this.#impersonatorKey);
         return true;
     }
-    /** Indica se a request corrente está impersonando (p/ exibir banner na UI). */
+    /**
+     * Indica se a request corrente está impersonando (p/ exibir banner na UI). Exige o
+     * mesmo vínculo do `stopImpersonating` — uma credencial órfã de outra sessão não
+     * faz o banner aparecer para quem não está impersonando ninguém.
+     */
     isImpersonating(ctx) {
-        return Boolean(ctx.session?.get(this.#impersonatorKey));
+        const session = ctx.session;
+        if (!session)
+            return false;
+        const parked = readParked(session.get(this.#impersonatorKey));
+        if (!parked)
+            return false;
+        const live = session.get(this.config.sessionKey);
+        return live?.impersonationBinding === parked.binding;
+    }
+    /**
+     * Encerra a sessão do AuthKit: remove o token set E qualquer credencial de
+     * impersonação parqueada. Todo caminho da lib que derruba a sessão passa por aqui
+     * — logout RP-initiated (`registerOidcClient`) e revogação back-channel.
+     *
+     * Existe porque um `session.forget(sessionKey)` solto deixava o refresh token do
+     * ATOR parqueado no browser depois de uma revogação central — o mecanismo que o
+     * operador usa justamente para matar a sessão.
+     */
+    endSession(ctx) {
+        const session = ctx.session;
+        if (!session)
+            return;
+        session.forget(this.config.sessionKey);
+        session.forget(this.#impersonatorKey);
+    }
+    /**
+     * Instala o token set de um login recém-concluído, descartando o que sobrou da
+     * sessão anterior no mesmo cookie jar.
+     *
+     * O `stopImpersonating` já recusa uma credencial órfã — o token set novo nasce sem
+     * `impersonationBinding`, então o vínculo não fecha. Mas recusar é só não DEVOLVER:
+     * sem esta limpeza o refresh token do ator continua serializado no cookie de sessão
+     * de outra identidade até a sessão expirar. Não devolver e não guardar são coisas
+     * diferentes, e a segunda é a que mantém a invariante — a credencial parqueada nunca
+     * sobrevive à sessão que a parqueou.
+     */
+    startSession(ctx, tokenSet) {
+        const session = ctx.session;
+        if (!session)
+            return;
+        session.forget(this.#impersonatorKey);
+        session.put(this.config.sessionKey, tokenSet);
     }
     async createAuthenticator(ctx) {
         const resolver = await this.#getResolver();

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

@@ -0,0 +1,52 @@
+import type { HttpContext } from '@adonisjs/core/http';
+export interface DashboardGuardOptions {
+    /** Global role required to pass the gate. Default `'ADMIN'`. */
+    role?: string;
+}
+/**
+ * Core predicate behind {@link authkitDashboardAuthorize} and
+ * {@link authkitDashboardMiddleware}: authenticated (a resolvable authkit `Identity`) AND holding
+ * the configured global role — `ctx.auth.hasGlobalRole('ADMIN')`, the pattern hosts already
+ * hand-roll per embedded admin dashboard (durable/media/agent/telescope).
+ *
+ * Resolves the session via {@link getAuthkit} rather than reading `ctx.auth` directly: `ctx.auth`'s
+ * TYPE is host-owned (each app augments `HttpContext.auth` for its own user model, or leaves it to
+ * `@adonisjs/auth`'s guard), so this module — shipped from the library, with no visibility into
+ * that augmentation — can't assume its shape. `getAuthkit` is the one session-resolution path that
+ * works either way (legacy `authkit_middleware`'s `ctx.auth` or the newer `authkitClientGuard`'s
+ * `ctx.authkit`), memoizing so a second call in the same request is free.
+ */
+export declare function isAuthkitAdmin(ctx: HttpContext, options?: DashboardGuardOptions): Promise<boolean>;
+/**
+ * Adapter for the `authorize: (ctx) => boolean` shape that `@adonis-agora/durable`,
+ * `@adonis-agora/agent` and `@adonis-agora/telescope` dashboard configs expect. A `false` return
+ * makes the provider reply `403 { error: 'forbidden' }` — the provider's own behavior, unchanged
+ * here.
+ *
+ * ```ts
+ * // config/durable_dashboard.ts
+ * import { defineConfig } from '@adonis-agora/durable/dashboard'
+ * import { authkitDashboardAuthorize } from '@adonis-agora/authkit-client'
+ *
+ * export default defineConfig({
+ *   authorize: authkitDashboardAuthorize(),
+ * })
+ * ```
+ */
+export declare function authkitDashboardAuthorize(options?: DashboardGuardOptions): (ctx: HttpContext) => Promise<boolean>;
+/**
+ * Adapter for the `middleware: (ctx, next) => Promise<void>` shape that
+ * `@adonis-agora/media`'s dashboard config expects. Mirrors the hand-rolled `requireAdmin` apps
+ * wrote themselves: no session -> `401`; session without the role -> `403`; otherwise `next()`.
+ *
+ * ```ts
+ * // config/media_dashboard.ts
+ * import { defineConfig } from '@adonis-agora/media/dashboard'
+ * import { authkitDashboardMiddleware } from '@adonis-agora/authkit-client'
+ *
+ * export default defineConfig({
+ *   middleware: authkitDashboardMiddleware(),
+ * })
+ * ```
+ */
+export declare function authkitDashboardMiddleware(options?: DashboardGuardOptions): (ctx: HttpContext, next: () => Promise<void>) => Promise<void>;

package/build/src/host/dashboard_guard.js

@@ -0,0 +1,72 @@
+import { getAuthkit } from './request_authenticator.js';
+/** Global role that counts as "admin" when the caller doesn't override it. Mirrors the default
+ *  used across `@adonis-agora/authkit-server`'s own admin console (`admin.roles`, `adminRoles` on
+ *  impersonation/token-exchange) — same convention, not a new one. */
+const DEFAULT_ADMIN_ROLE = 'ADMIN';
+/**
+ * Core predicate behind {@link authkitDashboardAuthorize} and
+ * {@link authkitDashboardMiddleware}: authenticated (a resolvable authkit `Identity`) AND holding
+ * the configured global role — `ctx.auth.hasGlobalRole('ADMIN')`, the pattern hosts already
+ * hand-roll per embedded admin dashboard (durable/media/agent/telescope).
+ *
+ * Resolves the session via {@link getAuthkit} rather than reading `ctx.auth` directly: `ctx.auth`'s
+ * TYPE is host-owned (each app augments `HttpContext.auth` for its own user model, or leaves it to
+ * `@adonisjs/auth`'s guard), so this module — shipped from the library, with no visibility into
+ * that augmentation — can't assume its shape. `getAuthkit` is the one session-resolution path that
+ * works either way (legacy `authkit_middleware`'s `ctx.auth` or the newer `authkitClientGuard`'s
+ * `ctx.authkit`), memoizing so a second call in the same request is free.
+ */
+export async function isAuthkitAdmin(ctx, options = {}) {
+    const authkit = await getAuthkit(ctx);
+    if (!(await authkit.check()))
+        return false;
+    return authkit.hasGlobalRole(options.role ?? DEFAULT_ADMIN_ROLE);
+}
+/**
+ * Adapter for the `authorize: (ctx) => boolean` shape that `@adonis-agora/durable`,
+ * `@adonis-agora/agent` and `@adonis-agora/telescope` dashboard configs expect. A `false` return
+ * makes the provider reply `403 { error: 'forbidden' }` — the provider's own behavior, unchanged
+ * here.
+ *
+ * ```ts
+ * // config/durable_dashboard.ts
+ * import { defineConfig } from '@adonis-agora/durable/dashboard'
+ * import { authkitDashboardAuthorize } from '@adonis-agora/authkit-client'
+ *
+ * export default defineConfig({
+ *   authorize: authkitDashboardAuthorize(),
+ * })
+ * ```
+ */
+export function authkitDashboardAuthorize(options = {}) {
+    return (ctx) => isAuthkitAdmin(ctx, options);
+}
+/**
+ * Adapter for the `middleware: (ctx, next) => Promise<void>` shape that
+ * `@adonis-agora/media`'s dashboard config expects. Mirrors the hand-rolled `requireAdmin` apps
+ * wrote themselves: no session -> `401`; session without the role -> `403`; otherwise `next()`.
+ *
+ * ```ts
+ * // config/media_dashboard.ts
+ * import { defineConfig } from '@adonis-agora/media/dashboard'
+ * import { authkitDashboardMiddleware } from '@adonis-agora/authkit-client'
+ *
+ * export default defineConfig({
+ *   middleware: authkitDashboardMiddleware(),
+ * })
+ * ```
+ */
+export function authkitDashboardMiddleware(options = {}) {
+    return async (ctx, next) => {
+        const authkit = await getAuthkit(ctx);
+        if (!(await authkit.check())) {
+            ctx.response.unauthorized({ message: 'Authentication required' });
+            return;
+        }
+        if (!authkit.hasGlobalRole(options.role ?? DEFAULT_ADMIN_ROLE)) {
+            ctx.response.forbidden({ message: 'Admin access required' });
+            return;
+        }
+        await next();
+    };
+}

package/build/src/middleware/backchannel_revocation_middleware.js

@@ -17,7 +17,6 @@ export default class BackchannelRevocationMiddleware {
         const store = manager.clientConfig.backchannelStore;
         if (!store)
             return next();
-        const sessionKey = manager.clientConfig.sessionKey;
         const idToken = manager.getIdToken(ctx);
         if (idToken) {
             const claims = decodeJwtPayload(idToken);
@@ -25,8 +24,9 @@ export default class BackchannelRevocationMiddleware {
             const sub = typeof claims?.sub === 'string' ? claims.sub : undefined;
             const authTime = typeof claims?.iat === 'number' ? claims.iat : undefined;
             if ((sid || sub) && (await store.isRevoked({ sid, sub, authTime }))) {
-                // session é augmentado por @adonisjs/session no app host; na lib usamos cast.
-                ctx.session?.forget(sessionKey);
+                // endSession, não `forget(sessionKey)`: uma revogação central não pode deixar
+                // a credencial de impersonação (refresh token do ATOR) parqueada no browser.
+                manager.endSession(ctx);
             }
         }
         return next();

package/build/src/register_oidc_client.js

@@ -63,7 +63,9 @@ export function registerOidcClient(router, options = {}) {
             code,
             codeVerifier: pkce.verifier,
         });
-        ctx.session?.put(cfg.sessionKey, tokenSet);
+        // startSession, não `put(sessionKey)`: um login novo no mesmo cookie jar não pode
+        // herdar a credencial de impersonação parqueada pela sessão anterior.
+        manager.startSession(ctx, tokenSet);
         ctx.session?.forget(pkceKey);
         const authenticator = await manager.createAuthenticator(ctx);
         const identity = await authenticator.getIdentity();
@@ -81,7 +83,9 @@ export function registerOidcClient(router, options = {}) {
         const manager = await ctx.containerResolver.make('authkit.client');
         const cfg = manager.clientConfig;
         const idToken = manager.getIdToken(ctx);
-        ctx.session?.forget(cfg.sessionKey);
+        // Leva junto a credencial de impersonação parqueada — era este logout que a
+        // deixava para trás, viva, para a próxima identidade do mesmo cookie jar.
+        manager.endSession(ctx);
         const postLogoutRedirectUri = typeof options.postLogoutRedirect === 'function'
             ? options.postLogoutRedirect(ctx)
             : (options.postLogoutRedirect ?? `${new URL(cfg.redirectUri).origin}/`);

package/build/src/types.d.ts

@@ -3,4 +3,13 @@ export interface TokenSet {
     accessToken: string;
     refreshToken?: string;
     expiresAt?: number;
+    /**
+     * Nonce opaco que amarra ESTE token set à credencial de impersonação parqueada
+     * em `${sessionKey}_impersonator`. Escrito só por `impersonate()`; preservado
+     * pelo `maybeRefresh`; conferido pelo `stopImpersonating()`. Qualquer outra
+     * escrita no slot da sessão (login novo, logout+login) nasce sem ele — que é
+     * exatamente o sinal de que a sessão deixou de ser aquela p/ a qual a
+     * credencial foi guardada. Não é segredo de autenticação: é um vínculo.
+     */
+    impersonationBinding?: string;
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@adonis-agora/authkit-client",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "AdonisJS OIDC/OAuth2 relying-party (client) toolkit: session-based authentication against an OpenID Connect identity provider, with JWT/PAT user resolvers and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",
   "homepage": "https://github.com/DavideCarvalho/adonis-authkit/tree/main/packages/authkit-client#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/DavideCarvalho/adonis-authkit.git",
+    "url": "https://github.com/DavideCarvalho/adonis-agora-authkit.git",
     "directory": "packages/authkit-client"
   },
   "bugs": {
@@ -39,6 +39,7 @@
     "./services/main": "./build/services/main.js",
     "./authkit_client_provider": "./build/providers/authkit_client_provider.js",
     "./auth": "./build/src/host/authkit_client_guard.js",
+    "./dashboard_guard": "./build/src/host/dashboard_guard.js",
     "./authkit_middleware": "./build/src/middleware/authkit_middleware.js",
     "./authkit_context_middleware": "./build/src/middleware/authkit_context_middleware.js",
     "./backchannel_revocation_middleware": "./build/src/middleware/backchannel_revocation_middleware.js",
@@ -74,23 +75,23 @@
     }
   },
   "dependencies": {
-    "jose": "^5.9.0",
+    "jose": "5.10.0",
     "@adonis-agora/authkit-core": "0.7.0"
   },
   "devDependencies": {
     "@adonisjs/auth": "10.1.0",
-    "@adonisjs/core": "7.3.5",
-    "@adonis-agora/resilience": "^0.1.0",
+    "@adonisjs/core": "7.4.0",
+    "@adonis-agora/resilience": "0.3.1",
     "@adonisjs/session": "8.1.0",
     "@adonisjs/lucid": "22.4.2",
     "@adonisjs/tsconfig": "2.0.0",
     "@japa/assert": "4.2.0",
     "@japa/runner": "5.3.0",
     "@poppinss/ts-exec": "1.4.4",
-    "ioredis-mock": "^8.9.0",
+    "ioredis-mock": "8.13.1",
     "@types/node": "25.9.1",
     "typescript": "6.0.3",
-    "@adonis-agora/authkit-server": "0.55.0"
+    "@adonis-agora/authkit-server": "0.56.0"
   },
   "scripts": {
     "build": "tsc && node -e \"require('node:fs').cpSync('stubs','build/stubs',{recursive:true,filter:(s)=>!s.endsWith('.ts')})\"",