@adonis-agora/authkit-server 1.0.0-rc.0 → 1.0.0-rc.10

package/build/src/agents/poppy/session_jwt.d.ts

@@ -1,30 +0,0 @@
-import type { PoppyClient } from './client_registry.js';
-export declare const SESSION_JWT_TYP = "poppy-session+jwt";
-export declare const DELEGATION_TYP = "pap-delegation+jwt";
-export declare class SessionJwtError extends Error {
-}
-export interface VerifiedSessionJwt {
-    clientId: string;
-    sid: string;
-    userId: string;
-    agentId: string | null;
-    jti: string;
-    iat: number;
-}
-export interface VerifySessionJwtInput {
-    /** Valor do(s) header(s) `Poppy-Session`. */
-    header: string | string[] | undefined;
-    method: string;
-    url: string;
-    /** Access token da request, ou `null`. */
-    accessToken: string | null;
-    /** O identificador da empresa: o issuer (§3.2). */
-    audience: string;
-    /** Janela de aceitação do `iat`, em segundos. */
-    maxAge: number;
-    /** Resolve o agente pelo `iss` (client metadata + `jwks_uri`). */
-    resolveClient: (clientId: unknown) => Promise<PoppyClient>;
-    now: Date;
-}
-/** Verifica o JWT (§5.3, passos 1–3). Lança {@link SessionJwtError}. */
-export declare function verifySessionJwt(input: VerifySessionJwtInput): Promise<VerifiedSessionJwt>;

package/build/src/agents/poppy/session_jwt.js

