@toa.io/extensions.exposition 1.0.0-alpha.34 → 1.0.0-alpha.340

package/components/identity.basic/types/index.d.ts

@@ -0,0 +1,26 @@
+export * from './toa.d.ts'
+
+// What a manifest does not state belongs here, and every run keeps it.
+
+import type { Query, CodedError } from '@toa.io/core/types'
+import type { Component, Configuration } from './toa.d.ts'
+
+/** Credentials whose Identity is granted the `system` role. */
+export type Principal = NonNullable<Configuration['principal']>
+
+/** What this component is given: its own operations, and the ones it calls. */
+export interface Context {
+  local: Component
+  remote: {
+    identity: {
+      tokens: { revoke: (request: { query: Query }) => Promise<null | CodedError> }
+      keys: {
+        revoke: (request: { input: { identity: string } }) => Promise<null | CodedError>
+      }
+      roles: {
+        principal: (request: { input: { id: string } }) => Promise<null | CodedError>
+      }
+    }
+  }
+  configuration: Configuration
+}

package/components/identity.basic/types/toa.d.ts

@@ -0,0 +1,125 @@
+// Written by `toa types`. Every run rewrites it.
+// What a manifest does not state belongs in a file of your own.
+
+import type { CodedError, Query } from '@toa.io/core/types'
+import type { Secret } from '@toa.io/extensions.configuration'
+import type { FetchInit } from '@toa.io/extensions.fetch'
+import type { Logs, Metrics, Span } from '@toa.io/extensions.telemetry'
+import type { Readable } from 'node:stream'
+
+export interface Entity {
+  authority: string
+  username: string
+  password: string
+  id: string
+  VERSION: number
+  CREATED: number
+  UPDATED: number
+  DELETED: number | null
+  REGION: number
+}
+
+export type State = Entity & { DISCARD: boolean, TRAILERS: Record<string, unknown> }
+
+export type TransitInput = {
+  username?: string
+  password?: string
+  authority?: string
+  /** Whether the credentials are being created rather than changed */
+  inception?: boolean
+}
+
+export type TransitOutput = {
+  id: string
+}
+
+export type CreateInput = {
+  authority: string
+  username: string
+  password: string
+  /** Whether the credentials are being created rather than changed */
+  inception?: boolean
+}
+
+export type CreateOutput = {
+  id: string
+}
+
+export type AddInput = {
+  id: string
+  authority: string
+  username: string
+  password: string
+}
+
+export type InceptInput = {
+  authority: string
+  id: string
+  credentials: string
+}
+
+export type InceptOutput = {
+  id?: string
+}
+
+export type AuthenticateInput = {
+  authority: string
+  credentials: string
+}
+
+export type AuthenticateOutput = {
+  identity?: {
+    id?: string
+  }
+}
+
+export type CheckInput = {
+  username: string
+}
+
+export type CheckOutput = null
+
+export type InfoInput = {
+  authority: string
+  identity: string
+}
+
+export type InfoOutput = {
+  username: string
+} | null
+
+export type DeleteInput = {
+  authority: string
+  identity: string
+}
+
+export interface Component {
+  transit: (request: { input: TransitInput, query?: Query<Entity>, task?: boolean }) => Promise<TransitOutput | CodedError<"PRINCIPAL_LOCKED" | "INVALID_USERNAME" | "INVALID_PASSWORD" | "EXISTS">>
+  create: (request: { input: CreateInput, task?: boolean }) => Promise<CreateOutput | CodedError<"PRINCIPAL_LOCKED" | "INVALID_USERNAME" | "INVALID_PASSWORD" | "EXISTS">>
+  add: (request: { input: AddInput, entity?: Partial<Entity>, task?: boolean }) => Promise<{} | null | undefined | CodedError<"PRINCIPAL_LOCKED" | "INVALID_USERNAME" | "INVALID_PASSWORD" | "EXISTS">>
+  incept: (request: { input: InceptInput, entity?: Partial<Entity>, task?: boolean }) => Promise<InceptOutput | CodedError<"INVALID_CREDENTIALS">>
+  authenticate: (request: { input: AuthenticateInput, task?: boolean }) => Promise<AuthenticateOutput | CodedError<"NOT_FOUND" | "PASSWORD_MISMATCH">>
+  check: (request: { input: CheckInput, task?: boolean }) => Promise<CheckOutput>
+  info: (request: { input: InfoInput, task?: boolean }) => Promise<InfoOutput>
+  delete: (request: { input: DeleteInput, entity?: Partial<Entity>, task?: boolean }) => Promise<unknown>
+  assign: (request: { input?: null, query?: Query<Entity>, task?: boolean }) => Promise<Entity>
+  ensure: (request: { input?: null, query?: Query<Entity>, entity?: Partial<Entity>, task?: boolean }) => Promise<Entity>
+  enumerate: (request: { input?: null, query?: Query<Entity>, task?: boolean }) => Promise<Entity[]>
+  observe: (request: { input?: null, query?: Query<Entity>, task?: boolean }) => Promise<Entity | null>
+  stream: (request: { input?: null, query?: Query<Entity>, task?: boolean }) => Promise<Readable>
+  terminate: (request: { input?: null, query?: Query<Entity>, task?: boolean }) => Promise<Entity>
+}
+
+export interface Configuration {
+  /** bcrypt cost */
+  rounds: number
+  /** Hashing pepper, a secret */
+  pepper?: Secret
+  /** Basic credentials whose Identity is granted the `system` role */
+  principal?: {
+    authority: string
+    username: string
+  }
+  username: string[]
+  password: string[]
+}

