eve 0.83.2 → 0.84.0

package/dist/src/channel/auth/definitions.d.ts

@@ -0,0 +1,532 @@
+/**
+ * Route-level HTTP authentication primitives.
+ *
+ * Strategy helpers return an {@link AuthFn} for route factories. Verifier
+ * helpers are lower-level pure functions for custom `fetch` handlers.
+ */
+import type { SessionAuthContext } from "#channel/types.js";
+import { type RuntimeIpAllowList } from "#channel/ip-allow-list.js";
+/**
+ * Result returned by the verifier helpers below. On success, `sessionAuth`
+ * is a fully-constructed {@link SessionAuthContext}; on failure no detail is
+ * returned so routes do not leak which credential check failed.
+ */
+export type VerifyResult = {
+    readonly ok: true;
+    readonly sessionAuth: SessionAuthContext;
+} | {
+    readonly ok: false;
+};
+/**
+ * Credentials accepted by {@link verifyHttpBasic}.
+ */
+export interface HttpBasicCredentials {
+    readonly username: string;
+    readonly password: string;
+}
+/**
+ * Verifies an HTTP Basic credential against the supplied username and
+ * password. Returns `{ ok: true, sessionAuth }` on success or `{ ok: false }`
+ * on a missing or mismatched credential. The password is compared with
+ * constant-time hash equality so a timing side channel cannot leak it. Both
+ * values are normalized to Unicode NFC before comparison, matching the
+ * `charset="UTF-8"` challenge advertised by {@link httpBasic}.
+ */
+export declare function verifyHttpBasic(authorizationHeader: string | null, credentials: HttpBasicCredentials): VerifyResult;
+/**
+ * Configuration for {@link verifyJwtHmac}. Optional fields have defaults so
+ * adapters can omit unused matchers. `secret` is read by the adapter from its
+ * secret store (e.g. `process.env`) and passed in directly.
+ */
+export interface VerifyJwtHmacConfig {
+    readonly algorithm: "HS256" | "HS384" | "HS512";
+    readonly audiences: readonly string[];
+    readonly issuer: string;
+    readonly secret: string;
+    /**
+     * Tolerance in seconds for the `exp` and `nbf` claims. Defaults to 30.
+     */
+    readonly clockSkewSeconds?: number;
+    /**
+     * AWS IAM-style `*`-wildcard patterns matched against the token `sub`.
+     * When supplied, the token is rejected unless one matches.
+     */
+    readonly subjects?: readonly string[];
+    /**
+     * Per-claim membership matcher: each named claim must contain at least one
+     * of the listed values, or the token is rejected.
+     */
+    readonly claims?: Readonly<Record<string, readonly string[]>>;
+}
+/**
+ * Verifies a bearer JWT signed with an HMAC secret. Pass the token without
+ * the `Bearer ` prefix (see {@link extractBearerToken}). Returns
+ * `{ ok: true, sessionAuth }` on success or `{ ok: false }` when verification
+ * fails or the token's claims don't match the supplied matchers.
+ */
+export declare function verifyJwtHmac(token: string | null, config: VerifyJwtHmacConfig): Promise<VerifyResult>;
+/**
+ * Configuration for {@link verifyJwtEcdsa}.
+ */
+export interface VerifyJwtEcdsaConfig {
+    readonly algorithm: "ES256" | "ES384" | "ES512";
+    readonly audiences: readonly string[];
+    readonly issuer: string;
+    /**
+     * PEM-encoded ECDSA public key (`-----BEGIN PUBLIC KEY-----` ...).
+     */
+    readonly publicKey: string;
+    /**
+     * Tolerance in seconds for the `exp` and `nbf` claims. Defaults to 30.
+     */
+    readonly clockSkewSeconds?: number;
+    /**
+     * AWS IAM-style `*`-wildcard patterns matched against the token `sub`.
+     * When supplied, the token is rejected unless one matches.
+     */
+    readonly subjects?: readonly string[];
+    /**
+     * Per-claim membership matcher: each named claim must contain at least one
+     * of the listed values, or the token is rejected.
+     */
+    readonly claims?: Readonly<Record<string, readonly string[]>>;
+}
+/**
+ * Verifies a bearer JWT signed with an ECDSA private key against the supplied
+ * PEM public key. Pass the token without the `Bearer ` prefix (see
+ * {@link extractBearerToken}). Returns `{ ok: true, sessionAuth }` on success
+ * or `{ ok: false }` when verification fails or the token's claims do not
+ * match the configured `subjects`/`claims`.
+ */
+export declare function verifyJwtEcdsa(token: string | null, config: VerifyJwtEcdsaConfig): Promise<VerifyResult>;
+/**
+ * Configuration for {@link verifyOidc}.
+ */
+export interface VerifyOidcConfig {
+    readonly audiences: readonly string[];
+    readonly issuer: string;
+    /**
+     * OIDC discovery URL. Defaults to
+     * `${issuer}/.well-known/openid-configuration` (any trailing slash on
+     * `issuer` is stripped first).
+     */
+    readonly discoveryUrl?: string;
+    /**
+     * Tolerance in seconds for the `exp` and `nbf` claims. Defaults to 30.
+     */
+    readonly clockSkewSeconds?: number;
+    /**
+     * AWS IAM-style `*`-wildcard patterns matched against the token `sub`.
+     * When supplied, the token is rejected unless one matches.
+     */
+    readonly subjects?: readonly string[];
+    /**
+     * Per-claim membership matcher: each named claim must contain at least one
+     * of the listed values, or the token is rejected.
+     */
+    readonly claims?: Readonly<Record<string, readonly string[]>>;
+}
+/**
+ * Verifies a bearer OIDC token against an issuer's discovery URL. Pass the
+ * token without the `Bearer ` prefix (see {@link extractBearerToken}). The
+ * token must satisfy the configured `subjects`/`claims` matchers; on success
+ * the principal is tagged `principalType: "service"`. Unlike
+ * {@link verifyVercelOidc}, this never grants the Vercel current-project
+ * bypass. Returns `{ ok: false }` on failed verification or matchers.
+ */
+export declare function verifyOidc(token: string | null, config: VerifyOidcConfig): Promise<VerifyResult>;
+/**
+ * Extracts the bearer token from an `Authorization: Bearer <token>` header.
+ * Returns `null` if the header is missing, the scheme isn't `Bearer`, or the
+ * value after `Bearer ` is empty.
+ */
+export declare function extractBearerToken(authorizationHeader: string | null): string | null;
+/**
+ * Parsed IP allowlist for repeated checks. Construct once at module load,
+ * then call {@link isIpAllowed} per request.
+ */
+export type IpAllowList = RuntimeIpAllowList;
+/**
+ * Parses exact IP addresses or CIDR blocks into a reusable
+ * {@link IpAllowList}. Entries are trimmed; throws on an empty entry, a `*`
+ * wildcard (use exact IP/CIDR syntax), or an invalid address or CIDR prefix.
+ */
+export declare function createIpAllowList(entries: readonly string[]): IpAllowList;
+/**
+ * Returns whether `ip` is permitted by `allowList`. `null` always returns
+ * `false`. Adapters that need to allow unknown IPs should not call this.
+ */
+export declare function isIpAllowed(ip: string | null, allowList: IpAllowList): boolean;
+/**
+ * One challenge entry attached to the `www-authenticate` header on a failure
+ * response. For a Basic+Bearer prompt, pass both:
+ * `[{ scheme: "Basic", parameters: { realm: "agent" } }, { scheme: "Bearer" }]`
+ */
+export interface UnauthorizedChallenge {
+    readonly scheme: "Basic" | "Bearer";
+    readonly parameters?: Readonly<Record<string, string>>;
+}
+/**
+ * Options accepted by {@link createUnauthorizedResponse}.
+ */
+export interface UnauthorizedResponseOptions {
+    /**
+     * HTTP status code. Defaults to `401`. Use `403` for "authenticated but
+     * not allowed" outcomes.
+     */
+    readonly status?: 401 | 403;
+    /**
+     * Machine-readable error code returned in the JSON body. Defaults to
+     * `"unauthorized"` (401) or `"forbidden"` (403).
+     */
+    readonly code?: string;
+    /**
+     * Human-readable error message returned in the JSON body. Defaults to a
+     * generic prompt.
+     */
+    readonly message?: string;
+    /**
+     * Optional `www-authenticate` challenge entries.
+     */
+    readonly challenges?: readonly UnauthorizedChallenge[];
+}
+/**
+ * Builds a JSON failure response shaped like the framework's other auth
+ * failures: `cache-control: no-store`, one `www-authenticate` header per
+ * challenge, and a `{ ok: false, code, error }` body.
+ */
+export declare function createUnauthorizedResponse(opts?: UnauthorizedResponseOptions): Response;
+/** @internal Escapes a value for an HTTP auth challenge quoted string. */
+export declare function escapeAuthChallengeParameter(value: string): string;
+/**
+ * Options accepted by auth error classes. The class chooses the HTTP status.
+ */
+export type AuthErrorOptions = Omit<UnauthorizedResponseOptions, "status">;
+/**
+ * Error thrown by auth callbacks to reject a route with a structured 401
+ * response. `routeAuth` catches it and returns its response; other errors
+ * propagate through the normal channel failure path.
+ */
+export declare class UnauthenticatedError extends Error {
+    readonly response: Response;
+    constructor(opts?: AuthErrorOptions);
+}
+/**
+ * Error thrown by auth callbacks to reject a route with a structured 403
+ * response. `routeAuth` catches it and returns its response; other errors
+ * propagate through the normal channel failure path.
+ */
+export declare class ForbiddenError extends Error {
+    readonly response: Response;
+    constructor(opts?: AuthErrorOptions);
+}
+export interface AuthResult extends SessionAuthContext {
+    /**
+     * Set to true to let this authenticated caller create sessions with tool stubs.
+     * Callers without this permission cannot supply stubs.
+     */
+    readonly allowToolStubs?: boolean;
+}
+/**
+ * Route auth callback. Returned value semantics inside {@link routeAuth}:
+ *
+ * - A {@link SessionAuthContext} accepts the request and halts the walk.
+ * - `null` or `undefined` skips to the next entry.
+ *
+ * If every entry skips (including the empty `[]` case), the walker returns a
+ * 401. To reject with a specific response, throw an
+ * {@link UnauthenticatedError} or {@link ForbiddenError}. To accept anonymous
+ * traffic, include {@link none} as the final entry.
+ */
+export type AuthFn<TEvent = Request> = (event: TEvent) => AuthResult | null | undefined | Promise<AuthResult | null | undefined>;
+/**
+ * OAuth protected-resource metadata attached to an inbound auth policy.
+ * `issuer` is shorthand for a single authorization server.
+ */
+export type OAuthResourceOptions = {
+    readonly metadataPath?: string;
+    readonly resource?: string;
+    readonly scopes?: readonly string[];
+} & ({
+    readonly authorizationServers?: never;
+    readonly issuer: string;
+} | {
+    readonly authorizationServers: readonly string[];
+    readonly issuer?: never;
+});
+declare const OAUTH_RESOURCE_SYMBOL: unique symbol;
+/**
+ * An ordinary route authenticator decorated with OAuth protected-resource
+ * discovery metadata.
+ */
+export type OAuthResourceAuth = AuthFn<Request> & {
+    readonly [OAUTH_RESOURCE_SYMBOL]: OAuthResourceOptions;
+};
+/**
+ * Adds OAuth protected-resource metadata to an existing inbound auth policy.
+ *
+ * The returned value remains an {@link AuthFn}: it preserves the ordered auth
+ * walk and can be used by any channel. A protocol-aware channel such as
+ * `mcpChannel` may additionally publish the metadata and discovery challenge.
+ */
+export declare function oauthResource(auth: AuthFn<Request> | readonly AuthFn<Request>[], options: OAuthResourceOptions): OAuthResourceAuth;
+/** @internal Reads OAuth resource metadata without widening `AuthFn`. */
+export declare function readOAuthResourceOptions(auth: AuthFn<Request> | readonly AuthFn<Request>[]): OAuthResourceOptions | undefined;
+/**
+ * Attaches declared `www-authenticate` challenges to an {@link AuthFn}
+ * without changing its call signature or behavior. {@link routeAuth} reads
+ * the declared challenges back when every entry in the walk skips, so the
+ * resulting 401 advertises the scheme(s) the configured strategies actually
+ * accept (e.g. `Basic` for {@link httpBasic}) instead of a fixed default.
+ *
+ * Built-in strategies (`httpBasic`, `jwtHmac`, `jwtEcdsa`, `oidc`,
+ * `vercelOidc`) already declare their challenge. Use this directly when
+ * authoring a custom `AuthFn`:
+ *
+ * ```ts
+ * const apiKey = withAuthChallenges(
+ *   (request) => (isValidApiKey(request) ? sessionAuth : null),
+ *   [{ scheme: "Bearer" }],
+ * );
+ * ```
+ */
+export declare function withAuthChallenges<TEvent>(fn: AuthFn<TEvent>, challenges: readonly UnauthorizedChallenge[]): AuthFn<TEvent>;
+/**
+ * Walks an `AuthFn` (or array) in order against `request`. The first entry
+ * returning a {@link SessionAuthContext} wins; entries returning `null` or
+ * `undefined` are skipped. If the walk exhausts without a winner (including
+ * the empty-array case), returns a 401 {@link createUnauthorizedResponse}
+ * whose `www-authenticate` challenges are collected from the entries'
+ * declared schemes (see {@link withAuthChallenges}), falling back to
+ * `Bearer` when none declared any.
+ *
+ * Channel factories that share this resolution policy (e.g. `eveChannel`, or
+ * a custom `defineChannel` route handler) should call `routeAuth` rather than
+ * re-implement the walk.
+ */
+export declare function routeAuth(request: Request, auth: AuthFn<Request> | readonly AuthFn<Request>[]): Promise<AuthResult | Response>;
+/**
+ * Returns an {@link AuthFn} for scaffolded apps that makes unfinished
+ * production auth fail as an intentional 401 rather than an internal route
+ * error. Replace it before serving real users:
+ *
+ * ```ts
+ * eveChannel({ auth: [vercelOidc(), localDev(), placeholderAuth()] });
+ * ```
+ *
+ * Outside production it returns `null`, so the auth walk keeps the same local
+ * development behavior as any other skipped entry.
+ */
+export declare function placeholderAuth(): AuthFn<Request>;
+/**
+ * Returns an {@link AuthFn} that accepts any request anonymously, producing
+ * a synthetic principal with `principalType: "anonymous"`. Use it as the
+ * final entry in an `auth` array to opt routes into unauthenticated access:
+ *
+ * ```ts
+ * eveChannel({ auth: [none()] }); // every request accepted anonymously
+ * ```
+ *
+ * The returned `SessionAuthContext` halts the {@link routeAuth} walk, so
+ * `none()` terminates whatever array it appears in. It ignores its event
+ * argument, so `TEvent` is inferred from the surrounding array (defaulting
+ * to `unknown`) and composes with `AuthFn<Request>` entries without a type
+ * argument.
+ */
+export declare function none<TEvent = unknown>(): AuthFn<TEvent>;
+/**
+ * Returns an {@link AuthFn} that authenticates a synthetic `local-dev`
+ * principal while the process is a local development server, and returns
+ * `null` everywhere else so the {@link routeAuth} walk falls through to the
+ * next entry.
+ *
+ * A process counts as a local development server when it is `eve dev`
+ * (`EVE_DEV=1`) or `vercel dev` (`VERCEL=1` with `VERCEL_ENV=development`).
+ * This is a property of the deployment, never of the inbound request, so no
+ * request header (for example `Host`) can flip the decision. A production
+ * deployment (`eve start`, a Vercel deployment, or any container host) sets
+ * neither flag, so `localDev()` authenticates nothing there. Layer a real
+ * authenticator on those hosts.
+ *
+ * On a development server, `localDev()` also refuses requests a browser sent
+ * on behalf of another site: a request addressed to a host that is neither
+ * loopback nor one of this machine's addresses, or one whose `Origin` is not. Browsers set both themselves and
+ * send `Origin` on every cross-origin request that can change state, so a web
+ * page cannot use the developer's browser to reach the local agent, including
+ * through DNS rebinding. Frontends on any loopback host and port, or on this
+ * machine's own address, still authenticate.
+ *
+ * On `eve dev`, `localDev()` also refuses callers whose connection comes from
+ * another machine, such as LAN clients of a server started with
+ * `--host 0.0.0.0`. A tunnel or reverse proxy on this machine still forwards
+ * its callers as `local-dev`, so expose a development server that way only
+ * behind an authenticator that runs before `localDev()`.
+ */
+export declare function localDev(): AuthFn<Request>;
+/**
+ * Options for verifying a Vercel OIDC token with {@link verifyVercelOidc}.
+ */
+export interface VerifyVercelOidcOptions {
+    /**
+     * Explicit current-project binding for the verified token. When omitted,
+     * the verifier reads `VERCEL_PROJECT_ID` and `VERCEL_TARGET_ENV` /
+     * `VERCEL_ENV` from the runtime environment.
+     */
+    readonly currentVercelProject?: {
+        readonly environment?: string;
+        readonly projectId: string;
+    };
+    /**
+     * Optional `sub` patterns granting callers access on top of the always-on
+     * current-project bypass. Patterns use AWS IAM-style `*` wildcards and may
+     * target tokens minted by other Vercel projects (e.g.
+     * `"owner:acme:project:partner-agent:environment:*"`). The current project
+     * is always accepted regardless of this list.
+     */
+    readonly subjects?: readonly string[];
+}
+/**
+ * Verifies a bearer JWT minted by Vercel OIDC.
+ *
+ * Acceptance rule:
+ *
+ * - Current-project tokens that reach the service/runtime path are accepted
+ *   regardless of `subjects`, so the deployment's own runtime callers
+ *   (subagent, internal fetches) authenticate without being enumerated.
+ * - Tokens with an `external_sub` claim authenticate as
+ *   `principalType: "user"` when they match the configured current project
+ *   and environment. `external_sub`
+ *   becomes the eve subject, `external_iss` or `connector_id` the eve issuer
+ *   when present, and string-valued OIDC profile claims (`name`, `picture`,
+ *   `email`) are exposed as auth attributes.
+ * - Development tokens with a `user_id` claim authenticate as
+ *   `principalType: "user"` only when both the token and configured current
+ *   project environment are `development`. Other same-project target
+ *   environments may use one as a `"service"` principal.
+ * - Tokens from other Vercel projects are accepted **only** when their `sub`
+ *   matches one of {@link VerifyVercelOidcOptions.subjects}.
+ *
+ * Tokens without a `user_id` claim are accepted for the current project in
+ * production, preview, and development. They are tagged `"runtime"` when the
+ * token's `environment` matches the current deployment, otherwise `"service"`.
+ */
+export declare function verifyVercelOidc(token: string | null, opts?: VerifyVercelOidcOptions): Promise<VerifyResult>;
+/**
+ * Allowed values for {@link VercelSubjectInput.environment}. Use `"*"`
+ * to match any of `production`, `preview`, and `development` for the
+ * named project.
+ */
+export type VercelSubjectEnvironment = "production" | "preview" | "development" | "*";
+/**
+ * Strict input shape accepted by {@link vercelSubject}.
+ *
+ * The `sub` claim carries human-readable slugs/names, not IDs. Stable
+ * project and team IDs (`prj_...`, `team_...`) live on the separate
+ * `project_id` / `owner_id` claims, which `verifyVercelOidc` matches
+ * against `VERCEL_PROJECT_ID` for the current-project bind. This helper
+ * composes a `sub` matcher, so its inputs are slugs.
+ */
+export interface VercelSubjectInput {
+    /**
+     * Vercel team slug (a.k.a. "owner"; e.g. `"acme"`) as embedded in the
+     * `sub` claim, **not** the stable team ID `team_...` (`VERCEL_TEAM_ID`).
+     *
+     * Must not contain `*` or `:` so authors cannot widen the matcher to
+     * "any team with a project of this name". Hand-write the subject string
+     * when cross-team federation is intentional.
+     */
+    readonly teamSlug: string;
+    /**
+     * Vercel project name (e.g. `"acme_website"`) as embedded in the `sub`
+     * claim, **not** the stable project ID `prj_...` (`VERCEL_PROJECT_ID`).
+     * Same constraints as {@link teamSlug}.
+     */
+    readonly projectName: string;
+    /**
+     * Vercel deployment environment, or `"*"` to match any environment for
+     * the named project. Defaults to `"production"` so an unspecified
+     * environment cannot silently accept preview/development tokens.
+     */
+    readonly environment?: VercelSubjectEnvironment;
+}
+/**
+ * Builds a Vercel OIDC `sub` matcher pattern from a typed input.
+ *
+ * Vercel-issued tokens carry a `sub` of the form
+ * `owner:[TEAM_SLUG]:project:[PROJECT_NAME]:environment:[ENVIRONMENT]`.
+ * Hand-writing it invites two foot-guns: a misspelled slug (silently
+ * rejecting all callers) and over-broad wildcards (silently accepting
+ * unrelated callers). This helper rejects malformed inputs at construction
+ * time and forces an explicit `environment`.
+ *
+ * Use it inside {@link VerifyVercelOidcOptions.subjects} to layer
+ * additional Vercel-project callers on top of the current-project bypass:
+ *
+ * ```ts
+ * vercelOidc({
+ *   subjects: [vercelSubject({ teamSlug: "partner", projectName: "data" })],
+ * });
+ * ```
+ *
+ * The `sub` claim flips when a team or project name changes, so any policy
+ * built on this helper must update with it; the stable team/project IDs are
+ * not exposed in `sub`. See Vercel's OIDC reference for the token anatomy.
+ */
+export declare function vercelSubject(input: VercelSubjectInput): string;
+export interface VercelOidcOptions extends Omit<VerifyVercelOidcOptions, "subjects"> {
+    /**
+     * Additional token subjects allowed to authenticate.
+     * To allow stubs, use { subject, allowToolStubs: true } for that subject.
+     */
+    readonly subjects?: readonly (string | {
+        readonly subject: string;
+        readonly allowToolStubs?: boolean;
+    })[];
+}
+/**
+ * Returns an HTTP route auth callback backed by Vercel OIDC. See
+ * {@link verifyVercelOidc} for the always-on current-project bypass and how
+ * `subjects` extends acceptance to other Vercel projects. Declares a
+ * `Bearer` {@link withAuthChallenges} challenge for {@link routeAuth}'s 401.
+ */
+export declare function vercelOidc(opts?: VercelOidcOptions): AuthFn<Request>;
+/**
+ * Options accepted by {@link httpBasic}.
+ */
+export interface HttpBasicAuthOptions {
+    /**
+     * Optional `realm` parameter advertised on the `WWW-Authenticate: Basic`
+     * challenge (e.g. browsers show it in the native login prompt). Defaults
+     * to `"eve"`.
+     */
+    readonly realm?: string;
+}
+/**
+ * Returns an {@link AuthFn} that verifies HTTP Basic credentials via
+ * {@link verifyHttpBasic}. Declares a `Basic` {@link withAuthChallenges}
+ * challenge so a {@link routeAuth} 401 advertises `WWW-Authenticate: Basic`
+ * (with `realm` first, when given, then `charset="UTF-8"`) instead of the
+ * `Bearer` fallback.
+ */
+export declare function httpBasic(credentials: HttpBasicCredentials, options?: HttpBasicAuthOptions): AuthFn<Request>;
+/**
+ * Returns an {@link AuthFn} that verifies an HMAC-signed bearer JWT via
+ * {@link verifyJwtHmac}. Declares a `Bearer` {@link withAuthChallenges}
+ * challenge for {@link routeAuth}'s 401.
+ */
+export declare function jwtHmac(config: VerifyJwtHmacConfig): AuthFn<Request>;
+/**
+ * Returns an {@link AuthFn} that verifies an ECDSA-signed bearer JWT via
+ * {@link verifyJwtEcdsa}. Declares a `Bearer` {@link withAuthChallenges}
+ * challenge for {@link routeAuth}'s 401.
+ */
+export declare function jwtEcdsa(config: VerifyJwtEcdsaConfig): AuthFn<Request>;
+/**
+ * Returns an {@link AuthFn} that verifies an OIDC bearer token on the inbound
+ * request via {@link verifyOidc}. Use {@link vercelOidc} instead for
+ * Vercel-issued tokens: it preconfigures the issuer, audience, and runtime
+ * principal flag. Declares a `Bearer` {@link withAuthChallenges} challenge
+ * for {@link routeAuth}'s 401.
+ */
+export declare function oidc(config: VerifyOidcConfig): AuthFn<Request>;
+export {};

package/dist/src/channel/auth/definitions.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{areTokenClaimMatchersSatisfied}from"#channel/auth/token-claims.js";import{decodeJwt}from"#compiled/jose/index.js";import{ANONYMOUS_SESSION_AUTH_CONTEXT}from"#channel/principal-identity.js";import{isEveDevEnvironment,isLocalDevelopmentServer}from"#internal/application/dev-environment.js";import{isLocalMachineAddress,readTrustedDevelopmentPeer}from"#internal/nitro/dev-client-address.js";import{authenticateHttpBasicStrategy}from"#channel/auth/http-basic.js";import{authenticateJwtEcdsaStrategy}from"#channel/auth/jwt-ecdsa.js";import{authenticateJwtHmacStrategy}from"#channel/auth/jwt-hmac.js";import{authenticateOidcStrategy}from"#channel/auth/oidc.js";import{resolveVercelOidcCurrentProject}from"#channel/auth/vercel-oidc-project.js";import{createRuntimeSessionAuthContext}from"#channel/auth/types.js";import{isVercelOidcIssuer}from"#shared/vercel-project.js";import{createRuntimeIpAllowList,isRuntimeIpAllowed}from"#channel/ip-allow-list.js";import{isLoopbackHostname}from"#shared/network-address.js";const vercelOidcLog=createLogger(`auth.vercel-oidc`);function verifyHttpBasic(e,t){if(e===null)return{ok:!1};let n=authenticateHttpBasicStrategy({authorization:e,strategy:{kind:`http-basic`,password:t.password,username:t.username}});return n.kind===`authenticated`?{ok:!0,sessionAuth:createRuntimeSessionAuthContext(n.principal)}:{ok:!1}}async function verifyJwtHmac(e,t){if(e===null||e.length===0)return{ok:!1};let n={algorithm:t.algorithm,audiences:[...t.audiences],clockSkewSeconds:t.clockSkewSeconds??30,issuer:t.issuer,kind:`jwt-hmac`,secret:t.secret,claims:t.claims,subjects:t.subjects},r=await authenticateJwtHmacStrategy({strategy:n,token:e});return r.kind===`authenticated`?{ok:!0,sessionAuth:createRuntimeSessionAuthContext(r.principal)}:{ok:!1}}async function verifyJwtEcdsa(e,t){if(e===null||e.length===0)return{ok:!1};let n={algorithm:t.algorithm,audiences:[...t.audiences],clockSkewSeconds:t.clockSkewSeconds??30,issuer:t.issuer,kind:`jwt-ecdsa`,publicKey:t.publicKey,claims:t.claims,subjects:t.subjects},r=await authenticateJwtEcdsaStrategy({strategy:n,token:e});return r.kind===`authenticated`?{ok:!0,sessionAuth:createRuntimeSessionAuthContext(r.principal)}:{ok:!1}}async function verifyOidc(e,t){let n=await runOidcVerification(e,{...t,acceptCurrentVercelProject:!1,currentVercelProject:void 0});return n.kind===`authenticated`?{ok:!0,sessionAuth:createRuntimeSessionAuthContext(n.principal)}:{ok:!1}}async function runOidcVerification(e,t){if(e===null||e.length===0)return{kind:`not-authenticated`};let n={acceptCurrentVercelProject:t.acceptCurrentVercelProject,audiences:[...t.audiences],clockSkewSeconds:t.clockSkewSeconds??30,discoveryUrl:t.discoveryUrl??`${t.issuer.replace(/\/$/,``)}/.well-known/openid-configuration`,issuer:t.issuer,kind:`oidc`,claims:t.claims,subjects:t.subjects},r=t.currentVercelProject===void 0?n:{...n,currentVercelProject:t.currentVercelProject};return await authenticateOidcStrategy({strategy:r,token:e})}function extractBearerToken(e){if(e===null)return null;let t=/^Bearer\s+(.+)$/i.exec(e)?.[1]?.trim();return t===void 0||t.length===0?null:t}function createIpAllowList(e){return createRuntimeIpAllowList(e)}function isIpAllowed(e,t){return e!==null&&isRuntimeIpAllowed(e,t)}function createUnauthorizedResponse(e={}){let t=e.status??401,n=e.code??(t===403?`forbidden`:`unauthorized`),r=e.message??(t===403?`Forbidden.`:`Authorization is required for this route.`),i=e.challenges??[],a=new Headers({"cache-control":`no-store`});for(let e of i)a.append(`www-authenticate`,formatChallenge(e));return Response.json({code:n,error:r,ok:!1},{headers:a,status:t})}function formatChallenge(e){if(e.parameters===void 0||Object.keys(e.parameters).length===0)return e.scheme;let t=Object.entries(e.parameters).map(([e,t])=>`${e}="${escapeAuthChallengeParameter(t)}"`).join(`, `);return`${e.scheme} ${t}`}function escapeAuthChallengeParameter(e){return e.replaceAll(`\\`,`\\\\`).replaceAll(`"`,`\\"`)}function isValidOAuthIdentifierUrl(e){try{let t=new URL(e);return(t.protocol===`https:`||t.protocol===`http:`&&isLoopbackHostname(t.hostname))&&t.username.length===0&&t.password.length===0&&t.search.length===0&&t.hash.length===0}catch{return!1}}function isValidMetadataPath(e){if(!e.startsWith(`/`)||e.startsWith(`//`))return!1;let t=new URL(e,`https://eve.invalid`);return t.origin===`https://eve.invalid`&&t.search.length===0&&t.hash.length===0}var UnauthenticatedError=class extends Error{response;constructor(e={}){super(e.message??`Authorization is required for this route.`),this.name=`UnauthenticatedError`,this.response=createUnauthorizedResponse({...e,status:401})}},ForbiddenError=class extends Error{response;constructor(e={}){super(e.message??`Forbidden.`),this.name=`ForbiddenError`,this.response=createUnauthorizedResponse({...e,status:403})}};const OAUTH_RESOURCE_SYMBOL=Symbol.for(`eve.channels.auth.oauthResource`);function oauthResource(e,t){let n=t.issuer===void 0?t.authorizationServers:[t.issuer];if(n.length===0||n.some(e=>!isValidOAuthIdentifierUrl(e)))throw Error(`oauthResource requires at least one HTTPS authorization server URL (HTTP is allowed only on loopback).`);if(t.resource!==void 0&&!isValidOAuthIdentifierUrl(t.resource))throw Error(`oauthResource resource must be an HTTPS URL without credentials, query, or fragment (HTTP is allowed only on loopback).`);if(t.metadataPath!==void 0&&!isValidMetadataPath(t.metadataPath))throw Error(`oauthResource metadataPath must be an absolute path without a host, query, or fragment.`);let r=Array.isArray(e)?e:[e],composed=async e=>{for(let t of r){let n=await t(e);if(n)return n}return null},i=collectDeclaredChallenges(r),a=withAuthChallenges(composed,i.length>0?i:[{scheme:`Bearer`}]);return Object.defineProperty(a,OAUTH_RESOURCE_SYMBOL,{enumerable:!1,value:t}),a}function readOAuthResourceOptions(e){if(!Array.isArray(e))return e[OAUTH_RESOURCE_SYMBOL]}const AUTH_CHALLENGES_SYMBOL=Symbol.for(`eve.channels.auth.challenges`);function withAuthChallenges(e,t){let wrapped=t=>e(t);return Object.defineProperty(wrapped,AUTH_CHALLENGES_SYMBOL,{value:t}),wrapped}function getDeclaredChallenges(e){return e[AUTH_CHALLENGES_SYMBOL]}function collectDeclaredChallenges(e){let t=new Set,n=[];for(let r of e)for(let e of getDeclaredChallenges(r)??[]){let r=formatChallenge(e);t.has(r)||(t.add(r),n.push(e))}return n}async function routeAuth(e,t){let n=Array.isArray(t)?t:[t];try{for(let t of n){let n=await t(e);if(n)return n}}catch(e){if(typeof e==`object`&&e&&`response`in e&&e.response instanceof Response)return e.response;throw e}let r=collectDeclaredChallenges(n);return createUnauthorizedResponse({challenges:r.length>0?addInvalidBearerTokenError(e,r):[{scheme:`Bearer`}]})}function addInvalidBearerTokenError(e,t){let n=e.headers.get(`authorization`);return n===null||!/^Bearer(?:\s|$)/i.test(n.trim())||!t.some(e=>e.scheme===`Bearer`)?t:t.map(e=>e.scheme!==`Bearer`||e.parameters?.error!==void 0?e:{...e,parameters:{...e.parameters,error:`invalid_token`}})}function placeholderAuth(){return()=>{if(process.env.VERCEL_ENV!==`production`)return null;throw new UnauthenticatedError({code:`eve_production_auth_not_configured`,message:`Production auth is not configured. Replace placeholderAuth() in agent/channels/eve.ts with your app's auth provider.`})}}function none(){return()=>ANONYMOUS_SESSION_AUTH_CONTEXT}function localDev(){return e=>isLocalDevelopmentServer()&&!isCrossSiteBrowserRequest(e)&&!isFromRemotePeer(e)?LOCAL_DEV_SESSION_AUTH_CONTEXT:null}function isCrossSiteBrowserRequest(e){if(!isLocalMachineAddress(new URL(e.url).hostname))return!0;let t=e.headers.get(`origin`);if(t===null)return!1;let n=URL.parse(t)?.hostname;return n===void 0||!isLocalMachineAddress(n)}function isFromRemotePeer(e){return readTrustedDevelopmentPeer(e.headers)===`remote`}const LOCAL_DEV_SESSION_AUTH_CONTEXT={attributes:{},authenticator:`local-dev`,principalId:`local-dev`,principalType:`local-dev`};async function verifyVercelOidc(e,t={}){if(e===null||e.length===0)return{ok:!1};let n=decodeUnverifiedJwtClaims(e);if(n===null)return vercelOidcLog.debug(`Rejected token that failed to decode as a JWT.`),{ok:!1};if(!isVercelOidcIssuer(n.issuer))return vercelOidcLog.debug(`Rejected token whose issuer is not a Vercel OIDC issuer.`,{issuer:n.issuer}),{ok:!1};if(n.audiences.length===0)return vercelOidcLog.debug(`Rejected token with no audience claim.`,{issuer:n.issuer}),{ok:!1};if(!n.audiences.some(e=>e.startsWith(`https://vercel.com/`)))return vercelOidcLog.debug(`Rejected token whose audience is not a Vercel audience.`,{audiences:n.audiences,issuer:n.issuer}),{ok:!1};let r=resolveCurrentVercelProject(t),i=await runOidcVerification(e,{acceptCurrentVercelProject:!0,audiences:n.audiences,currentVercelProject:r,issuer:n.issuer,subjects:t.subjects??[]});return i.kind===`authenticated`?(vercelOidcLog.debug(`Accepted Vercel OIDC token.`,{issuer:n.issuer,principalType:i.principal.principalType,subject:i.principal.subject}),{ok:!0,sessionAuth:createRuntimeSessionAuthContext(i.principal)}):(vercelOidcLog.debug(`Rejected Vercel OIDC token after verification.`,{audiences:n.audiences,issuer:n.issuer,reason:i.kind,subjectsConfigured:(t.subjects??[]).length>0,detail:i.kind===`misconfigured`?i.message:void 0}),{ok:!1})}function resolveCurrentVercelProject(e){if(e.currentVercelProject!==void 0)return e.currentVercelProject;let t=process.env.VERCEL_PROJECT_ID?.trim();if(t===void 0||t.length===0)return;let n=process.env.VERCEL_TARGET_ENV?.trim()||process.env.VERCEL_ENV?.trim();return n===void 0||n.length===0?{projectId:t}:{environment:n,projectId:t}}function vercelSubject(e){assertVercelSubjectSegment(`teamSlug`,e.teamSlug),assertVercelSubjectSegment(`projectName`,e.projectName);let t=e.environment??`production`;if(t!==`production`&&t!==`preview`&&t!==`development`&&t!==`*`)throw Error(`vercelSubject: invalid environment ${JSON.stringify(t)}; expected "production", "preview", "development", or "*".`);return`owner:${e.teamSlug}:project:${e.projectName}:environment:${t}`}function assertVercelSubjectSegment(e,t){if(t.length===0)throw Error(`vercelSubject: ${e} must be a non-empty string.`);if(t.includes(`*`)||t.includes(`:`))throw Error(`vercelSubject: ${e} ${JSON.stringify(t)} may not contain ${t.includes(`:`)?`':'`:`'*'`}. Hand-write the subject string when wildcards are intentional.`)}function vercelOidc(e={}){let{subjects:t,...n}=e,r={...n,subjects:t?.map(e=>typeof e==`string`?e:e.subject)};return withAuthChallenges(async n=>{let i=extractBearerToken(n.headers.get(`authorization`)),a=e.currentVercelProject??(i!==null&&isLocalDevelopmentVercelOidc()?await resolveVercelOidcCurrentProject(n):void 0),o=await verifyVercelOidc(i,a===void 0?r:{...r,currentVercelProject:a});if(!o.ok)return null;let s=o.sessionAuth;return(s.principalType===`service`||s.principalType===`runtime`)&&t?.some(e=>typeof e!=`string`&&e.allowToolStubs===!0&&areTokenClaimMatchersSatisfied({sub:s.subject},{subjects:[e.subject]}))?{...s,allowToolStubs:!0}:s},[{scheme:`Bearer`}])}function isLocalDevelopmentVercelOidc(){return process.env.VERCEL_ENV===`development`?!0:process.env.VERCEL_ENV===`preview`||process.env.VERCEL_ENV===`production`?!1:isEveDevEnvironment()}function httpBasic(e,t){return withAuthChallenges(t=>{let n=verifyHttpBasic(t.headers.get(`authorization`),e);return n.ok?n.sessionAuth:null},[{parameters:{realm:t?.realm??`eve`,charset:`UTF-8`},scheme:`Basic`}])}function jwtHmac(e){return withAuthChallenges(async t=>{let n=await verifyJwtHmac(extractBearerToken(t.headers.get(`authorization`)),e);return n.ok?n.sessionAuth:null},[{scheme:`Bearer`}])}function jwtEcdsa(e){return withAuthChallenges(async t=>{let n=await verifyJwtEcdsa(extractBearerToken(t.headers.get(`authorization`)),e);return n.ok?n.sessionAuth:null},[{scheme:`Bearer`}])}function oidc(e){return withAuthChallenges(async t=>{let n=await verifyOidc(extractBearerToken(t.headers.get(`authorization`)),e);return n.ok?n.sessionAuth:null},[{scheme:`Bearer`}])}function decodeUnverifiedJwtClaims(e){let t;try{t=decodeJwt(e)}catch{return null}return typeof t.iss!=`string`||t.iss.length===0?null:{audiences:typeof t.aud==`string`?[t.aud]:Array.isArray(t.aud)?t.aud.filter(e=>typeof e==`string`):[],issuer:t.iss}}export{ForbiddenError,UnauthenticatedError,createIpAllowList,createUnauthorizedResponse,escapeAuthChallengeParameter,extractBearerToken,httpBasic,isIpAllowed,jwtEcdsa,jwtHmac,localDev,none,oauthResource,oidc,placeholderAuth,readOAuthResourceOptions,routeAuth,vercelOidc,vercelSubject,verifyHttpBasic,verifyJwtEcdsa,verifyJwtHmac,verifyOidc,verifyVercelOidc,withAuthChallenges};

package/dist/src/channel/auth/jwt-ecdsa.js

@@ -1 +1 @@
-import{importJWK,importSPKI,jwtVerify}from"#compiled/jose/index.js";import{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal}from"#channel/auth/token-claims.js";const importedJwtPublicKeyCache=new Map;async function authenticateJwtEcdsaStrategy(e){let t;try{t=await getImportedJwtPublicKey(e.strategy)}catch(e){return{kind:`misconfigured`,message:`Failed to import JWT ECDSA public key. ${e instanceof Error?e.message:`Unknown key import failure.`}`}}try{let n=await jwtVerify(e.token,t,{algorithms:[e.strategy.algorithm],audience:[...e.strategy.audiences],clockTolerance:e.strategy.clockSkewSeconds,issuer:e.strategy.issuer});return typeof n.payload.sub!=`string`||n.payload.sub.length===0?{kind:`not-authenticated`}:areTokenClaimMatchersSatisfied(n.payload,e.strategy)?{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`jwt-ecdsa`,payload:n.payload,principalType:`service`})}:{kind:`caller-not-allowed`}}catch{return{kind:`not-authenticated`}}}async function getImportedJwtPublicKey(e){let t=`${e.algorithm}:${e.publicKey}`,n=importedJwtPublicKeyCache.get(t);if(n!==void 0)return await n;let r=importJwtPublicKey(e.publicKey,e.algorithm).catch(e=>{throw importedJwtPublicKeyCache.delete(t),e});return importedJwtPublicKeyCache.set(t,r),await r}async function importJwtPublicKey(e,t){let n=e.trim();return n.startsWith(`{`)?await importJWK(JSON.parse(n),t):await importSPKI(n,t)}export{authenticateJwtEcdsaStrategy};
+import{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal}from"#channel/auth/token-claims.js";import{importJWK,importSPKI,jwtVerify}from"#compiled/jose/index.js";const importedJwtPublicKeyCache=new Map;async function authenticateJwtEcdsaStrategy(e){let t;try{t=await getImportedJwtPublicKey(e.strategy)}catch(e){return{kind:`misconfigured`,message:`Failed to import JWT ECDSA public key. ${e instanceof Error?e.message:`Unknown key import failure.`}`}}try{let n=await jwtVerify(e.token,t,{algorithms:[e.strategy.algorithm],audience:[...e.strategy.audiences],clockTolerance:e.strategy.clockSkewSeconds,issuer:e.strategy.issuer});return typeof n.payload.sub!=`string`||n.payload.sub.length===0?{kind:`not-authenticated`}:areTokenClaimMatchersSatisfied(n.payload,e.strategy)?{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`jwt-ecdsa`,payload:n.payload,principalType:`service`})}:{kind:`caller-not-allowed`}}catch{return{kind:`not-authenticated`}}}async function getImportedJwtPublicKey(e){let t=`${e.algorithm}:${e.publicKey}`,n=importedJwtPublicKeyCache.get(t);if(n!==void 0)return await n;let r=importJwtPublicKey(e.publicKey,e.algorithm).catch(e=>{throw importedJwtPublicKeyCache.delete(t),e});return importedJwtPublicKeyCache.set(t,r),await r}async function importJwtPublicKey(e,t){let n=e.trim();return n.startsWith(`{`)?await importJWK(JSON.parse(n),t):await importSPKI(n,t)}export{authenticateJwtEcdsaStrategy};

package/dist/src/channel/auth/jwt-hmac.js

@@ -1 +1 @@
-import{createSecretKey}from"node:crypto";import{jwtVerify}from"#compiled/jose/index.js";import{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal}from"#channel/auth/token-claims.js";async function authenticateJwtHmacStrategy(e){try{let t=await jwtVerify(e.token,createSecretKey(Buffer.from(e.strategy.secret,`utf8`)),{algorithms:[e.strategy.algorithm],audience:[...e.strategy.audiences],clockTolerance:e.strategy.clockSkewSeconds,issuer:e.strategy.issuer});return typeof t.payload.sub!=`string`||t.payload.sub.length===0?{kind:`not-authenticated`}:areTokenClaimMatchersSatisfied(t.payload,e.strategy)?{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`jwt-hmac`,payload:t.payload,principalType:`service`})}:{kind:`caller-not-allowed`}}catch{return{kind:`not-authenticated`}}}export{authenticateJwtHmacStrategy};
+import{createSecretKey}from"node:crypto";import{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal}from"#channel/auth/token-claims.js";import{jwtVerify}from"#compiled/jose/index.js";async function authenticateJwtHmacStrategy(e){try{let t=await jwtVerify(e.token,createSecretKey(Buffer.from(e.strategy.secret,`utf8`)),{algorithms:[e.strategy.algorithm],audience:[...e.strategy.audiences],clockTolerance:e.strategy.clockSkewSeconds,issuer:e.strategy.issuer});return typeof t.payload.sub!=`string`||t.payload.sub.length===0?{kind:`not-authenticated`}:areTokenClaimMatchersSatisfied(t.payload,e.strategy)?{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`jwt-hmac`,payload:t.payload,principalType:`service`})}:{kind:`caller-not-allowed`}}catch{return{kind:`not-authenticated`}}}export{authenticateJwtHmacStrategy};

package/dist/src/channel/auth/oidc.js

@@ -1 +1 @@
-import{createRemoteJWKSet,jwtVerify}from"#compiled/jose/index.js";import{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal}from"#channel/auth/token-claims.js";import{z}from"#compiled/zod/index.js";import{isVercelOidcIssuer}from"#shared/vercel-project.js";const oidcDiscoveryDocumentSchema=z.object({issuer:z.string().optional(),jwks_uri:z.string().url()}).passthrough(),oidcDiscoveryDocumentCache=new Map,oidcJwksCache=new Map;async function authenticateOidcStrategy(e){let t;try{t=await getOidcRemoteJwks(e.strategy)}catch(e){return{kind:`misconfigured`,message:`Failed to load OIDC discovery metadata. ${e instanceof Error?e.message:`Unknown discovery failure.`}`}}try{let n=await jwtVerify(e.token,t,{audience:[...e.strategy.audiences],clockTolerance:e.strategy.clockSkewSeconds,issuer:e.strategy.issuer});if(e.strategy.acceptCurrentVercelProject&&isVercelOidcIssuer(e.strategy.issuer)&&n.payload.external_sub!==void 0)return typeof n.payload.external_sub!=`string`||n.payload.external_sub.length===0||!currentVercelProjectMatches({payload:n.payload,strategy:e.strategy})||!currentVercelEnvironmentMatches({payload:n.payload,strategy:e.strategy})?{kind:`caller-not-allowed`}:{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,issuerClaims:[`external_iss`,`connector_id`],payload:n.payload,principalType:`user`,subjectClaim:`external_sub`})};if(e.strategy.acceptCurrentVercelProject&&isVercelOidcIssuer(e.strategy.issuer)&&n.payload.user_id!==void 0){if(typeof n.payload.user_id!=`string`||n.payload.user_id.length===0||n.payload.environment!==`development`||!currentVercelProjectMatches({payload:n.payload,strategy:e.strategy}))return{kind:`caller-not-allowed`};if(currentVercelEnvironmentMatches({payload:n.payload,strategy:e.strategy}))return{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,payload:n.payload,principalType:`user`,subjectClaim:`user_id`})}}if(typeof n.payload.sub!=`string`||n.payload.sub.length===0)return{kind:`not-authenticated`};let r=e.strategy.acceptCurrentVercelProject&&isCurrentVercelProjectToken({issuer:e.strategy.issuer,payload:n.payload,strategy:e.strategy}),i=r&&isCurrentVercelEnvironmentToken({payload:n.payload,strategy:e.strategy});return!r&&!areTokenClaimMatchersSatisfied(n.payload,e.strategy)?{kind:`caller-not-allowed`}:{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,payload:n.payload,principalType:i?`runtime`:`service`})}}catch{return{kind:`not-authenticated`}}}async function getOidcRemoteJwks(e){let t=await getOidcDiscoveryDocument(e.discoveryUrl),n=oidcJwksCache.get(t.jwks_uri);if(n!==void 0)return n;let r=createRemoteJWKSet(new URL(t.jwks_uri));return oidcJwksCache.set(t.jwks_uri,r),r}async function getOidcDiscoveryDocument(e){let t=oidcDiscoveryDocumentCache.get(e);if(t!==void 0)return await t;let n=fetch(e,{headers:{accept:`application/json`}}).then(async e=>{if(!e.ok)throw Error(`Discovery route returned HTTP ${e.status}.`);return oidcDiscoveryDocumentSchema.parse(await e.json())}).catch(t=>{throw oidcDiscoveryDocumentCache.delete(e),t});return oidcDiscoveryDocumentCache.set(e,n),await n}function isCurrentVercelProjectToken(e){if(!isVercelOidcIssuer(e.issuer))return!1;let t=e.strategy.currentVercelProject;return t!==void 0&&typeof e.payload.project_id==`string`&&e.payload.project_id===t.projectId}function currentVercelProjectMatches(e){let t=e.strategy.currentVercelProject;return t!==void 0&&typeof e.payload.project_id==`string`&&e.payload.project_id===t.projectId}function isCurrentVercelEnvironmentToken(e){let t=e.strategy.currentVercelProject?.environment;return t===void 0||t.length===0?!1:typeof e.payload.environment==`string`&&e.payload.environment===t}function currentVercelEnvironmentMatches(e){let t=e.strategy.currentVercelProject?.environment;return t===void 0||t.length===0?!1:typeof e.payload.environment==`string`&&e.payload.environment===t}export{authenticateOidcStrategy};
+import{areTokenClaimMatchersSatisfied,createJwtAuthenticatedCallerPrincipal}from"#channel/auth/token-claims.js";import{createRemoteJWKSet,jwtVerify}from"#compiled/jose/index.js";import{isVercelOidcIssuer}from"#shared/vercel-project.js";import{z}from"#compiled/zod/index.js";const oidcDiscoveryDocumentSchema=z.object({issuer:z.string().optional(),jwks_uri:z.string().url()}).passthrough(),oidcDiscoveryDocumentCache=new Map,oidcJwksCache=new Map;async function authenticateOidcStrategy(e){let t;try{t=await getOidcRemoteJwks(e.strategy)}catch(e){return{kind:`misconfigured`,message:`Failed to load OIDC discovery metadata. ${e instanceof Error?e.message:`Unknown discovery failure.`}`}}try{let n=await jwtVerify(e.token,t,{audience:[...e.strategy.audiences],clockTolerance:e.strategy.clockSkewSeconds,issuer:e.strategy.issuer});if(e.strategy.acceptCurrentVercelProject&&isVercelOidcIssuer(e.strategy.issuer)&&n.payload.external_sub!==void 0)return typeof n.payload.external_sub!=`string`||n.payload.external_sub.length===0||!currentVercelProjectMatches({payload:n.payload,strategy:e.strategy})||!currentVercelEnvironmentMatches({payload:n.payload,strategy:e.strategy})?{kind:`caller-not-allowed`}:{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,issuerClaims:[`external_iss`,`connector_id`],payload:n.payload,principalType:`user`,subjectClaim:`external_sub`})};if(e.strategy.acceptCurrentVercelProject&&isVercelOidcIssuer(e.strategy.issuer)&&n.payload.user_id!==void 0){if(typeof n.payload.user_id!=`string`||n.payload.user_id.length===0||n.payload.environment!==`development`||!currentVercelProjectMatches({payload:n.payload,strategy:e.strategy}))return{kind:`caller-not-allowed`};if(currentVercelEnvironmentMatches({payload:n.payload,strategy:e.strategy}))return{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,payload:n.payload,principalType:`user`,subjectClaim:`user_id`})}}if(typeof n.payload.sub!=`string`||n.payload.sub.length===0)return{kind:`not-authenticated`};let r=e.strategy.acceptCurrentVercelProject&&isCurrentVercelProjectToken({issuer:e.strategy.issuer,payload:n.payload,strategy:e.strategy}),i=r&&isCurrentVercelEnvironmentToken({payload:n.payload,strategy:e.strategy});return!r&&!areTokenClaimMatchersSatisfied(n.payload,e.strategy)?{kind:`caller-not-allowed`}:{kind:`authenticated`,principal:createJwtAuthenticatedCallerPrincipal({authenticator:`oidc`,payload:n.payload,principalType:i?`runtime`:`service`})}}catch{return{kind:`not-authenticated`}}}async function getOidcRemoteJwks(e){let t=await getOidcDiscoveryDocument(e.discoveryUrl),n=oidcJwksCache.get(t.jwks_uri);if(n!==void 0)return n;let r=createRemoteJWKSet(new URL(t.jwks_uri));return oidcJwksCache.set(t.jwks_uri,r),r}async function getOidcDiscoveryDocument(e){let t=oidcDiscoveryDocumentCache.get(e);if(t!==void 0)return await t;let n=fetch(e,{headers:{accept:`application/json`}}).then(async e=>{if(!e.ok)throw Error(`Discovery route returned HTTP ${e.status}.`);return oidcDiscoveryDocumentSchema.parse(await e.json())}).catch(t=>{throw oidcDiscoveryDocumentCache.delete(e),t});return oidcDiscoveryDocumentCache.set(e,n),await n}function isCurrentVercelProjectToken(e){if(!isVercelOidcIssuer(e.issuer))return!1;let t=e.strategy.currentVercelProject;return t!==void 0&&typeof e.payload.project_id==`string`&&e.payload.project_id===t.projectId}function currentVercelProjectMatches(e){let t=e.strategy.currentVercelProject;return t!==void 0&&typeof e.payload.project_id==`string`&&e.payload.project_id===t.projectId}function isCurrentVercelEnvironmentToken(e){let t=e.strategy.currentVercelProject?.environment;return t===void 0||t.length===0?!1:typeof e.payload.environment==`string`&&e.payload.environment===t}function currentVercelEnvironmentMatches(e){let t=e.strategy.currentVercelProject?.environment;return t===void 0||t.length===0?!1:typeof e.payload.environment==`string`&&e.payload.environment===t}export{authenticateOidcStrategy};

package/dist/src/channel/channel-address.d.ts

@@ -1,9 +1,11 @@
-import type { UserContent } from "ai";
+import type { MessageContent } from "#shared/message-content.js";
+import type { Delivery } from "#shared/delivery.js";
 import type { ChannelAdapter } from "#channel/adapter.js";
 import { type ChannelDeliverySource } from "#channel/delivery-metadata.js";
 import type { SendPayload } from "#channel/routes.js";
 import { type Session } from "#channel/session.js";
-import type { CancelTurnResult, ClearSessionResult, CompactSessionResult, ResetSessionResult, Runtime, SessionAuthContext, SessionCallback, TurnPolicy } from "#channel/types.js";
+import type { Runtime, SessionAuthContext, SessionCallback, TurnPolicy } from "#channel/types.js";
+import type { SessionControlOptions } from "#channel/types.js";
 interface BaseChannelAddressCreateOptions {
     readonly auth: SessionAuthContext | null;
     readonly history?: SendPayload["history"];
@@ -42,18 +44,18 @@ export type ChannelAddressDeliveryOptions<TState = undefined> = [TState] extends
  */
 interface ChannelAddress<TState = undefined> {
     readonly continuationToken: string;
-    deliver(input: SendPayload, options: ChannelAddressDeliveryOptions<TState>): Promise<Session>;
     create(options: ChannelAddressCreateOptions<TState>): Promise<ChannelCreateResult>;
-    send(message: string | UserContent, options: ChannelAddressDeliveryOptions<TState>): Promise<Session>;
-    respond(inputResponses: SendPayload["inputResponses"], options: ChannelAddressDeliveryOptions<TState>): Promise<Session>;
+    deliver(input: SendPayload, options: ChannelAddressDeliveryOptions<TState>): Promise<Delivery>;
+    send(message: MessageContent, options: ChannelAddressDeliveryOptions<TState>): Promise<Delivery>;
+    respond(answers: SendPayload["answers"], options: ChannelAddressDeliveryOptions<TState>): Promise<Delivery>;
     cancel(options?: {
-        readonly turnId?: string;
-    }): Promise<CancelTurnResult>;
-    compact(): Promise<CompactSessionResult>;
-    clear(): Promise<ClearSessionResult>;
+        readonly turnId?: string | null;
+    } & SessionControlOptions): Promise<Delivery>;
+    compact(options?: SessionControlOptions): Promise<Delivery>;
+    clear(options?: SessionControlOptions): Promise<Delivery>;
     reset(options?: {
         readonly reason?: string;
-    }): Promise<ResetSessionResult>;
+    } & SessionControlOptions): Promise<Delivery>;
     resolveSession(): Promise<Session | undefined>;
 }
 /** Factory for binding a route-local continuation token to a {@link ChannelAddress}. */