@dbx-tools/cli-tunnel 0.6.48 → 0.6.49

package/lib/src/env.js

@@ -0,0 +1,51 @@
+/**
+ * Environment-variable names the tunnel reads.
+ *
+ * Every setting is `TUNNEL_`-prefixed, matching the repo convention of naming a
+ * variable after the package that owns it (`MASTRA_*`, `TEAMS_*`,
+ * `WEB_SEARCH_*`). The gate's original names were unprefixed (`AUTH_SUBJECT`,
+ * `PUBLIC_DOMAIN`, ...), which is a real hazard for a package that runs as a
+ * WRAPPER: the tunnel and the app it wraps share one environment, so a generic
+ * name is one the wrapped app may already use for something else, and
+ * `PUBLIC_DOMAIN` in particular reads like an app-wide setting rather than a
+ * portr detail. `EMAIL_AUTH_ALLOW` was worse than generic - it sat in
+ * `@dbx-tools/email`'s `EMAIL_*` namespace while configuring the gate, not email.
+ *
+ * Each entry is an {@link EnvKey} list, EARLIEST-WINS, whose first element is the
+ * current name and whose remaining elements are the deprecated originals. A
+ * deployment set up against the old names keeps working; nothing needs a
+ * coordinated rename. Read them through `env.string` / `env.positiveInt` /
+ * `env.list`, which accept the list directly.
+ *
+ * Not renamed:
+ *
+ *   - `DATABRICKS_APP_PORT` - the Databricks Apps runtime contract. The platform
+ *     sets it; the gate honours it.
+ *   - `PORTR_TOKEN` / `PORTR_SERVER` / `PORTR_AUTO_ADD_PATH` - upstream
+ *     [portr](https://github.com/amalshaji/portr)'s own namespace, and
+ *     `PORTR_AUTO_ADD_PATH` is passed straight to that binary. Renaming these
+ *     would rename someone else's contract.
+ *
+ * @module
+ */
+/** Access allow-list patterns (domain / glob / `/regex/`). */
+export const ALLOW_ENV = ["TUNNEL_AUTH_ALLOW", "EMAIL_AUTH_ALLOW"];
+/** Subject line for the code email. */
+export const SUBJECT_ENV = ["TUNNEL_AUTH_SUBJECT", "AUTH_SUBJECT"];
+/** Display name used in the code email copy. */
+export const BRAND_NAME_ENV = ["TUNNEL_AUTH_BRAND_NAME", "AUTH_BRAND_NAME"];
+/** Line shown immediately above the code in the email. */
+export const MESSAGE_ENV = ["TUNNEL_AUTH_MESSAGE", "AUTH_MESSAGE"];
+/** Session lifetime, in seconds. */
+export const SESSION_TTL_ENV = ["TUNNEL_AUTH_SESSION_TTL", "AUTH_SESSION_TTL"];
+/** One-time-code lifetime, in seconds. */
+export const CODE_TTL_ENV = ["TUNNEL_AUTH_CODE_TTL", "AUTH_CODE_TTL"];
+/** HS256 signing secret for the session JWT. */
+export const JWT_SECRET_ENV = ["TUNNEL_AUTH_JWT_SECRET", "AUTH_JWT_SECRET"];
+/** The public `<subdomain>.<server>` portr should serve on. */
+export const PUBLIC_DOMAIN_ENV = ["TUNNEL_PUBLIC_DOMAIN", "PUBLIC_DOMAIN"];
+/** Run the tunnel OPEN, with no gate. Ignored unless truthy. */
+export const INSECURE_ENV = "TUNNEL_INSECURE";
+/** Extra `x-` request headers tunnel traffic may forward. */
+export const FORWARD_HEADERS_ENV = "TUNNEL_FORWARD_HEADERS";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/headers.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Inbound header policy for tunnel traffic.
+ *
+ * Everything the gate forwards arrives from the PUBLIC internet through the
+ * portr client, so every header on it is attacker-controlled. The headers an app
+ * trusts are precisely the ones a caller must not be able to write, because the
+ * app cannot tell a header the Databricks front door set from one a browser
+ * typed.
+ *
+ * ## Policy shape: strip by default, allow by pattern
+ *
+ * Enumerating what to remove is a losing game - a deny-list is only correct until
+ * the platform adds a header or a library starts trusting another one - so the
+ * policy is inverted. EVERY `x-`-prefixed request header is dropped from tunnel
+ * traffic unless it matches a configured pattern. That fails CLOSED: a header
+ * nobody thought about is removed rather than trusted.
+ *
+ * The allow-list is zero-to-many literals, globs, or `/regex/`es, compiled by
+ * shared-core's {@link pattern.toPatternMatcher}, and is UNIONED with
+ * {@link DEFAULT_FORWARD_HEADERS} so extending it never silently breaks the
+ * built-in surfaces. Configure it with `forwardHeaders` /
+ * `TUNNEL_FORWARD_HEADERS`.
+ *
+ * Non-`x-` headers are untouched. Standard ones (`content-type`, `accept`,
+ * `authorization`, `cookie`, ...) are the app's normal input and the gate has no
+ * business rewriting them.
+ *
+ * ## The headers no pattern can forward
+ *
+ * {@link PROTECTED_HEADERS} is stripped BEFORE the allow-list is consulted, so a
+ * permissive pattern (`x-*`, or a careless `*`) cannot re-open impersonation:
+ *
+ * | Header                           | What an app does with it        | Why spoofing it matters |
+ * | -------------------------------- | ------------------------------- | ----------------------- |
+ * | `x-forwarded-access-token`       | OBO auth (AppKit `asUser`)      | Paste any workspace token and every call runs as its owner. The gate's verified email says nothing about who a pasted credential belongs to. |
+ * | `x-forwarded-user`               | Caller identity                 | Impersonate another user. The gate sets this itself, from a verified session. |
+ * | `x-forwarded-email`              | Caller identity                 | Same. |
+ * | `x-forwarded-preferred-username` | Display name from the IdP       | Same. |
+ * | `x-forwarded-host`               | The originally-requested host    | Poison absolute URLs the app builds (the classic reset-link attack). |
+ * | `x-forwarded-proto` / `-port`    | Original scheme / port          | Convince the app a plaintext request arrived over TLS. |
+ * | `x-forwarded-for`                | Client IP                       | Forge the audit trail, and fan out per-IP rate-limit keys (see below). |
+ * | `x-real-ip`                      | Client IP                       | Same. |
+ * | `x-request-id`                   | Request correlation UUID        | Forge or collide trace ids, making logs unreliable. |
+ *
+ * The identity four are AppKit's OBO contract; the rest are the `X-Forwarded-*`
+ * set the Databricks Apps reverse proxy documents passing to an app
+ * ({@link https://docs.databricks.com/aws/en/dev-tools/databricks-apps/http-headers}),
+ * plus the conventional `x-forwarded-proto`/`-port`/`x-real-ip` an app or one of
+ * its libraries may read even though the table omits them.
+ *
+ * Stripping the `x-forwarded-*` transport trio is safe because `http-proxy-3` is
+ * configured with `xfwd: true` and re-adds them AFTER this policy runs - from the
+ * real socket, not from the caller's claim. The app therefore sees the honest
+ * (loopback) values instead of whatever the internet asserted. The gate reads the
+ * client IP for rate limiting from the raw inbound headers BEFORE stripping, and
+ * takes the RIGHTMOST `x-forwarded-for` entry, which is the only one a proxy
+ * appended rather than a client supplied.
+ *
+ * @module
+ */
+/**
+ * Headers the gate strips UNCONDITIONALLY, before the allow-list is consulted -
+ * the platform-shaped set documented in this module's table.
+ *
+ * These answer WHO a request is and WHERE it came from, and on tunnel traffic
+ * only the gate may answer that: it injects {@link token.USER_ID_HEADER} /
+ * {@link token.USER_EMAIL_HEADER} itself after verifying a session, and the proxy
+ * re-derives the transport headers from the real socket.
+ *
+ * The identity names come from the shared `token` constants, so a renamed wire
+ * contract cannot leave a stale spelling here. `x-forwarded-preferred-username`
+ * has no constant because nothing in this repo READS it - it is listed precisely
+ * so a host app that does read it cannot be fed one.
+ */
+export declare const PROTECTED_HEADERS: readonly string[];
+/**
+ * The `x-` headers forwarded when a deployment configures nothing.
+ *
+ * These are the header NAMESPACES this repo's own UI sends and its own server
+ * reads - Mastra thread/model routing (`x-mastra-thread-id`, `x-mastra-model`)
+ * and MLflow trace correlation (`x-mlflow-trace-id`) - so a dbx-tools app keeps
+ * working behind the tunnel with no configuration.
+ *
+ * Deliberately GLOBS rather than the exact constants from
+ * `@dbx-tools/shared-mastra`: importing them would make the gate - a
+ * transport-level component that has no other opinion about Mastra - depend on
+ * an agent package for three strings, and a namespace glob also covers the next
+ * header those packages add. The namespaces are the stable part of the contract.
+ */
+export declare const DEFAULT_FORWARD_HEADERS: readonly string[];
+/** A compiled inbound-header policy. Build one with {@link toHeaderPolicy}. */
+export interface HeaderPolicy {
+    /** The allow-list entries backing this policy (for diagnostics and tests). */
+    readonly patterns: readonly string[];
+    /** Whether `name` survives on tunnel traffic. */
+    forwards(name: string): boolean;
+    /**
+     * Delete every disallowed header from a mutable Node header bag, returning the
+     * lower-cased names removed (for debug logging).
+     */
+    apply(headers: Record<string, unknown>): string[];
+}
+/**
+ * Compile the inbound-header policy. `configured` entries are UNIONED with
+ * {@link DEFAULT_FORWARD_HEADERS}; each may be a literal name, a glob
+ * (`x-myapp-*`), or a `/regex/`. Matching is case-insensitive.
+ */
+export declare function toHeaderPolicy(configured?: readonly string[]): HeaderPolicy;

package/lib/src/headers.js

@@ -0,0 +1,140 @@
+/**
+ * Inbound header policy for tunnel traffic.
+ *
+ * Everything the gate forwards arrives from the PUBLIC internet through the
+ * portr client, so every header on it is attacker-controlled. The headers an app
+ * trusts are precisely the ones a caller must not be able to write, because the
+ * app cannot tell a header the Databricks front door set from one a browser
+ * typed.
+ *
+ * ## Policy shape: strip by default, allow by pattern
+ *
+ * Enumerating what to remove is a losing game - a deny-list is only correct until
+ * the platform adds a header or a library starts trusting another one - so the
+ * policy is inverted. EVERY `x-`-prefixed request header is dropped from tunnel
+ * traffic unless it matches a configured pattern. That fails CLOSED: a header
+ * nobody thought about is removed rather than trusted.
+ *
+ * The allow-list is zero-to-many literals, globs, or `/regex/`es, compiled by
+ * shared-core's {@link pattern.toPatternMatcher}, and is UNIONED with
+ * {@link DEFAULT_FORWARD_HEADERS} so extending it never silently breaks the
+ * built-in surfaces. Configure it with `forwardHeaders` /
+ * `TUNNEL_FORWARD_HEADERS`.
+ *
+ * Non-`x-` headers are untouched. Standard ones (`content-type`, `accept`,
+ * `authorization`, `cookie`, ...) are the app's normal input and the gate has no
+ * business rewriting them.
+ *
+ * ## The headers no pattern can forward
+ *
+ * {@link PROTECTED_HEADERS} is stripped BEFORE the allow-list is consulted, so a
+ * permissive pattern (`x-*`, or a careless `*`) cannot re-open impersonation:
+ *
+ * | Header                           | What an app does with it        | Why spoofing it matters |
+ * | -------------------------------- | ------------------------------- | ----------------------- |
+ * | `x-forwarded-access-token`       | OBO auth (AppKit `asUser`)      | Paste any workspace token and every call runs as its owner. The gate's verified email says nothing about who a pasted credential belongs to. |
+ * | `x-forwarded-user`               | Caller identity                 | Impersonate another user. The gate sets this itself, from a verified session. |
+ * | `x-forwarded-email`              | Caller identity                 | Same. |
+ * | `x-forwarded-preferred-username` | Display name from the IdP       | Same. |
+ * | `x-forwarded-host`               | The originally-requested host    | Poison absolute URLs the app builds (the classic reset-link attack). |
+ * | `x-forwarded-proto` / `-port`    | Original scheme / port          | Convince the app a plaintext request arrived over TLS. |
+ * | `x-forwarded-for`                | Client IP                       | Forge the audit trail, and fan out per-IP rate-limit keys (see below). |
+ * | `x-real-ip`                      | Client IP                       | Same. |
+ * | `x-request-id`                   | Request correlation UUID        | Forge or collide trace ids, making logs unreliable. |
+ *
+ * The identity four are AppKit's OBO contract; the rest are the `X-Forwarded-*`
+ * set the Databricks Apps reverse proxy documents passing to an app
+ * ({@link https://docs.databricks.com/aws/en/dev-tools/databricks-apps/http-headers}),
+ * plus the conventional `x-forwarded-proto`/`-port`/`x-real-ip` an app or one of
+ * its libraries may read even though the table omits them.
+ *
+ * Stripping the `x-forwarded-*` transport trio is safe because `http-proxy-3` is
+ * configured with `xfwd: true` and re-adds them AFTER this policy runs - from the
+ * real socket, not from the caller's claim. The app therefore sees the honest
+ * (loopback) values instead of whatever the internet asserted. The gate reads the
+ * client IP for rate limiting from the raw inbound headers BEFORE stripping, and
+ * takes the RIGHTMOST `x-forwarded-for` entry, which is the only one a proxy
+ * appended rather than a client supplied.
+ *
+ * @module
+ */
+import { pattern, token } from "@dbx-tools/shared-core";
+/**
+ * Headers the gate strips UNCONDITIONALLY, before the allow-list is consulted -
+ * the platform-shaped set documented in this module's table.
+ *
+ * These answer WHO a request is and WHERE it came from, and on tunnel traffic
+ * only the gate may answer that: it injects {@link token.USER_ID_HEADER} /
+ * {@link token.USER_EMAIL_HEADER} itself after verifying a session, and the proxy
+ * re-derives the transport headers from the real socket.
+ *
+ * The identity names come from the shared `token` constants, so a renamed wire
+ * contract cannot leave a stale spelling here. `x-forwarded-preferred-username`
+ * has no constant because nothing in this repo READS it - it is listed precisely
+ * so a host app that does read it cannot be fed one.
+ */
+export const PROTECTED_HEADERS = [
+    token.ACCESS_TOKEN_HEADER,
+    token.USER_ID_HEADER,
+    token.USER_EMAIL_HEADER,
+    "x-forwarded-preferred-username",
+    "x-forwarded-host",
+    "x-forwarded-proto",
+    "x-forwarded-port",
+    "x-forwarded-for",
+    "x-real-ip",
+    "x-request-id",
+];
+/**
+ * The `x-` headers forwarded when a deployment configures nothing.
+ *
+ * These are the header NAMESPACES this repo's own UI sends and its own server
+ * reads - Mastra thread/model routing (`x-mastra-thread-id`, `x-mastra-model`)
+ * and MLflow trace correlation (`x-mlflow-trace-id`) - so a dbx-tools app keeps
+ * working behind the tunnel with no configuration.
+ *
+ * Deliberately GLOBS rather than the exact constants from
+ * `@dbx-tools/shared-mastra`: importing them would make the gate - a
+ * transport-level component that has no other opinion about Mastra - depend on
+ * an agent package for three strings, and a namespace glob also covers the next
+ * header those packages add. The namespaces are the stable part of the contract.
+ */
+export const DEFAULT_FORWARD_HEADERS = [
+    "x-mastra-*",
+    "x-mlflow-*",
+    // Sent by fetch/XHR wrappers to mark an AJAX request; harmless and widely read.
+    "x-requested-with",
+];
+/**
+ * Compile the inbound-header policy. `configured` entries are UNIONED with
+ * {@link DEFAULT_FORWARD_HEADERS}; each may be a literal name, a glob
+ * (`x-myapp-*`), or a `/regex/`. Matching is case-insensitive.
+ */
+export function toHeaderPolicy(configured = []) {
+    const patterns = [...DEFAULT_FORWARD_HEADERS, ...configured];
+    const allowed = pattern.toPatternMatcher(patterns);
+    const protectedNames = new Set(PROTECTED_HEADERS);
+    const forwards = (name) => {
+        const lower = name.toLowerCase();
+        if (protectedNames.has(lower))
+            return false;
+        if (!lower.startsWith("x-"))
+            return true;
+        return allowed(lower);
+    };
+    return {
+        patterns,
+        forwards,
+        apply: (headers) => {
+            const removed = [];
+            for (const name of Object.keys(headers)) {
+                if (forwards(name))
+                    continue;
+                delete headers[name];
+                removed.push(name.toLowerCase());
+            }
+            return removed;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"headers.js","sourceRoot":"","sources":["../../src/headers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH,OAAO,EAAE,OAAO,EAAE,KAAK,EAAkB,MAAM,wBAAwB,CAAC;AAExE;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAsB;IAClD,KAAK,CAAC,mBAAmB;IACzB,KAAK,CAAC,cAAc;IACpB,KAAK,CAAC,iBAAiB;IACvB,gCAAgC;IAChC,kBAAkB;IAClB,mBAAmB;IACnB,kBAAkB;IAClB,iBAAiB;IACjB,WAAW;IACX,cAAc;CACf,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAsB;IACxD,YAAY;IACZ,YAAY;IACZ,gFAAgF;IAChF,kBAAkB;CACnB,CAAC;AAeF;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,aAAgC,EAAE;IAC/D,MAAM,QAAQ,GAAG,CAAC,GAAG,uBAAuB,EAAE,GAAG,UAAU,CAAC,CAAC;IAC7D,MAAM,OAAO,GAAsB,OAAO,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IACtE,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAElD,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAW,EAAE;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACjC,IAAI,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QACzC,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC,CAAC;IAEF,OAAO;QACL,QAAQ;QACR,QAAQ;QACR,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE;YACjB,MAAM,OAAO,GAAa,EAAE,CAAC;YAC7B,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;gBACxC,IAAI,QAAQ,CAAC,IAAI,CAAC;oBAAE,SAAS;gBAC7B,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;gBACrB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;YACnC,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Inbound header policy for tunnel traffic.\n *\n * Everything the gate forwards arrives from the PUBLIC internet through the\n * portr client, so every header on it is attacker-controlled. The headers an app\n * trusts are precisely the ones a caller must not be able to write, because the\n * app cannot tell a header the Databricks front door set from one a browser\n * typed.\n *\n * ## Policy shape: strip by default, allow by pattern\n *\n * Enumerating what to remove is a losing game - a deny-list is only correct until\n * the platform adds a header or a library starts trusting another one - so the\n * policy is inverted. EVERY `x-`-prefixed request header is dropped from tunnel\n * traffic unless it matches a configured pattern. That fails CLOSED: a header\n * nobody thought about is removed rather than trusted.\n *\n * The allow-list is zero-to-many literals, globs, or `/regex/`es, compiled by\n * shared-core's {@link pattern.toPatternMatcher}, and is UNIONED with\n * {@link DEFAULT_FORWARD_HEADERS} so extending it never silently breaks the\n * built-in surfaces. Configure it with `forwardHeaders` /\n * `TUNNEL_FORWARD_HEADERS`.\n *\n * Non-`x-` headers are untouched. Standard ones (`content-type`, `accept`,\n * `authorization`, `cookie`, ...) are the app's normal input and the gate has no\n * business rewriting them.\n *\n * ## The headers no pattern can forward\n *\n * {@link PROTECTED_HEADERS} is stripped BEFORE the allow-list is consulted, so a\n * permissive pattern (`x-*`, or a careless `*`) cannot re-open impersonation:\n *\n * | Header                           | What an app does with it        | Why spoofing it matters |\n * | -------------------------------- | ------------------------------- | ----------------------- |\n * | `x-forwarded-access-token`       | OBO auth (AppKit `asUser`)      | Paste any workspace token and every call runs as its owner. The gate's verified email says nothing about who a pasted credential belongs to. |\n * | `x-forwarded-user`               | Caller identity                 | Impersonate another user. The gate sets this itself, from a verified session. |\n * | `x-forwarded-email`              | Caller identity                 | Same. |\n * | `x-forwarded-preferred-username` | Display name from the IdP       | Same. |\n * | `x-forwarded-host`               | The originally-requested host    | Poison absolute URLs the app builds (the classic reset-link attack). |\n * | `x-forwarded-proto` / `-port`    | Original scheme / port          | Convince the app a plaintext request arrived over TLS. |\n * | `x-forwarded-for`                | Client IP                       | Forge the audit trail, and fan out per-IP rate-limit keys (see below). |\n * | `x-real-ip`                      | Client IP                       | Same. |\n * | `x-request-id`                   | Request correlation UUID        | Forge or collide trace ids, making logs unreliable. |\n *\n * The identity four are AppKit's OBO contract; the rest are the `X-Forwarded-*`\n * set the Databricks Apps reverse proxy documents passing to an app\n * ({@link https://docs.databricks.com/aws/en/dev-tools/databricks-apps/http-headers}),\n * plus the conventional `x-forwarded-proto`/`-port`/`x-real-ip` an app or one of\n * its libraries may read even though the table omits them.\n *\n * Stripping the `x-forwarded-*` transport trio is safe because `http-proxy-3` is\n * configured with `xfwd: true` and re-adds them AFTER this policy runs - from the\n * real socket, not from the caller's claim. The app therefore sees the honest\n * (loopback) values instead of whatever the internet asserted. The gate reads the\n * client IP for rate limiting from the raw inbound headers BEFORE stripping, and\n * takes the RIGHTMOST `x-forwarded-for` entry, which is the only one a proxy\n * appended rather than a client supplied.\n *\n * @module\n */\n\nimport { pattern, token, type Predicate } from \"@dbx-tools/shared-core\";\n\n/**\n * Headers the gate strips UNCONDITIONALLY, before the allow-list is consulted -\n * the platform-shaped set documented in this module's table.\n *\n * These answer WHO a request is and WHERE it came from, and on tunnel traffic\n * only the gate may answer that: it injects {@link token.USER_ID_HEADER} /\n * {@link token.USER_EMAIL_HEADER} itself after verifying a session, and the proxy\n * re-derives the transport headers from the real socket.\n *\n * The identity names come from the shared `token` constants, so a renamed wire\n * contract cannot leave a stale spelling here. `x-forwarded-preferred-username`\n * has no constant because nothing in this repo READS it - it is listed precisely\n * so a host app that does read it cannot be fed one.\n */\nexport const PROTECTED_HEADERS: readonly string[] = [\n  token.ACCESS_TOKEN_HEADER,\n  token.USER_ID_HEADER,\n  token.USER_EMAIL_HEADER,\n  \"x-forwarded-preferred-username\",\n  \"x-forwarded-host\",\n  \"x-forwarded-proto\",\n  \"x-forwarded-port\",\n  \"x-forwarded-for\",\n  \"x-real-ip\",\n  \"x-request-id\",\n];\n\n/**\n * The `x-` headers forwarded when a deployment configures nothing.\n *\n * These are the header NAMESPACES this repo's own UI sends and its own server\n * reads - Mastra thread/model routing (`x-mastra-thread-id`, `x-mastra-model`)\n * and MLflow trace correlation (`x-mlflow-trace-id`) - so a dbx-tools app keeps\n * working behind the tunnel with no configuration.\n *\n * Deliberately GLOBS rather than the exact constants from\n * `@dbx-tools/shared-mastra`: importing them would make the gate - a\n * transport-level component that has no other opinion about Mastra - depend on\n * an agent package for three strings, and a namespace glob also covers the next\n * header those packages add. The namespaces are the stable part of the contract.\n */\nexport const DEFAULT_FORWARD_HEADERS: readonly string[] = [\n  \"x-mastra-*\",\n  \"x-mlflow-*\",\n  // Sent by fetch/XHR wrappers to mark an AJAX request; harmless and widely read.\n  \"x-requested-with\",\n];\n\n/** A compiled inbound-header policy. Build one with {@link toHeaderPolicy}. */\nexport interface HeaderPolicy {\n  /** The allow-list entries backing this policy (for diagnostics and tests). */\n  readonly patterns: readonly string[];\n  /** Whether `name` survives on tunnel traffic. */\n  forwards(name: string): boolean;\n  /**\n   * Delete every disallowed header from a mutable Node header bag, returning the\n   * lower-cased names removed (for debug logging).\n   */\n  apply(headers: Record<string, unknown>): string[];\n}\n\n/**\n * Compile the inbound-header policy. `configured` entries are UNIONED with\n * {@link DEFAULT_FORWARD_HEADERS}; each may be a literal name, a glob\n * (`x-myapp-*`), or a `/regex/`. Matching is case-insensitive.\n */\nexport function toHeaderPolicy(configured: readonly string[] = []): HeaderPolicy {\n  const patterns = [...DEFAULT_FORWARD_HEADERS, ...configured];\n  const allowed: Predicate<string> = pattern.toPatternMatcher(patterns);\n  const protectedNames = new Set(PROTECTED_HEADERS);\n\n  const forwards = (name: string): boolean => {\n    const lower = name.toLowerCase();\n    if (protectedNames.has(lower)) return false;\n    if (!lower.startsWith(\"x-\")) return true;\n    return allowed(lower);\n  };\n\n  return {\n    patterns,\n    forwards,\n    apply: (headers) => {\n      const removed: string[] = [];\n      for (const name of Object.keys(headers)) {\n        if (forwards(name)) continue;\n        delete headers[name];\n        removed.push(name.toLowerCase());\n      }\n      return removed;\n    },\n  };\n}\n"]}

package/lib/src/otp.d.ts

@@ -9,7 +9,7 @@
  * the hash, and the entry is deleted on success or once attempts are exhausted.
  *
  * The session JWT is a short-lived HS256 token (via `jose`) carrying only the
- * email. Its signing key comes from `AUTH_JWT_SECRET`; when unset the gate uses an
+ * email. Its signing key comes from `TUNNEL_AUTH_JWT_SECRET`; when unset the gate uses an
  * ephemeral per-process key rather than refusing service, so an unset secret
  * degrades to "sessions don't survive a restart", not "nobody can log in". Note
  * what this does NOT weaken: a caller still needs a code delivered to an

package/lib/src/otp.js

@@ -9,7 +9,7 @@
  * the hash, and the entry is deleted on success or once attempts are exhausted.
  *
  * The session JWT is a short-lived HS256 token (via `jose`) carrying only the
- * email. Its signing key comes from `AUTH_JWT_SECRET`; when unset the gate uses an
+ * email. Its signing key comes from `TUNNEL_AUTH_JWT_SECRET`; when unset the gate uses an
  * ephemeral per-process key rather than refusing service, so an unset secret
  * degrades to "sessions don't survive a restart", not "nobody can log in". Note
  * what this does NOT weaken: a caller still needs a code delivered to an
@@ -21,8 +21,9 @@
  */
 import { createHash, randomBytes, randomInt, timingSafeEqual } from "node:crypto";
 import { CacheManager } from "@databricks/appkit";
-import { log } from "@dbx-tools/shared-core";
+import { env, log } from "@dbx-tools/shared-core";
 import { jwtVerify, SignJWT } from "jose";
+import { JWT_SECRET_ENV } from "./env.js";
 const logger = log.logger("tunnel:otp");
 /** JWT issuer/audience so a token minted for this gate isn't accepted elsewhere. */
 const JWT_AUD = "dbx-tools-tunnel-auth";
@@ -91,19 +92,19 @@ export class CodeStore {
     }
 }
 /**
- * Resolve the HS256 signing key. Prefers `AUTH_JWT_SECRET`; when unset, mints an
+ * Resolve the HS256 signing key. Prefers `TUNNEL_AUTH_JWT_SECRET`; when unset, mints an
  * ephemeral per-process key (fail-open) and warns once. Memoized.
  */
 let cachedKey;
 function signingKey() {
     if (cachedKey)
         return cachedKey;
-    const secret = process.env.AUTH_JWT_SECRET?.trim();
+    const secret = env.text(JWT_SECRET_ENV);
     if (secret) {
         cachedKey = new TextEncoder().encode(secret);
     }
     else {
-        logger.warn("AUTH_JWT_SECRET is not set - using an ephemeral per-process key; sessions will not survive a restart");
+        logger.warn(`${JWT_SECRET_ENV[0]} is not set - using an ephemeral per-process key; sessions will not survive a restart`);
         cachedKey = randomBytes(32);
     }
     return cachedKey;
@@ -134,4 +135,4 @@ export async function verifySession(token) {
         return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"otp.js","sourceRoot":"","sources":["../../src/otp.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * One-time-code store + session JWT for the email-OTP tunnel gate.\n *\n * The code store is backed by AppKit's `CacheManager` (auto-configured to memory,\n * or Lakebase when the app wires a persistent `CacheStorage`), so TTL EXPIRY and\n * eviction are the cache's job - no hand-rolled Map or timers. A 6-digit code is\n * generated with `crypto.randomInt` and stored as a SHA-256 hash with an attempt\n * counter (never the plaintext, never in the JWT); `verify` is constant-time on\n * the hash, and the entry is deleted on success or once attempts are exhausted.\n *\n * The session JWT is a short-lived HS256 token (via `jose`) carrying only the\n * email. Its signing key comes from `AUTH_JWT_SECRET`; when unset the gate uses an\n * ephemeral per-process key rather than refusing service, so an unset secret\n * degrades to \"sessions don't survive a restart\", not \"nobody can log in\". Note\n * what this does NOT weaken: a caller still needs a code delivered to an\n * allow-listed address, because the signing key only validates an ALREADY-issued\n * session. Set it in any deployment running more than one instance, or sessions\n * minted by one will not verify on another.\n *\n * @module\n */\n\nimport { createHash, randomBytes, randomInt, timingSafeEqual } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { jwtVerify, SignJWT } from \"jose\";\n\nconst logger = log.logger(\"tunnel:otp\");\n\n/** JWT issuer/audience so a token minted for this gate isn't accepted elsewhere. */\nconst JWT_AUD = \"dbx-tools-tunnel-auth\";\n\n/** Cache-key prefix for pending codes, namespaced away from any other cache use. */\nconst CODE_PREFIX = \"tunnel:otp:\";\n\n/** SHA-256 hex of a value. */\nfunction sha256(value: string): string {\n  return createHash(\"sha256\").update(value).digest(\"hex\");\n}\n\n/** Constant-time compare of two equal-length hex digests. */\nfunction safeEqualHex(a: string, b: string): boolean {\n  if (a.length !== b.length) return false;\n  return timingSafeEqual(Buffer.from(a, \"hex\"), Buffer.from(b, \"hex\"));\n}\n\ninterface CodeEntry {\n  hash: string;\n  attempts: number;\n}\n\n/** Result of {@link CodeStore.verify}. */\nexport type VerifyOutcome = \"ok\" | \"invalid\" | \"expired\" | \"too-many-attempts\";\n\n/**\n * Pending one-time codes, stored in AppKit's cache keyed by lowercased email.\n * Expiry is the cache's TTL (no manual clock); a miss means expired-or-never.\n */\nexport class CodeStore {\n  constructor(\n    private readonly ttlSeconds: number,\n    private readonly maxAttempts: number,\n  ) {}\n\n  private cache(): CacheManager {\n    return CacheManager.getInstanceSync();\n  }\n\n  private key(email: string): string {\n    return `${CODE_PREFIX}${email.toLowerCase()}`;\n  }\n\n  /**\n   * Generate, store (hashed, with the cache TTL), and RETURN a fresh 6-digit\n   * code. The caller emails the returned plaintext; only the hash is retained.\n   * Replaces any pending code for the address.\n   */\n  async issue(email: string): Promise<string> {\n    const code = String(randomInt(0, 1_000_000)).padStart(6, \"0\");\n    const entry: CodeEntry = { hash: sha256(code), attempts: 0 };\n    await this.cache().set(this.key(email), entry, { ttl: this.ttlSeconds });\n    return code;\n  }\n\n  /**\n   * Check `code` for `email`. A cache miss is `expired` (TTL elapsed or never\n   * issued). Deletes the entry on success or when attempts are exhausted, so a\n   * code is single-use and can't be brute-forced past the cap. An attempt\n   * increments the stored counter (re-persisted with a fresh TTL window).\n   */\n  async verify(email: string, code: string): Promise<VerifyOutcome> {\n    const key = this.key(email);\n    const entry = await this.cache().get<CodeEntry>(key);\n    if (!entry) return \"expired\";\n    const attempts = entry.attempts + 1;\n    if (safeEqualHex(entry.hash, sha256(code))) {\n      await this.cache().delete(key);\n      return \"ok\";\n    }\n    if (attempts >= this.maxAttempts) {\n      await this.cache().delete(key);\n      return \"too-many-attempts\";\n    }\n    await this.cache().set(key, { ...entry, attempts }, { ttl: this.ttlSeconds });\n    return \"invalid\";\n  }\n}\n\n/**\n * Resolve the HS256 signing key. Prefers `AUTH_JWT_SECRET`; when unset, mints an\n * ephemeral per-process key (fail-open) and warns once. Memoized.\n */\nlet cachedKey: Uint8Array | undefined;\nfunction signingKey(): Uint8Array {\n  if (cachedKey) return cachedKey;\n  const secret = process.env.AUTH_JWT_SECRET?.trim();\n  if (secret) {\n    cachedKey = new TextEncoder().encode(secret);\n  } else {\n    logger.warn(\n      \"AUTH_JWT_SECRET is not set - using an ephemeral per-process key; sessions will not survive a restart\",\n    );\n    cachedKey = randomBytes(32);\n  }\n  return cachedKey;\n}\n\n/** Reset the memoized key (tests, or after changing the env in-process). */\nexport function resetSigningKey(): void {\n  cachedKey = undefined;\n}\n\n/** Mint a short-lived session JWT for `email`, expiring in `ttlSeconds`. */\nexport async function signSession(email: string, ttlSeconds: number): Promise<string> {\n  return new SignJWT({ email })\n    .setProtectedHeader({ alg: \"HS256\" })\n    .setSubject(email)\n    .setAudience(JWT_AUD)\n    .setIssuedAt()\n    .setExpirationTime(`${ttlSeconds}s`)\n    .sign(signingKey());\n}\n\n/** Validate a session JWT, returning the email it was minted for, or `undefined`. */\nexport async function verifySession(token: string | undefined): Promise<string | undefined> {\n  if (!token) return undefined;\n  try {\n    const { payload } = await jwtVerify(token, signingKey(), { audience: JWT_AUD });\n    return typeof payload.email === \"string\" ? payload.email : undefined;\n  } catch {\n    return undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"otp.js","sourceRoot":"","sources":["../../src/otp.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * One-time-code store + session JWT for the email-OTP tunnel gate.\n *\n * The code store is backed by AppKit's `CacheManager` (auto-configured to memory,\n * or Lakebase when the app wires a persistent `CacheStorage`), so TTL EXPIRY and\n * eviction are the cache's job - no hand-rolled Map or timers. A 6-digit code is\n * generated with `crypto.randomInt` and stored as a SHA-256 hash with an attempt\n * counter (never the plaintext, never in the JWT); `verify` is constant-time on\n * the hash, and the entry is deleted on success or once attempts are exhausted.\n *\n * The session JWT is a short-lived HS256 token (via `jose`) carrying only the\n * email. Its signing key comes from `TUNNEL_AUTH_JWT_SECRET`; when unset the gate uses an\n * ephemeral per-process key rather than refusing service, so an unset secret\n * degrades to \"sessions don't survive a restart\", not \"nobody can log in\". Note\n * what this does NOT weaken: a caller still needs a code delivered to an\n * allow-listed address, because the signing key only validates an ALREADY-issued\n * session. Set it in any deployment running more than one instance, or sessions\n * minted by one will not verify on another.\n *\n * @module\n */\n\nimport { createHash, randomBytes, randomInt, timingSafeEqual } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { env, log } from \"@dbx-tools/shared-core\";\nimport { jwtVerify, SignJWT } from \"jose\";\nimport { JWT_SECRET_ENV } from \"./env.ts\";\n\nconst logger = log.logger(\"tunnel:otp\");\n\n/** JWT issuer/audience so a token minted for this gate isn't accepted elsewhere. */\nconst JWT_AUD = \"dbx-tools-tunnel-auth\";\n\n/** Cache-key prefix for pending codes, namespaced away from any other cache use. */\nconst CODE_PREFIX = \"tunnel:otp:\";\n\n/** SHA-256 hex of a value. */\nfunction sha256(value: string): string {\n  return createHash(\"sha256\").update(value).digest(\"hex\");\n}\n\n/** Constant-time compare of two equal-length hex digests. */\nfunction safeEqualHex(a: string, b: string): boolean {\n  if (a.length !== b.length) return false;\n  return timingSafeEqual(Buffer.from(a, \"hex\"), Buffer.from(b, \"hex\"));\n}\n\ninterface CodeEntry {\n  hash: string;\n  attempts: number;\n}\n\n/** Result of {@link CodeStore.verify}. */\nexport type VerifyOutcome = \"ok\" | \"invalid\" | \"expired\" | \"too-many-attempts\";\n\n/**\n * Pending one-time codes, stored in AppKit's cache keyed by lowercased email.\n * Expiry is the cache's TTL (no manual clock); a miss means expired-or-never.\n */\nexport class CodeStore {\n  constructor(\n    private readonly ttlSeconds: number,\n    private readonly maxAttempts: number,\n  ) {}\n\n  private cache(): CacheManager {\n    return CacheManager.getInstanceSync();\n  }\n\n  private key(email: string): string {\n    return `${CODE_PREFIX}${email.toLowerCase()}`;\n  }\n\n  /**\n   * Generate, store (hashed, with the cache TTL), and RETURN a fresh 6-digit\n   * code. The caller emails the returned plaintext; only the hash is retained.\n   * Replaces any pending code for the address.\n   */\n  async issue(email: string): Promise<string> {\n    const code = String(randomInt(0, 1_000_000)).padStart(6, \"0\");\n    const entry: CodeEntry = { hash: sha256(code), attempts: 0 };\n    await this.cache().set(this.key(email), entry, { ttl: this.ttlSeconds });\n    return code;\n  }\n\n  /**\n   * Check `code` for `email`. A cache miss is `expired` (TTL elapsed or never\n   * issued). Deletes the entry on success or when attempts are exhausted, so a\n   * code is single-use and can't be brute-forced past the cap. An attempt\n   * increments the stored counter (re-persisted with a fresh TTL window).\n   */\n  async verify(email: string, code: string): Promise<VerifyOutcome> {\n    const key = this.key(email);\n    const entry = await this.cache().get<CodeEntry>(key);\n    if (!entry) return \"expired\";\n    const attempts = entry.attempts + 1;\n    if (safeEqualHex(entry.hash, sha256(code))) {\n      await this.cache().delete(key);\n      return \"ok\";\n    }\n    if (attempts >= this.maxAttempts) {\n      await this.cache().delete(key);\n      return \"too-many-attempts\";\n    }\n    await this.cache().set(key, { ...entry, attempts }, { ttl: this.ttlSeconds });\n    return \"invalid\";\n  }\n}\n\n/**\n * Resolve the HS256 signing key. Prefers `TUNNEL_AUTH_JWT_SECRET`; when unset, mints an\n * ephemeral per-process key (fail-open) and warns once. Memoized.\n */\nlet cachedKey: Uint8Array | undefined;\nfunction signingKey(): Uint8Array {\n  if (cachedKey) return cachedKey;\n  const secret = env.text(JWT_SECRET_ENV);\n  if (secret) {\n    cachedKey = new TextEncoder().encode(secret);\n  } else {\n    logger.warn(\n      `${JWT_SECRET_ENV[0]} is not set - using an ephemeral per-process key; sessions will not survive a restart`,\n    );\n    cachedKey = randomBytes(32);\n  }\n  return cachedKey;\n}\n\n/** Reset the memoized key (tests, or after changing the env in-process). */\nexport function resetSigningKey(): void {\n  cachedKey = undefined;\n}\n\n/** Mint a short-lived session JWT for `email`, expiring in `ttlSeconds`. */\nexport async function signSession(email: string, ttlSeconds: number): Promise<string> {\n  return new SignJWT({ email })\n    .setProtectedHeader({ alg: \"HS256\" })\n    .setSubject(email)\n    .setAudience(JWT_AUD)\n    .setIssuedAt()\n    .setExpirationTime(`${ttlSeconds}s`)\n    .sign(signingKey());\n}\n\n/** Validate a session JWT, returning the email it was minted for, or `undefined`. */\nexport async function verifySession(token: string | undefined): Promise<string | undefined> {\n  if (!token) return undefined;\n  try {\n    const { payload } = await jwtVerify(token, signingKey(), { audience: JWT_AUD });\n    return typeof payload.email === \"string\" ? payload.email : undefined;\n  } catch {\n    return undefined;\n  }\n}\n"]}

package/lib/src/plugin.d.ts

@@ -19,10 +19,10 @@ import { Plugin, type BasePluginConfig } from "@databricks/appkit";
 import type { AuthStatus } from "@dbx-tools/shared-email";
 /** Options for the {@link authGate} plugin (all resolvable from env - see below). */
 export interface AuthGateConfig extends BasePluginConfig {
-    /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env EMAIL_AUTH_ALLOW. */
+    /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */
     allow?: string | string[];
     /**
-     * Subject line for the code email. Env AUTH_SUBJECT.
+     * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.
      *
      * Defaults to "Your verification code". The wording of the subject and
      * {@link message} is deliberately the conventional phrasing rather than
@@ -32,7 +32,7 @@ export interface AuthGateConfig extends BasePluginConfig {
      */
     subject?: string;
     /**
-     * Display name used in the code email copy. Env AUTH_BRAND_NAME.
+     * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.
      *
      * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`
      * when it has one, else the dbx-tools default. Set this only to override the
@@ -40,15 +40,15 @@ export interface AuthGateConfig extends BasePluginConfig {
      */
     brandName?: string;
     /**
-     * Line shown immediately above the code in the email. Env AUTH_MESSAGE.
+     * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.
      *
      * Keep the code on its OWN line directly after this text - that adjacency is
      * what the platform code-detection heuristics key on.
      */
     message?: string;
-    /** Session lifetime (seconds). Env AUTH_SESSION_TTL. Default 43200 (12h). */
+    /** Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 43200 (12h). */
     sessionTtlSeconds?: number;
-    /** One-time-code lifetime (seconds). Env AUTH_CODE_TTL. Default 600 (10m). */
+    /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */
     codeTtlSeconds?: number;
     /** Max verify attempts per issued code. Default 5. */
     maxAttempts?: number;

package/lib/src/plugin.js

@@ -18,6 +18,7 @@
 import { Plugin, toPlugin } from "@databricks/appkit";
 import { brand, env, log, string } from "@dbx-tools/shared-core";
 import { looksLikeEmail, matchesAllowlist } from "./allowlist.js";
+import { ALLOW_ENV, BRAND_NAME_ENV, CODE_TTL_ENV, MESSAGE_ENV, SESSION_TTL_ENV, SUBJECT_ENV, } from "./env.js";
 import { CodeStore, signSession, verifySession } from "./otp.js";
 import { RateLimiter } from "./rate-limit.js";
 const logger = log.logger("tunnel:auth");
@@ -39,13 +40,15 @@ const DEFAULTS = {
 export function resolveAuthGateConfig(config) {
     return {
         // Both sources are unioned rather than one overriding: a deployment-wide
-        // EMAIL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.
-        allow: [...string.parseList(config.allow), ...string.parseList(process.env.EMAIL_AUTH_ALLOW)],
-        subject: env.string(config.subject, "AUTH_SUBJECT") ?? DEFAULTS.subject,
-        brandName: env.string(config.brandName, "AUTH_BRAND_NAME") ?? DEFAULTS.brandName,
-        message: env.string(config.message, "AUTH_MESSAGE") ?? DEFAULTS.message,
-        sessionTtlSeconds: env.positiveInt(config.sessionTtlSeconds, "AUTH_SESSION_TTL", DEFAULTS.sessionTtlSeconds),
-        codeTtlSeconds: env.positiveInt(config.codeTtlSeconds, "AUTH_CODE_TTL", DEFAULTS.codeTtlSeconds),
+        // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.
+        // Hence `parseList` on each rather than `env.list`, which stops at the first
+        // source that yields anything.
+        allow: [...string.parseList(config.allow), ...string.parseList(env.text(ALLOW_ENV))],
+        subject: env.string(config.subject, SUBJECT_ENV) ?? DEFAULTS.subject,
+        brandName: env.string(config.brandName, BRAND_NAME_ENV) ?? DEFAULTS.brandName,
+        message: env.string(config.message, MESSAGE_ENV) ?? DEFAULTS.message,
+        sessionTtlSeconds: env.positiveInt(config.sessionTtlSeconds, SESSION_TTL_ENV, DEFAULTS.sessionTtlSeconds),
+        codeTtlSeconds: env.positiveInt(config.codeTtlSeconds, CODE_TTL_ENV, DEFAULTS.codeTtlSeconds),
         maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,
     };
 }
@@ -124,4 +127,4 @@ export class AuthGatePlugin extends Plugin {
 }
 /** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */
 export const authGate = toPlugin(AuthGatePlugin);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.\n *\n * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the\n * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin\n * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed\n * one-time-code store, and the session JWT. `createApp` (with no `server()`) is\n * used only to auto-init `CacheManager` + prime the sibling `email` transport;\n * this plugin is where the gate logic lives.\n *\n * Options come from CLI flags OR env, with sensible defaults - see\n * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't\n * resolve itself is HOW to email the code, so it takes a `sendCode` callback the\n * app wires to the email plugin.\n *\n * @module\n */\n\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { brand, env, log, string } from \"@dbx-tools/shared-core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-email\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { CodeStore, signSession, verifySession } from \"./otp.ts\";\nimport { RateLimiter } from \"./rate-limit.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env EMAIL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /** Session lifetime (seconds). Env AUTH_SESSION_TTL. Default 43200 (12h). */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /** Deliver a code to an address. Wired by the app to the email plugin. */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName` (see\n  // {@link startGateApp}, which resolves the on-disk context); the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  sessionTtlSeconds: 43200,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  return {\n    // Both sources are unioned rather than one overriding: a deployment-wide\n    // EMAIL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.\n    allow: [...string.parseList(config.allow), ...string.parseList(process.env.EMAIL_AUTH_ALLOW)],\n    subject: env.string(config.subject, \"AUTH_SUBJECT\") ?? DEFAULTS.subject,\n    brandName: env.string(config.brandName, \"AUTH_BRAND_NAME\") ?? DEFAULTS.brandName,\n    message: env.string(config.message, \"AUTH_MESSAGE\") ?? DEFAULTS.message,\n    sessionTtlSeconds: env.positiveInt(\n      config.sessionTtlSeconds,\n      \"AUTH_SESSION_TTL\",\n      DEFAULTS.sessionTtlSeconds,\n    ),\n    codeTtlSeconds: env.positiveInt(\n      config.codeTtlSeconds,\n      \"AUTH_CODE_TTL\",\n      DEFAULTS.codeTtlSeconds,\n    ),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n  };\n}\n\n/** The handlers the proxy calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Handle a code request. Always resolves `{ ok: true }` (anti-enumeration). */\n  request(email: string, ip: string): Promise<{ ok: true; retryAfter?: number }>;\n  /** Handle a code verification. On success returns the session token to cookie. */\n  verify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }>;\n  /** Resolve the authenticated email for a session token, or undefined. */\n  session(token: string | undefined): Promise<string | undefined>;\n  /** Session TTL in seconds (for the cookie Max-Age). */\n  readonly sessionTtlSeconds: number;\n  /** The gate status payload (`enabled` is always true when this plugin runs). */\n  status(token: string | undefined): Promise<AuthStatus>;\n}\n\n/** AppKit plugin owning the email-OTP gate's logic (no HTTP routes; proxy-driven). */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Email one-time-password access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private codes!: CodeStore;\n  // Requesting a code is email-spam-prone; verifying is a brute-force surface.\n  // Per-email AND per-IP so neither axis alone is a bypass.\n  private readonly requestLimiter = new RateLimiter(5, 15 * 60 * 1000);\n  private readonly verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n    this.codes = new CodeStore(this.resolved.codeTtlSeconds, this.resolved.maxAttempts);\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n    });\n  }\n\n  override exports(): AuthGateApi {\n    return {\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      request: (email, ip) => this.handleRequest(email, ip),\n      verify: (email, code, ip) => this.handleVerify(email, code, ip),\n      session: (token) => verifySession(token),\n      status: async (token) => ({\n        authenticated: Boolean(await verifySession(token)),\n        email: (await verifySession(token)) ?? undefined,\n        enabled: true,\n      }),\n    };\n  }\n\n  private async handleRequest(\n    email: string,\n    ip: string,\n  ): Promise<{ ok: true; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.requestLimiter.hit(`ip:${ip}`);\n    const byEmail = this.requestLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if (looksLikeEmail(address) && matchesAllowlist(address, this.resolved.allow)) {\n      const code = await this.codes.issue(address);\n      try {\n        await this.config.sendCode?.(address, code, {\n          subject: this.resolved.subject,\n          brandName: this.resolved.brandName,\n          message: this.resolved.message,\n          codeTtlSeconds: this.resolved.codeTtlSeconds,\n        });\n      } catch (error) {\n        logger.warn(\"failed to send OTP email\", { error });\n      }\n    }\n    return { ok: true };\n  }\n\n  private async handleVerify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.verifyLimiter.hit(`ip:${ip}`);\n    const byEmail = this.verifyLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if ((await this.codes.verify(address, code.trim())) !== \"ok\") return { ok: false };\n    this.requestLimiter.reset(`email:${address}`);\n    this.verifyLimiter.reset(`email:${address}`);\n    return { ok: true, token: await signSession(address, this.resolved.sessionTtlSeconds) };\n  }\n}\n\n/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */\nexport const authGate = toPlugin(AuthGatePlugin);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.\n *\n * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the\n * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin\n * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed\n * one-time-code store, and the session JWT. `createApp` (with no `server()`) is\n * used only to auto-init `CacheManager` + prime the sibling `email` transport;\n * this plugin is where the gate logic lives.\n *\n * Options come from CLI flags OR env, with sensible defaults - see\n * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't\n * resolve itself is HOW to email the code, so it takes a `sendCode` callback the\n * app wires to the email plugin.\n *\n * @module\n */\n\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { brand, env, log, string } from \"@dbx-tools/shared-core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-email\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport {\n  ALLOW_ENV,\n  BRAND_NAME_ENV,\n  CODE_TTL_ENV,\n  MESSAGE_ENV,\n  SESSION_TTL_ENV,\n  SUBJECT_ENV,\n} from \"./env.ts\";\nimport { CodeStore, signSession, verifySession } from \"./otp.ts\";\nimport { RateLimiter } from \"./rate-limit.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /** Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 43200 (12h). */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /** Deliver a code to an address. Wired by the app to the email plugin. */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName` (see\n  // {@link startGateApp}, which resolves the on-disk context); the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  sessionTtlSeconds: 43200,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  return {\n    // Both sources are unioned rather than one overriding: a deployment-wide\n    // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.\n    // Hence `parseList` on each rather than `env.list`, which stops at the first\n    // source that yields anything.\n    allow: [...string.parseList(config.allow), ...string.parseList(env.text(ALLOW_ENV))],\n    subject: env.string(config.subject, SUBJECT_ENV) ?? DEFAULTS.subject,\n    brandName: env.string(config.brandName, BRAND_NAME_ENV) ?? DEFAULTS.brandName,\n    message: env.string(config.message, MESSAGE_ENV) ?? DEFAULTS.message,\n    sessionTtlSeconds: env.positiveInt(\n      config.sessionTtlSeconds,\n      SESSION_TTL_ENV,\n      DEFAULTS.sessionTtlSeconds,\n    ),\n    codeTtlSeconds: env.positiveInt(config.codeTtlSeconds, CODE_TTL_ENV, DEFAULTS.codeTtlSeconds),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n  };\n}\n\n/** The handlers the proxy calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Handle a code request. Always resolves `{ ok: true }` (anti-enumeration). */\n  request(email: string, ip: string): Promise<{ ok: true; retryAfter?: number }>;\n  /** Handle a code verification. On success returns the session token to cookie. */\n  verify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }>;\n  /** Resolve the authenticated email for a session token, or undefined. */\n  session(token: string | undefined): Promise<string | undefined>;\n  /** Session TTL in seconds (for the cookie Max-Age). */\n  readonly sessionTtlSeconds: number;\n  /** The gate status payload (`enabled` is always true when this plugin runs). */\n  status(token: string | undefined): Promise<AuthStatus>;\n}\n\n/** AppKit plugin owning the email-OTP gate's logic (no HTTP routes; proxy-driven). */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Email one-time-password access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private codes!: CodeStore;\n  // Requesting a code is email-spam-prone; verifying is a brute-force surface.\n  // Per-email AND per-IP so neither axis alone is a bypass.\n  private readonly requestLimiter = new RateLimiter(5, 15 * 60 * 1000);\n  private readonly verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n    this.codes = new CodeStore(this.resolved.codeTtlSeconds, this.resolved.maxAttempts);\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n    });\n  }\n\n  override exports(): AuthGateApi {\n    return {\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      request: (email, ip) => this.handleRequest(email, ip),\n      verify: (email, code, ip) => this.handleVerify(email, code, ip),\n      session: (token) => verifySession(token),\n      status: async (token) => ({\n        authenticated: Boolean(await verifySession(token)),\n        email: (await verifySession(token)) ?? undefined,\n        enabled: true,\n      }),\n    };\n  }\n\n  private async handleRequest(\n    email: string,\n    ip: string,\n  ): Promise<{ ok: true; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.requestLimiter.hit(`ip:${ip}`);\n    const byEmail = this.requestLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if (looksLikeEmail(address) && matchesAllowlist(address, this.resolved.allow)) {\n      const code = await this.codes.issue(address);\n      try {\n        await this.config.sendCode?.(address, code, {\n          subject: this.resolved.subject,\n          brandName: this.resolved.brandName,\n          message: this.resolved.message,\n          codeTtlSeconds: this.resolved.codeTtlSeconds,\n        });\n      } catch (error) {\n        logger.warn(\"failed to send OTP email\", { error });\n      }\n    }\n    return { ok: true };\n  }\n\n  private async handleVerify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.verifyLimiter.hit(`ip:${ip}`);\n    const byEmail = this.verifyLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if ((await this.codes.verify(address, code.trim())) !== \"ok\") return { ok: false };\n    this.requestLimiter.reset(`email:${address}`);\n    this.verifyLimiter.reset(`email:${address}`);\n    return { ok: true, token: await signSession(address, this.resolved.sessionTtlSeconds) };\n  }\n}\n\n/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */\nexport const authGate = toPlugin(AuthGatePlugin);\n"]}