package/components/identity.clients/manifest.toa.yaml

@@ -0,0 +1,239 @@
+namespace: identity
+name: clients
+
+# A registration is addressed by the hash of what it says, so the same metadata is the
+# same client however many times it arrives. `associated` is what lets a transition create
+# the record at an id decided outside the storage.
+entity:
+  associated: true
+  properties:
+    authority:
+      type: string
+    name:
+      description: client_name
+      type: string
+      maxLength: 128
+    uris:
+      description: redirect_uris
+      type: array
+      minItems: 1
+      maxItems: 8
+      items:
+        type: string
+        maxLength: 2048
+    uri:
+      description: client_uri
+      type: string
+      maxLength: 2048
+    logo:
+      description: logo_uri
+      type: string
+      maxLength: 2048
+    scope:
+      type: string
+      maxLength: 512
+    expires:
+      description: When a registration nothing has used is swept
+      type: number
+  required:
+    - authority
+    - uris
+
+operations:
+  transit:
+    concurrency: retry
+    input:
+      type: object
+      properties:
+        authority:
+          type: string
+        name:
+          type: string
+        uri:
+          type: string
+        logo:
+          type: string
+        scope:
+          type: string
+        uris:
+          type: array
+          items:
+            type: string
+        expires:
+          type: number
+      required:
+        - authority
+        - uris
+
+  register:
+    query: false
+    input:
+      type: object
+      properties:
+        authority:
+          type: string
+        client_name:
+          type: string
+          maxLength: 128
+        client_uri:
+          type: string
+          maxLength: 2048
+        logo_uri:
+          type: string
+          maxLength: 2048
+        redirect_uris:
+          type: array
+          minItems: 1
+          maxItems: 8
+          items:
+            type: string
+            maxLength: 2048
+        scope:
+          type: string
+          maxLength: 512
+        grant_types:
+          type: array
+          items:
+            type: string
+        response_types:
+          type: array
+          items:
+            type: string
+        token_endpoint_auth_method:
+          type: string
+      required:
+        - authority
+        - redirect_uris
+    # RFC 7591 §3.2.2 states a registration error as a body, not as a status of its own
+    output:
+      type: object
+      properties:
+        status:
+          description: Read and removed by `map:status`
+          type: number
+        client_id:
+          type: string
+        client_id_issued_at:
+          type: number
+        client_name:
+          type: string
+        client_uri:
+          type: string
+        logo_uri:
+          type: string
+        redirect_uris:
+          type: array
+          items:
+            type: string
+        grant_types:
+          type: array
+          items:
+            type: string
+        response_types:
+          type: array
+          items:
+            type: string
+        token_endpoint_auth_method:
+          type: string
+        error:
+          type: string
+        error_description:
+          type: string
+
+  describe:
+    query: false
+    input:
+      type: object
+      properties:
+        authority:
+          type: string
+        id:
+          description: client_id, which is an https URL when the client publishes its own metadata
+          type: string
+          maxLength: 2048
+        redirect:
+          description: Asked about together with the client, since only this component may answer it
+          type: string
+          maxLength: 2048
+      required:
+        - authority
+        - id
+    output:
+      type: object
+      properties:
+        client_id:
+          type: string
+        client_name:
+          type: string
+        client_uri:
+          type: string
+        logo_uri:
+          type: string
+        redirect_uris:
+          type: array
+          items:
+            type: string
+        permitted:
+          description: Whether `redirect` is one this client may receive a code at
+          type: boolean
+    errors:
+      - UNKNOWN_CLIENT
+
+configuration:
+  schema:
+    type: object
+    properties:
+      trust:
+        description: Origins whose Client ID Metadata Documents may be read; none are without one
+        type: array
+        items:
+          type: string
+          pattern: ^https://
+      lifetime:
+        description: Seconds a Client ID Metadata Document is held before it is read again
+        type: integer
+        minimum: 1
+      ttl:
+        description: Seconds a registration nothing has used is kept
+        type: integer
+        minimum: 1
+      size:
+        description: Bytes of a Client ID Metadata Document that are read
+        type: integer
+        minimum: 1
+      timeout:
+        description: Milliseconds a Client ID Metadata Document has to arrive
+        type: integer
+        minimum: 1
+  defaults:
+    trust: []
+    lifetime: 3600
+    ttl: 2592000
+    size: 16384
+    timeout: 3000
+
+stash: ~
+
+exposition:
+  isolated: true
+  /:
+    POST:
+      anonymous: true
+      map:authority: authority
+      io:input: [client_name, client_uri, logo_uri, redirect_uris, scope, grant_types, response_types, token_endpoint_auth_method]
+      io:output: true
+      io:throttle:
+        key: ip
+        requests: 10
+        interval: 3600
+      io:status: status
+      cache:exact: no-store
+      endpoint: register
+    /:id:
+      GET:
+        anyone: true
+        map:authority: authority
+        map:segments:
+          id: id
+        io:output: [client_id, client_name, client_uri, logo_uri, redirect_uris]
+        endpoint: describe

