@dbx-tools/tunnel 0.6.81 → 0.6.85

package/index.ts

@@ -4,7 +4,6 @@
 
 export * as allowlist from "./src/allowlist.ts";
 export * as codeEmail from "./src/code-email.ts";
-export * as env from "./src/env.ts";
 export * as gate from "./src/gate.ts";
 export * as headers from "./src/headers.ts";
 export * as interceptor from "./src/interceptor.ts";
@@ -15,9 +14,8 @@ export * as rateLimit from "./src/rate-limit.ts";
 export * as sendCode from "./src/send-code.ts";
 export * as signingKey from "./src/signing-key.ts";
 export type { CodeCopy } from "./src/code-email.ts";
-export { ALLOW_ENV, SUBJECT_ENV, BRAND_NAME_ENV, MESSAGE_ENV, SESSION_TTL_ENV, CODE_TTL_ENV, JWT_SECRET_ENV, SESSION_CUTOFF_ENV, PUBLIC_DOMAIN_ENV, INSECURE_ENV, FORWARD_HEADERS_ENV } from "./src/env.ts";
-export { AUTH_PREFIX } from "./src/gate.ts";
-export type { GateOptions } from "./src/gate.ts";
+export { AUTH_PREFIX, UNAUTHORIZED_BODY, LOGOUT_SET_COOKIE } from "./src/gate.ts";
+export type { GateOptions, GateAction } from "./src/gate.ts";
 export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS } from "./src/headers.ts";
 export type { HeaderPolicy } from "./src/headers.ts";
 export type { TunnelInterceptorOptions } from "./src/interceptor.ts";

package/lib/index.d.ts

@@ -1,6 +1,5 @@
 export * as allowlist from "./src/allowlist.ts";
 export * as codeEmail from "./src/code-email.ts";
-export * as env from "./src/env.ts";
 export * as gate from "./src/gate.ts";
 export * as headers from "./src/headers.ts";
 export * as interceptor from "./src/interceptor.ts";
@@ -11,9 +10,8 @@ export * as rateLimit from "./src/rate-limit.ts";
 export * as sendCode from "./src/send-code.ts";
 export * as signingKey from "./src/signing-key.ts";
 export type { CodeCopy } from "./src/code-email.ts";
-export { ALLOW_ENV, SUBJECT_ENV, BRAND_NAME_ENV, MESSAGE_ENV, SESSION_TTL_ENV, CODE_TTL_ENV, JWT_SECRET_ENV, SESSION_CUTOFF_ENV, PUBLIC_DOMAIN_ENV, INSECURE_ENV, FORWARD_HEADERS_ENV } from "./src/env.ts";
-export { AUTH_PREFIX } from "./src/gate.ts";
-export type { GateOptions } from "./src/gate.ts";
+export { AUTH_PREFIX, UNAUTHORIZED_BODY, LOGOUT_SET_COOKIE } from "./src/gate.ts";
+export type { GateOptions, GateAction } from "./src/gate.ts";
 export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS } from "./src/headers.ts";
 export type { HeaderPolicy } from "./src/headers.ts";
 export type { TunnelInterceptorOptions } from "./src/interceptor.ts";

package/lib/index.js

@@ -3,7 +3,6 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 export * as allowlist from "./src/allowlist.js";
 export * as codeEmail from "./src/code-email.js";
-export * as env from "./src/env.js";
 export * as gate from "./src/gate.js";
 export * as headers from "./src/headers.js";
 export * as interceptor from "./src/interceptor.js";
@@ -13,11 +12,10 @@ export * as portr from "./src/portr.js";
 export * as rateLimit from "./src/rate-limit.js";
 export * as sendCode from "./src/send-code.js";
 export * as signingKey from "./src/signing-key.js";
-export { ALLOW_ENV, SUBJECT_ENV, BRAND_NAME_ENV, MESSAGE_ENV, SESSION_TTL_ENV, CODE_TTL_ENV, JWT_SECRET_ENV, SESSION_CUTOFF_ENV, PUBLIC_DOMAIN_ENV, INSECURE_ENV, FORWARD_HEADERS_ENV } from "./src/env.js";
-export { AUTH_PREFIX } from "./src/gate.js";
+export { AUTH_PREFIX, UNAUTHORIZED_BODY, LOGOUT_SET_COOKIE } from "./src/gate.js";
 export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS } from "./src/headers.js";
 export { CodeStore } from "./src/otp.js";
 export { AuthGatePlugin, authGate } from "./src/plugin.js";
 export { RateLimiter } from "./src/rate-limit.js";
 export { KEY_TTL_SECONDS } from "./src/signing-key.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_config.d.ts

@@ -0,0 +1,4 @@
+/** Package-private namespace options for layered tunnel configuration. */
+export declare const TUNNEL_CONFIG: {
+    readonly prefix: "TUNNEL";
+};

package/lib/src/_config.js

@@ -0,0 +1,3 @@
+/** Package-private namespace options for layered tunnel configuration. */
+export const TUNNEL_CONFIG = { prefix: "TUNNEL" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiX2NvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9fY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDBFQUEwRTtBQUMxRSxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogUGFja2FnZS1wcml2YXRlIG5hbWVzcGFjZSBvcHRpb25zIGZvciBsYXllcmVkIHR1bm5lbCBjb25maWd1cmF0aW9uLiAqL1xuZXhwb3J0IGNvbnN0IFRVTk5FTF9DT05GSUcgPSB7IHByZWZpeDogXCJUVU5ORUxcIiB9IGFzIGNvbnN0O1xuIl19

package/lib/src/gate.d.ts

@@ -21,7 +21,9 @@
  *
  * @module
  */
-import type { Request, RequestHandler } from "express";
+import type { IncomingMessage } from "node:http";
+import type { RequestHandler } from "express";
+import { type HeaderPolicy } from "./headers.ts";
 import type { AuthGateApi } from "./plugin.ts";
 /** Route prefix the login flow lives under (open, answered in-process). */
 export declare const AUTH_PREFIX = "/api/email/auth";
@@ -47,7 +49,52 @@ export interface GateOptions {
  * over portr. Case-insensitive; the optional `:port` is ignored. When no public
  * domain is configured, nothing is tunnel traffic.
  */
-export declare function isTunnelHost(req: Request, publicDomain: string | undefined): boolean;
+export declare function isTunnelHost(req: IncomingMessage, publicDomain: string | undefined): boolean;
+/**
+ * Client IP for rate-limiting: the RIGHTMOST `x-forwarded-for` entry (the value
+ * the nearest trusted hop - portr - wrote), else the socket address. Reading the
+ * rightmost, not the leftmost, stops a caller minting a fresh rate-limit bucket by
+ * varying the header. Called before {@link stripHeaders}.
+ */
+export declare function clientIp(req: IncomingMessage): string;
+/**
+ * What the caller should do with a request, from {@link gateRequest}.
+ *
+ *   - `pass` - not tunnel traffic, or an open login route. Forward untouched.
+ *   - `allow` - tunnel traffic that is authorized. The request's headers have
+ *     ALREADY been rewritten (policy applied, identity injected, session cookie
+ *     stripped), so forward it as it now stands.
+ *   - `deny` - tunnel traffic with no valid session. Answer `401` with
+ *     {@link AUTH_PREFIX} as the login path.
+ */
+export type GateAction = "pass" | "allow" | "deny";
+/**
+ * THE gating decision, for one request, independent of how it will be answered.
+ *
+ * Both paths call this: the Express middleware below (where the app is the
+ * process) and `@dbx-tools/cli-tunnel`'s reverse proxy (where the app is a child
+ * process on a private port). A divergence between them would be a security bug
+ * the second path could not be tested into agreement - one path forgetting to
+ * strip `x-forwarded-access-token` is enough - so the decision, the header
+ * rewriting, and the identity injection live here once and the transports only
+ * differ in how they WRITE the outcome.
+ *
+ * Mutates `req.headers` on the `allow`/`pass`-with-cookie paths, which is exactly
+ * what both callers want: Express hands the same object to the app's handlers, and
+ * the proxy forwards it upstream.
+ */
+export declare function gateRequest(req: IncomingMessage, options: GateOptions & {
+    headerPolicy?: HeaderPolicy;
+}): Promise<GateAction>;
+/** The body of a `deny`, shared so both paths answer a 401 identically. */
+export declare const UNAUTHORIZED_BODY: {
+    readonly error: "authentication required";
+    readonly loginPath: "/api/email/auth";
+};
+/** The `Set-Cookie` value that issues a verified session. */
+export declare function sessionSetCookie(sessionToken: string, maxAgeSeconds: number): string;
+/** The `Set-Cookie` value that clears the session. */
+export declare const LOGOUT_SET_COOKIE = "dbx-tools-auth=; Path=/; HttpOnly; Max-Age=0";
 /**
  * Register the login routes and the gating middleware on the app's Express
  * instance. Called from {@link AuthGatePlugin} with the router AppKit hands

package/lib/src/gate.js

@@ -59,7 +59,7 @@ function sessionCookie(value, maxAgeSeconds) {
  * rightmost, not the leftmost, stops a caller minting a fresh rate-limit bucket by
  * varying the header. Called before {@link stripHeaders}.
  */
-function clientIp(req) {
+export function clientIp(req) {
     const forwarded = req.headers["x-forwarded-for"];
     const chain = (Array.isArray(forwarded) ? forwarded.join(",") : (forwarded ?? ""))
         .split(",")
@@ -119,6 +119,61 @@ function readBody(req) {
         req.on("error", () => resolve(data));
     });
 }
+/**
+ * THE gating decision, for one request, independent of how it will be answered.
+ *
+ * Both paths call this: the Express middleware below (where the app is the
+ * process) and `@dbx-tools/cli-tunnel`'s reverse proxy (where the app is a child
+ * process on a private port). A divergence between them would be a security bug
+ * the second path could not be tested into agreement - one path forgetting to
+ * strip `x-forwarded-access-token` is enough - so the decision, the header
+ * rewriting, and the identity injection live here once and the transports only
+ * differ in how they WRITE the outcome.
+ *
+ * Mutates `req.headers` on the `allow`/`pass`-with-cookie paths, which is exactly
+ * what both callers want: Express hands the same object to the app's handlers, and
+ * the proxy forwards it upstream.
+ */
+export async function gateRequest(req, options) {
+    const { gate, publicDomain } = options;
+    // Not tunnel traffic (platform front door, or any other local caller): the
+    // request is already authenticated, or is not ours to gate.
+    if (!isTunnelHost(req, publicDomain))
+        return "pass";
+    const path = (req.url ?? "/").split("?")[0] ?? "/";
+    // The login flow is open so the browser can render <AuthGate> and sign in.
+    if (path.startsWith(AUTH_PREFIX))
+        return "pass";
+    // Anti-spoof: only the gate may assert identity on tunnel traffic.
+    const policy = options.headerPolicy ?? toHeaderPolicy(options.forwardHeaders);
+    const removed = policy.apply(req.headers);
+    if (removed.length)
+        logger.debug("stripped inbound headers", { removed });
+    // Static (non-API) loads freely so the SPA can render; drop the gate cookie.
+    if (!path.startsWith("/api/")) {
+        stripSessionCookie(req);
+        return "pass";
+    }
+    // Every other /api/* needs a valid OTP session.
+    const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
+    const email = await gate.session(cookie);
+    if (!email)
+        return "deny";
+    injectIdentity(req, email);
+    stripSessionCookie(req);
+    return "allow";
+}
+/** The body of a `deny`, shared so both paths answer a 401 identically. */
+export const UNAUTHORIZED_BODY = {
+    error: "authentication required",
+    loginPath: AUTH_PREFIX,
+};
+/** The `Set-Cookie` value that issues a verified session. */
+export function sessionSetCookie(sessionToken, maxAgeSeconds) {
+    return sessionCookie(sessionToken, maxAgeSeconds);
+}
+/** The `Set-Cookie` value that clears the session. */
+export const LOGOUT_SET_COOKIE = `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`;
 /**
  * Register the login routes and the gating middleware on the app's Express
  * instance. Called from {@link AuthGatePlugin} with the router AppKit hands
@@ -132,11 +187,6 @@ export function mountGate(opts, addRoute, addMiddleware) {
     const { gate, publicDomain, forwardHeaders } = opts;
     const headerPolicy = toHeaderPolicy(forwardHeaders);
     logger.debug("gate mounted", { publicDomain, forward: headerPolicy.patterns });
-    const applyHeaderPolicy = (req) => {
-        const removed = headerPolicy.apply(req.headers);
-        if (removed.length)
-            logger.debug("stripped inbound headers", { removed });
-    };
     // --- Login routes (open on tunnel traffic; answered in-process) ---
     const statusHandler = (async (req, res) => {
         // A local or front-door caller is never gated, so the honest answer is that
@@ -177,7 +227,7 @@ export function mountGate(opts, addRoute, addMiddleware) {
             sendJson(res, 404, { error: "not found" });
             return;
         }
-        sendJson(res, 200, { ok: true }, `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`);
+        sendJson(res, 200, { ok: true }, LOGOUT_SET_COOKIE);
     });
     addRoute("get", `${AUTH_PREFIX}/status`, statusHandler);
     addRoute("post", `${AUTH_PREFIX}/request`, requestHandler);
@@ -185,32 +235,12 @@ export function mountGate(opts, addRoute, addMiddleware) {
     addRoute("post", `${AUTH_PREFIX}/logout`, logoutHandler);
     // --- The gate middleware (runs before static + the app's /api handlers) ---
     const gateMiddleware = (async (req, res, next) => {
-        // Not tunnel traffic (platform front door, or any other local caller): the
-        // request is already authenticated (or is not ours to gate). Pass through.
-        if (!isTunnelHost(req, publicDomain))
-            return next();
-        const path = (req.url ?? "/").split("?")[0] ?? "/";
-        // The login flow is open so the browser can render <AuthGate> and sign in.
-        if (path.startsWith(AUTH_PREFIX))
-            return next();
-        // Anti-spoof: only the gate may assert identity on tunnel traffic.
-        applyHeaderPolicy(req);
-        // Static (non-API) loads freely so the SPA can render; drop the gate cookie.
-        if (!path.startsWith("/api/")) {
-            stripSessionCookie(req);
-            return next();
-        }
-        // Every other /api/* needs a valid OTP session.
-        const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
-        const email = await gate.session(cookie);
-        if (!email) {
-            sendJson(res, 401, { error: "authentication required", loginPath: AUTH_PREFIX });
-            return;
-        }
-        injectIdentity(req, email);
-        stripSessionCookie(req);
-        next();
+        const action = await gateRequest(req, { gate, publicDomain, headerPolicy });
+        if (action === "deny")
+            sendJson(res, 401, UNAUTHORIZED_BODY);
+        else
+            next();
     });
     addMiddleware("/", gateMiddleware);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gate.js","sourceRoot":"","sources":["../../src/gate.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel's in-app AUTH GATE - Express middleware + login routes the\n * {@link AuthGatePlugin} registers on the app's OWN server via `this.context`.\n *\n * The gate is MIDDLEWARE, not a reverse proxy - the app is the process, so there is\n * nothing to forward to. It either short-circuits (401, or answers the open login\n * routes) or calls `next()` to let the app's real handlers run. It is the\n * \"stands in for AppKit auth\" path:\n * a portr caller proves an email via OTP, and on success the gate injects the\n * identity headers AppKit reads, so a gated request runs like a front-door one.\n *\n * WHICH TRAFFIC IS GATED - the `Host` header, not the socket. portr's client\n * forwards with Go's `httputil.NewSingleHostReverseProxy` and a `Director` that\n * PRESERVES the original `Host`, so tunnel requests arrive with\n * `Host: <subdomain>.<server>` (the public domain). A local process hitting the\n * app directly sends `Host: 127.0.0.1:<port>` / `localhost`. So ONLY requests whose\n * `Host` matches the configured public domain are gated; the platform front door\n * and any other local client pass through untouched. There is no portr-injected\n * identifying header and no TCP/source-IP signal to use instead (the client dials\n * the target over plain loopback).\n *\n * @module\n */\n\nimport { http, json, log, token } from \"@dbx-tools/shared-core\";\nimport { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from \"@dbx-tools/shared-email\";\nimport type { Request, RequestHandler, Response } from \"express\";\nimport { toHeaderPolicy } from \"./headers.ts\";\nimport type { AuthGateApi } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:gate\");\n\n/** Route prefix the login flow lives under (open, answered in-process). */\nexport const AUTH_PREFIX = \"/api/email/auth\";\n\n/** Options for {@link mountGate}. */\nexport interface GateOptions {\n  /** The in-process gate API (session/request/verify/status). */\n  gate: AuthGateApi;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by `Host`.\n   * When absent, no request is ever classified as tunnel traffic and the gate is\n   * inert (everything passes through) - a tunnel with no public domain gates\n   * nothing.\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (unioned with the\n   * built-in allow-list). Every other `x-` header is stripped from tunnel traffic.\n   */\n  forwardHeaders?: readonly string[];\n}\n\n/**\n * True when the request's `Host` is the tunnel's public domain - i.e. it came in\n * over portr. Case-insensitive; the optional `:port` is ignored. When no public\n * domain is configured, nothing is tunnel traffic.\n */\nexport function isTunnelHost(req: Request, publicDomain: string | undefined): boolean {\n  if (!publicDomain) return false;\n  const host = (req.headers.host ?? \"\").toLowerCase().split(\":\")[0];\n  return host === publicDomain.toLowerCase().split(\":\")[0];\n}\n\n/** The session cookie for a verified email, as a Set-Cookie string. */\nfunction sessionCookie(value: string, maxAgeSeconds: number): string {\n  return [\n    `${SESSION_COOKIE_NAME}=${value}`,\n    \"Path=/\",\n    \"HttpOnly\",\n    \"SameSite=Lax\",\n    `Max-Age=${maxAgeSeconds}`,\n    // Real enforcement in production: the session cookie must be Secure so it is\n    // never sent over plaintext. Local dev (http) omits it so the cookie works.\n    process.env.NODE_ENV === \"production\" ? \"Secure\" : \"\",\n  ]\n    .filter(Boolean)\n    .join(\"; \");\n}\n\n/**\n * Client IP for rate-limiting: the RIGHTMOST `x-forwarded-for` entry (the value\n * the nearest trusted hop - portr - wrote), else the socket address. Reading the\n * rightmost, not the leftmost, stops a caller minting a fresh rate-limit bucket by\n * varying the header. Called before {@link stripHeaders}.\n */\nfunction clientIp(req: Request): string {\n  const forwarded = req.headers[\"x-forwarded-for\"];\n  const chain = (Array.isArray(forwarded) ? forwarded.join(\",\") : (forwarded ?? \"\"))\n    .split(\",\")\n    .map((entry) => entry.trim())\n    .filter(Boolean);\n  return chain.at(-1) ?? req.socket.remoteAddress ?? \"unknown\";\n}\n\n/**\n * Remove the gate's session cookie from the `Cookie` header before the app's\n * handlers run, so the app never sees `dbx_auth` (it is the gate's concern).\n * Preserves other cookies; deletes the header when it becomes empty.\n */\nfunction stripSessionCookie(req: Request): void {\n  const raw = req.headers.cookie;\n  if (!raw) return;\n  const kept = raw\n    .split(\";\")\n    .map((c) => c.trim())\n    .filter((c) => c && !c.startsWith(`${SESSION_COOKIE_NAME}=`));\n  if (kept.length) req.headers.cookie = kept.join(\"; \");\n  else delete req.headers.cookie;\n}\n\n/**\n * Present an OTP-authenticated caller to the app the SAME way a platform front\n * door does: set the front-door identity headers to the verified address (AppKit\n * reads {@link token.USER_ID_HEADER} for the OBO user id), so the app needs no\n * gate-specific code path.\n *\n * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an OTP session\n * proves an email, not possession of a Databricks credential. Its absence is what\n * `@dbx-tools/appkit`'s `identity: \"auto\"` detects, so a gated request runs as the\n * app service principal instead of throwing.\n */\nfunction injectIdentity(req: Request, email: string): void {\n  req.headers[token.USER_ID_HEADER] = email;\n  req.headers[token.USER_EMAIL_HEADER] = email;\n}\n\nfunction sendJson(res: Response, status: number, body: unknown, setCookie?: string): void {\n  if (setCookie) res.setHeader(\"set-cookie\", setCookie);\n  res.status(status).json(body);\n}\n\n/** Read the raw request body as text (AppKit parses JSON, but the gate routes\n * are mounted before that runs for tunnel traffic, so read defensively). */\nfunction readBody(req: Request): Promise<string> {\n  // AppKit's json body-parser may have already populated req.body; prefer it.\n  if (req.body !== undefined && req.body !== null) {\n    return Promise.resolve(typeof req.body === \"string\" ? req.body : JSON.stringify(req.body));\n  }\n  return new Promise((resolve) => {\n    let data = \"\";\n    req.on(\"data\", (chunk) => (data += chunk));\n    req.on(\"end\", () => resolve(data));\n    req.on(\"error\", () => resolve(data));\n  });\n}\n\n/**\n * Register the login routes and the gating middleware on the app's Express\n * instance. Called from {@link AuthGatePlugin} with the router AppKit hands\n * `injectRoutes`, plus `this.context.addMiddleware` for the global gate.\n *\n * `addRoute`/`addMiddleware` are used (via the passed callbacks) because the login\n * routes live at an ABSOLUTE path (`/api/email/auth/*`, the client's contract),\n * not under the plugin's `/api/authGate` base.\n */\nexport function mountGate(\n  opts: GateOptions,\n  addRoute: (method: \"get\" | \"post\", path: string, handler: RequestHandler) => void,\n  addMiddleware: (path: string, handler: RequestHandler) => void,\n): void {\n  const { gate, publicDomain, forwardHeaders } = opts;\n  const headerPolicy = toHeaderPolicy(forwardHeaders);\n  logger.debug(\"gate mounted\", { publicDomain, forward: headerPolicy.patterns });\n\n  const applyHeaderPolicy = (req: Request): void => {\n    const removed = headerPolicy.apply(req.headers as Record<string, unknown>);\n    if (removed.length) logger.debug(\"stripped inbound headers\", { removed });\n  };\n\n  // --- Login routes (open on tunnel traffic; answered in-process) ---\n\n  const statusHandler = (async (req, res) => {\n    // A local or front-door caller is never gated, so the honest answer is that\n    // the gate does not apply - not the session state of a cookie it would never\n    // check. Without this, a browser on `localhost` renders the OTP login screen\n    // for a request that would have passed through untouched.\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 200, { authenticated: false, enabled: false });\n      return;\n    }\n    const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    sendJson(res, 200, await gate.status(cookie));\n  }) as RequestHandler;\n\n  const requestHandler = (async (req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 404, { error: \"not found\" });\n      return;\n    }\n    const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));\n    if (!parsed.success) return sendJson(res, 200, { ok: true }); // anti-enumeration\n    sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));\n  }) as RequestHandler;\n\n  const verifyHandler = (async (req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 404, { error: \"not found\" });\n      return;\n    }\n    const parsed = authVerifySchema.safeParse(json.parseRecord(await readBody(req)));\n    if (!parsed.success) return sendJson(res, 200, { ok: false });\n    const result = await gate.verify(parsed.data.email, parsed.data.code, clientIp(req));\n    const cookie =\n      result.ok && result.token ? sessionCookie(result.token, gate.sessionTtlSeconds) : undefined;\n    sendJson(\n      res,\n      200,\n      { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) },\n      cookie,\n    );\n  }) as RequestHandler;\n\n  const logoutHandler = ((req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 404, { error: \"not found\" });\n      return;\n    }\n    sendJson(res, 200, { ok: true }, `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`);\n  }) as RequestHandler;\n\n  addRoute(\"get\", `${AUTH_PREFIX}/status`, statusHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/request`, requestHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/verify`, verifyHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/logout`, logoutHandler);\n\n  // --- The gate middleware (runs before static + the app's /api handlers) ---\n\n  const gateMiddleware = (async (req, res, next) => {\n    // Not tunnel traffic (platform front door, or any other local caller): the\n    // request is already authenticated (or is not ours to gate). Pass through.\n    if (!isTunnelHost(req, publicDomain)) return next();\n\n    const path = (req.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n\n    // The login flow is open so the browser can render <AuthGate> and sign in.\n    if (path.startsWith(AUTH_PREFIX)) return next();\n\n    // Anti-spoof: only the gate may assert identity on tunnel traffic.\n    applyHeaderPolicy(req);\n\n    // Static (non-API) loads freely so the SPA can render; drop the gate cookie.\n    if (!path.startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      return next();\n    }\n\n    // Every other /api/* needs a valid OTP session.\n    const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    const email = await gate.session(cookie);\n    if (!email) {\n      sendJson(res, 401, { error: \"authentication required\", loginPath: AUTH_PREFIX });\n      return;\n    }\n    injectIdentity(req, email);\n    stripSessionCookie(req);\n    next();\n  }) as RequestHandler;\n\n  addMiddleware(\"/\", gateMiddleware);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gate.js","sourceRoot":"","sources":["../../src/gate.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel's in-app AUTH GATE - Express middleware + login routes the\n * {@link AuthGatePlugin} registers on the app's OWN server via `this.context`.\n *\n * The gate is MIDDLEWARE, not a reverse proxy - the app is the process, so there is\n * nothing to forward to. It either short-circuits (401, or answers the open login\n * routes) or calls `next()` to let the app's real handlers run. It is the\n * \"stands in for AppKit auth\" path:\n * a portr caller proves an email via OTP, and on success the gate injects the\n * identity headers AppKit reads, so a gated request runs like a front-door one.\n *\n * WHICH TRAFFIC IS GATED - the `Host` header, not the socket. portr's client\n * forwards with Go's `httputil.NewSingleHostReverseProxy` and a `Director` that\n * PRESERVES the original `Host`, so tunnel requests arrive with\n * `Host: <subdomain>.<server>` (the public domain). A local process hitting the\n * app directly sends `Host: 127.0.0.1:<port>` / `localhost`. So ONLY requests whose\n * `Host` matches the configured public domain are gated; the platform front door\n * and any other local client pass through untouched. There is no portr-injected\n * identifying header and no TCP/source-IP signal to use instead (the client dials\n * the target over plain loopback).\n *\n * @module\n */\n\nimport type { IncomingMessage } from \"node:http\";\nimport { http, json, log, token } from \"@dbx-tools/shared-core\";\nimport { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from \"@dbx-tools/shared-email\";\nimport type { Request, RequestHandler, Response } from \"express\";\nimport { toHeaderPolicy, type HeaderPolicy } from \"./headers.ts\";\nimport type { AuthGateApi } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:gate\");\n\n/** Route prefix the login flow lives under (open, answered in-process). */\nexport const AUTH_PREFIX = \"/api/email/auth\";\n\n/** Options for {@link mountGate}. */\nexport interface GateOptions {\n  /** The in-process gate API (session/request/verify/status). */\n  gate: AuthGateApi;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by `Host`.\n   * When absent, no request is ever classified as tunnel traffic and the gate is\n   * inert (everything passes through) - a tunnel with no public domain gates\n   * nothing.\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (unioned with the\n   * built-in allow-list). Every other `x-` header is stripped from tunnel traffic.\n   */\n  forwardHeaders?: readonly string[];\n}\n\n/**\n * True when the request's `Host` is the tunnel's public domain - i.e. it came in\n * over portr. Case-insensitive; the optional `:port` is ignored. When no public\n * domain is configured, nothing is tunnel traffic.\n */\nexport function isTunnelHost(req: IncomingMessage, publicDomain: string | undefined): boolean {\n  if (!publicDomain) return false;\n  const host = (req.headers.host ?? \"\").toLowerCase().split(\":\")[0];\n  return host === publicDomain.toLowerCase().split(\":\")[0];\n}\n\n/** The session cookie for a verified email, as a Set-Cookie string. */\nfunction sessionCookie(value: string, maxAgeSeconds: number): string {\n  return [\n    `${SESSION_COOKIE_NAME}=${value}`,\n    \"Path=/\",\n    \"HttpOnly\",\n    \"SameSite=Lax\",\n    `Max-Age=${maxAgeSeconds}`,\n    // Real enforcement in production: the session cookie must be Secure so it is\n    // never sent over plaintext. Local dev (http) omits it so the cookie works.\n    process.env.NODE_ENV === \"production\" ? \"Secure\" : \"\",\n  ]\n    .filter(Boolean)\n    .join(\"; \");\n}\n\n/**\n * Client IP for rate-limiting: the RIGHTMOST `x-forwarded-for` entry (the value\n * the nearest trusted hop - portr - wrote), else the socket address. Reading the\n * rightmost, not the leftmost, stops a caller minting a fresh rate-limit bucket by\n * varying the header. Called before {@link stripHeaders}.\n */\nexport function clientIp(req: IncomingMessage): string {\n  const forwarded = req.headers[\"x-forwarded-for\"];\n  const chain = (Array.isArray(forwarded) ? forwarded.join(\",\") : (forwarded ?? \"\"))\n    .split(\",\")\n    .map((entry) => entry.trim())\n    .filter(Boolean);\n  return chain.at(-1) ?? req.socket.remoteAddress ?? \"unknown\";\n}\n\n/**\n * Remove the gate's session cookie from the `Cookie` header before the app's\n * handlers run, so the app never sees `dbx_auth` (it is the gate's concern).\n * Preserves other cookies; deletes the header when it becomes empty.\n */\nfunction stripSessionCookie(req: IncomingMessage): void {\n  const raw = req.headers.cookie;\n  if (!raw) return;\n  const kept = raw\n    .split(\";\")\n    .map((c) => c.trim())\n    .filter((c) => c && !c.startsWith(`${SESSION_COOKIE_NAME}=`));\n  if (kept.length) req.headers.cookie = kept.join(\"; \");\n  else delete req.headers.cookie;\n}\n\n/**\n * Present an OTP-authenticated caller to the app the SAME way a platform front\n * door does: set the front-door identity headers to the verified address (AppKit\n * reads {@link token.USER_ID_HEADER} for the OBO user id), so the app needs no\n * gate-specific code path.\n *\n * What the gate CANNOT set is {@link token.ACCESS_TOKEN_HEADER}: an OTP session\n * proves an email, not possession of a Databricks credential. Its absence is what\n * `@dbx-tools/appkit`'s `identity: \"auto\"` detects, so a gated request runs as the\n * app service principal instead of throwing.\n */\nfunction injectIdentity(req: IncomingMessage, email: string): void {\n  req.headers[token.USER_ID_HEADER] = email;\n  req.headers[token.USER_EMAIL_HEADER] = email;\n}\n\nfunction sendJson(res: Response, status: number, body: unknown, setCookie?: string): void {\n  if (setCookie) res.setHeader(\"set-cookie\", setCookie);\n  res.status(status).json(body);\n}\n\n/** Read the raw request body as text (AppKit parses JSON, but the gate routes\n * are mounted before that runs for tunnel traffic, so read defensively). */\nfunction readBody(req: Request): Promise<string> {\n  // AppKit's json body-parser may have already populated req.body; prefer it.\n  if (req.body !== undefined && req.body !== null) {\n    return Promise.resolve(typeof req.body === \"string\" ? req.body : JSON.stringify(req.body));\n  }\n  return new Promise((resolve) => {\n    let data = \"\";\n    req.on(\"data\", (chunk) => (data += chunk));\n    req.on(\"end\", () => resolve(data));\n    req.on(\"error\", () => resolve(data));\n  });\n}\n\n/**\n * What the caller should do with a request, from {@link gateRequest}.\n *\n *   - `pass` - not tunnel traffic, or an open login route. Forward untouched.\n *   - `allow` - tunnel traffic that is authorized. The request's headers have\n *     ALREADY been rewritten (policy applied, identity injected, session cookie\n *     stripped), so forward it as it now stands.\n *   - `deny` - tunnel traffic with no valid session. Answer `401` with\n *     {@link AUTH_PREFIX} as the login path.\n */\nexport type GateAction = \"pass\" | \"allow\" | \"deny\";\n\n/**\n * THE gating decision, for one request, independent of how it will be answered.\n *\n * Both paths call this: the Express middleware below (where the app is the\n * process) and `@dbx-tools/cli-tunnel`'s reverse proxy (where the app is a child\n * process on a private port). A divergence between them would be a security bug\n * the second path could not be tested into agreement - one path forgetting to\n * strip `x-forwarded-access-token` is enough - so the decision, the header\n * rewriting, and the identity injection live here once and the transports only\n * differ in how they WRITE the outcome.\n *\n * Mutates `req.headers` on the `allow`/`pass`-with-cookie paths, which is exactly\n * what both callers want: Express hands the same object to the app's handlers, and\n * the proxy forwards it upstream.\n */\nexport async function gateRequest(\n  req: IncomingMessage,\n  options: GateOptions & { headerPolicy?: HeaderPolicy },\n): Promise<GateAction> {\n  const { gate, publicDomain } = options;\n  // Not tunnel traffic (platform front door, or any other local caller): the\n  // request is already authenticated, or is not ours to gate.\n  if (!isTunnelHost(req, publicDomain)) return \"pass\";\n\n  const path = (req.url ?? \"/\").split(\"?\")[0] ?? \"/\";\n  // The login flow is open so the browser can render <AuthGate> and sign in.\n  if (path.startsWith(AUTH_PREFIX)) return \"pass\";\n\n  // Anti-spoof: only the gate may assert identity on tunnel traffic.\n  const policy = options.headerPolicy ?? toHeaderPolicy(options.forwardHeaders);\n  const removed = policy.apply(req.headers as Record<string, unknown>);\n  if (removed.length) logger.debug(\"stripped inbound headers\", { removed });\n\n  // Static (non-API) loads freely so the SPA can render; drop the gate cookie.\n  if (!path.startsWith(\"/api/\")) {\n    stripSessionCookie(req);\n    return \"pass\";\n  }\n\n  // Every other /api/* needs a valid OTP session.\n  const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n  const email = await gate.session(cookie);\n  if (!email) return \"deny\";\n  injectIdentity(req, email);\n  stripSessionCookie(req);\n  return \"allow\";\n}\n\n/** The body of a `deny`, shared so both paths answer a 401 identically. */\nexport const UNAUTHORIZED_BODY = {\n  error: \"authentication required\",\n  loginPath: AUTH_PREFIX,\n} as const;\n\n/** The `Set-Cookie` value that issues a verified session. */\nexport function sessionSetCookie(sessionToken: string, maxAgeSeconds: number): string {\n  return sessionCookie(sessionToken, maxAgeSeconds);\n}\n\n/** The `Set-Cookie` value that clears the session. */\nexport const LOGOUT_SET_COOKIE = `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`;\n\n/**\n * Register the login routes and the gating middleware on the app's Express\n * instance. Called from {@link AuthGatePlugin} with the router AppKit hands\n * `injectRoutes`, plus `this.context.addMiddleware` for the global gate.\n *\n * `addRoute`/`addMiddleware` are used (via the passed callbacks) because the login\n * routes live at an ABSOLUTE path (`/api/email/auth/*`, the client's contract),\n * not under the plugin's `/api/authGate` base.\n */\nexport function mountGate(\n  opts: GateOptions,\n  addRoute: (method: \"get\" | \"post\", path: string, handler: RequestHandler) => void,\n  addMiddleware: (path: string, handler: RequestHandler) => void,\n): void {\n  const { gate, publicDomain, forwardHeaders } = opts;\n  const headerPolicy = toHeaderPolicy(forwardHeaders);\n  logger.debug(\"gate mounted\", { publicDomain, forward: headerPolicy.patterns });\n\n  // --- Login routes (open on tunnel traffic; answered in-process) ---\n\n  const statusHandler = (async (req, res) => {\n    // A local or front-door caller is never gated, so the honest answer is that\n    // the gate does not apply - not the session state of a cookie it would never\n    // check. Without this, a browser on `localhost` renders the OTP login screen\n    // for a request that would have passed through untouched.\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 200, { authenticated: false, enabled: false });\n      return;\n    }\n    const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    sendJson(res, 200, await gate.status(cookie));\n  }) as RequestHandler;\n\n  const requestHandler = (async (req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 404, { error: \"not found\" });\n      return;\n    }\n    const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));\n    if (!parsed.success) return sendJson(res, 200, { ok: true }); // anti-enumeration\n    sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));\n  }) as RequestHandler;\n\n  const verifyHandler = (async (req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 404, { error: \"not found\" });\n      return;\n    }\n    const parsed = authVerifySchema.safeParse(json.parseRecord(await readBody(req)));\n    if (!parsed.success) return sendJson(res, 200, { ok: false });\n    const result = await gate.verify(parsed.data.email, parsed.data.code, clientIp(req));\n    const cookie =\n      result.ok && result.token ? sessionCookie(result.token, gate.sessionTtlSeconds) : undefined;\n    sendJson(\n      res,\n      200,\n      { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) },\n      cookie,\n    );\n  }) as RequestHandler;\n\n  const logoutHandler = ((req, res) => {\n    if (!isTunnelHost(req, publicDomain)) {\n      sendJson(res, 404, { error: \"not found\" });\n      return;\n    }\n    sendJson(res, 200, { ok: true }, LOGOUT_SET_COOKIE);\n  }) as RequestHandler;\n\n  addRoute(\"get\", `${AUTH_PREFIX}/status`, statusHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/request`, requestHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/verify`, verifyHandler);\n  addRoute(\"post\", `${AUTH_PREFIX}/logout`, logoutHandler);\n\n  // --- The gate middleware (runs before static + the app's /api handlers) ---\n\n  const gateMiddleware = (async (req, res, next) => {\n    const action = await gateRequest(req, { gate, publicDomain, headerPolicy });\n    if (action === \"deny\") sendJson(res, 401, UNAUTHORIZED_BODY);\n    else next();\n  }) as RequestHandler;\n\n  addMiddleware(\"/\", gateMiddleware);\n}\n"]}

package/lib/src/plugin.js

@@ -16,9 +16,10 @@
  * @module
  */
 import { Plugin, toPlugin } from "@databricks/appkit";
-import { brand, env, log, object, string } from "@dbx-tools/shared-core";
+import { config as configModule } from "@dbx-tools/core";
+import { brand, log, object, string } from "@dbx-tools/shared-core";
+import { TUNNEL_CONFIG } from "./_config.js";
 import { looksLikeEmail, matchesAllowlist } from "./allowlist.js";
-import { ALLOW_ENV, BRAND_NAME_ENV, CODE_TTL_ENV, FORWARD_HEADERS_ENV, INSECURE_ENV, MESSAGE_ENV, PUBLIC_DOMAIN_ENV, SESSION_TTL_ENV, SUBJECT_ENV, } from "./env.js";
 import { mountGate } from "./gate.js";
 import { CodeStore, signSession, verifySession } from "./otp.js";
 import { RateLimiter } from "./rate-limit.js";
@@ -62,22 +63,25 @@ export function resolveAuthGateConfig(config) {
     return {
         // Both sources are unioned rather than one overriding: a deployment-wide
         // 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),
+        // Hence `parseList` on each rather than `config.list`, which stops at the
+        // first source that yields anything.
+        allow: [
+            ...string.parseList(config.allow),
+            ...string.parseList(configModule.text(["AUTH_ALLOW", "EMAIL_AUTH_ALLOW"], TUNNEL_CONFIG)),
+        ],
+        subject: configModule.string(config.subject, "AUTH_SUBJECT", TUNNEL_CONFIG) ?? DEFAULTS.subject,
+        brandName: configModule.string(config.brandName, "AUTH_BRAND_NAME", TUNNEL_CONFIG) ?? DEFAULTS.brandName,
+        message: configModule.string(config.message, "AUTH_MESSAGE", TUNNEL_CONFIG) ?? DEFAULTS.message,
+        sessionTtlSeconds: configModule.positiveInt(config.sessionTtlSeconds, "AUTH_SESSION_TTL", DEFAULTS.sessionTtlSeconds, TUNNEL_CONFIG),
+        codeTtlSeconds: configModule.positiveInt(config.codeTtlSeconds, "AUTH_CODE_TTL", DEFAULTS.codeTtlSeconds, TUNNEL_CONFIG),
         maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,
         sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),
-        publicDomain: env.string(config.publicDomain, PUBLIC_DOMAIN_ENV) ?? undefined,
+        publicDomain: configModule.string(config.publicDomain, "PUBLIC_DOMAIN", TUNNEL_CONFIG),
         forwardHeaders: [
             ...string.parseList(config.forwardHeaders),
-            ...string.parseList(env.text(FORWARD_HEADERS_ENV)),
+            ...string.parseList(configModule.text("FORWARD_HEADERS", TUNNEL_CONFIG)),
         ],
-        insecure: env.boolean(config.insecure, INSECURE_ENV) ?? false,
+        insecure: configModule.boolean(config.insecure, "INSECURE", TUNNEL_CONFIG) ?? false,
     };
 }
 /**
@@ -206,4 +210,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, object, string } from \"@dbx-tools/shared-core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-email\";\nimport type { RequestHandler } from \"express\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport {\n  ALLOW_ENV,\n  BRAND_NAME_ENV,\n  CODE_TTL_ENV,\n  FORWARD_HEADERS_ENV,\n  INSECURE_ENV,\n  MESSAGE_ENV,\n  PUBLIC_DOMAIN_ENV,\n  SESSION_TTL_ENV,\n  SUBJECT_ENV,\n} from \"./env.ts\";\nimport { mountGate, type GateOptions } from \"./gate.ts\";\nimport { CodeStore, signSession, verifySession } from \"./otp.ts\";\nimport { RateLimiter } from \"./rate-limit.ts\";\nimport { ensureEmailAvailable, sendCode as defaultSendCode } from \"./send-code.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\ninterface GateServerApplication {\n  get(path: string, handler: RequestHandler): unknown;\n  post(path: string, handler: RequestHandler): unknown;\n  use(path: string, handler: RequestHandler): unknown;\n}\n\ninterface GateMountContext {\n  addRoute(method: string, path: string, handler: RequestHandler): void;\n  addMiddleware(path: string, handler: RequestHandler): void;\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\nfunction serverApplication(context: GateMountContext): GateServerApplication | undefined {\n  const server = context.getPlugins().get(\"server\") as\n    { serverApplication?: Partial<GateServerApplication> } | undefined;\n  const application = server?.serverApplication;\n  return application &&\n    typeof application.get === \"function\" &&\n    typeof application.post === \"function\" &&\n    typeof application.use === \"function\"\n    ? (application as GateServerApplication)\n    : undefined;\n}\n\nexport function mountGateOnContext(context: GateMountContext, options: GateOptions): void {\n  const application = serverApplication(context);\n  if (application) {\n    mountGate(\n      options,\n      (method, path, handler) => application[method](path, handler),\n      (path, handler) => application.use(path, handler),\n    );\n    return;\n  }\n  mountGate(\n    options,\n    (method, path, handler) => context.addRoute(method, path, handler),\n    (path, handler) => context.addMiddleware(path, handler),\n  );\n}\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   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./code-email.ts`.\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  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\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  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /**\n   * Deliver a code to an address. Defaults to sending through the host app's\n   * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a\n   * different delivery path.\n   */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`\n   * header. Only requests whose `Host` matches this are gated; everything else\n   * (the platform front door, other local callers) passes through. Env\n   * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel\n   * traffic).\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (literal / glob /\n   * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.\n   */\n  forwardHeaders?: string | string[];\n  /**\n   * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate\n   * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when\n   * the tunnel is deliberately public.\n   */\n  insecure?: boolean;\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  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n  /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */\n  publicDomain?: string;\n  /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */\n  forwardHeaders: string[];\n  /** Run OPEN with no gate. */\n  insecure: boolean;\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`; the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\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    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n    publicDomain: env.string(config.publicDomain, PUBLIC_DOMAIN_ENV) ?? undefined,\n    forwardHeaders: [\n      ...string.parseList(config.forwardHeaders),\n      ...string.parseList(env.text(FORWARD_HEADERS_ENV)),\n    ],\n    insecure: env.boolean(config.insecure, INSECURE_ENV) ?? false,\n  };\n}\n\n/** The handlers the gate middleware 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/**\n * AppKit plugin owning the email-OTP gate. On `setup()` it registers the login\n * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express\n * server via `this.context`, so a public portr caller must prove an email before\n * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and\n * other local callers pass through untouched (the gate keys on the `Host` header).\n */\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    // Resolve the signing key HERE rather than lazily on the first sign-in, so a\n    // cache that cannot hold it (and the resulting \"sessions won't survive a\n    // restart\" warning) shows up in the startup log, not hours later.\n    const { cutoffMs } = await signingKey(this.resolved.sessionCutoffMs);\n\n    if (this.resolved.insecure) {\n      logger.warn(\"insecure mode - the tunnel runs OPEN with no email-OTP gate\");\n    } else {\n      // `server()` is deferred, so it does not exist during this plugin's setup.\n      // At `setup:complete` the Express app exists but has not injected plugin\n      // routes or static handling yet, which is the one point the gate can mount\n      // ahead of every protected route.\n      this.context?.onLifecycle(\"setup:complete\", async () => {\n        this.mountGateRoutes();\n        // Fail fast once the sibling email plugin has primed its transport: a\n        // gate that cannot email a code lets nobody in.\n        await ensureEmailAvailable();\n      });\n    }\n\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      publicDomain: this.resolved.publicDomain ?? null,\n      insecure: this.resolved.insecure,\n      ...object.optional(\"sessionCutoff\", cutoffMs > 0 ? new Date(cutoffMs).toISOString() : null),\n    });\n  }\n\n  /**\n   * Register the login routes (`/api/email/auth/*`) and the gating middleware on\n   * the app's OWN Express server. At `setup:complete`, the deferred server plugin\n   * has constructed its Express app but has not injected plugin routes or static\n   * handling, so direct registration puts the gate first. The context's buffered\n   * route API remains a fallback for compatible non-standard server plugins.\n   */\n  private mountGateRoutes(): void {\n    const context = this.context;\n    if (!context) {\n      logger.warn(\"no plugin context - the OTP gate cannot mount its routes\");\n      return;\n    }\n    mountGateOnContext(context, {\n      gate: this.exports(),\n      publicDomain: this.resolved.publicDomain,\n      forwardHeaders: this.resolved.forwardHeaders,\n    });\n  }\n\n  /** The code sender: the configured `sendCode`, else the shared-transport default. */\n  private get sendCode(): NonNullable<AuthGateConfig[\"sendCode\"]> {\n    return this.config.sendCode ?? defaultSendCode;\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.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 { config as configModule } from \"@dbx-tools/core\";\nimport { brand, log, object, string } from \"@dbx-tools/shared-core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-email\";\nimport type { RequestHandler } from \"express\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { mountGate, type GateOptions } from \"./gate.ts\";\nimport { CodeStore, signSession, verifySession } from \"./otp.ts\";\nimport { RateLimiter } from \"./rate-limit.ts\";\nimport { ensureEmailAvailable, sendCode as defaultSendCode } from \"./send-code.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\ninterface GateServerApplication {\n  get(path: string, handler: RequestHandler): unknown;\n  post(path: string, handler: RequestHandler): unknown;\n  use(path: string, handler: RequestHandler): unknown;\n}\n\ninterface GateMountContext {\n  addRoute(method: string, path: string, handler: RequestHandler): void;\n  addMiddleware(path: string, handler: RequestHandler): void;\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\nfunction serverApplication(context: GateMountContext): GateServerApplication | undefined {\n  const server = context.getPlugins().get(\"server\") as\n    { serverApplication?: Partial<GateServerApplication> } | undefined;\n  const application = server?.serverApplication;\n  return application &&\n    typeof application.get === \"function\" &&\n    typeof application.post === \"function\" &&\n    typeof application.use === \"function\"\n    ? (application as GateServerApplication)\n    : undefined;\n}\n\nexport function mountGateOnContext(context: GateMountContext, options: GateOptions): void {\n  const application = serverApplication(context);\n  if (application) {\n    mountGate(\n      options,\n      (method, path, handler) => application[method](path, handler),\n      (path, handler) => application.use(path, handler),\n    );\n    return;\n  }\n  mountGate(\n    options,\n    (method, path, handler) => context.addRoute(method, path, handler),\n    (path, handler) => context.addMiddleware(path, handler),\n  );\n}\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   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./code-email.ts`.\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  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\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  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /**\n   * Deliver a code to an address. Defaults to sending through the host app's\n   * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a\n   * different delivery path.\n   */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`\n   * header. Only requests whose `Host` matches this are gated; everything else\n   * (the platform front door, other local callers) passes through. Env\n   * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel\n   * traffic).\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (literal / glob /\n   * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.\n   */\n  forwardHeaders?: string | string[];\n  /**\n   * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate\n   * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when\n   * the tunnel is deliberately public.\n   */\n  insecure?: boolean;\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  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n  /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */\n  publicDomain?: string;\n  /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */\n  forwardHeaders: string[];\n  /** Run OPEN with no gate. */\n  insecure: boolean;\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`; the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\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 `config.list`, which stops at the\n    // first source that yields anything.\n    allow: [\n      ...string.parseList(config.allow),\n      ...string.parseList(configModule.text([\"AUTH_ALLOW\", \"EMAIL_AUTH_ALLOW\"], TUNNEL_CONFIG)),\n    ],\n    subject: configModule.string(config.subject, \"AUTH_SUBJECT\", TUNNEL_CONFIG) ?? DEFAULTS.subject,\n    brandName:\n      configModule.string(config.brandName, \"AUTH_BRAND_NAME\", TUNNEL_CONFIG) ?? DEFAULTS.brandName,\n    message: configModule.string(config.message, \"AUTH_MESSAGE\", TUNNEL_CONFIG) ?? DEFAULTS.message,\n    sessionTtlSeconds: configModule.positiveInt(\n      config.sessionTtlSeconds,\n      \"AUTH_SESSION_TTL\",\n      DEFAULTS.sessionTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    codeTtlSeconds: configModule.positiveInt(\n      config.codeTtlSeconds,\n      \"AUTH_CODE_TTL\",\n      DEFAULTS.codeTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n    publicDomain: configModule.string(config.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG),\n    forwardHeaders: [\n      ...string.parseList(config.forwardHeaders),\n      ...string.parseList(configModule.text(\"FORWARD_HEADERS\", TUNNEL_CONFIG)),\n    ],\n    insecure: configModule.boolean(config.insecure, \"INSECURE\", TUNNEL_CONFIG) ?? false,\n  };\n}\n\n/** The handlers the gate middleware 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/**\n * AppKit plugin owning the email-OTP gate. On `setup()` it registers the login\n * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express\n * server via `this.context`, so a public portr caller must prove an email before\n * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and\n * other local callers pass through untouched (the gate keys on the `Host` header).\n */\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    // Resolve the signing key HERE rather than lazily on the first sign-in, so a\n    // cache that cannot hold it (and the resulting \"sessions won't survive a\n    // restart\" warning) shows up in the startup log, not hours later.\n    const { cutoffMs } = await signingKey(this.resolved.sessionCutoffMs);\n\n    if (this.resolved.insecure) {\n      logger.warn(\"insecure mode - the tunnel runs OPEN with no email-OTP gate\");\n    } else {\n      // `server()` is deferred, so it does not exist during this plugin's setup.\n      // At `setup:complete` the Express app exists but has not injected plugin\n      // routes or static handling yet, which is the one point the gate can mount\n      // ahead of every protected route.\n      this.context?.onLifecycle(\"setup:complete\", async () => {\n        this.mountGateRoutes();\n        // Fail fast once the sibling email plugin has primed its transport: a\n        // gate that cannot email a code lets nobody in.\n        await ensureEmailAvailable();\n      });\n    }\n\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      publicDomain: this.resolved.publicDomain ?? null,\n      insecure: this.resolved.insecure,\n      ...object.optional(\"sessionCutoff\", cutoffMs > 0 ? new Date(cutoffMs).toISOString() : null),\n    });\n  }\n\n  /**\n   * Register the login routes (`/api/email/auth/*`) and the gating middleware on\n   * the app's OWN Express server. At `setup:complete`, the deferred server plugin\n   * has constructed its Express app but has not injected plugin routes or static\n   * handling, so direct registration puts the gate first. The context's buffered\n   * route API remains a fallback for compatible non-standard server plugins.\n   */\n  private mountGateRoutes(): void {\n    const context = this.context;\n    if (!context) {\n      logger.warn(\"no plugin context - the OTP gate cannot mount its routes\");\n      return;\n    }\n    mountGateOnContext(context, {\n      gate: this.exports(),\n      publicDomain: this.resolved.publicDomain,\n      forwardHeaders: this.resolved.forwardHeaders,\n    });\n  }\n\n  /** The code sender: the configured `sendCode`, else the shared-transport default. */\n  private get sendCode(): NonNullable<AuthGateConfig[\"sendCode\"]> {\n    return this.config.sendCode ?? defaultSendCode;\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.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"]}