diff --git a/.gitignore b/.gitignore index acc78571f..69a75d2cc 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,7 @@ node_modules !.env.example test-results/ playwright-report/ +.playwright-mcp/ vite.config.js.timestamp-* vite.config.ts.timestamp-* diff --git a/src/lib/helpers/oauth2-authorization-details.ts b/src/lib/helpers/oauth2-authorization-details.ts new file mode 100644 index 000000000..e18cb71ac --- /dev/null +++ b/src/lib/helpers/oauth2-authorization-details.ts @@ -0,0 +1,202 @@ +import { sdk } from '$lib/stores/sdk'; + +/** + * RFC 9396 Rich Authorization Requests (RAR) helpers for the OAuth2 consent + * screen. + * + * The console OAuth2 server keeps a small set of identity scopes on the + * standard `scope` parameter (`openid`, `profile`, `email`, `account.admin`) + * and moves every granular permission into `authorization_details` entries of + * type `appwrite_console`. The consent screen lets the user approve a *subset* + * of the requested actions; the approved set is sent back to the approve + * endpoint and replaces what the client originally requested. We only ever + * downscope — actions the client did not request are never offered. + */ + +/** The single RAR `type` the console OAuth2 server understands. */ +export const APPWRITE_CONSOLE_RAR_TYPE = 'appwrite_console'; + +/** Fields an `appwrite_console` entry may carry, besides `type`/`actions`. */ +const RESOURCE_FIELDS = ['projectIds', 'organizationIds', 'locations'] as const; + +export interface AuthorizationDetail { + type: string; + actions?: string[]; + projectIds?: string[]; + organizationIds?: string[]; + locations?: string[]; + [key: string]: unknown; +} + +export interface ActionDescriptor { + /** Scope id, e.g. `databases.write`. */ + action: string; + /** Human title derived from the scope id. */ + title: string; + /** Catalog description, or a generic fallback. */ + description: string; + /** Catalog category used for grouping, e.g. `Databases`. */ + category: string; + deprecated: boolean; +} + +export type ActionCatalog = Map>; + +/** + * Account-level scopes are not exposed by the project/organization scope + * endpoints, so we describe them locally. They are few and stable. + */ +const ACCOUNT_SCOPE_CATALOG: ActionCatalog = new Map([ + [ + 'account', + { + category: 'Account', + description: 'Manage your account, organizations, sessions, tokens, and billing.', + deprecated: false + } + ], + [ + 'teams.read', + { + category: 'Account', + description: "Read your account's organizations.", + deprecated: false + } + ], + [ + 'teams.write', + { + category: 'Account', + description: "Create, update, and delete your account's organizations and memberships.", + deprecated: false + } + ] +]); + +const UNCATEGORIZED = 'Other'; + +/** Parse the grant's `authorizationDetails` JSON string into entries. */ +export function parseAuthorizationDetails(raw: string | null | undefined): AuthorizationDetail[] { + if (!raw) return []; + try { + const parsed = JSON.parse(raw); + return Array.isArray(parsed) ? (parsed as AuthorizationDetail[]) : []; + } catch { + return []; + } +} + +export function isAppwriteConsoleDetail(detail: AuthorizationDetail): boolean { + return detail.type === APPWRITE_CONSOLE_RAR_TYPE; +} + +/** Distinct, requested actions for a single `appwrite_console` entry. */ +export function actionsOf(detail: AuthorizationDetail): string[] { + if (!Array.isArray(detail.actions)) return []; + const seen = new Set(); + const out: string[] = []; + for (const action of detail.actions) { + if (typeof action === 'string' && action !== '' && !seen.has(action)) { + seen.add(action); + out.push(action); + } + } + return out; +} + +/** Turn `databases.write` into `Databases write` for a readable title. */ +export function titleizeAction(action: string): string { + const cleaned = action.replace(/[._:-]+/g, ' ').trim(); + if (!cleaned) return action; + return cleaned.charAt(0).toUpperCase() + cleaned.slice(1); +} + +/** + * Build the action catalog from the live project + organization scope + * endpoints, falling back to the local account-scope map. The consent screen + * always runs for a signed-in console user, so these admin-scoped endpoints are + * available; if they fail we still describe actions via the fallback + titleize + * so the screen never breaks. + */ +export async function loadActionCatalog(): Promise { + const catalog: ActionCatalog = new Map(ACCOUNT_SCOPE_CATALOG); + + const results = await Promise.allSettled([ + sdk.forConsole.console.listProjectScopes(), + sdk.forConsole.console.listOrganizationScopes() + ]); + + for (const result of results) { + if (result.status !== 'fulfilled') continue; + for (const scope of result.value.scopes) { + // Project + organization scopes can overlap (e.g. `teams.read`); + // first writer wins, which keeps the project description. + if (!catalog.has(scope.$id)) { + catalog.set(scope.$id, { + category: scope.category || UNCATEGORIZED, + description: scope.description, + deprecated: scope.deprecated + }); + } + } + } + + return catalog; +} + +/** Resolve a single action to a descriptor, falling back to a titleized one. */ +export function describeAction(action: string, catalog: ActionCatalog): ActionDescriptor { + const entry = catalog.get(action); + return { + action, + title: titleizeAction(action), + description: entry?.description ?? `Access to ${action}.`, + category: entry?.category ?? UNCATEGORIZED, + deprecated: entry?.deprecated ?? false + }; +} + +/** + * Rebuild the `authorization_details` array from the user's selection, keyed by + * entry index. Only `appwrite_console` entries are filtered to the selected + * actions; entries that end up with no actions are dropped, and entries of + * other types pass through untouched. Returns a JSON string ready for the + * approve endpoint, or `'[]'` when nothing remains (an empty string would tell + * the server to keep the originally requested details, which is never what the + * consent screen wants). + */ +export function serializeGrantedDetails( + requested: AuthorizationDetail[], + selectedByIndex: Record> +): string { + const granted: AuthorizationDetail[] = []; + + requested.forEach((detail, index) => { + if (!isAppwriteConsoleDetail(detail)) { + granted.push(detail); + return; + } + + const requestedActions = actionsOf(detail); + const selected = selectedByIndex[index] ?? {}; + const keptActions = requestedActions.filter((action) => selected[action]); + + if (keptActions.length === 0) { + return; + } + + const rebuilt: AuthorizationDetail = { + type: APPWRITE_CONSOLE_RAR_TYPE, + actions: keptActions + }; + for (const field of RESOURCE_FIELDS) { + const value = detail[field]; + if (Array.isArray(value) && value.length > 0) { + rebuilt[field] = value as string[]; + } + } + granted.push(rebuilt); + }); + + return JSON.stringify(granted); +} diff --git a/src/routes/(public)/oauth2/consent-card.svelte b/src/routes/(public)/oauth2/consent-card.svelte index 1738a3d15..4e7aafcab 100644 --- a/src/routes/(public)/oauth2/consent-card.svelte +++ b/src/routes/(public)/oauth2/consent-card.svelte @@ -7,24 +7,19 @@ import { sdk } from '$lib/stores/sdk'; import { Submit, trackError, trackEvent } from '$lib/actions/analytics'; import { groupConsentScopes } from '$lib/helpers/oauth2-scopes'; + import { + actionsOf, + isAppwriteConsoleDetail, + loadActionCatalog, + parseAuthorizationDetails, + serializeGrantedDetails, + type ActionCatalog, + type AuthorizationDetail + } from '$lib/helpers/oauth2-authorization-details'; + import OAuth2ScopePicker from './oauth2-scope-picker.svelte'; export type OAuth2Flow = 'authorization' | 'device'; - interface AuthorizationDetail { - type: string; - [key: string]: unknown; - } - - function parseAuthorizationDetails(raw: string): AuthorizationDetail[] { - if (!raw) return []; - try { - const parsed = JSON.parse(raw); - return Array.isArray(parsed) ? (parsed as AuthorizationDetail[]) : []; - } catch { - return []; - } - } - function hostnameOf(uri: string): string | null { try { return new URL(uri).hostname; @@ -48,13 +43,85 @@ let rejecting = $state(false); let busy = $derived(approving || rejecting); + // Requested scopes (identity + account/console-tier) are shown read-only, + // grouped by resource. The granular per-project permissions live in + // authorization_details and are chosen individually below. const scopes = $derived(groupConsentScopes(grant.scopes ?? [])); - const details = $derived(parseAuthorizationDetails(grant.authorizationDetails ?? '')); + const details = $derived( + parseAuthorizationDetails(grant.authorizationDetails) + ); + const hasConsoleActions = $derived( + details.some((detail) => isAppwriteConsoleDetail(detail) && actionsOf(detail).length > 0) + ); const redirectHost = $derived(hostnameOf(grant.redirectUri)); const appInitial = $derived((app.name || '?').charAt(0).toUpperCase()); const accountInitial = $derived((accountLabel || '?').charAt(0).toUpperCase()); + // Lazily loaded scope metadata (category + descriptions) for grouping the + // requested actions. Never blocks approve/reject — the picker just shows a + // spinner until it resolves. + let catalog = $state(null); + $effect(() => { + if (!hasConsoleActions || catalog) return; + let cancelled = false; + void loadActionCatalog().then((loaded) => { + if (!cancelled) catalog = loaded; + }); + return () => { + cancelled = true; + }; + }); + + // Per-entry action selection: entryIndex -> { action -> granted }. Requested + // actions start selected (the user opts OUT of what they don't want). Reset + // whenever the grant changes so a stale selection can't leak across requests. + let selection = $state>>({}); + $effect(() => { + // Re-init keyed on the grant id + its requested details. + grant.$id; + const next: Record> = {}; + details.forEach((detail, index) => { + if (!isAppwriteConsoleDetail(detail)) return; + const actionMap: Record = {}; + for (const action of actionsOf(detail)) { + actionMap[action] = true; + } + next[index] = actionMap; + }); + selection = next; + }); + + /** A short, human context line for an entry's resource scoping. */ + function detailContext(detail: AuthorizationDetail): string | null { + const parts: string[] = []; + const projects = detail.projectIds?.length ?? 0; + const orgs = detail.organizationIds?.length ?? 0; + if (projects > 0) parts.push(`${projects} project${projects === 1 ? '' : 's'}`); + if (orgs > 0) parts.push(`${orgs} organization${orgs === 1 ? '' : 's'}`); + if (parts.length === 0) return null; + return `Limited to ${parts.join(' and ')}`; + } + + function locationHosts(detail: AuthorizationDetail): string[] { + return (detail.locations ?? []) + .map((location) => hostnameOf(location)) + .filter((host): host is string => Boolean(host)); + } + + // Approving is meaningless if the request offered actions but the user + // unchecked every one and granted no identity scope either. + const grantedActionCount = $derived( + Object.values(selection).reduce( + (total, actionMap) => + total + Object.values(actionMap).filter((isGranted) => isGranted).length, + 0 + ) + ); + const nothingToGrant = $derived( + hasConsoleActions && grantedActionCount === 0 && (grant.scopes ?? []).length === 0 + ); + async function approve() { if (busy) return; // Pin the request we're acting on. If the parent swaps in a different @@ -65,8 +132,16 @@ error = null; approving = true; try { + // When the request carries appwrite_console actions, send back the + // exact subset the user consented to (downscope-only — the picker + // never offers actions the client didn't request). Otherwise omit + // it and keep whatever the client originally requested. + const authorizationDetails = hasConsoleActions + ? serializeGrantedDetails(details, selection) + : undefined; const result = await sdk.forConsole.oauth2.approve({ - grantId + grantId, + authorizationDetails }); if (grant.$id !== grantId) return; trackEvent(Submit.AccountOAuth2ConsentApprove, { @@ -176,7 +251,7 @@ {#if scopes.groups.length > 0}
- +
    {#each scopes.groups as group (group.resource)}
  • @@ -197,15 +272,46 @@ {/if} {#if details.length > 0} - - - Also requested - -
    - {#each details as detail, i (`${detail.type}-${i}`)} - {detail.type} - {/each} -
    + + + Choose what to allow + + {app.name} requested these permissions. Grant only the ones you're comfortable + with — you can turn any of them off. + + + + {#each details as detail, index (`${detail.type}-${index}`)} + {#if isAppwriteConsoleDetail(detail) && actionsOf(detail).length > 0} + {@const context = detailContext(detail)} + {@const hosts = locationHosts(detail)} +
    + {#if context || hosts.length > 0} +
    + {#if context}{context}{/if} + {#if hosts.length > 0}{hosts.join(', ')}{/if} +
    + {/if} + {#if catalog} + + {:else} +
    + +
    + {/if} +
    + {:else} + +
    + {detail.type} +
    + {/if} + {/each}
    {/if} @@ -220,7 +326,7 @@
    - + + + + + + {#if actions.length > 6} + + {/if} + + {#if categories.length === 0} + + No permissions match “{search}”. + + {:else} + +
    + + + {#each categories as category, index (category)} + {@const inCategory = actionsInCategory(category)} + {@const activeCount = inCategory.filter((d) => selected[d.action]).length} + onCategoryChange(event, category)}> + + {#each inCategory as action (action.action)} + + + + + + + {/each} + + + {/each} + +
    + {/if} + + +