package/components/identity.clients/migrations/0002-indexes.yaml

@@ -0,0 +1,4 @@
+- index:
+    name: index_authority
+    keys:
+      authority: asc

package/components/identity.clients/operations/describe.js

@@ -0,0 +1,44 @@
+import { ERR_UNKNOWN_CLIENT, permits, read } from './lib/index.js';
+/**
+ * What a client is, whichever way it came to be known: a `client_id` that is an https URL
+ * publishes its own metadata, and anything else was registered here. The caller is not told
+ * which, and neither mechanism is visible past this operation.
+ *
+ * Whether a redirect is one the client may receive a code at is answered here too. The rule
+ * is this component's — nothing else knows a loopback port is ignored — and asking for it
+ * with the client saves a second call on the path a person is waiting on.
+ */
+export class Computation {
+    context;
+    mount(context) {
+        this.context = context;
+    }
+    async execute(input) {
+        const client = input.id.startsWith(HTTPS)
+            ? await read(input.id, this.context)
+            : await this.registered(input);
+        if (client instanceof Error)
+            return client;
+        return {
+            ...client,
+            ...(input.redirect === undefined
+                ? {}
+                : { permitted: permits(client.redirect_uris, input.redirect) })
+        };
+    }
+    async registered(input) {
+        const entity = await this.context.local.observe({ query: { id: input.id } });
+        // credentials are scoped to an authority, and so is what may act for them
+        if (entity === null || entity.authority !== input.authority)
+            return ERR_UNKNOWN_CLIENT;
+        return {
+            client_id: entity.id,
+            client_name: entity.name,
+            client_uri: entity.uri,
+            logo_uri: entity.logo,
+            redirect_uris: entity.uris
+        };
+    }
+}
+const HTTPS = 'https://';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzY3JpYmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zb3VyY2UvZGVzY3JpYmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQTtBQUtsRTs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sT0FBTyxXQUFXO0lBQ2QsT0FBTyxDQUFVO0lBRWxCLEtBQUssQ0FBQyxPQUFnQjtRQUMzQixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQTtJQUN4QixDQUFDO0lBRU0sS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFZO1FBQy9CLE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQztZQUN2QyxDQUFDLENBQUMsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDO1lBQ3BDLENBQUMsQ0FBQyxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUE7UUFFaEMsSUFBSSxNQUFNLFlBQVksS0FBSztZQUFFLE9BQU8sTUFBTSxDQUFBO1FBRTFDLE9BQU87WUFDTCxHQUFHLE1BQU07WUFDVCxHQUFHLENBQUMsS0FBSyxDQUFDLFFBQVEsS0FBSyxTQUFTO2dCQUM5QixDQUFDLENBQUMsRUFBRTtnQkFDSixDQUFDLENBQUMsRUFBRSxTQUFTLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxhQUFhLEVBQUUsS0FBSyxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7U0FDbEUsQ0FBQTtJQUNILENBQUM7SUFFTyxLQUFLLENBQUMsVUFBVSxDQUFDLEtBQVk7UUFDbkMsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsRUFBRSxLQUFLLEVBQUUsRUFBRSxFQUFFLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQTtRQUU1RSwwRUFBMEU7UUFDMUUsSUFBSSxNQUFNLEtBQUssSUFBSSxJQUFJLE1BQU0sQ0FBQyxTQUFTLEtBQUssS0FBSyxDQUFDLFNBQVM7WUFBRSxPQUFPLGtCQUFrQixDQUFBO1FBRXRGLE9BQU87WUFDTCxTQUFTLEVBQUUsTUFBTSxDQUFDLEVBQUU7WUFDcEIsV0FBVyxFQUFFLE1BQU0sQ0FBQyxJQUFJO1lBQ3hCLFVBQVUsRUFBRSxNQUFNLENBQUMsR0FBRztZQUN0QixRQUFRLEVBQUUsTUFBTSxDQUFDLElBQUk7WUFDckIsYUFBYSxFQUFFLE1BQU0sQ0FBQyxJQUFJO1NBQzNCLENBQUE7SUFDSCxDQUFDO0NBQ0Y7QUFFRCxNQUFNLEtBQUssR0FBRyxVQUFVLENBQUEifQ==

