@toa.io/extensions.exposition 1.0.0-alpha.282 → 1.0.0-alpha.284

package/source/directives/mcp/Tool.test.ts

@@ -0,0 +1,66 @@
+import assert from 'node:assert'
+import { describe, it } from 'node:test'
+import { Tool } from './Tool.js'
+import { MCP } from './MCP.js'
+
+describe('mcp:tool', () => {
+  it('should take what the route states the tool is', () => {
+    assert.strictEqual(new Tool('The pots that are hot.', '/pots/hot').description,
+      'The pots that are hot.')
+  })
+
+  it('should not accept an empty description', () => {
+    assert.throws(() => new Tool('  ', '/pots'), /cannot be empty/)
+  })
+
+  it('should not accept a value that is not one', () => {
+    // `true` published a tool that stated nothing, back when an operation stated it instead
+    assert.throws(() => new Tool(true, '/pots'), /the value is what the tool is/)
+    assert.throws(() => new Tool(false, '/pots'), /the value is what the tool is/)
+    assert.throws(() => new Tool(1, '/pots'), /the value is what the tool is/)
+  })
+
+  it('should refuse a route no name can spell', () => {
+    assert.throws(() => new Tool('A pot.', '/pots/a.b'), /no tool name can spell/)
+    assert.throws(() => new Tool('A pot.', '/pots/:a.b'), /no tool name can spell/)
+
+    // an underscore is what the convention keeps for itself
+    assert.throws(() => new Tool('A pot.', '/pots/a_b'), /no tool name can spell/)
+  })
+
+  it('should name the route it refuses', () => {
+    assert.throws(() => new Tool('A pot.', '/pots/a.b'), /'\/pots\/a\.b'/)
+  })
+})
+
+describe('mcp:tool inheritance', () => {
+  const family = new MCP()
+
+  it('should take the nearest declaration', () => {
+    const own = new Tool('Nearest.', '/pots')
+    const inherited = new Tool('Furthest.', '/pots')
+
+    assert.strictEqual(MCP.published([own, inherited])?.description, 'Nearest.')
+  })
+
+  it('should publish nothing where nothing is declared', () => {
+    assert.strictEqual(MCP.published(undefined), null)
+    assert.strictEqual(MCP.published([]), null)
+  })
+
+  it('should describe a method with what the route states', () => {
+    const described = family.explain([new Tool('What the route is.', '/pots')], null as never,
+      { description: 'What the operation is.' })
+
+    assert.strictEqual(described.description, 'What the route is.')
+  })
+
+  it('should state nothing where nothing is declared', () => {
+    assert.strictEqual(family.explain([], null as never, {}).description, undefined)
+  })
+
+  it('should refuse a directive it does not know', () => {
+    assert.throws(() => family.create('resource', 'A pot.', null, '/pots'),
+      /Unknown directive: mcp:resource/)
+  })
+})

package/source/directives/mcp/Tool.ts

@@ -0,0 +1,28 @@
+import assert from 'node:assert'
+import { refusal } from '../../RPC/names.js'
+import { segment } from '../../RTD/segment.js'
+
+/**
+ * What one method is, published to a model. Declaring it is what publishes it, and what it
+ * says is what it says it is: a tool a model cannot read the purpose of is one it cannot
+ * choose, so there is no way to publish one that states nothing.
+ *
+ * The operation states what it is too, and that is not this. An operation is written without
+ * knowledge of any route, and a tool is an operation and a route together — the same
+ * operation mounted twice is two tools, and one sentence cannot be true of both.
+ */
+export class Tool {
+  public readonly description: string
+
+  public constructor (value: unknown, route: string) {
+    assert.ok(typeof value === 'string' && value.trim().length > 0,
+      'Directive mcp:tool: the value is what the tool is, which cannot be empty')
+
+    // a tool is called by name, so a route that cannot be named cannot be one — said where
+    // the mistake is, rather than as a tool that is quietly never listed
+    assert.ok(refusal(segment(route)) === null,
+      `Directive mcp:tool: '${route}' holds a segment no tool name can spell`)
+
+    this.description = value
+  }
+}

package/source/directives/mcp/index.ts

@@ -0,0 +1,6 @@
+import { MCP } from './MCP.js'
+
+export const mcp = new MCP()
+
+export { FAMILY, MCP } from './MCP.js'
+export type { Tool } from './Tool.js'

package/source/directives/oauth/Discovery.ts

@@ -0,0 +1,70 @@
+import { documents, type Documents } from './documents.js'
+import type * as http from '../../HTTP/index.js'
+import type { Input, Output } from '../../io.js'
+import type { Interceptor } from '../../Interception.js'
+
+/**
+ * What a client reads before it can authenticate: where the authorization server is, and
+ * what this resource expects. Both are fixed paths a specification names, both must be
+ * answered to anyone, and both are a function of the annotation alone — nothing is read to
+ * build them, so they are built once per authority and served as they are.
+ *
+ * An interceptor rather than a route because `auth` runs before any directive: a client
+ * re-reading discovery while holding a stale token would have it verified, and then be
+ * refused a document that has to be public.
+ */
+export class Discovery implements Interceptor {
+  /**
+   * A map, because the key is the request's authority and an unconfigured host is passed
+   * through as itself: `Host: constructor` names something a plain object answers on its own.
+   */
+  private readonly authorities = new Map<string, Documents>()
+
+  public mount (options: http.Options): void {
+    this.authorities.clear()
+
+    if (options.oauth === undefined)
+      return
+
+    /*
+     * `https` always: RFC 8414 has an issuer be one, and OAuth 2.1 has every endpoint of an
+     * authorization server be one — the loopback exception is a client's redirect URI, not
+     * a server's address. A gateway served without TLS has no authorization server a client
+     * may use, and naming it `http` would hide that behind documents none should accept.
+     *
+     * The host is the configured one, not the request's, which is the client's to write: a
+     * forged one would have these documents name someone else's token endpoint.
+     */
+    for (const [authority, host] of Object.entries(options.authorities))
+      this.authorities.set(authority, documents(`https://${host}`, options.oauth))
+  }
+
+  public reset (): void {
+    this.authorities.clear()
+  }
+
+  public intercept (input: Input): Output {
+    const known = this.authorities.get(input.authority)
+
+    if (known === undefined)
+      return null
+
+    // every reply, not just a document's: the challenge is what points a client here
+    input.pipelines.response.push((response) => {
+      if (response.status !== UNAUTHORIZED)
+        return
+
+      response.headers ??= new Headers()
+      response.headers.set('www-authenticate', known.challenge(input.url.pathname))
+    })
+
+    const body = known.read(input.url.pathname)
+
+    if (body === undefined)
+      return null
+
+    return { body, headers: new Headers({ 'cache-control': 'public, max-age=3600' }) }
+  }
+}
+
+const UNAUTHORIZED = 401

package/source/directives/oauth/documents.ts

@@ -0,0 +1,113 @@
+import type { OAuth } from '../../Annotation.js'
+
+/** The discovery documents of one authority, and the challenge that points at them. */
+export interface Documents {
+  /** The document a path names, or nothing when it names none. */
+  read: (pathname: string) => object | undefined
+
+  /** `WWW-Authenticate` for a request to this path, which names the resource it failed at. */
+  challenge: (pathname: string) => string
+}
+
+export function documents (issuer: string, oauth: OAuth): Documents {
+  const server = authorizationServer(issuer, oauth)
+  const resources = protectedResources(issuer, oauth)
+  const scope = oauth.scopes === undefined ? '' : `, scope="${oauth.scopes.join(' ')}"`
+
+  function read (pathname: string): object | undefined {
+    if (pathname === AUTHORIZATION_SERVER || pathname === OPENID_CONFIGURATION)
+      return server
+
+    if (pathname.startsWith(PROTECTED_RESOURCE))
+      return resources.get(pathname.slice(PROTECTED_RESOURCE.length))
+
+    return undefined
+  }
+
+  function challenge (pathname: string): string {
+    return `Bearer resource_metadata="${issuer}${PROTECTED_RESOURCE}${suffix(oauth, pathname)}"${scope}`
+  }
+
+  return { read, challenge }
+}
+
+/**
+ * RFC 8414. `authorization_endpoint` is the application's own page and may be anywhere;
+ * everything else this extension serves. Both flags are load-bearing for a client that
+ * prefers Client ID Metadata Documents: without either it falls back to registration.
+ */
+function authorizationServer (issuer: string, oauth: OAuth): object {
+  const metadata: Record<string, unknown> = {
+    issuer,
+    authorization_endpoint: oauth.authorize,
+    token_endpoint: `${issuer}${TOKEN}`,
+    response_types_supported: ['code'],
+    grant_types_supported: ['authorization_code'],
+    code_challenge_methods_supported: ['S256'],
+    token_endpoint_auth_methods_supported: ['none'],
+    client_id_metadata_document_supported: true,
+    authorization_response_iss_parameter_supported: true
+  }
+
+  if (oauth.registration === 'open')
+    metadata.registration_endpoint = `${issuer}${REGISTRATION}`
+
+  if (oauth.scopes !== undefined)
+    metadata.scopes_supported = oauth.scopes
+
+  return metadata
+}
+
+/**
+ * RFC 9728, keyed by the path the well-known segment is followed by: a client resolving
+ * `https://host/mcp` reads `/.well-known/oauth-protected-resource/mcp`, and one that names
+ * no path reads the document at the origin.
+ */
+function protectedResources (issuer: string, oauth: OAuth): Map<string, object> {
+  const map = new Map<string, object>()
+
+  for (const path of oauth.resources ?? [])
+    map.set(canonical(path), resource(issuer, canonical(path), oauth))
+
+  map.set('', resource(issuer, '', oauth))
+
+  return map
+}
+
+function resource (issuer: string, path: string, oauth: OAuth): object {
+  const metadata: Record<string, unknown> = {
+    resource: issuer + path,
+    authorization_servers: [issuer],
+    bearer_methods_supported: ['header']
+  }
+
+  if (oauth.scopes !== undefined)
+    metadata.scopes_supported = oauth.scopes
+
+  return metadata
+}
+
+/** The document a request to this path was refused against: the longest resource holding it. */
+function suffix (oauth: OAuth, pathname: string): string {
+  let longest = ''
+
+  for (const path of oauth.resources ?? [])
+    if (pathname.startsWith(path) && path.length > longest.length)
+      longest = path
+
+  return canonical(longest)
+}
+
+/**
+ * A resource is identified without its trailing slash — the form MCP asks for — while a
+ * route is declared with one, so `/mcp/` identifies `…/mcp`.
+ */
+function canonical (path: string): string {
+  return path.endsWith('/') ? path.slice(0, -1) : path
+}
+
+const AUTHORIZATION_SERVER = '/.well-known/oauth-authorization-server'
+const PROTECTED_RESOURCE = '/.well-known/oauth-protected-resource'
+const OPENID_CONFIGURATION = '/.well-known/openid-configuration'
+const TOKEN = '/identity/grants/'
+const REGISTRATION = '/identity/clients/'

package/source/directives/oauth/index.ts

@@ -0,0 +1,3 @@
+import { Discovery } from './Discovery.js'
+
+export const discovery = new Discovery()

package/source/directives/octets/Delete.ts

@@ -5,7 +5,7 @@ import { Workflow } from './workflows/index.js'
 import { Directive } from './Directive.js'
 import type { Parameter } from '../../RTD/index.js'
 import type { Unit, Location } from './workflows/index.js'
-import type { Maybe } from '@toa.io/types'
+import type { Maybe } from '@toa.io/core'
 import type { Component } from '@toa.io/core'
 import type { Output } from '../../io.js'
 import type { Input } from './types.js'

package/source/directives/octets/Get.ts

@@ -1,7 +1,7 @@
 import { Forbidden, NotFound } from '../../HTTP/index.js'
 import * as schemas from './schemas.js'
 import { Directive } from './Directive.js'
-import type { Maybe } from '@toa.io/types'
+import type { Maybe } from '@toa.io/core'
 import type { Entry, Stream } from '@toa.io/extensions.storages'
 import type { Component } from '@toa.io/core'
 import type { Output } from '../../io.js'

package/source/directives/octets/Octets.ts

@@ -28,7 +28,7 @@ export class Octets implements DirectiveFamily<Directive> {
     return new Class(value, this.discovery, remotes)
   }
 
-  public async preflight (directives: Directive[], input: Input, parameters: Parameter[]): Promise<Output> {
+  public async precall (directives: Directive[], input: Input, parameters: Parameter[]): Promise<Output> {
     let context: Context | null = null
     let action: Directive | null = null
 

package/source/directives/octets/Workflow.ts

@@ -7,7 +7,7 @@ import type { Input } from './types.js'
 import type { Component } from '@toa.io/core'
 import type { Output } from '../../io.js'
 import type { Remotes } from '../../Remotes.js'
-import type { Maybe } from '@toa.io/types'
+import type { Maybe } from '@toa.io/core'
 import type { Entry } from '@toa.io/extensions.storages'
 import type { Parameter } from '../../RTD/index.js'
 

package/source/directives/octets/workflows/Execution.ts

@@ -3,7 +3,7 @@ import { console } from 'openspan'
 import type { Unit } from './Workflow.js'
 import type { Remotes } from '../../../Remotes.js'
 import type { Component } from '@toa.io/core'
-import type { Maybe } from '@toa.io/types'
+import type { Maybe } from '@toa.io/core'
 import type { Entry } from '@toa.io/extensions.storages'
 
 export class Execution extends Readable {

package/source/directives/require/Directive.ts

@@ -1,5 +1,5 @@
 import type { Input } from '../../io.js'
 
 export interface Directive {
-  preflight: (context: Input) => void
+  precall: (context: Input) => void
 }

package/source/directives/require/Headers.ts

@@ -12,7 +12,7 @@ export class Headers implements Directive {
     this.headers = headers
   }
 
-  public preflight (context: Input): void {
+  public precall (context: Input): void {
     for (const header of this.headers)
       if (context.request.headers[header] === undefined)
         throw new BadRequest(`Header required: ${header}`)

package/source/directives/require/Require.ts

@@ -14,9 +14,9 @@ export class Require implements DirectiveFamily {
     return new directives[name](value)
   }
 
-  public preflight (instances: Directive[], context: Input): null {
+  public precall (instances: Directive[], context: Input): null {
     for (const instance of instances)
-      instance.preflight(context)
+      instance.precall(context)
 
     return null
   }

package/source/index.ts

@@ -4,3 +4,9 @@ export { components } from './Composition.js'
 export { Factory } from './Factory.js'
 
 export type { Remotes } from './Remotes.js'
+
+// what an operation is written against, rather than the gateway's own
+export type { Claims, Identity } from './userland.js'
+
+// what an octets workflow is given
+export type * as octets from './octets.js'

package/source/octets.d.ts

@@ -0,0 +1,17 @@
+export interface WorkflowInput<
+  TParameters extends Record<string, string> = Record<string, string>,
+  TSteps extends Record<string, unknown> = Record<string, unknown>,
+> {
+  authority: string
+  identity?: string
+  storage: string
+  path: string
+  entry: {
+    id: string
+    type: string
+    size: number
+    meta: Record<string, unknown>
+  }
+  parameters: TParameters
+  steps: TSteps
+}

package/source/schemas.ts

@@ -2,6 +2,7 @@ import { resolve } from 'node:path'
 import * as schemas from '@toa.io/schemas'
 import type { Query } from './HTTP/index.js'
 import type { Node } from './RTD/index.js'
+import type { Call } from './RPC/types.js'
 import type { Schema } from '@toa.io/schemas'
 import type { Annotation } from './Annotation.js'
 
@@ -11,3 +12,4 @@ const namespace = schemas.namespace(path)
 export const querystring: Schema<Query> = namespace.schema('querystring')
 export const annotation: Schema<Annotation> = namespace.schema('annotation')
 export const node: Schema<Node> = namespace.schema('node')
+export const call: Schema<Call> = namespace.schema('call')

package/source/userland.ts

@@ -0,0 +1,47 @@
+/**
+ * What Exposition puts into an operation's input, for the operation to be written against.
+ *
+ * The gateway's own types are its business; these are the application's.
+ */
+
+/**
+ * The identity behind the call, as `auth:delegate` embeds it:
+ *
+ * ```yaml
+ * /echo:
+ *   GET:
+ *     auth:assert: true
+ *     auth:delegate: identity
+ *     endpoint: echo
+ * ```
+ *
+ * ```javascript
+ * export async function computation ({ identity }, context) { }
+ * ```
+ */
+export interface Identity {
+  readonly id: string
+
+  /** What the identity holds. Delegation resolves them, so they are always here. */
+  roles: string[]
+
+  permissions?: Record<string, string[]>
+
+  /** How the identity was authenticated; `null` for a transient one. */
+  scheme: string | null
+
+  /** Whether the credentials presented are due to be exchanged. */
+  refresh: boolean
+
+  /** The token's claims, where the identity was federated. */
+  claims?: Claims
+}
+
+/** A federated token's payload: what it must carry, and whatever else the issuer put there. */
+export interface Claims {
+  iss: string
+  sub: string
+  aud?: string | string[]
+
+  [claim: string]: unknown
+}

package/transpiled/Annotation.d.ts

@@ -19,8 +19,49 @@ export interface Annotation {
     ip?: string;
     /** Failed authentications an address may make; none are metered unless set. See `identity.md`. */
     bouncer?: Bouncer;
+    /** The authorization server this context exposes; none is exposed without it. */
+    oauth?: OAuth;
+    /** JSON-RPC at `/.rpc`; none is served without it. See `documentation/rpc.md`. */
+    rpc?: RPC;
+    /** MCP at `/.mcp`; none is served without it. See `documentation/mcp.md`. */
+    mcp?: MCP;
     '/'?: object;
 }
+export interface OAuth {
+    /**
+     * Where a client sends the user to consent. The one endpoint of the flow that needs a
+     * person, and so the one this extension does not serve: an application builds it.
+     */
+    authorize: string;
+    /** Paths a token may be restricted to, each advertised as a protected resource. */
+    resources?: string[];
+    /** What a client may ask for. Each is a role, or a scope within one. */
+    scopes?: string[];
+    /** Origins whose Client ID Metadata Documents may be read. None are without it. */
+    trust?: string[];
+    /** Dynamic Client Registration, off unless opened. */
+    registration?: 'open' | 'closed';
+}
+export interface RPC {
+    /**
+     * Calls one request may carry, 32 by default. One request is one authentication and one
+     * reply however many calls it makes, so what a caller may ask for at once is bounded.
+     */
+    batch?: number;
+}
+export interface MCP {
+    /** What the server calls itself, which a client shows a user. */
+    name: string;
+    /** What a model is told before it calls anything here. */
+    instructions?: string;
+    /**
+     * Browser origins the endpoint answers, which the revision requires against DNS rebinding.
+     * None are admitted without it; a request carrying no `Origin` is not a browser's.
+     */
+    origins?: string[];
+    /** Whether the endpoint answers without a credential. It does not unless it says so. */
+    anonymous?: boolean;
+}
 export interface Bouncer {
     /** what an address may fail at once, 20 by default */
     attempts?: number;

package/transpiled/Directive.d.ts

@@ -2,13 +2,21 @@ import type { Context, OutgoingMessage, Options } from './HTTP/index.js';
 import type { Remotes } from './Remotes.js';
 import type { Host } from './Factory.js';
 import type { Output } from './io.js';
+import type { Introspection } from './Introspection.js';
 import type * as RTD from './RTD/index.js';
 export declare class Directives implements RTD.Directives {
     private readonly sets;
     /** the span of a stage depends only on the set, so it is built once per route */
     private readonly spans;
     constructor(sets: RTD.DirectiveSet[]);
-    preflight(context: Context, parameters: RTD.Parameter[]): Promise<Output>;
+    declared<T>(family: string): T[] | undefined;
+    precall(context: Context, parameters: RTD.Parameter[]): Promise<Output>;
+    /**
+     * What the method says about itself, as its directives leave it. Each family is given
+     * what the one before it returned, and the first to refuse ends it: a method this caller
+     * cannot reach is not described at all.
+     */
+    explain(context: Context, introspection: Introspection): Promise<Introspection | null>;
     settle(context: Context, response: OutgoingMessage): Promise<void>;
     dispose(): void;
 }
@@ -17,7 +25,16 @@ export declare class DirectivesFactory implements RTD.DirectiveFactory {
     private readonly families;
     private readonly mandatory;
     private readonly instances;
+    /** The request-scoped stages, in registration order, with the spans they run in. */
+    private readonly stages;
     constructor(families: RTD.DirectiveFamily[], remotes: Remotes, host: Host, options: Options);
+    /**
+     * Request-scoped, before anything is routed, so no directives are passed: a family
+     * answers here only for what it does on its own behalf.
+     */
+    preflight(context: Context): Promise<void>;
+    /** Request-scoped, on the message going back. */
+    depart(context: Context, response: OutgoingMessage): Promise<void>;
     create(declarations: RTD.syntax.Directive[], route?: string): Directives;
     dispose(): void;
     /** Mandatory families first, in their own order; everything else keeps its own. */

package/transpiled/Directive.js

@@ -6,26 +6,48 @@ export class Directives {
     constructor(sets) {
         this.sets = sets;
         this.spans = sets.map((set) => ({
-            preflight: options(set, 'preflight'),
-            settle: options(set, 'settle')
+            precall: options(set, 'precall'),
+            settle: options(set, 'settle'),
+            explain: options(set, 'explain')
         }));
     }
-    async preflight(context, parameters) {
+    declared(family) {
+        return this.sets.find((set) => set.family.name === family)?.directives;
+    }
+    async precall(context, parameters) {
         let output = null;
         for (let i = 0; i < this.sets.length; i++) {
             const set = this.sets[i];
-            if (set.family.preflight === undefined)
+            if (set.family.precall === undefined)
                 continue;
-            const out = await console.span(this.spans[i].preflight, async () => await set.family.preflight(set.directives, context, parameters));
+            const out = await console.span(this.spans[i].precall, async () => await set.family.precall(set.directives, context, parameters));
             if (out === null)
                 continue;
             if (output !== null)
-                throw new Error('Multiple preflight directives responded');
+                throw new Error('Multiple precall directives responded');
             else
                 output = out;
         }
         return output;
     }
+    /**
+     * What the method says about itself, as its directives leave it. Each family is given
+     * what the one before it returned, and the first to refuse ends it: a method this caller
+     * cannot reach is not described at all.
+     */
+    async explain(context, introspection) {
+        let described = introspection;
+        for (let i = 0; i < this.sets.length; i++) {
+            const set = this.sets[i];
+            if (set.family.explain === undefined)
+                continue;
+            const next = await console.span(this.spans[i].explain, async () => await set.family.explain(set.directives, context, described));
+            if (next === null)
+                return null;
+            described = next;
+        }
+        return described;
+    }
     async settle(context, response) {
         for (let i = 0; i < this.sets.length; i++) {
             const set = this.sets[i];
@@ -43,6 +65,8 @@ export class DirectivesFactory {
     families = {};
     mandatory = [];
     instances = [];
+    /** The request-scoped stages, in registration order, with the spans they run in. */
+    stages = [];
     // eslint-disable-next-line max-params
     constructor(families, remotes, host, options) {
         for (const family of families) {
@@ -50,9 +74,29 @@ export class DirectivesFactory {
             this.families[family.name] = family;
             if (family.mandatory)
                 this.mandatory.push(family.name);
+            this.stages.push({
+                family,
+                preflight: { name: `${family.name} preflight` },
+                depart: { name: `${family.name} depart` }
+            });
         }
         this.remotes = remotes;
     }
+    /**
+     * Request-scoped, before anything is routed, so no directives are passed: a family
+     * answers here only for what it does on its own behalf.
+     */
+    async preflight(context) {
+        for (const stage of this.stages)
+            if (stage.family.preflight !== undefined)
+                await console.span(stage.preflight, async () => { await stage.family.preflight(context); });
+    }
+    /** Request-scoped, on the message going back. */
+    async depart(context, response) {
+        for (const stage of this.stages)
+            if (stage.family.depart !== undefined)
+                await console.span(stage.depart, async () => { await stage.family.depart(context, response); });
+    }
     create(declarations, route = '') {
         const groups = {};
         const mandatory = new Set(this.mandatory);