@dbx-tools/shared-core 0.6.48 → 0.6.49

package/README.md

@@ -261,6 +261,36 @@ const internal = cidr ? net.ipInCidr("10.1.2.3", cidr) : false;
 `net.pathMatch()` compares path prefixes on segment boundaries. IP/CIDR helpers
 parse IPv4 and IPv6 into a shared bigint comparison model.
 
+## Allow-List Patterns
+
+```ts
+// One matcher from a config array OR a delimited env string.
+const forwardable = pattern.toPatternMatcher(["x-mastra-*", "/^x-trace-/", "x-tenant"]);
+
+forwardable("x-mastra-model"); // true  (glob)
+forwardable("x-trace-parent"); // true  (regex literal)
+forwardable("x-tenant"); // true  (literal, whole-string)
+forwardable("x-forwarded-user"); // false
+```
+
+Every configurable allow-list in this repo takes the same three shapes, so the
+compilation lives here once: a `/regex/` literal (with optional flags), a
+shell-style glob (`*`, `?`, anchored at both ends, all other characters escaped),
+or a literal compared whole-string. Matching is case-insensitive by default -
+what HTTP header names and email addresses both want - and `caseSensitive` opts
+out.
+
+An invalid regex is skipped with a warning instead of throwing, so one bad
+config entry cannot stop a process from starting. No usable patterns yields a
+matcher that always returns `false`; a caller that reads "no patterns" as "permit
+everything" must say so itself. The result is a `predicate`, so it composes with
+`.and()` / `.or()` / `.negate()`.
+
+Reach for [`@dbx-tools/path`](../../node/path)'s `toPathMatcher` instead when
+matching a filesystem path or URL path, where `/` is a segment boundary and `**`
+is meaningful - that one is `minimatch`-backed. This module is deliberately
+dependency-free so it stays usable in a browser bundle.
+
 ## Token Claims
 
 ```ts
@@ -312,6 +342,8 @@ without paying formatting cost when disabled.
 - `env` - config-over-environment resolution: strings, booleans, positive
   numbers/integers, and lists, with env-name fallback chains.
 - `predicate` - composable boolean/type predicates.
+- `pattern` - literal / glob / `/regex/` allow-list matching compiled to a
+  predicate.
 - `http` - header iteration, cookie parsing, and fetch error creation.
 - `execution` - direct executor fallback, cancellation merging, and result unwrapping.
 - `net` - URL building, email parsing, path matching, IP/CIDR helpers.

package/index.ts

@@ -14,6 +14,7 @@ export * as json from "./src/json.ts";
 export * as log from "./src/log.ts";
 export * as net from "./src/net.ts";
 export * as object from "./src/object.ts";
+export * as pattern from "./src/pattern.ts";
 export * as predicate from "./src/predicate.ts";
 export * as string from "./src/string.ts";
 export * as token from "./src/token.ts";
@@ -28,5 +29,7 @@ export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";
 export type { UrlLike, IpVersion, ParsedIp, Cidr, UrlBuilder, ParseEmailsOptions } from "./src/net.ts";
 export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, DeepEqualComparator } from "./src/object.ts";
+export type { PatternOptions } from "./src/pattern.ts";
 export type { PredicateFunction, TypePredicateFunction, PredicateInput, Predicate } from "./src/predicate.ts";
 export type { TokenizeOptions, KeyOptions, IdentifierOptions, Description } from "./src/string.ts";
+export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER } from "./src/token.ts";

package/lib/index.d.ts

@@ -10,6 +10,7 @@ export * as json from "./src/json.ts";
 export * as log from "./src/log.ts";
 export * as net from "./src/net.ts";
 export * as object from "./src/object.ts";
+export * as pattern from "./src/pattern.ts";
 export * as predicate from "./src/predicate.ts";
 export * as string from "./src/string.ts";
 export * as token from "./src/token.ts";
@@ -24,5 +25,7 @@ export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";
 export type { UrlLike, IpVersion, ParsedIp, Cidr, UrlBuilder, ParseEmailsOptions } from "./src/net.ts";
 export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, DeepEqualComparator } from "./src/object.ts";
+export type { PatternOptions } from "./src/pattern.ts";
 export type { PredicateFunction, TypePredicateFunction, PredicateInput, Predicate } from "./src/predicate.ts";
 export type { TokenizeOptions, KeyOptions, IdentifierOptions, Description } from "./src/string.ts";
+export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER } from "./src/token.ts";

package/lib/index.js

@@ -13,8 +13,10 @@ export * as json from "./src/json.js";
 export * as log from "./src/log.js";
 export * as net from "./src/net.js";
 export * as object from "./src/object.js";
+export * as pattern from "./src/pattern.js";
 export * as predicate from "./src/predicate.js";
 export * as string from "./src/string.js";
 export * as token from "./src/token.js";
 export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.js";
-//# sourceMappingURL=data:application/json;base64,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
+export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER } from "./src/token.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/pattern.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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 * as predicate from "./predicate.ts";
+/** 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 declare function escapeRegExp(value: string): string;
+/**
+ * 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 declare function toPattern(pattern: string, options?: PatternOptions): predicate.Predicate<string> | undefined;
+/**
+ * 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 declare function toPatternMatcher(patterns: string | readonly string[] | undefined | null, options?: PatternOptions): predicate.Predicate<string>;

package/lib/src/pattern.js

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

package/lib/src/token.d.ts

@@ -7,6 +7,20 @@
  * @module
  */
 import { type HeaderLike } from "./http.ts";
+/**
+ * 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 declare const ACCESS_TOKEN_HEADER = "x-forwarded-access-token";
+/** Header the front door forwards the caller's user id on. */
+export declare const USER_ID_HEADER = "x-forwarded-user";
+/** Header the front door forwards the caller's email on. */
+export declare const USER_EMAIL_HEADER = "x-forwarded-email";
 /**
  * Decode the JWT payload from a bearer token string or request headers.
  *

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/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/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.48",
+  "version": "0.6.49",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

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")) {