@dbx-tools/cli-tunnel 0.6.45 → 0.6.47

package/lib/src/otp.js

@@ -9,10 +9,13 @@
  * 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 FAILS
- * OPEN with an ephemeral per-process key (sessions reset on restart) rather than
- * refusing service - a Databricks App is already access-limited, so an unset
- * secret degrades to "sessions don't survive restarts", not "nobody can log in".
+ * email. Its signing key comes from `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
+ * allow-listed address, because the signing key only validates an ALREADY-issued
+ * session. Set it in any deployment running more than one instance, or sessions
+ * minted by one will not verify on another.
  *
  * @module
  */
@@ -131,4 +134,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 FAILS\n * OPEN with an ephemeral per-process key (sessions reset on restart) rather than\n * refusing service - a Databricks App is already access-limited, so an unset\n * secret degrades to \"sessions don't survive restarts\", not \"nobody can log in\".\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 `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"]}

package/lib/src/plugin.d.ts

@@ -21,11 +21,30 @@ import type { AuthStatus } from "@dbx-tools/shared-email";
 export interface AuthGateConfig extends BasePluginConfig {
     /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env EMAIL_AUTH_ALLOW. */
     allow?: string | string[];
-    /** Subject line for the code email. Env AUTH_SUBJECT. */
+    /**
+     * Subject line for the code email. Env AUTH_SUBJECT.
+     *
+     * Defaults to "Your verification code". The wording of the subject and
+     * {@link message} is deliberately the conventional phrasing rather than
+     * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time
+     * code from this shape and offer to autofill it, and a novel phrasing is what
+     * breaks that detection.
+     */
     subject?: string;
-    /** Product/brand name used in the email + login copy. Env AUTH_BRAND_NAME. */
+    /**
+     * Display name used in the code email copy. Env 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
+     * brand for this gate.
+     */
     brandName?: string;
-    /** One-line message shown above the code in the email. Env AUTH_MESSAGE. */
+    /**
+     * Line shown immediately above the code in the email. Env 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). */
     sessionTtlSeconds?: number;
@@ -41,6 +60,13 @@ export interface SendCodeOptions {
     subject: string;
     brandName: string;
     message: string;
+    /**
+     * Lifetime of the code being sent, in seconds - the RESOLVED
+     * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real
+     * expiry ("This code expires in 10 minutes") instead of a vague "shortly"
+     * that drifts from the configured TTL.
+     */
+    codeTtlSeconds: number;
 }
 /** Resolved gate config with env fallbacks + defaults applied. */
 export interface ResolvedAuthGateConfig {

package/lib/src/plugin.js

@@ -16,33 +16,36 @@
  * @module
  */
 import { Plugin, toPlugin } from "@databricks/appkit";
-import { log, string } from "@dbx-tools/shared-core";
+import { brand, env, log, string } from "@dbx-tools/shared-core";
 import { looksLikeEmail, matchesAllowlist } from "./allowlist.js";
 import { CodeStore, signSession, verifySession } from "./otp.js";
 import { RateLimiter } from "./rate-limit.js";
 const logger = log.logger("tunnel:auth");
 const DEFAULTS = {
-    subject: "Your sign-in code",
-    brandName: "This app",
-    message: "Your one-time sign-in code is:",
+    subject: "Your verification code",
+    // The repo-wide brand context's display name, NOT a hardcoded product string:
+    // this name is what the recipient reads in the code email, so it has to be the
+    // same identity the rest of the app presents. A host with its own
+    // `branding/brand.yaml` overrides it by passing `brandName` (see
+    // {@link startGateApp}, which resolves the on-disk context); the shared default
+    // is the fallback when nothing is configured.
+    brandName: brand.defaultBrandContext.name,
+    message: "Your verification code is:",
     sessionTtlSeconds: 43200,
     codeTtlSeconds: 600,
     maxAttempts: 5,
 };
-/** Positive finite number from a value / env string, else the fallback. */
-function num(value, env, fallback) {
-    const raw = value ?? (env ? Number(env) : undefined);
-    return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : fallback;
-}
 /** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */
 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: config.subject ?? process.env.AUTH_SUBJECT?.trim() ?? DEFAULTS.subject,
-        brandName: config.brandName ?? process.env.AUTH_BRAND_NAME?.trim() ?? DEFAULTS.brandName,
-        message: config.message ?? process.env.AUTH_MESSAGE?.trim() ?? DEFAULTS.message,
-        sessionTtlSeconds: num(config.sessionTtlSeconds, process.env.AUTH_SESSION_TTL, DEFAULTS.sessionTtlSeconds),
-        codeTtlSeconds: num(config.codeTtlSeconds, process.env.AUTH_CODE_TTL, DEFAULTS.codeTtlSeconds),
+        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),
         maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,
     };
 }
@@ -96,6 +99,7 @@ export class AuthGatePlugin extends Plugin {
                     subject: this.resolved.subject,
                     brandName: this.resolved.brandName,
                     message: this.resolved.message,
+                    codeTtlSeconds: this.resolved.codeTtlSeconds,
                 });
             }
             catch (error) {
@@ -120,4 +124,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 { 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  /** Subject line for the code email. Env AUTH_SUBJECT. */\n  subject?: string;\n  /** Product/brand name used in the email + login copy. Env AUTH_BRAND_NAME. */\n  brandName?: string;\n  /** One-line message shown above the code in the email. Env AUTH_MESSAGE. */\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\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 sign-in code\",\n  brandName: \"This app\",\n  message: \"Your one-time sign-in code is:\",\n  sessionTtlSeconds: 43200,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n};\n\n/** Positive finite number from a value / env string, else the fallback. */\nfunction num(value: number | undefined, env: string | undefined, fallback: number): number {\n  const raw = value ?? (env ? Number(env) : undefined);\n  return typeof raw === \"number\" && Number.isFinite(raw) && raw > 0 ? raw : fallback;\n}\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  return {\n    allow: [...string.parseList(config.allow), ...string.parseList(process.env.EMAIL_AUTH_ALLOW)],\n    subject: config.subject ?? process.env.AUTH_SUBJECT?.trim() ?? DEFAULTS.subject,\n    brandName: config.brandName ?? process.env.AUTH_BRAND_NAME?.trim() ?? DEFAULTS.brandName,\n    message: config.message ?? process.env.AUTH_MESSAGE?.trim() ?? DEFAULTS.message,\n    sessionTtlSeconds: num(\n      config.sessionTtlSeconds,\n      process.env.AUTH_SESSION_TTL,\n      DEFAULTS.sessionTtlSeconds,\n    ),\n    codeTtlSeconds: num(config.codeTtlSeconds, process.env.AUTH_CODE_TTL, 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        });\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 { 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"]}

package/lib/src/portr.d.ts

@@ -1,8 +1,9 @@
 /**
  * portr install + config + launch for the tunnel CLI.
  *
- * On a Databricks App the container's `$HOME` is read-only on cold start, so the
- * portr binary and its config are placed under a writable, cwd-rooted `.home`.
+ * Some hosts (Databricks Apps among them) mount the container's `$HOME` read-only
+ * on cold start, so the portr binary and its config are placed under a writable,
+ * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.
  * The install is idempotent (the installer skips when the on-PATH binary is
  * current). The config is rendered from `PUBLIC_DOMAIN` (`<subdomain>.<server>`)
  * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).

package/lib/src/portr.js

@@ -1,8 +1,9 @@
 /**
  * portr install + config + launch for the tunnel CLI.
  *
- * On a Databricks App the container's `$HOME` is read-only on cold start, so the
- * portr binary and its config are placed under a writable, cwd-rooted `.home`.
+ * Some hosts (Databricks Apps among them) mount the container's `$HOME` read-only
+ * on cold start, so the portr binary and its config are placed under a writable,
+ * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.
  * The install is idempotent (the installer skips when the on-PATH binary is
  * current). The config is rendered from `PUBLIC_DOMAIN` (`<subdomain>.<server>`)
  * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).
@@ -87,4 +88,4 @@ export function startPortr(config, env) {
 export function portrInstalled(env) {
     return existsSync(join(env.HOME, ".portr", "bin", "portr"));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portr.js","sourceRoot":"","sources":["../../src/portr.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * portr install + config + launch for the tunnel CLI.\n *\n * On a Databricks App the container's `$HOME` is read-only on cold start, so the\n * portr binary and its config are placed under a writable, cwd-rooted `.home`.\n * The install is idempotent (the installer skips when the on-PATH binary is\n * current). The config is rendered from `PUBLIC_DOMAIN` (`<subdomain>.<server>`)\n * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).\n *\n * @module\n */\n\nimport { spawn, spawnSync } from \"node:child_process\";\nimport { existsSync, mkdirSync, writeFileSync } from \"node:fs\";\nimport { delimiter, join } from \"node:path\";\nimport { log } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"tunnel:portr\");\n\n/** Resolved portr wiring, or `undefined` when no tunnel is configured. */\nexport interface PortrConfig {\n  subdomain: string;\n  server: string;\n  token: string;\n  port: number;\n}\n\n/**\n * Resolve portr config from `PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an explicit\n * `subdomain`. `PUBLIC_DOMAIN` is `<subdomain>.<server>` (e.g.\n * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a\n * usable domain is absent.\n */\nexport function resolvePortrConfig(opts: {\n  publicDomain?: string;\n  subdomain?: string;\n  token?: string;\n  port: number;\n}): PortrConfig | undefined {\n  const token = opts.token ?? process.env.PORTR_TOKEN;\n  const domain = opts.publicDomain ?? process.env.PUBLIC_DOMAIN;\n  if (!token) return undefined;\n  let subdomain = opts.subdomain;\n  let server: string | undefined;\n  if (domain) {\n    subdomain ??= domain.split(\".\")[0];\n    server = domain.slice(domain.indexOf(\".\") + 1);\n  }\n  server ??= process.env.PORTR_SERVER;\n  if (!subdomain || !server || server === domain) return undefined;\n  return { subdomain, server, token, port: opts.port };\n}\n\n/** The writable home portr installs + configures under (Apps `$HOME` is read-only). */\nfunction portrHome(): string {\n  const home = join(process.cwd(), \".home\");\n  mkdirSync(join(home, \".portr\", \"bin\"), { recursive: true });\n  return home;\n}\n\n/** Install portr (idempotent) into the cwd-rooted home and return the child env. */\nexport function installPortr(): NodeJS.ProcessEnv {\n  const home = portrHome();\n  const env: NodeJS.ProcessEnv = {\n    ...process.env,\n    HOME: home,\n    PORTR_AUTO_ADD_PATH: \"no\",\n    PATH: [join(home, \".portr\", \"bin\"), process.env.PATH ?? \"\"].join(delimiter),\n  };\n  logger.info(\"installing portr (idempotent)\");\n  const res = spawnSync(\"bash\", [\"-c\", \"curl -sSf https://install.portr.dev | sh\"], {\n    env,\n    stdio: \"inherit\",\n  });\n  if (res.status !== 0) throw new Error(\"portr install failed\");\n  return env;\n}\n\n/** Render `~/.portr/config.yaml` for the resolved tunnel. */\nexport function writePortrConfig(config: PortrConfig, env: NodeJS.ProcessEnv): void {\n  const path = join(env.HOME!, \".portr\", \"config.yaml\");\n  writeFileSync(\n    path,\n    [\n      `server_url: ${config.server}`,\n      `ssh_url: ${config.server}:4444`,\n      `secret_key: ${config.token}`,\n      \"disable_dashboard: true\",\n      \"disable_tui: true\",\n      \"tunnels:\",\n      `  - name: ${config.subdomain}`,\n      `    subdomain: ${config.subdomain}`,\n      `    port: ${config.port}`,\n      \"\",\n    ].join(\"\\n\"),\n  );\n}\n\n/** Launch `portr start` as a child process (caller supervises + kills it). */\nexport function startPortr(config: PortrConfig, env: NodeJS.ProcessEnv): ReturnType<typeof spawn> {\n  // Reclaim the subdomain from any portr left by a previous boot in this container.\n  spawnSync(\"pkill\", [\"-x\", \"portr\"], { stdio: \"ignore\" });\n  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);\n  return spawn(\"portr\", [\"start\"], { env, stdio: \"inherit\" });\n}\n\n/** True when the installed portr binary path exists (post-install sanity). */\nexport function portrInstalled(env: NodeJS.ProcessEnv): boolean {\n  return existsSync(join(env.HOME!, \".portr\", \"bin\", \"portr\"));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portr.js","sourceRoot":"","sources":["../../src/portr.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * portr install + config + launch for the tunnel CLI.\n *\n * Some hosts (Databricks Apps among them) mount the container's `$HOME` read-only\n * on cold start, so the portr binary and its config are placed under a writable,\n * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.\n * The install is idempotent (the installer skips when the on-PATH binary is\n * current). The config is rendered from `PUBLIC_DOMAIN` (`<subdomain>.<server>`)\n * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).\n *\n * @module\n */\n\nimport { spawn, spawnSync } from \"node:child_process\";\nimport { existsSync, mkdirSync, writeFileSync } from \"node:fs\";\nimport { delimiter, join } from \"node:path\";\nimport { log } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"tunnel:portr\");\n\n/** Resolved portr wiring, or `undefined` when no tunnel is configured. */\nexport interface PortrConfig {\n  subdomain: string;\n  server: string;\n  token: string;\n  port: number;\n}\n\n/**\n * Resolve portr config from `PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an explicit\n * `subdomain`. `PUBLIC_DOMAIN` is `<subdomain>.<server>` (e.g.\n * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a\n * usable domain is absent.\n */\nexport function resolvePortrConfig(opts: {\n  publicDomain?: string;\n  subdomain?: string;\n  token?: string;\n  port: number;\n}): PortrConfig | undefined {\n  const token = opts.token ?? process.env.PORTR_TOKEN;\n  const domain = opts.publicDomain ?? process.env.PUBLIC_DOMAIN;\n  if (!token) return undefined;\n  let subdomain = opts.subdomain;\n  let server: string | undefined;\n  if (domain) {\n    subdomain ??= domain.split(\".\")[0];\n    server = domain.slice(domain.indexOf(\".\") + 1);\n  }\n  server ??= process.env.PORTR_SERVER;\n  if (!subdomain || !server || server === domain) return undefined;\n  return { subdomain, server, token, port: opts.port };\n}\n\n/** The writable home portr installs + configures under (Apps `$HOME` is read-only). */\nfunction portrHome(): string {\n  const home = join(process.cwd(), \".home\");\n  mkdirSync(join(home, \".portr\", \"bin\"), { recursive: true });\n  return home;\n}\n\n/** Install portr (idempotent) into the cwd-rooted home and return the child env. */\nexport function installPortr(): NodeJS.ProcessEnv {\n  const home = portrHome();\n  const env: NodeJS.ProcessEnv = {\n    ...process.env,\n    HOME: home,\n    PORTR_AUTO_ADD_PATH: \"no\",\n    PATH: [join(home, \".portr\", \"bin\"), process.env.PATH ?? \"\"].join(delimiter),\n  };\n  logger.info(\"installing portr (idempotent)\");\n  const res = spawnSync(\"bash\", [\"-c\", \"curl -sSf https://install.portr.dev | sh\"], {\n    env,\n    stdio: \"inherit\",\n  });\n  if (res.status !== 0) throw new Error(\"portr install failed\");\n  return env;\n}\n\n/** Render `~/.portr/config.yaml` for the resolved tunnel. */\nexport function writePortrConfig(config: PortrConfig, env: NodeJS.ProcessEnv): void {\n  const path = join(env.HOME!, \".portr\", \"config.yaml\");\n  writeFileSync(\n    path,\n    [\n      `server_url: ${config.server}`,\n      `ssh_url: ${config.server}:4444`,\n      `secret_key: ${config.token}`,\n      \"disable_dashboard: true\",\n      \"disable_tui: true\",\n      \"tunnels:\",\n      `  - name: ${config.subdomain}`,\n      `    subdomain: ${config.subdomain}`,\n      `    port: ${config.port}`,\n      \"\",\n    ].join(\"\\n\"),\n  );\n}\n\n/** Launch `portr start` as a child process (caller supervises + kills it). */\nexport function startPortr(config: PortrConfig, env: NodeJS.ProcessEnv): ReturnType<typeof spawn> {\n  // Reclaim the subdomain from any portr left by a previous boot in this container.\n  spawnSync(\"pkill\", [\"-x\", \"portr\"], { stdio: \"ignore\" });\n  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);\n  return spawn(\"portr\", [\"start\"], { env, stdio: \"inherit\" });\n}\n\n/** True when the installed portr binary path exists (post-install sanity). */\nexport function portrInstalled(env: NodeJS.ProcessEnv): boolean {\n  return existsSync(join(env.HOME!, \".portr\", \"bin\", \"portr\"));\n}\n"]}

package/lib/src/proxy.d.ts

@@ -7,9 +7,11 @@
  *
  *   - **portr client** (same container, connects over LOOPBACK) - the public
  *     tunnel. This is what the gate protects.
- *   - **Databricks control plane / front door** (reaches the `0.0.0.0` port from
- *     a NON-loopback container-network address) - passed through UNGATED, per the
- *     rule "if it's not from the portr client, let it in".
+ *   - **the hosting platform's front door** (Databricks Apps' control plane, or
+ *     any other host reaching the `0.0.0.0` port from a NON-loopback
+ *     container-network address) - passed through UNGATED, per the rule "if it's
+ *     not from the portr client, let it in". The platform already authenticates
+ *     that path; the gate exists for the tunnel, which nothing else protects.
  *
  * The distinguisher is the connection's source address: a loopback
  * `req.socket.remoteAddress` is the portr client; anything else is the platform.

package/lib/src/proxy.js

@@ -7,9 +7,11 @@
  *
  *   - **portr client** (same container, connects over LOOPBACK) - the public
  *     tunnel. This is what the gate protects.
- *   - **Databricks control plane / front door** (reaches the `0.0.0.0` port from
- *     a NON-loopback container-network address) - passed through UNGATED, per the
- *     rule "if it's not from the portr client, let it in".
+ *   - **the hosting platform's front door** (Databricks Apps' control plane, or
+ *     any other host reaching the `0.0.0.0` port from a NON-loopback
+ *     container-network address) - passed through UNGATED, per the rule "if it's
+ *     not from the portr client, let it in". The platform already authenticates
+ *     that path; the gate exists for the tunnel, which nothing else protects.
  *
  * The distinguisher is the connection's source address: a loopback
  * `req.socket.remoteAddress` is the portr client; anything else is the platform.
@@ -103,10 +105,11 @@ export function startProxy({ publicPort, appPort, gate }) {
             delete req.headers.cookie;
     };
     /**
-     * Present an OTP-authenticated caller to the app the SAME way the Databricks
-     * front door does: set `x-forwarded-user` / `x-forwarded-email` to the verified
-     * address (AppKit reads `x-forwarded-user` for the OBO user id). Any inbound
-     * copies are overwritten so a client can't spoof identity through the gate.
+     * Present an OTP-authenticated caller to the app the SAME way a platform front
+     * door does: set `x-forwarded-user` / `x-forwarded-email` to the verified
+     * address (AppKit reads `x-forwarded-user` for the OBO user id), so the app
+     * needs no gate-specific code path. Any inbound copies are overwritten so a
+     * client can't spoof identity through the gate.
      */
     const injectIdentity = (req, email) => {
         req.headers["x-forwarded-user"] = email;
@@ -114,8 +117,8 @@ export function startProxy({ publicPort, appPort, gate }) {
     };
     const server = createServer(async (req, res) => {
         const path = (req.url ?? "/").split("?")[0];
-        // Insecure/open mode (no gate) OR non-loopback traffic (the Databricks front
-        // door / control plane): forward ungated.
+        // Insecure/open mode (no gate) OR non-loopback traffic (the hosting
+        // platform's front door / control plane): forward ungated.
         if (!gate || !isLoopback(req.socket.remoteAddress)) {
             proxy.web(req, res);
             return;
@@ -159,7 +162,7 @@ export function startProxy({ publicPort, appPort, gate }) {
         const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
         const email = await gate.session(token);
         if (email) {
-            // Present the OTP user like the Databricks front door, and drop the gate
+            // Present the OTP user like a platform front door, and drop the gate
             // cookie so the app sees a clean, front-door-shaped request.
             injectIdentity(req, email);
             stripSessionCookie(req);
@@ -201,4 +204,4 @@ export function startProxy({ publicPort, appPort, gate }) {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/proxy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel gate reverse-proxy.\n *\n * Binds the PUBLIC port (the container's `DATABRICKS_APP_PORT`) and forwards to\n * the real app on a private loopback port. It is the single front door for both\n * traffic paths into the container:\n *\n *   - **portr client** (same container, connects over LOOPBACK) - the public\n *     tunnel. This is what the gate protects.\n *   - **Databricks control plane / front door** (reaches the `0.0.0.0` port from\n *     a NON-loopback container-network address) - passed through UNGATED, per the\n *     rule \"if it's not from the portr client, let it in\".\n *\n * The distinguisher is the connection's source address: a loopback\n * `req.socket.remoteAddress` is the portr client; anything else is the platform.\n *\n * For portr traffic the gate is a standard SPA gate: static assets + the login\n * flow (`/api/email/auth/*`, answered IN-PROCESS by this proxy via the\n * {@link AuthGateApi}) are open so the browser can load the client and render the\n * `<AuthGate>`; every other `/api/*` needs a valid session cookie or gets 401.\n * WebSocket upgrades are gated the same way and forwarded with `http-proxy-3`.\n *\n * @module\n */\n\nimport { createServer, type IncomingMessage, type ServerResponse } from \"node:http\";\nimport type { Socket } from \"node:net\";\nimport { http, json, log } from \"@dbx-tools/shared-core\";\nimport { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from \"@dbx-tools/shared-email\";\nimport ProxyModule from \"http-proxy-3\";\nimport type { AuthGateApi } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:proxy\");\n\n/** Route prefix the login flow lives under (open, answered in-process). */\nconst AUTH_PREFIX = \"/api/email/auth\";\n\n/** True when a socket address is loopback (the portr client, same container). */\nfunction isLoopback(addr: string | undefined): boolean {\n  if (!addr) return false;\n  // Normalize IPv4-mapped IPv6 (`::ffff:127.0.0.1`) and bare IPv6 loopback.\n  const a = addr.replace(/^::ffff:/, \"\");\n  return a === \"127.0.0.1\" || a.startsWith(\"127.\") || a === \"::1\" || a === \"localhost\";\n}\n\n/** Read the whole request body as text (small JSON payloads only). */\nfunction readBody(req: IncomingMessage): Promise<string> {\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\nfunction sendJson(res: ServerResponse, status: number, body: unknown, setCookie?: string): void {\n  const headers: Record<string, string> = { \"content-type\": \"application/json\" };\n  if (setCookie) headers[\"set-cookie\"] = setCookie;\n  res.writeHead(status, headers);\n  res.end(JSON.stringify(body));\n}\n\n/** Options for {@link startProxy}. */\nexport interface ProxyOptions {\n  /** Public port to listen on (the container's DATABRICKS_APP_PORT). */\n  publicPort: number;\n  /** Private port the real app listens on (loopback). */\n  appPort: number;\n  /**\n   * The in-process gate API, or `undefined` to run OPEN (insecure mode): every\n   * request - including portr traffic - is forwarded ungated. Used when the\n   * operator passed `--insecure` / `TUNNEL_INSECURE=true`.\n   */\n  gate?: AuthGateApi;\n}\n\n/** Start the gate proxy. Resolves once it is listening. */\nexport function startProxy({ publicPort, appPort, gate }: ProxyOptions): Promise<void> {\n  const proxy = ProxyModule.createProxyServer({\n    target: { host: \"127.0.0.1\", port: appPort },\n    ws: true,\n    xfwd: true,\n  });\n  proxy.on(\"error\", (err: Error, _req: unknown, res: unknown) => {\n    logger.warn(\"upstream proxy error\", { error: err.message });\n    const r = res as ServerResponse | undefined;\n    if (r && \"writeHead\" in r && !r.headersSent) {\n      sendJson(r, 502, { error: \"upstream unavailable\" });\n    }\n  });\n\n  /** The session cookie for a verified email, as a Set-Cookie string. */\n  const sessionCookie = (token: string, maxAgeSeconds: number): string =>\n    [\n      `${SESSION_COOKIE_NAME}=${token}`,\n      \"Path=/\",\n      \"HttpOnly\",\n      \"SameSite=Lax\",\n      `Max-Age=${maxAgeSeconds}`,\n      process.env.NODE_ENV === \"production\" ? \"Secure\" : \"\",\n    ]\n      .filter(Boolean)\n      .join(\"; \");\n\n  /** Client IP for rate-limiting: the portr-forwarded XFF, else the socket. */\n  const clientIp = (req: IncomingMessage): string => {\n    const fwd = req.headers[\"x-forwarded-for\"];\n    const first = Array.isArray(fwd) ? fwd[0] : fwd?.split(\",\")[0];\n    return (first ?? req.socket.remoteAddress ?? \"unknown\").trim();\n  };\n\n  /**\n   * Remove the gate's session cookie from the `Cookie` header before forwarding,\n   * so the app never sees `dbx_auth` (it is the proxy's concern, not the app's).\n   * Preserves any other cookies. Removes the header entirely when it becomes empty.\n   */\n  const 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 the Databricks\n   * front door does: set `x-forwarded-user` / `x-forwarded-email` to the verified\n   * address (AppKit reads `x-forwarded-user` for the OBO user id). Any inbound\n   * copies are overwritten so a client can't spoof identity through the gate.\n   */\n  const injectIdentity = (req: IncomingMessage, email: string): void => {\n    req.headers[\"x-forwarded-user\"] = email;\n    req.headers[\"x-forwarded-email\"] = email;\n  };\n\n  const server = createServer(async (req, res) => {\n    const path = (req.url ?? \"/\").split(\"?\")[0]!;\n\n    // Insecure/open mode (no gate) OR non-loopback traffic (the Databricks front\n    // door / control plane): forward ungated.\n    if (!gate || !isLoopback(req.socket.remoteAddress)) {\n      proxy.web(req, res);\n      return;\n    }\n\n    // --- portr traffic: the gate applies ---\n\n    // The login flow is answered IN-PROCESS (the app has no server to forward to).\n    if (path === `${AUTH_PREFIX}/status`) {\n      const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n      sendJson(res, 200, await gate.status(token));\n      return;\n    }\n    if (path === `${AUTH_PREFIX}/request` && req.method === \"POST\") {\n      const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));\n      if (!parsed.success) return sendJson(res, 200, { ok: true }); // anti-enumeration\n      return sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));\n    }\n    if (path === `${AUTH_PREFIX}/verify` && req.method === \"POST\") {\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      return sendJson(\n        res,\n        200,\n        { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) },\n        cookie,\n      );\n    }\n    if (path === `${AUTH_PREFIX}/logout` && req.method === \"POST\") {\n      return sendJson(\n        res,\n        200,\n        { ok: true },\n        `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`,\n      );\n    }\n\n    // Anti-spoof: strip any inbound identity headers on portr traffic - only the\n    // gate may set them, below, for a verified session.\n    delete req.headers[\"x-forwarded-user\"];\n    delete req.headers[\"x-forwarded-email\"];\n\n    // Static (non-API) loads freely so the SPA + <AuthGate> can render. Strip the\n    // session cookie so it never leaks to the static handler.\n    if (!path.startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      proxy.web(req, res);\n      return;\n    }\n\n    // Every other /api/* requires a valid session.\n    const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    const email = await gate.session(token);\n    if (email) {\n      // Present the OTP user like the Databricks front door, and drop the gate\n      // cookie so the app sees a clean, front-door-shaped request.\n      injectIdentity(req, email);\n      stripSessionCookie(req);\n      proxy.web(req, res);\n    } else {\n      sendJson(res, 401, { error: \"authentication required\", loginPath: AUTH_PREFIX });\n    }\n  });\n\n  // WebSocket upgrades: forward front-door traffic untouched; gate loopback\n  // (portr) API upgrades the same way as HTTP (strip cookie + inject identity).\n  server.on(\"upgrade\", (req: IncomingMessage, socket: Socket, head: Buffer) => {\n    if (!gate || !isLoopback(req.socket.remoteAddress)) {\n      proxy.ws(req, socket, head);\n      return;\n    }\n    delete req.headers[\"x-forwarded-user\"];\n    delete req.headers[\"x-forwarded-email\"];\n    if (!(req.url ?? \"\").startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      proxy.ws(req, socket, head);\n      return;\n    }\n    const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    void gate.session(token).then((email) => {\n      if (!email) {\n        socket.destroy();\n        return;\n      }\n      injectIdentity(req, email);\n      stripSessionCookie(req);\n      proxy.ws(req, socket, head);\n    });\n  });\n\n  return new Promise((resolve) => {\n    server.listen(publicPort, \"0.0.0.0\", () => {\n      logger.info(`gate proxy on 0.0.0.0:${publicPort} -> app 127.0.0.1:${appPort}`);\n      resolve();\n    });\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/proxy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel gate reverse-proxy.\n *\n * Binds the PUBLIC port (the container's `DATABRICKS_APP_PORT`) and forwards to\n * the real app on a private loopback port. It is the single front door for both\n * traffic paths into the container:\n *\n *   - **portr client** (same container, connects over LOOPBACK) - the public\n *     tunnel. This is what the gate protects.\n *   - **the hosting platform's front door** (Databricks Apps' control plane, or\n *     any other host reaching the `0.0.0.0` port from a NON-loopback\n *     container-network address) - passed through UNGATED, per the rule \"if it's\n *     not from the portr client, let it in\". The platform already authenticates\n *     that path; the gate exists for the tunnel, which nothing else protects.\n *\n * The distinguisher is the connection's source address: a loopback\n * `req.socket.remoteAddress` is the portr client; anything else is the platform.\n *\n * For portr traffic the gate is a standard SPA gate: static assets + the login\n * flow (`/api/email/auth/*`, answered IN-PROCESS by this proxy via the\n * {@link AuthGateApi}) are open so the browser can load the client and render the\n * `<AuthGate>`; every other `/api/*` needs a valid session cookie or gets 401.\n * WebSocket upgrades are gated the same way and forwarded with `http-proxy-3`.\n *\n * @module\n */\n\nimport { createServer, type IncomingMessage, type ServerResponse } from \"node:http\";\nimport type { Socket } from \"node:net\";\nimport { http, json, log } from \"@dbx-tools/shared-core\";\nimport { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from \"@dbx-tools/shared-email\";\nimport ProxyModule from \"http-proxy-3\";\nimport type { AuthGateApi } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:proxy\");\n\n/** Route prefix the login flow lives under (open, answered in-process). */\nconst AUTH_PREFIX = \"/api/email/auth\";\n\n/** True when a socket address is loopback (the portr client, same container). */\nfunction isLoopback(addr: string | undefined): boolean {\n  if (!addr) return false;\n  // Normalize IPv4-mapped IPv6 (`::ffff:127.0.0.1`) and bare IPv6 loopback.\n  const a = addr.replace(/^::ffff:/, \"\");\n  return a === \"127.0.0.1\" || a.startsWith(\"127.\") || a === \"::1\" || a === \"localhost\";\n}\n\n/** Read the whole request body as text (small JSON payloads only). */\nfunction readBody(req: IncomingMessage): Promise<string> {\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\nfunction sendJson(res: ServerResponse, status: number, body: unknown, setCookie?: string): void {\n  const headers: Record<string, string> = { \"content-type\": \"application/json\" };\n  if (setCookie) headers[\"set-cookie\"] = setCookie;\n  res.writeHead(status, headers);\n  res.end(JSON.stringify(body));\n}\n\n/** Options for {@link startProxy}. */\nexport interface ProxyOptions {\n  /** Public port to listen on (the container's DATABRICKS_APP_PORT). */\n  publicPort: number;\n  /** Private port the real app listens on (loopback). */\n  appPort: number;\n  /**\n   * The in-process gate API, or `undefined` to run OPEN (insecure mode): every\n   * request - including portr traffic - is forwarded ungated. Used when the\n   * operator passed `--insecure` / `TUNNEL_INSECURE=true`.\n   */\n  gate?: AuthGateApi;\n}\n\n/** Start the gate proxy. Resolves once it is listening. */\nexport function startProxy({ publicPort, appPort, gate }: ProxyOptions): Promise<void> {\n  const proxy = ProxyModule.createProxyServer({\n    target: { host: \"127.0.0.1\", port: appPort },\n    ws: true,\n    xfwd: true,\n  });\n  proxy.on(\"error\", (err: Error, _req: unknown, res: unknown) => {\n    logger.warn(\"upstream proxy error\", { error: err.message });\n    const r = res as ServerResponse | undefined;\n    if (r && \"writeHead\" in r && !r.headersSent) {\n      sendJson(r, 502, { error: \"upstream unavailable\" });\n    }\n  });\n\n  /** The session cookie for a verified email, as a Set-Cookie string. */\n  const sessionCookie = (token: string, maxAgeSeconds: number): string =>\n    [\n      `${SESSION_COOKIE_NAME}=${token}`,\n      \"Path=/\",\n      \"HttpOnly\",\n      \"SameSite=Lax\",\n      `Max-Age=${maxAgeSeconds}`,\n      process.env.NODE_ENV === \"production\" ? \"Secure\" : \"\",\n    ]\n      .filter(Boolean)\n      .join(\"; \");\n\n  /** Client IP for rate-limiting: the portr-forwarded XFF, else the socket. */\n  const clientIp = (req: IncomingMessage): string => {\n    const fwd = req.headers[\"x-forwarded-for\"];\n    const first = Array.isArray(fwd) ? fwd[0] : fwd?.split(\",\")[0];\n    return (first ?? req.socket.remoteAddress ?? \"unknown\").trim();\n  };\n\n  /**\n   * Remove the gate's session cookie from the `Cookie` header before forwarding,\n   * so the app never sees `dbx_auth` (it is the proxy's concern, not the app's).\n   * Preserves any other cookies. Removes the header entirely when it becomes empty.\n   */\n  const 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 `x-forwarded-user` / `x-forwarded-email` to the verified\n   * address (AppKit reads `x-forwarded-user` for the OBO user id), so the app\n   * needs no gate-specific code path. Any inbound copies are overwritten so a\n   * client can't spoof identity through the gate.\n   */\n  const injectIdentity = (req: IncomingMessage, email: string): void => {\n    req.headers[\"x-forwarded-user\"] = email;\n    req.headers[\"x-forwarded-email\"] = email;\n  };\n\n  const server = createServer(async (req, res) => {\n    const path = (req.url ?? \"/\").split(\"?\")[0]!;\n\n    // Insecure/open mode (no gate) OR non-loopback traffic (the hosting\n    // platform's front door / control plane): forward ungated.\n    if (!gate || !isLoopback(req.socket.remoteAddress)) {\n      proxy.web(req, res);\n      return;\n    }\n\n    // --- portr traffic: the gate applies ---\n\n    // The login flow is answered IN-PROCESS (the app has no server to forward to).\n    if (path === `${AUTH_PREFIX}/status`) {\n      const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n      sendJson(res, 200, await gate.status(token));\n      return;\n    }\n    if (path === `${AUTH_PREFIX}/request` && req.method === \"POST\") {\n      const parsed = authRequestSchema.safeParse(json.parseRecord(await readBody(req)));\n      if (!parsed.success) return sendJson(res, 200, { ok: true }); // anti-enumeration\n      return sendJson(res, 200, await gate.request(parsed.data.email, clientIp(req)));\n    }\n    if (path === `${AUTH_PREFIX}/verify` && req.method === \"POST\") {\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      return sendJson(\n        res,\n        200,\n        { ok: result.ok, ...(result.retryAfter ? { retryAfter: result.retryAfter } : {}) },\n        cookie,\n      );\n    }\n    if (path === `${AUTH_PREFIX}/logout` && req.method === \"POST\") {\n      return sendJson(\n        res,\n        200,\n        { ok: true },\n        `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`,\n      );\n    }\n\n    // Anti-spoof: strip any inbound identity headers on portr traffic - only the\n    // gate may set them, below, for a verified session.\n    delete req.headers[\"x-forwarded-user\"];\n    delete req.headers[\"x-forwarded-email\"];\n\n    // Static (non-API) loads freely so the SPA + <AuthGate> can render. Strip the\n    // session cookie so it never leaks to the static handler.\n    if (!path.startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      proxy.web(req, res);\n      return;\n    }\n\n    // Every other /api/* requires a valid session.\n    const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    const email = await gate.session(token);\n    if (email) {\n      // Present the OTP user like a platform front door, and drop the gate\n      // cookie so the app sees a clean, front-door-shaped request.\n      injectIdentity(req, email);\n      stripSessionCookie(req);\n      proxy.web(req, res);\n    } else {\n      sendJson(res, 401, { error: \"authentication required\", loginPath: AUTH_PREFIX });\n    }\n  });\n\n  // WebSocket upgrades: forward front-door traffic untouched; gate loopback\n  // (portr) API upgrades the same way as HTTP (strip cookie + inject identity).\n  server.on(\"upgrade\", (req: IncomingMessage, socket: Socket, head: Buffer) => {\n    if (!gate || !isLoopback(req.socket.remoteAddress)) {\n      proxy.ws(req, socket, head);\n      return;\n    }\n    delete req.headers[\"x-forwarded-user\"];\n    delete req.headers[\"x-forwarded-email\"];\n    if (!(req.url ?? \"\").startsWith(\"/api/\")) {\n      stripSessionCookie(req);\n      proxy.ws(req, socket, head);\n      return;\n    }\n    const token = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];\n    void gate.session(token).then((email) => {\n      if (!email) {\n        socket.destroy();\n        return;\n      }\n      injectIdentity(req, email);\n      stripSessionCookie(req);\n      proxy.ws(req, socket, head);\n    });\n  });\n\n  return new Promise((resolve) => {\n    server.listen(publicPort, \"0.0.0.0\", () => {\n      logger.info(`gate proxy on 0.0.0.0:${publicPort} -> app 127.0.0.1:${appPort}`);\n      resolve();\n    });\n  });\n}\n"]}