package/components/identity.clients/operations/lib/Context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NvdXJjZS9saWIvQ29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/components/identity.clients/operations/lib/Entity.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRW50aXR5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc291cmNlL2xpYi9FbnRpdHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/components/identity.clients/operations/lib/canonical.js

@@ -0,0 +1,24 @@
+import { createHash } from 'node:crypto';
+/**
+ * The id of a registration: a hash of what it says, so identical metadata is one client
+ * however many times it arrives. A client cannot remember that it registered here, and
+ * registers again on every fresh connection; without this the registry only grows.
+ *
+ * Only what is honoured is hashed. A field this component ignores would otherwise mint a
+ * client per release of whoever sends it, and the authority is in there because credentials
+ * are scoped to one.
+ */
+export function identify(authority, metadata) {
+    const canonical = JSON.stringify([
+        authority,
+        metadata.client_name ?? null,
+        metadata.client_uri ?? null,
+        metadata.logo_uri ?? null,
+        metadata.scope ?? null,
+        [...metadata.redirect_uris].sort()
+    ]);
+    return createHash('sha256').update(canonical).digest('hex').slice(0, LENGTH);
+}
+/** What the entity prototype accepts as an id. */
+const LENGTH = 32;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2Fub25pY2FsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc291cmNlL2xpYi9jYW5vbmljYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUd4Qzs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sVUFBVSxRQUFRLENBQUMsU0FBaUIsRUFBRSxRQUFrQjtJQUM1RCxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDO1FBQy9CLFNBQVM7UUFDVCxRQUFRLENBQUMsV0FBVyxJQUFJLElBQUk7UUFDNUIsUUFBUSxDQUFDLFVBQVUsSUFBSSxJQUFJO1FBQzNCLFFBQVEsQ0FBQyxRQUFRLElBQUksSUFBSTtRQUN6QixRQUFRLENBQUMsS0FBSyxJQUFJLElBQUk7UUFDdEIsQ0FBQyxHQUFHLFFBQVEsQ0FBQyxhQUFhLENBQUMsQ0FBQyxJQUFJLEVBQUU7S0FDbkMsQ0FBQyxDQUFBO0lBRUYsT0FBTyxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxDQUFBO0FBQzlFLENBQUM7QUFFRCxrREFBa0Q7QUFDbEQsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFBIn0=