@@ -1,133 +0,0 @@
-/**
- * O header `Poppy-Session` (Draft 0.3, §5.2–§5.3): um JWT que o personal agent assina para uma
- * request, com uma chave delegada. Uma chave do `jwks_uri` assina a delegação
- * (`pap-delegation+jwt`), que vai no header `pap_dlg` do JWT e atesta a chave delegada em `cnf.jwk`.
- *
- * Só as checagens do JWT em si: o `client_id` do token, a Session e o replay ficam no `PoppyService`.
- */
-import { calculateJwkThumbprint, decodeJwt, decodeProtectedHeader, importJWK, jwtVerify, } from 'jose';
-import { accessTokenHash, normalizeHtu } from './dpop.js';
-export const SESSION_JWT_TYP = 'poppy-session+jwt';
-export const DELEGATION_TYP = 'pap-delegation+jwt';
-/** Delegação: `ES256` obrigatório; `PS384` permite a assinatura cega (§5.2, §10.7). */
-const DELEGATION_ALGS = ['ES256', 'PS384'];
-const DELEGATION_MAX_LIFETIME_S = 24 * 3600;
-const CLOCK_SKEW_S = 5;
-/** Mesmos caracteres dos Conversation IDs (§8.2). */
-const SESSION_ID = /^[A-Za-z0-9_-]{1,256}$/;
-/** Tamanho da coluna `user_id`/`agent_id`. */
-const MAX_ID_LENGTH = 255;
-export class SessionJwtError extends Error {
-}
-const fail = (why) => new SessionJwtError(why);
-/** Passos 1–4 de "Delegated keys" (§5.2): devolve a chave delegada, já conferida. */
-async function verifyDelegation(delegation, client, now) {
-    if (typeof delegation !== 'string' || !delegation)
-        throw fail('pap_dlg is required');
-    let payload;
-    try {
-        ({ payload } = await jwtVerify(delegation, client.keys, {
-            algorithms: DELEGATION_ALGS,
-            typ: DELEGATION_TYP,
-            issuer: client.clientId,
-            currentDate: now,
-            clockTolerance: CLOCK_SKEW_S,
-            requiredClaims: ['iat', 'exp', 'jti'],
-        }));
-    }
-    catch {
-        throw fail('delegation verification failed');
-    }
-    if (payload.exp - payload.iat > DELEGATION_MAX_LIFETIME_S) {
-        throw fail('delegation lasts more than 24 hours');
-    }
-    const jwk = payload.cnf?.jwk;
-    if (!jwk || jwk.kty !== 'EC' || jwk.crv !== 'P-256' || 'd' in jwk) {
-        throw fail('cnf.jwk must be a public P-256 key');
-    }
-    return { jwk: jwk, exp: payload.exp };
-}
-/** Verifica o JWT (§5.3, passos 1–3). Lança {@link SessionJwtError}. */
-export async function verifySessionJwt(input) {
-    const token = input.header;
-    if (typeof token !== 'string' || !token)
-        throw fail('exactly one Poppy-Session header required');
-    let header;
-    let iss;
-    try {
-        header = decodeProtectedHeader(token);
-        iss = decodeJwt(token).iss;
-    }
-    catch {
-        throw fail('malformed Session JWT');
-    }
-    if (header.typ !== SESSION_JWT_TYP)
-        throw fail(`typ must be ${SESSION_JWT_TYP}`);
-    if (header.alg !== 'ES256')
-        throw fail('alg must be ES256');
-    let client;
-    try {
-        client = await input.resolveClient(iss);
-    }
-    catch {
-        throw fail('the client_id was refused');
-    }
-    const delegation = await verifyDelegation(header.pap_dlg, client, input.now);
-    if (header.kid !== (await calculateJwkThumbprint(delegation.jwk, 'sha256'))) {
-        throw fail('kid must be the thumbprint of the delegated key');
-    }
-    let claims;
-    try {
-        const key = await importJWK(delegation.jwk, 'ES256');
-        ({ payload: claims } = await jwtVerify(token, key, {
-            algorithms: ['ES256'],
-            typ: SESSION_JWT_TYP,
-            issuer: client.clientId,
-            currentDate: input.now,
-        }));
-    }
-    catch {
-        throw fail('Session JWT signature verification failed');
-    }
-    if (typeof claims.aud !== 'string' || claims.aud !== input.audience) {
-        throw fail('aud must be the Company identifier, as a single string');
-    }
-    if (claims.htm !== input.method.toUpperCase())
-        throw fail('htm does not match the request');
-    const htu = typeof claims.htu === 'string' ? normalizeHtu(claims.htu) : null;
-    if (htu === null || htu !== normalizeHtu(input.url))
-        throw fail('htu does not match the request');
-    const nowS = Math.floor(input.now.getTime() / 1000);
-    if (typeof claims.iat !== 'number' || Math.abs(nowS - claims.iat) > input.maxAge) {
-        throw fail('iat is outside the acceptance window');
-    }
-    if (claims.iat > delegation.exp)
-        throw fail('signed after the delegation expired');
-    if (typeof claims.jti !== 'string' || !claims.jti)
-        throw fail('jti is required');
-    if (typeof claims.sid !== 'string' || !SESSION_ID.test(claims.sid))
-        throw fail('invalid sid');
-    if (typeof claims.sub !== 'string' || !claims.sub || claims.sub.length > MAX_ID_LENGTH) {
-        throw fail('sub (the User ID) is required');
-    }
-    const agentId = claims.agent_id;
-    if (agentId !== undefined &&
-        (typeof agentId !== 'string' || !agentId || agentId.length > MAX_ID_LENGTH)) {
-        throw fail('invalid agent_id');
-    }
-    if (input.accessToken === null) {
-        if (claims.ath !== undefined)
-            throw fail('ath must be absent without an access token');
-    }
-    else if (claims.ath !== accessTokenHash(input.accessToken)) {
-        throw fail('ath does not match the access token');
-    }
-    return {
-        clientId: client.clientId,
-        sid: claims.sid,
-        userId: claims.sub,
-        agentId: agentId ?? null,
-        jti: claims.jti,
-        iat: claims.iat,
-    };
-}

package/build/src/agents/poppy/store.d.ts

@@ -1,106 +0,0 @@
-/**
- * Persistência do Poppy — tabelas LIB-OWNED (ver `schema/ensure.ts`): Sessions, access tokens (só o
- * hash), pedidos de sign-in e de entrada de navegador, e `jti` vistos. Os refresh tokens
- * reaproveitam `auth_agent_grants` + `auth_agent_refresh_tokens` (ver `DelegationStore`).
- *
- * Mesmas regras do `DelegationStore`: query builder puro, datas comparadas em JS
- * depois de buscar a linha pela chave, transições de estado atômicas por
- * `where status = from`.
- */
-export declare const SESSION_TABLE = "auth_poppy_sessions";
-export declare const TOKEN_TABLE = "auth_poppy_tokens";
-export declare const REQUEST_TABLE = "auth_poppy_requests";
-export interface SessionRow {
-    /** Derivado de `client_id` + `sid` (§5.3). */
-    id: string;
-    clientId: string;
-    userId: string;
-    agentId: string | null;
-    /** Conta que a Session já usou: recusamos outra com `invalid_session` (§5.4). */
-    accountId: string | null;
-    /** Colunas da Draft 0.1, sem uso: o acesso à conta não passa pela Session. */
-    grantId: string | null;
-    scope: string;
-    expiresAt: Date;
-    endedAt: Date | null;
-    createdAt: Date;
-    updatedAt: Date;
-}
-/** Access token (§4.5). */
-export interface TokenRow {
-    tokenHash: string;
-    clientId: string;
-    accountId: string | null;
-    grantId: string | null;
-    scope: string;
-    resource: string | null;
-    /** Thumbprint da chave DPoP; `null` = Bearer. */
-    jkt: string | null;
-    expiresAt: Date;
-    createdAt: Date;
-}
-export type RequestKind = 'authorize' | 'device' | 'mediated' | 'browser';
-export type RequestStatus = 'pending' | 'approved' | 'denied' | 'consumed' | 'failed';
-export interface RequestRow {
-    id: string;
-    kind: RequestKind;
-    /** Hash do código de autorização / device code. */
-    codeHash: string | null;
-    userCode: string | null;
-    clientId: string;
-    sessionId: string | null;
-    accountId: string | null;
-    requestedScope: string;
-    grantedScope: string | null;
-    redirectUri: string | null;
-    codeChallenge: string | null;
-    status: RequestStatus;
-    attempts: number;
-    intervalSeconds: number | null;
-    lastPolledAt: Date | null;
-    data: Record<string, unknown> | null;
-    expiresAt: Date;
-    createdAt: Date;
-}
-export declare class PoppyStore {
-    private conn;
-    constructor(conn: () => any);
-    insertSession(row: Omit<SessionRow, 'endedAt'>): Promise<void>;
-    findSession(id: string): Promise<SessionRow | null>;
-    /** Estende a vida da Session (uso). */
-    touchSession(id: string, expiresAt: Date, at: Date): Promise<void>;
-    /**
-     * Registra a conta que a Session usa (§5.4). Atômico: só se nenhuma foi registrada ou é a MESMA.
-     * `false` = outra conta chegou nesse meio-tempo.
-     */
-    bindSessionAccount(id: string, accountId: string, at: Date): Promise<boolean>;
-    /** Encerra todas as Sessions de um agente (bloqueio no console): param na hora. */
-    endSessionsOfClient(clientId: string, at: Date): Promise<number>;
-    insertToken(row: TokenRow): Promise<void>;
-    findToken(hash: string): Promise<TokenRow | null>;
-    deleteToken(hash: string): Promise<boolean>;
-    deleteTokensExpiredBefore(before: Date): Promise<void>;
-    insertRequest(row: Omit<RequestRow, 'attempts' | 'lastPolledAt' | 'grantedScope'> & {
-        grantedScope?: string | null;
-    }): Promise<void>;
-    findRequest(id: string): Promise<RequestRow | null>;
-    findRequestByCodeHash(hash: string): Promise<RequestRow | null>;
-    findRequestByUserCode(userCode: string): Promise<RequestRow | null>;
-    /** Transição atômica — só se o pedido ainda está em `from`. */
-    transitionRequest(id: string, from: RequestStatus, patch: {
-        status: RequestStatus;
-        accountId?: string;
-        grantedScope?: string;
-        codeHash?: string;
-        attempts?: number;
-        expiresAt?: Date;
-        clientId?: string;
-        sessionId?: string;
-        data?: Record<string, unknown>;
-    }): Promise<boolean>;
-    /** Conta uma tentativa errada (atômico sobre o valor lido). */
-    bumpAttempts(id: string, from: number): Promise<boolean>;
-    setRequestData(id: string, data: Record<string, unknown>): Promise<void>;
-    markPolled(id: string, at: Date): Promise<void>;
-    deleteRequestsExpiredBefore(before: Date): Promise<void>;
-}

package/build/src/agents/poppy/store.js

@@ -1,261 +0,0 @@
-/**
- * Persistência do Poppy — tabelas LIB-OWNED (ver `schema/ensure.ts`): Sessions, access tokens (só o
- * hash), pedidos de sign-in e de entrada de navegador, e `jti` vistos. Os refresh tokens
- * reaproveitam `auth_agent_grants` + `auth_agent_refresh_tokens` (ver `DelegationStore`).
- *
- * Mesmas regras do `DelegationStore`: query builder puro, datas comparadas em JS
- * depois de buscar a linha pela chave, transições de estado atômicas por
- * `where status = from`.
- */
-export const SESSION_TABLE = 'auth_poppy_sessions';
-export const TOKEN_TABLE = 'auth_poppy_tokens';
-export const REQUEST_TABLE = 'auth_poppy_requests';
-function toDate(value) {
-    if (value instanceof Date)
-        return value;
-    if (typeof value === 'number')
-        return new Date(value);
-    if (typeof value === 'string' && /^\d+$/.test(value))
-        return new Date(Number(value));
-    return new Date(String(value));
-}
-function toDateOrNull(value) {
-    return value === null || value === undefined ? null : toDate(value);
-}
-function affected(result) {
-    if (typeof result === 'number')
-        return result;
-    if (Array.isArray(result))
-        return result.length;
-    return 0;
-}
-function toSession(row) {
-    return {
-        id: row.id,
-        clientId: row.client_id,
-        userId: row.user_id,
-        agentId: row.agent_id ?? null,
-        accountId: row.account_id ?? null,
-        grantId: row.grant_id ?? null,
-        scope: row.scope ?? '',
-        expiresAt: toDate(row.expires_at),
-        endedAt: toDateOrNull(row.ended_at),
-        createdAt: toDate(row.created_at),
-        updatedAt: toDate(row.updated_at),
-    };
-}
-function toToken(row) {
-    return {
-        tokenHash: row.token_hash,
-        clientId: row.client_id,
-        accountId: row.account_id ?? null,
-        grantId: row.grant_id ?? null,
-        scope: row.scope ?? '',
-        resource: row.resource ?? null,
-        jkt: row.jkt ?? null,
-        expiresAt: toDate(row.expires_at),
-        createdAt: toDate(row.created_at),
-    };
-}
-function toRequest(row) {
-    let data = null;
-    if (row.data) {
-        try {
-            data = JSON.parse(row.data);
-        }
-        catch {
-            data = null;
-        }
-    }
-    return {
-        id: row.id,
-        kind: row.kind,
-        codeHash: row.code_hash ?? null,
-        userCode: row.user_code ?? null,
-        clientId: row.client_id,
-        sessionId: row.session_id ?? null,
-        accountId: row.account_id ?? null,
-        requestedScope: row.requested_scope ?? '',
-        grantedScope: row.granted_scope ?? null,
-        redirectUri: row.redirect_uri ?? null,
-        codeChallenge: row.code_challenge ?? null,
-        status: row.status,
-        attempts: Number(row.attempts ?? 0),
-        intervalSeconds: row.interval_seconds === null || row.interval_seconds === undefined
-            ? null
-            : Number(row.interval_seconds),
-        lastPolledAt: toDateOrNull(row.last_polled_at),
-        data,
-        expiresAt: toDate(row.expires_at),
-        createdAt: toDate(row.created_at),
-    };
-}
-export class PoppyStore {
-    conn;
-    constructor(conn) {
-        this.conn = conn;
-    }
-    // ─── sessions ─────────────────────────────────────────────────────────────
-    async insertSession(row) {
-        await this.conn().table(SESSION_TABLE).insert({
-            id: row.id,
-            client_id: row.clientId,
-            user_id: row.userId,
-            agent_id: row.agentId,
-            account_id: row.accountId,
-            grant_id: row.grantId,
-            scope: row.scope,
-            expires_at: row.expiresAt,
-            created_at: row.createdAt,
-            updated_at: row.updatedAt,
-        });
-    }
-    async findSession(id) {
-        if (typeof id !== 'string' || !id)
-            return null;
-        const row = await this.conn().from(SESSION_TABLE).where('id', id).first();
-        return row ? toSession(row) : null;
-    }
-    /** Estende a vida da Session (uso). */
-    async touchSession(id, expiresAt, at) {
-        await this.conn()
-            .from(SESSION_TABLE)
-            .where('id', id)
-            .whereNull('ended_at')
-            .update({ expires_at: expiresAt, updated_at: at });
-    }
-    /**
-     * Registra a conta que a Session usa (§5.4). Atômico: só se nenhuma foi registrada ou é a MESMA.
-     * `false` = outra conta chegou nesse meio-tempo.
-     */
-    async bindSessionAccount(id, accountId, at) {
-        const result = await this.conn()
-            .from(SESSION_TABLE)
-            .where('id', id)
-            .where((q) => q.whereNull('account_id').orWhere('account_id', accountId))
-            .update({ account_id: accountId, updated_at: at });
-        return affected(result) > 0;
-    }
-    /** Encerra todas as Sessions de um agente (bloqueio no console): param na hora. */
-    async endSessionsOfClient(clientId, at) {
-        const result = await this.conn()
-            .from(SESSION_TABLE)
-            .where('client_id', clientId)
-            .whereNull('ended_at')
-            .update({ ended_at: at, grant_id: null, scope: '', updated_at: at });
-        return affected(result);
-    }
-    // ─── access tokens ────────────────────────────────────────────────────────
-    async insertToken(row) {
-        await this.conn().table(TOKEN_TABLE).insert({
-            token_hash: row.tokenHash,
-            // `session_id`/`user_id` são NOT NULL desde a Draft 0.1 e o schema só é aditivo; o sign-in
-            // não conhece a Session nem o User ID (§4.4).
-            session_id: '',
-            client_id: row.clientId,
-            user_id: '',
-            account_id: row.accountId,
-            grant_id: row.grantId,
-            scope: row.scope,
-            resource: row.resource,
-            jkt: row.jkt,
-            expires_at: row.expiresAt,
-            created_at: row.createdAt,
-        });
-    }
-    async findToken(hash) {
-        const row = await this.conn().from(TOKEN_TABLE).where('token_hash', hash).first();
-        return row ? toToken(row) : null;
-    }
-    async deleteToken(hash) {
-        return affected(await this.conn().from(TOKEN_TABLE).where('token_hash', hash).delete()) > 0;
-    }
-    async deleteTokensExpiredBefore(before) {
-        await this.conn().from(TOKEN_TABLE).where('expires_at', '<', before).delete();
-    }
-    // ─── sign-in requests ─────────────────────────────────────────────────────
-    async insertRequest(row) {
-        await this.conn()
-            .table(REQUEST_TABLE)
-            .insert({
-            id: row.id,
-            kind: row.kind,
-            code_hash: row.codeHash,
-            user_code: row.userCode,
-            client_id: row.clientId,
-            session_id: row.sessionId,
-            account_id: row.accountId,
-            requested_scope: row.requestedScope,
-            granted_scope: row.grantedScope ?? null,
-            redirect_uri: row.redirectUri,
-            code_challenge: row.codeChallenge,
-            status: row.status,
-            attempts: 0,
-            interval_seconds: row.intervalSeconds,
-            data: row.data ? JSON.stringify(row.data) : null,
-            expires_at: row.expiresAt,
-            created_at: row.createdAt,
-        });
-    }
-    async findRequest(id) {
-        if (typeof id !== 'string' || !id)
-            return null;
-        const row = await this.conn().from(REQUEST_TABLE).where('id', id).first();
-        return row ? toRequest(row) : null;
-    }
-    async findRequestByCodeHash(hash) {
-        const row = await this.conn().from(REQUEST_TABLE).where('code_hash', hash).first();
-        return row ? toRequest(row) : null;
-    }
-    async findRequestByUserCode(userCode) {
-        const row = await this.conn().from(REQUEST_TABLE).where('user_code', userCode).first();
-        return row ? toRequest(row) : null;
-    }
-    /** Transição atômica — só se o pedido ainda está em `from`. */
-    async transitionRequest(id, from, patch) {
-        const update = { status: patch.status };
-        if (patch.accountId !== undefined)
-            update.account_id = patch.accountId;
-        if (patch.grantedScope !== undefined)
-            update.granted_scope = patch.grantedScope;
-        if (patch.codeHash !== undefined)
-            update.code_hash = patch.codeHash;
-        if (patch.attempts !== undefined)
-            update.attempts = patch.attempts;
-        if (patch.expiresAt !== undefined)
-            update.expires_at = patch.expiresAt;
-        if (patch.clientId !== undefined)
-            update.client_id = patch.clientId;
-        if (patch.sessionId !== undefined)
-            update.session_id = patch.sessionId;
-        if (patch.data !== undefined)
-            update.data = JSON.stringify(patch.data);
-        const result = await this.conn()
-            .from(REQUEST_TABLE)
-            .where('id', id)
-            .where('status', from)
-            .update(update);
-        return affected(result) > 0;
-    }
-    /** Conta uma tentativa errada (atômico sobre o valor lido). */
-    async bumpAttempts(id, from) {
-        const result = await this.conn()
-            .from(REQUEST_TABLE)
-            .where('id', id)
-            .where('attempts', from)
-            .update({ attempts: from + 1 });
-        return affected(result) > 0;
-    }
-    async setRequestData(id, data) {
-        await this.conn()
-            .from(REQUEST_TABLE)
-            .where('id', id)
-            .update({ data: JSON.stringify(data) });
-    }
-    async markPolled(id, at) {
-        await this.conn().from(REQUEST_TABLE).where('id', id).update({ last_polled_at: at });
-    }
-    async deleteRequestsExpiredBefore(before) {
-        await this.conn().from(REQUEST_TABLE).where('expires_at', '<', before).delete();
-    }
-}

package/build/src/agents/poppy/web_session.d.ts

@@ -1,39 +0,0 @@
-/**
- * O cookie do site para o navegador de um personal agent (§6): a entrada na Session, e o
- * acompanhamento do acesso à conta autorizado nela a cada request.
- */
-import type { HttpContext } from '@adonisjs/core/http';
-import type { PoppyBrowserJoin, PoppySessionState } from './service.js';
-export interface PoppyWebSessionMarker {
-    sessionId: string;
-    clientId: string;
-    userId: string;
-    /** Conta, grant e scopes autorizados na entrada (§6, passo 2); `null` = entrada deslogada. */
-    accountId: string | null;
-    grantId: string | null;
-    scopes: string[];
-}
-/**
- * Liga o navegador à Session (§6, passo 3): regenera a sessão do app (session fixation) e a marca
- * como do agente. Uma entrada com access token faz o login na conta autorizada, no lugar de qualquer
- * outro, com o mecanismo do app — o hook `web.login`, ou a sessão de conta do authkit +
- * `adonisAuth.guard`. Uma entrada sem access token não mexe no login do navegador — a não ser que
- * uma entrada anterior o tenha logado: aí o sign-in dela termina aqui.
- */
-export declare function loginPoppyBrowser(httpCtx: HttpContext, result: PoppyBrowserJoin): Promise<void>;
-/**
- * Estado da Session Poppy deste navegador (preenchido por {@link poppyWebSession}).
- *
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — acompanha a spec em desenvolvimento e PODE MUDAR
- *   de forma incompatível fora de majors enquanto ela for draft.
- */
-export declare function poppyWebSessionOf(ctx: HttpContext): PoppySessionState | null;
-/**
- * Middleware do site: o cookie age pela conta e pelos scopes autorizados na entrada e deixa de agir
- * quando o sign-in termina (sign-out, agente desconectado); não sobrevive à Session (§6). Um login
- * antigo não volta. Coloque-o depois do middleware de sessão.
- *
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — acompanha a spec em desenvolvimento e PODE MUDAR
- *   de forma incompatível fora de majors enquanto ela for draft.
- */
-export declare function poppyWebSession(): (httpCtx: HttpContext, next: () => Promise<void>) => Promise<void>;