@dbx-tools/shared-core 0.6.46 → 0.6.49

package/lib/src/token.js

@@ -12,6 +12,20 @@ import { isLevelEnabled, logger } from "./log.js";
 const BEARER_PREFIX_REGEX = /^bearer\s+/i;
 const SPLIT_REGEX = /\s+|\s*,\s*/;
 const log = logger("shared/token");
+/**
+ * Header the Databricks Apps front door forwards the caller's OAuth (OBO) token
+ * on - the default source for every helper here.
+ *
+ * Exported because it is a wire contract several packages branch on, not just a
+ * default argument: `@dbx-tools/appkit`'s `identity` module decides whether a
+ * request can use OBO auth at all by its presence, and `@dbx-tools/cli-tunnel`
+ * must know the name to strip inbound copies of it. One spelling, one place.
+ */
+export const ACCESS_TOKEN_HEADER = "x-forwarded-access-token";
+/** Header the front door forwards the caller's user id on. */
+export const USER_ID_HEADER = "x-forwarded-user";
+/** Header the front door forwards the caller's email on. */
+export const USER_EMAIL_HEADER = "x-forwarded-email";
 /**
  * Decode a JWT segment (base64url with standard base64 padding), or
  * `undefined` when the segment is not valid base64.
@@ -34,7 +48,7 @@ function decodeJwtSegment(segment) {
  * When `input` is header-like, walks every value for `headerName` (default
  * `x-forwarded-access-token`) and merges claim keys left-to-right.
  */
-export function getAccessTokenPayload(input, headerName = "x-forwarded-access-token") {
+export function getAccessTokenPayload(input, headerName = ACCESS_TOKEN_HEADER) {
     let accessTokenPayload;
     if (!(typeof input === "string")) {
         if (headerName) {
@@ -123,4 +137,4 @@ function* iterateClaims(input, distinct = true) {
     }
     yield* visit(input);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token.js","sourceRoot":"","sources":["../../src/token.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * JWT access-token helpers for Databricks Apps.\n *\n * Parses bearer tokens and `x-forwarded-access-token` payloads to read\n * OAuth scopes and other claims from incoming HTTP requests.\n *\n * @module\n */\n\nimport { forEachHeaderValue, type HeaderLike } from \"./http.ts\";\nimport * as json from \"./json.ts\";\nimport { isLevelEnabled, logger } from \"./log.ts\";\n\nconst BEARER_PREFIX_REGEX = /^bearer\\s+/i;\nconst SPLIT_REGEX = /\\s+|\\s*,\\s*/;\nconst log = logger(\"shared/token\");\n\n/**\n * Decode a JWT segment (base64url with standard base64 padding), or\n * `undefined` when the segment is not valid base64.\n */\nfunction decodeJwtSegment(segment: string): string | undefined {\n  const normalized = segment.replace(/-/g, \"+\").replace(/_/g, \"/\");\n  const padded = normalized + \"=\".repeat((4 - (normalized.length % 4)) % 4);\n  try {\n    const binary = atob(padded);\n    const bytes = Uint8Array.from(binary, (ch) => ch.charCodeAt(0));\n    return new TextDecoder().decode(bytes);\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Decode the JWT payload from a bearer token string or request headers.\n *\n * When `input` is header-like, walks every value for `headerName` (default\n * `x-forwarded-access-token`) and merges claim keys left-to-right.\n */\nexport function getAccessTokenPayload(\n  input: HeaderLike | string,\n  headerName: string | undefined = \"x-forwarded-access-token\",\n): Record<string, unknown> {\n  let accessTokenPayload: Record<string, unknown> | undefined;\n  if (!(typeof input === \"string\")) {\n    if (headerName) {\n      forEachHeaderValue(input, headerName, (value: string) => {\n        for (const [payloadKey, payloadValue] of Object.entries(getAccessTokenPayload(value))) {\n          if (!accessTokenPayload || !(payloadKey in accessTokenPayload)) {\n            if (!accessTokenPayload) accessTokenPayload = {};\n            accessTokenPayload[payloadKey] = payloadValue;\n          }\n        }\n      });\n    }\n  } else {\n    input = input.trim();\n    if (input) {\n      const match = BEARER_PREFIX_REGEX.exec(input);\n      if (match) {\n        const endIndex = match.index + match[0].length;\n        input = input.slice(endIndex);\n      }\n      const parts = input.split(\".\", 4);\n      if (parts.length === 2 || parts.length === 3) {\n        // A malformed segment yields undefined; fall through to empty object.\n        accessTokenPayload = json.parseRecord(decodeJwtSegment(parts[1]!));\n      }\n    }\n  }\n  if (!accessTokenPayload) accessTokenPayload = {};\n  log.debug(\"getAccessTokenPayload\", { accessTokenPayload });\n  return accessTokenPayload;\n}\n\n/**\n * OAuth scopes from the access-token JWT on `input`.\n *\n * Defaults to the `x-forwarded-access-token` header, which Databricks Apps\n * forward from the browser session.\n */\nexport function getAccessTokenScopes(\n  input: HeaderLike | string,\n  headerName?: string,\n): Iterable<string> {\n  const payload = getAccessTokenPayload(input, headerName);\n  let accessTokenScopes: Iterable<string> = iterateClaims(payload.scope);\n  if (isLevelEnabled(\"debug\")) {\n    accessTokenScopes = Array.from(accessTokenScopes);\n    log.debug(\"getAccessTokenScopes\", { accessTokenScopes });\n  }\n  return accessTokenScopes;\n}\n\n/**\n * Return true when `scopes` contains any value from `allowed`.\n *\n * Accepts the raw {@link MASTRA_SCOPES_KEY} array stamped on\n * `RequestContext` as well as iterables from {@link getAccessTokenScopes}.\n */\nexport function includesAccessTokenScope(scopes: unknown, allowed: readonly string[]): boolean {\n  if (allowed.length) {\n    for (const scope of iterateClaims(scopes)) {\n      if (allowed.includes(scope)) {\n        log.debug(\"includesAccessTokenScope\", { scope, allowed });\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/** Split a JWT `scope` claim string or array into individual scope tokens. */\nfunction* iterateClaims(input: unknown, distinct = true): Iterable<string> {\n  const seen = distinct ? new Set<string>() : undefined;\n\n  function* visit(value: unknown): Iterable<string> {\n    if (typeof value === \"string\") {\n      for (const claim of value.split(SPLIT_REGEX)) {\n        const token = claim.trim();\n        if (!token || seen?.has(token)) {\n          continue;\n        }\n        seen?.add(token);\n        yield token;\n      }\n    } else if (Array.isArray(value)) {\n      for (const item of value) {\n        yield* visit(item);\n      }\n    }\n  }\n\n  yield* visit(input);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token.js","sourceRoot":"","sources":["../../src/token.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * JWT access-token helpers for Databricks Apps.\n *\n * Parses bearer tokens and `x-forwarded-access-token` payloads to read\n * OAuth scopes and other claims from incoming HTTP requests.\n *\n * @module\n */\n\nimport { forEachHeaderValue, type HeaderLike } from \"./http.ts\";\nimport * as json from \"./json.ts\";\nimport { isLevelEnabled, logger } from \"./log.ts\";\n\nconst BEARER_PREFIX_REGEX = /^bearer\\s+/i;\nconst SPLIT_REGEX = /\\s+|\\s*,\\s*/;\nconst log = logger(\"shared/token\");\n\n/**\n * Header the Databricks Apps front door forwards the caller's OAuth (OBO) token\n * on - the default source for every helper here.\n *\n * Exported because it is a wire contract several packages branch on, not just a\n * default argument: `@dbx-tools/appkit`'s `identity` module decides whether a\n * request can use OBO auth at all by its presence, and `@dbx-tools/cli-tunnel`\n * must know the name to strip inbound copies of it. One spelling, one place.\n */\nexport const ACCESS_TOKEN_HEADER = \"x-forwarded-access-token\";\n\n/** Header the front door forwards the caller's user id on. */\nexport const USER_ID_HEADER = \"x-forwarded-user\";\n\n/** Header the front door forwards the caller's email on. */\nexport const USER_EMAIL_HEADER = \"x-forwarded-email\";\n\n/**\n * Decode a JWT segment (base64url with standard base64 padding), or\n * `undefined` when the segment is not valid base64.\n */\nfunction decodeJwtSegment(segment: string): string | undefined {\n  const normalized = segment.replace(/-/g, \"+\").replace(/_/g, \"/\");\n  const padded = normalized + \"=\".repeat((4 - (normalized.length % 4)) % 4);\n  try {\n    const binary = atob(padded);\n    const bytes = Uint8Array.from(binary, (ch) => ch.charCodeAt(0));\n    return new TextDecoder().decode(bytes);\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Decode the JWT payload from a bearer token string or request headers.\n *\n * When `input` is header-like, walks every value for `headerName` (default\n * `x-forwarded-access-token`) and merges claim keys left-to-right.\n */\nexport function getAccessTokenPayload(\n  input: HeaderLike | string,\n  headerName: string | undefined = ACCESS_TOKEN_HEADER,\n): Record<string, unknown> {\n  let accessTokenPayload: Record<string, unknown> | undefined;\n  if (!(typeof input === \"string\")) {\n    if (headerName) {\n      forEachHeaderValue(input, headerName, (value: string) => {\n        for (const [payloadKey, payloadValue] of Object.entries(getAccessTokenPayload(value))) {\n          if (!accessTokenPayload || !(payloadKey in accessTokenPayload)) {\n            if (!accessTokenPayload) accessTokenPayload = {};\n            accessTokenPayload[payloadKey] = payloadValue;\n          }\n        }\n      });\n    }\n  } else {\n    input = input.trim();\n    if (input) {\n      const match = BEARER_PREFIX_REGEX.exec(input);\n      if (match) {\n        const endIndex = match.index + match[0].length;\n        input = input.slice(endIndex);\n      }\n      const parts = input.split(\".\", 4);\n      if (parts.length === 2 || parts.length === 3) {\n        // A malformed segment yields undefined; fall through to empty object.\n        accessTokenPayload = json.parseRecord(decodeJwtSegment(parts[1]!));\n      }\n    }\n  }\n  if (!accessTokenPayload) accessTokenPayload = {};\n  log.debug(\"getAccessTokenPayload\", { accessTokenPayload });\n  return accessTokenPayload;\n}\n\n/**\n * OAuth scopes from the access-token JWT on `input`.\n *\n * Defaults to the `x-forwarded-access-token` header, which Databricks Apps\n * forward from the browser session.\n */\nexport function getAccessTokenScopes(\n  input: HeaderLike | string,\n  headerName?: string,\n): Iterable<string> {\n  const payload = getAccessTokenPayload(input, headerName);\n  let accessTokenScopes: Iterable<string> = iterateClaims(payload.scope);\n  if (isLevelEnabled(\"debug\")) {\n    accessTokenScopes = Array.from(accessTokenScopes);\n    log.debug(\"getAccessTokenScopes\", { accessTokenScopes });\n  }\n  return accessTokenScopes;\n}\n\n/**\n * Return true when `scopes` contains any value from `allowed`.\n *\n * Accepts the raw {@link MASTRA_SCOPES_KEY} array stamped on\n * `RequestContext` as well as iterables from {@link getAccessTokenScopes}.\n */\nexport function includesAccessTokenScope(scopes: unknown, allowed: readonly string[]): boolean {\n  if (allowed.length) {\n    for (const scope of iterateClaims(scopes)) {\n      if (allowed.includes(scope)) {\n        log.debug(\"includesAccessTokenScope\", { scope, allowed });\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/** Split a JWT `scope` claim string or array into individual scope tokens. */\nfunction* iterateClaims(input: unknown, distinct = true): Iterable<string> {\n  const seen = distinct ? new Set<string>() : undefined;\n\n  function* visit(value: unknown): Iterable<string> {\n    if (typeof value === \"string\") {\n      for (const claim of value.split(SPLIT_REGEX)) {\n        const token = claim.trim();\n        if (!token || seen?.has(token)) {\n          continue;\n        }\n        seen?.add(token);\n        yield token;\n      }\n    } else if (Array.isArray(value)) {\n      for (const item of value) {\n        yield* visit(item);\n      }\n    }\n  }\n\n  yield* visit(input);\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/async.ts","../src/brand.ts","../src/error.ts","../src/function.ts","../src/hash.ts","../src/http.ts","../src/json.ts","../src/log.ts","../src/net.ts","../src/object.ts","../src/predicate.ts","../src/string.ts","../src/token.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/async.ts","../src/brand.ts","../src/env.ts","../src/error.ts","../src/execution.ts","../src/function.ts","../src/hash.ts","../src/http.ts","../src/json.ts","../src/log.ts","../src/net.ts","../src/object.ts","../src/pattern.ts","../src/predicate.ts","../src/string.ts","../src/token.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -43,7 +43,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.46",
+  "version": "0.6.49",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/env.ts

@@ -0,0 +1,133 @@
+/**
+ * Reading configuration out of the environment.
+ *
+ * Every plugin config in this repo resolves the same way: take the typed
+ * config value when the caller set one, else fall back to one or more
+ * environment variables, else a default. Written by hand that becomes a
+ * `config.x ?? Number(process.env.X)` chain per field, and each package grew
+ * its own `fromEnv` / `resolvePositiveInt` helper with slightly different
+ * coercion rules. These are those helpers, once.
+ *
+ * Browser-safe: `process` is reached through `globalThis` and guarded, so this
+ * module needs no Node types and is inert in a browser (every lookup misses and
+ * the caller's fallback applies).
+ *
+ * @module
+ */
+
+import { toBoolean } from "./object.ts";
+import { parseList, trimToNull } from "./string.ts";
+
+/** `process`-shaped view off `globalThis`, so no node types are needed. */
+interface ProcessLike {
+  env?: Record<string, string | undefined>;
+}
+
+/** One env var name, or several tried in order. */
+export type EnvKey = string | readonly string[];
+
+/** The ambient environment, or `{}` off-process (a browser). */
+function environment(): Record<string, string | undefined> {
+  return (globalThis as { process?: ProcessLike }).process?.env ?? {};
+}
+
+/**
+ * First non-empty value among `keys`, trimmed, else `null`.
+ *
+ * Several names for one setting is the norm (a package-specific variable plus
+ * the Databricks-standard one), so `keys` is order-sensitive: earlier names win.
+ *
+ * @example
+ * env.text(["TEAMS_APP_ID", "MICROSOFT_APP_ID"]);
+ */
+export function text(keys: EnvKey): string | null {
+  const env = environment();
+  for (const key of typeof keys === "string" ? [keys] : keys) {
+    const value = trimToNull(env[key]);
+    if (value !== null) return value;
+  }
+  return null;
+}
+
+/**
+ * Resolve a string setting: `configured` when set and non-empty, else the first
+ * non-empty variable among `keys`, else `null`.
+ *
+ * @example
+ * env.string(config.host, "SMTP_HOST");
+ */
+export function string(configured: unknown, keys: EnvKey): string | null {
+  return trimToNull(configured) ?? text(keys);
+}
+
+/**
+ * Resolve a boolean setting through {@link toBoolean}, so the loose spellings an
+ * env var actually carries (`1`, `on`, `yes`, ...) are accepted. Returns
+ * `undefined` when neither source is interpretable, letting the caller pick a
+ * default with `??`.
+ *
+ * @example
+ * env.boolean(config.fuzzy, "WEB_SEARCH_FUZZY") ?? true;
+ */
+export function boolean(configured: unknown, keys: EnvKey): boolean | undefined {
+  return toBoolean(configured) ?? toBoolean(text(keys));
+}
+
+/**
+ * Resolve a positive-number setting that may be fractional (a score threshold,
+ * a ratio): `configured` when it is a finite number greater than zero, else the
+ * first variable among `keys` that parses that way, else `fallback`.
+ *
+ * {@link positiveInt} is the right choice for a count; this one keeps the
+ * fraction, so a `0.4` threshold does not floor to `0`.
+ *
+ * @example
+ * env.positiveNumber(config.fuzzyThreshold, "SEARCH_FUZZY_THRESHOLD", 0.4);
+ */
+export function positiveNumber(configured: unknown, keys: EnvKey, fallback: number): number {
+  return toPositiveNumber(configured) ?? toPositiveNumber(text(keys)) ?? fallback;
+}
+
+/**
+ * Resolve a positive-integer setting (a port, timeout, page size, or cap):
+ * `configured` when it is a finite number greater than zero, else the first
+ * variable among `keys` that parses that way, else `fallback`. Floored, so a
+ * fractional value can't leak into a count.
+ *
+ * A non-numeric or non-positive value is treated as absent rather than fatal -
+ * these are ceilings and timeouts where a sane default beats a boot failure.
+ *
+ * @example
+ * env.positiveInt(config.timeoutMs, "SEARCH_TIMEOUT_MS", 30_000);
+ */
+export function positiveInt(configured: unknown, keys: EnvKey, fallback: number): number {
+  return toPositiveInt(configured) ?? toPositiveInt(text(keys)) ?? fallback;
+}
+
+function toPositiveNumber(value: unknown): number | undefined {
+  if (value === null || value === undefined || value === "") return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function toPositiveInt(value: unknown): number | undefined {
+  const parsed = toPositiveNumber(value);
+  return parsed === undefined ? undefined : Math.floor(parsed);
+}
+
+/**
+ * Resolve a list setting through {@link parseList}, so an array from typed
+ * config and a `"a, b c"` env string normalize identically. Returns `[]` when
+ * neither source has entries.
+ *
+ * @example
+ * env.list(config.modelFallbacks, "WEB_SEARCH_MODEL_FALLBACKS");
+ */
+export function list(
+  configured: string | readonly string[] | undefined | null,
+  keys: EnvKey,
+  transform?: (entry: string) => string,
+): string[] {
+  const fromConfig = parseList(configured, transform);
+  return fromConfig.length > 0 ? fromConfig : parseList(text(keys), transform);
+}

package/src/execution.ts

@@ -0,0 +1,71 @@
+/** Generic helpers for AppKit-style intercepted execution. */
+import * as async from "./async.ts";
+import * as error from "./error.ts";
+import * as object from "./object.ts";
+
+/** Success/failure shape returned by an interceptor-backed executor. */
+export type ExecutionResult<T> =
+  { ok: true; data: T } | { ok: false; status: number; message: string };
+
+/** Function signature shared by AppKit plugin executors. */
+export type Executor<Settings> = <T>(
+  fn: (signal?: AbortSignal) => Promise<T>,
+  settings: Settings,
+) => Promise<ExecutionResult<T>>;
+
+/** Failure details supplied when an intercepted operation cannot complete. */
+export interface ExecutionFailure {
+  operation: string;
+  status: number;
+  message: string;
+}
+
+/** Options for running and unwrapping one intercepted operation. */
+export interface RunOptions<T, Settings> {
+  operation: string;
+  settings: Settings;
+  execute: Executor<Settings>;
+  fn: (signal?: AbortSignal) => Promise<T>;
+  signal?: AbortSignal;
+  canceled: () => Error;
+  failed: (failure: ExecutionFailure) => Error;
+}
+
+function errorStatus(value: unknown): number {
+  if (!object.isRecord(value)) return 500;
+  const status = value.statusCode;
+  return typeof status === "number" && Number.isFinite(status) ? status : 500;
+}
+
+/**
+ * Build the executor used before a plugin installs its interceptor chain.
+ * Errors are mapped onto the same result shape as AppKit's `Plugin.execute()`.
+ */
+export function directExecutor<Settings>(): Executor<Settings> {
+  return async (fn) => {
+    try {
+      return { ok: true, data: await fn() };
+    } catch (cause) {
+      return {
+        ok: false,
+        status: errorStatus(cause),
+        message: error.errorMessage(cause),
+      };
+    }
+  };
+}
+
+/** Run an operation through an executor, merge cancellation, and unwrap its result. */
+export async function run<T, Settings>(options: RunOptions<T, Settings>): Promise<T> {
+  const result = await options.execute(
+    (executeSignal) => options.fn(async.combineAbortSignals(executeSignal, options.signal)),
+    options.settings,
+  );
+  if (result.ok) return result.data;
+  if (options.signal?.aborted) throw options.canceled();
+  throw options.failed({
+    operation: options.operation,
+    status: result.status,
+    message: result.message,
+  });
+}

package/src/object.ts

@@ -3,8 +3,9 @@
  *
  * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON
  * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link
- * deepEqual} compares structurally, and {@link NameLike}/{@link NonFunctionKeys}
- * describe object shapes.
+ * optional} spreads a field only when it is present, {@link deepEqual} compares
+ * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object
+ * shapes.
  *
  * Iterable helpers: {@link generator} flattens mixed arguments; {@link sequence}
  * wraps source(s) in a lazy, `Array`-compatible {@link Sequence}. Every
@@ -812,6 +813,28 @@ export function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+/**
+ * `{ [key]: value }` when `value` is present, otherwise `undefined` - so an
+ * absent optional field stays ABSENT when spread, rather than becoming an
+ * explicit `undefined` that `exactOptionalPropertyTypes` rejects.
+ *
+ * Spelling that inline costs a repeated, double-evaluated ternary per field
+ * (`...(v ? { key: v } : {})`), which is how config resolvers end up computing
+ * the same value twice.
+ *
+ * @example
+ * return {
+ *   ...optional("appId", env.text("MICROSOFT_APP_ID")),
+ *   ...optional("endpoint", config.endpoint),
+ * };
+ */
+export function optional<K extends string, V>(
+  key: K,
+  value: V | null | undefined,
+): Record<K, V> | undefined {
+  return value === null || value === undefined ? undefined : ({ [key]: value } as Record<K, V>);
+}
+
 /**
  * Coerce a loose boolean-ish value to a real `boolean`, or `undefined`
  * when it can't be interpreted. Recognizes `true`/`t`/`on`/`1`/`yes`/`y`

package/src/pattern.ts

@@ -0,0 +1,148 @@
+/**
+ * Literal / glob / regex string matching, compiled to a composable
+ * {@link Predicate}.
+ *
+ * A configurable allow-list is the same shape everywhere in this repo: a list of
+ * patterns from a config field or an env var, where an operator reasonably
+ * expects to write a plain value, a `*` wildcard, or - when neither is enough -
+ * a real regex. Each consumer used to grow its own `globToRegExp` +
+ * `/pattern/flags` parser; this is that parser, once.
+ *
+ * Three shapes are recognized per entry, tried in order:
+ *
+ * - **regex** - wrapped in slashes (`/^x-mastra-/`, with optional trailing
+ *   flags). Compiled as written. An invalid regex never matches: it is skipped
+ *   with a warning rather than throwing, so one bad entry cannot take a process
+ *   down at startup.
+ * - **glob** - contains `*` or `?` (`x-mastra-*`). Shell-style, anchored at both
+ *   ends: `*` matches any run of characters, `?` exactly one.
+ * - **literal** - anything else. Whole-string equality.
+ *
+ * Matching is case-INSENSITIVE by default, which is what the callers want (HTTP
+ * header names and email addresses are both case-insensitive); pass
+ * `caseSensitive` to opt out. An empty pattern list matches NOTHING, so a
+ * caller that treats "no patterns" as "permit everything" must special-case it
+ * rather than relying on the matcher.
+ *
+ * Browser-safe: hand-compiled to `RegExp` with no glob dependency, so this stays
+ * usable from a client bundle. Node code that needs path-aware globbing
+ * (`/` as a segment boundary, `**`) wants `@dbx-tools/path`'s `toPathMatcher`
+ * instead - that one is `minimatch`-backed and understands path semantics.
+ *
+ * @example
+ * const allowed = toPatternMatcher(["x-mastra-*", "/^x-trace-/"]);
+ * allowed("x-mastra-thread-id"); // true
+ * allowed("x-forwarded-user");   // false
+ *
+ * @module
+ */
+
+import { logger } from "./log.ts";
+import * as predicate from "./predicate.ts";
+import { parseList } from "./string.ts";
+
+const log = logger("shared/pattern");
+
+/** Options for {@link toPattern} / {@link toPatternMatcher}. */
+export interface PatternOptions {
+  /** Match case-sensitively. Default `false` (case-insensitive). */
+  caseSensitive?: boolean;
+}
+
+/** Escape a string for literal use inside a `RegExp`. */
+export function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** True when `pattern` is a `/.../flags` regex literal. */
+function isRegexLiteral(pattern: string): boolean {
+  return pattern.length > 1 && pattern.startsWith("/") && /\/[a-z]*$/i.test(pattern);
+}
+
+/** True when `pattern` contains a glob wildcard. */
+function isGlob(pattern: string): boolean {
+  return pattern.includes("*") || pattern.includes("?");
+}
+
+/**
+ * Compile a `/pattern/flags` literal, or `undefined` when it is malformed or
+ * the body is not a valid regex.
+ */
+function compileRegexLiteral(pattern: string, caseSensitive: boolean): RegExp | undefined {
+  const parsed = /^\/(.+)\/([a-z]*)$/is.exec(pattern);
+  if (!parsed) return undefined;
+  const body = parsed[1]!;
+  const flags = parsed[2]!;
+  try {
+    return new RegExp(body, caseSensitive || flags.includes("i") ? flags : `${flags}i`);
+  } catch (error) {
+    log.warn("ignoring invalid regex pattern", { pattern, error });
+    return undefined;
+  }
+}
+
+/**
+ * Compile a shell-style glob (`*`, `?`) into an anchored `RegExp`. Every other
+ * character is escaped, so a glob can safely contain regex metacharacters
+ * (`x-app.*` matches a literal dot followed by anything).
+ */
+function compileGlob(pattern: string, caseSensitive: boolean): RegExp {
+  const body = pattern
+    .split(/([*?])/)
+    .map((part) => (part === "*" ? ".*" : part === "?" ? "." : escapeRegExp(part)))
+    .join("");
+  return new RegExp(`^${body}$`, caseSensitive ? "" : "i");
+}
+
+/**
+ * Compile ONE pattern into a predicate, or `undefined` when the entry is empty
+ * or an unparseable regex literal.
+ *
+ * Callers that want a whole list should use {@link toPatternMatcher}; this is
+ * exported for the case where a consumer applies its own semantics to some
+ * shapes and only wants the glob/regex handling (the email gate's bare-domain
+ * shortcut, for one).
+ */
+export function toPattern(
+  pattern: string,
+  options: PatternOptions = {},
+): predicate.Predicate<string> | undefined {
+  const trimmed = pattern.trim();
+  if (!trimmed) return undefined;
+  const caseSensitive = options.caseSensitive ?? false;
+
+  if (isRegexLiteral(trimmed)) {
+    const compiled = compileRegexLiteral(trimmed, caseSensitive);
+    return compiled && predicate.create<string>((value) => compiled.test(value));
+  }
+  if (isGlob(trimmed)) {
+    const compiled = compileGlob(trimmed, caseSensitive);
+    return predicate.create<string>((value) => compiled.test(value));
+  }
+  // Literal: whole-string equality.
+  const expected = caseSensitive ? trimmed : trimmed.toLowerCase();
+  return predicate.create<string>((value) =>
+    caseSensitive ? value === expected : value.toLowerCase() === expected,
+  );
+}
+
+/**
+ * Compile patterns into a single OR'd {@link Predicate}. Accepts the raw config
+ * shapes {@link parseList} does - an array, or one comma/whitespace-separated
+ * string - so a field and its env var need no separate handling.
+ *
+ * With no usable patterns the result always returns `false`.
+ *
+ * @example
+ * const forwardable = toPatternMatcher(process.env.TUNNEL_FORWARD_HEADERS);
+ */
+export function toPatternMatcher(
+  patterns: string | readonly string[] | undefined | null,
+  options: PatternOptions = {},
+): predicate.Predicate<string> {
+  const compiled = parseList(patterns)
+    .map((pattern) => toPattern(pattern, options))
+    .filter((value): value is predicate.Predicate<string> => value !== undefined);
+  if (compiled.length === 0) return predicate.create<string>(() => false);
+  return compiled.slice(1).reduce((acc, next) => acc.or(next), compiled[0]!);
+}

package/src/token.ts

@@ -15,6 +15,23 @@ const BEARER_PREFIX_REGEX = /^bearer\s+/i;
 const SPLIT_REGEX = /\s+|\s*,\s*/;
 const log = logger("shared/token");
 
+/**
+ * Header the Databricks Apps front door forwards the caller's OAuth (OBO) token
+ * on - the default source for every helper here.
+ *
+ * Exported because it is a wire contract several packages branch on, not just a
+ * default argument: `@dbx-tools/appkit`'s `identity` module decides whether a
+ * request can use OBO auth at all by its presence, and `@dbx-tools/cli-tunnel`
+ * must know the name to strip inbound copies of it. One spelling, one place.
+ */
+export const ACCESS_TOKEN_HEADER = "x-forwarded-access-token";
+
+/** Header the front door forwards the caller's user id on. */
+export const USER_ID_HEADER = "x-forwarded-user";
+
+/** Header the front door forwards the caller's email on. */
+export const USER_EMAIL_HEADER = "x-forwarded-email";
+
 /**
  * Decode a JWT segment (base64url with standard base64 padding), or
  * `undefined` when the segment is not valid base64.
@@ -39,7 +56,7 @@ function decodeJwtSegment(segment: string): string | undefined {
  */
 export function getAccessTokenPayload(
   input: HeaderLike | string,
-  headerName: string | undefined = "x-forwarded-access-token",
+  headerName: string | undefined = ACCESS_TOKEN_HEADER,
 ): Record<string, unknown> {
   let accessTokenPayload: Record<string, unknown> | undefined;
   if (!(typeof input === "string")) {