package/components/identity.clients/operations/lib/cimd.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { ERR_UNKNOWN_CLIENT } from './errors.js';
+/**
+ * A Client ID Metadata Document: the client publishes what it is at an https URL, and that
+ * URL is its `client_id`. Control of the origin is what proves the identity, so nothing is
+ * registered and nothing is written — the document is read and held for a while.
+ */
+export async function read(id, context) {
+    // before anything is fetched: the id is the caller's to choose, and this runs inside
+    // the cluster. An origin the configuration does not name is not reached at all.
+    if (!trusted(id, context.configuration.trust))
+        return ERR_UNKNOWN_CLIENT;
+    const key = CACHE + createHash('sha256').update(id).digest('hex');
+    const cached = await context.stash.get(key);
+    if (cached !== null)
+        return cached === MISS ? ERR_UNKNOWN_CLIENT : JSON.parse(cached);
+    const client = await fetch(id, context);
+    // a document that does not answer is remembered too, or a bad id is fetched per request
+    await context.stash.set(key, client instanceof Error ? MISS : JSON.stringify(client), 'EX', context.configuration.lifetime);
+    return client;
+}
+/**
+ * An https URL whose origin the configuration names. Compared by origin so that a path on a
+ * trusted host cannot be escaped by one that merely starts the same way.
+ */
+function trusted(id, trust) {
+    let url;
+    try {
+        url = new URL(id);
+    }
+    catch {
+        return false;
+    }
+    if (url.protocol !== 'https:')
+        return false;
+    return trust.some((origin) => {
+        try {
+            return new URL(origin).origin === url.origin;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+async function fetch(id, context) {
+    const { size, timeout } = context.configuration;
+    try {
+        const response = await context.fetch(id, {
+            redirect: 'error', // a redirect leaves the origin that was trusted
+            signal: AbortSignal.timeout(timeout),
+            headers: { accept: 'application/json' }
+        });
+        if (!response.ok)
+            return ERR_UNKNOWN_CLIENT;
+        const text = await response.text();
+        if (text.length > size)
+            return ERR_UNKNOWN_CLIENT;
+        return validate(id, JSON.parse(text));
+    }
+    catch (error) {
+        context.logs.debug('Client metadata document is unreadable', {
+            client: id,
+            error: error?.toString?.()
+        });
+        return ERR_UNKNOWN_CLIENT;
+    }
+}
+function validate(id, metadata) {
+    // the document names itself, so one client's cannot claim another's identity
+    if (metadata.client_id !== id)
+        return ERR_UNKNOWN_CLIENT;
+    if (!Array.isArray(metadata.redirect_uris) ||
+        metadata.redirect_uris.length === 0 ||
+        metadata.redirect_uris.some((uri) => typeof uri !== 'string'))
+        return ERR_UNKNOWN_CLIENT;
+    return {
+        client_id: id,
+        client_name: metadata.client_name,
+        client_uri: metadata.client_uri,
+        logo_uri: metadata.logo_uri,
+        redirect_uris: metadata.redirect_uris
+    };
+}
+const CACHE = 'cimd:';
+/** Held in place of a document that could not be read, so a bad id is not refetched. */
+const MISS = '';
+//# sourceMappingURL=data:application/json;base64,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

package/components/identity.clients/operations/lib/errors.js

@@ -0,0 +1,2 @@
+export const ERR_UNKNOWN_CLIENT = new Error('UNKNOWN_CLIENT');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc291cmNlL2xpYi9lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxLQUFLLENBQUMsZ0JBQWdCLENBQUMsQ0FBQSJ9

package/components/identity.clients/operations/lib/index.js

@@ -0,0 +1,7 @@
+export * from './canonical.js';
+export * from './cimd.js';
+export * from './Context.js';
+export * from './Entity.js';
+export * from './errors.js';
+export * from './redirect.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zb3VyY2UvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUE7QUFDOUIsY0FBYyxXQUFXLENBQUE7QUFDekIsY0FBYyxjQUFjLENBQUE7QUFDNUIsY0FBYyxhQUFhLENBQUE7QUFDM0IsY0FBYyxhQUFhLENBQUE7QUFDM0IsY0FBYyxlQUFlLENBQUEifQ==

package/components/identity.clients/operations/lib/redirect.js

@@ -0,0 +1,35 @@
+/**
+ * Whether a client may receive a code at this address.
+ *
+ * Exact string comparison, which RFC 6749 §3.1.2.3 requires, except for a loopback
+ * address: a native client binds whatever port is free when it starts, so RFC 8252 §7.3
+ * has the port ignored there. Claude Code registers `http://localhost/callback` and
+ * `http://127.0.0.1/callback` and comes back on an ephemeral port; comparing those
+ * literally would refuse every one of them.
+ */
+export function permits(registered, redirect) {
+    return registered.some((uri) => uri === redirect || loopback(uri, redirect));
+}
+function loopback(registered, redirect) {
+    const a = parse(registered);
+    const b = parse(redirect);
+    if (a === null || b === null)
+        return false;
+    return (a.protocol === 'http:' &&
+        b.protocol === 'http:' &&
+        LOOPBACK.has(a.hostname) &&
+        a.hostname === b.hostname &&
+        a.pathname === b.pathname &&
+        a.search === b.search);
+}
+function parse(value) {
+    try {
+        return new URL(value);
+    }
+    catch {
+        return null;
+    }
+}
+/** `localhost` resolves through the host's own configuration, which RFC 8252 §8.3 warns of. */
+const LOOPBACK = new Set(['127.0.0.1', '[::1]', 'localhost']);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVkaXJlY3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zb3VyY2UvbGliL3JlZGlyZWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxVQUFVLE9BQU8sQ0FBQyxVQUFvQixFQUFFLFFBQWdCO0lBQzVELE9BQU8sVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsR0FBRyxLQUFLLFFBQVEsSUFBSSxRQUFRLENBQUMsR0FBRyxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBQUE7QUFDOUUsQ0FBQztBQUVELFNBQVMsUUFBUSxDQUFDLFVBQWtCLEVBQUUsUUFBZ0I7SUFDcEQsTUFBTSxDQUFDLEdBQUcsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFBO0lBQzNCLE1BQU0sQ0FBQyxHQUFHLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUV6QixJQUFJLENBQUMsS0FBSyxJQUFJLElBQUksQ0FBQyxLQUFLLElBQUk7UUFBRSxPQUFPLEtBQUssQ0FBQTtJQUUxQyxPQUFPLENBQ0wsQ0FBQyxDQUFDLFFBQVEsS0FBSyxPQUFPO1FBQ3RCLENBQUMsQ0FBQyxRQUFRLEtBQUssT0FBTztRQUN0QixRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUM7UUFDeEIsQ0FBQyxDQUFDLFFBQVEsS0FBSyxDQUFDLENBQUMsUUFBUTtRQUN6QixDQUFDLENBQUMsUUFBUSxLQUFLLENBQUMsQ0FBQyxRQUFRO1FBQ3pCLENBQUMsQ0FBQyxNQUFNLEtBQUssQ0FBQyxDQUFDLE1BQU0sQ0FDdEIsQ0FBQTtBQUNILENBQUM7QUFFRCxTQUFTLEtBQUssQ0FBQyxLQUFhO0lBQzFCLElBQUksQ0FBQztRQUNILE9BQU8sSUFBSSxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDdkIsQ0FBQztJQUFDLE1BQU0sQ0FBQztRQUNQLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztBQUNILENBQUM7QUFFRCwrRkFBK0Y7QUFDL0YsTUFBTSxRQUFRLEdBQUcsSUFBSSxHQUFHLENBQUMsQ0FBQyxXQUFXLEVBQUUsT0FBTyxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUEifQ==