@dbx-tools/cli-tunnel 0.6.49 → 0.6.51

package/lib/src/plugin.js

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

@@ -0,0 +1,83 @@
+/**
+ * The gate's HS256 session-signing key, persisted in AppKit's cache.
+ *
+ * The key decides whether a session COOKIE still verifies. Before this module the
+ * fallback was `randomBytes(32)` per process, so every restart invalidated every
+ * outstanding cookie and each signed-in user had to request a new code - painful
+ * for a tunnel, which restarts whenever the app it wraps does. Now the key is
+ * stored in the cache AppKit already configured (memory, or Lakebase when the
+ * host wires a persistent `CacheStorage`), so with persistent storage a restart
+ * keeps sessions alive for {@link KEY_TTL_SECONDS}.
+ *
+ * An explicitly configured `TUNNEL_AUTH_JWT_SECRET` still wins outright. That is
+ * the right answer for a fleet: an operator-held secret needs no shared cache and
+ * no convergence, and it survives a cache flush.
+ *
+ * ## get / generate / get
+ *
+ * Two instances booting at once both miss, so both would generate - and the loser
+ * would sign cookies with a key the winner rejects. Resolution is a re-READ after
+ * the write: whatever the cache holds afterwards is the key everyone adopts, so
+ * the instances converge on ONE value instead of trusting the one they minted.
+ * (`set` is not conditional in the cache API - there is no `setnx` to lean on -
+ * and this runs once per process, so the extra round-trip is free.)
+ *
+ * A pathological interleave can still cost a key: if A writes between B's write
+ * and B's re-read, B adopts A's key while A adopts its own. The cost is bounded -
+ * a cookie minted in that window fails to verify and the holder signs in again -
+ * and it cannot produce a key one instance TRUSTS but another rejects for longer
+ * than the window itself. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race
+ * entirely.
+ *
+ * ## Forcing every session to end
+ *
+ * {@link resolveSessionEpoch} reads a date from `TUNNEL_AUTH_SESSION_EPOCH` (or
+ * `--session-epoch`), and that date is part of the cache KEY. Moving it forward
+ * makes every prior key unreachable, so every cookie signed against it stops
+ * verifying - the log-everyone-out switch, without having to find and flush a
+ * cache entry. The epoch is also asserted against each token's `iat`, so a
+ * cookie that predates it is refused even if it was signed with the key that is
+ * somehow still current.
+ *
+ * @module
+ */
+/**
+ * How long a cached signing key lives: 30 days.
+ *
+ * This is the ceiling on how long a session cookie can stay valid across
+ * restarts, so it is deliberately >= the default session TTL - a key that expired
+ * before the cookies it signed would log everyone out for no reason.
+ */
+export declare const KEY_TTL_SECONDS: number;
+/**
+ * Resolve the force-clear epoch as epoch MILLISECONDS, or `0` when unset.
+ *
+ * Accepts anything `Date` parses (`2026-08-02`, an ISO timestamp) plus a bare
+ * epoch-seconds / epoch-millis number, so a value pasted from `date +%s` works.
+ * An UNPARSEABLE value is ignored with a warning rather than throwing: this is
+ * the switch that logs a fleet back in, and failing to boot over a typo is worse
+ * than not rotating.
+ */
+export declare function resolveSessionEpoch(configured?: string | number | Date): number;
+/** A resolved key plus the epoch it is scoped to. */
+export interface SigningKey {
+    key: Uint8Array;
+    /** Force-clear epoch in ms; `0` when unset. Tokens older than this are refused. */
+    epochMs: number;
+}
+/**
+ * The signing key for this gate, resolved once per process.
+ *
+ * Resolved ONCE, so `configuredEpoch` is honoured only on the first call - the
+ * plugin's `setup()` passes its resolved value there, before any request can
+ * reach the lazy path.
+ *
+ * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed key. A cache that is
+ * unavailable degrades to an ephemeral per-process key (the previous behaviour)
+ * rather than refusing to sign: the key only validates an ALREADY-issued session,
+ * so losing it costs sessions, never admission - a caller still needs a code
+ * delivered to an allow-listed address.
+ */
+export declare function signingKey(configuredEpoch?: string | number | Date): Promise<SigningKey>;
+/** Reset the per-process key (tests, or after changing the env in-process). */
+export declare function resetSigningKey(): void;

package/lib/src/signing-key.js

@@ -0,0 +1,181 @@
+/**
+ * The gate's HS256 session-signing key, persisted in AppKit's cache.
+ *
+ * The key decides whether a session COOKIE still verifies. Before this module the
+ * fallback was `randomBytes(32)` per process, so every restart invalidated every
+ * outstanding cookie and each signed-in user had to request a new code - painful
+ * for a tunnel, which restarts whenever the app it wraps does. Now the key is
+ * stored in the cache AppKit already configured (memory, or Lakebase when the
+ * host wires a persistent `CacheStorage`), so with persistent storage a restart
+ * keeps sessions alive for {@link KEY_TTL_SECONDS}.
+ *
+ * An explicitly configured `TUNNEL_AUTH_JWT_SECRET` still wins outright. That is
+ * the right answer for a fleet: an operator-held secret needs no shared cache and
+ * no convergence, and it survives a cache flush.
+ *
+ * ## get / generate / get
+ *
+ * Two instances booting at once both miss, so both would generate - and the loser
+ * would sign cookies with a key the winner rejects. Resolution is a re-READ after
+ * the write: whatever the cache holds afterwards is the key everyone adopts, so
+ * the instances converge on ONE value instead of trusting the one they minted.
+ * (`set` is not conditional in the cache API - there is no `setnx` to lean on -
+ * and this runs once per process, so the extra round-trip is free.)
+ *
+ * A pathological interleave can still cost a key: if A writes between B's write
+ * and B's re-read, B adopts A's key while A adopts its own. The cost is bounded -
+ * a cookie minted in that window fails to verify and the holder signs in again -
+ * and it cannot produce a key one instance TRUSTS but another rejects for longer
+ * than the window itself. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race
+ * entirely.
+ *
+ * ## Forcing every session to end
+ *
+ * {@link resolveSessionEpoch} reads a date from `TUNNEL_AUTH_SESSION_EPOCH` (or
+ * `--session-epoch`), and that date is part of the cache KEY. Moving it forward
+ * makes every prior key unreachable, so every cookie signed against it stops
+ * verifying - the log-everyone-out switch, without having to find and flush a
+ * cache entry. The epoch is also asserted against each token's `iat`, so a
+ * cookie that predates it is refused even if it was signed with the key that is
+ * somehow still current.
+ *
+ * @module
+ */
+import { randomBytes } from "node:crypto";
+import { CacheManager } from "@databricks/appkit";
+import { env, log } from "@dbx-tools/shared-core";
+import { JWT_SECRET_ENV, SESSION_EPOCH_ENV } from "./env.js";
+const logger = log.logger("tunnel:signing-key");
+/**
+ * How long a cached signing key lives: 30 days.
+ *
+ * This is the ceiling on how long a session cookie can stay valid across
+ * restarts, so it is deliberately >= the default session TTL - a key that expired
+ * before the cookies it signed would log everyone out for no reason.
+ */
+export const KEY_TTL_SECONDS = 30 * 24 * 60 * 60;
+/** Cache-key prefix for the signing key, namespaced away from other cache use. */
+const KEY_PREFIX = "tunnel:auth:signing-key:";
+/** Bytes of entropy in a generated key (256-bit, matching HS256's hash width). */
+const KEY_BYTES = 32;
+/**
+ * Resolve the force-clear epoch as epoch MILLISECONDS, or `0` when unset.
+ *
+ * Accepts anything `Date` parses (`2026-08-02`, an ISO timestamp) plus a bare
+ * epoch-seconds / epoch-millis number, so a value pasted from `date +%s` works.
+ * An UNPARSEABLE value is ignored with a warning rather than throwing: this is
+ * the switch that logs a fleet back in, and failing to boot over a typo is worse
+ * than not rotating.
+ */
+export function resolveSessionEpoch(configured) {
+    const raw = configured ?? env.text(SESSION_EPOCH_ENV) ?? undefined;
+    if (raw === undefined || raw === null || raw === "")
+        return 0;
+    return clampToPast(parseEpoch(raw));
+}
+/** Parse the accepted epoch spellings to ms, or `0` when unusable. */
+function parseEpoch(raw) {
+    if (raw instanceof Date)
+        return Number.isNaN(raw.getTime()) ? 0 : raw.getTime();
+    const text = String(raw).trim();
+    // A bare number is a timestamp, not a date string: `Date.parse("1785...")`
+    // would read it as a YEAR. Values below ~1e11 are seconds (any millis
+    // timestamp since 1973 is larger), which is what `date +%s` prints.
+    if (/^\d+$/.test(text)) {
+        const numeric = Number(text);
+        return numeric < 1e11 ? numeric * 1000 : numeric;
+    }
+    const parsed = Date.parse(text);
+    if (Number.isNaN(parsed)) {
+        logger.warn(`ignoring unparseable ${env.name(SESSION_EPOCH_ENV)}`, { value: text });
+        return 0;
+    }
+    return parsed;
+}
+/**
+ * Hold the cutoff at "now", because a FUTURE epoch would refuse the sessions it
+ * is about to mint as well as the old ones - an app nobody can sign in to, from a
+ * mistyped year, with the fix hidden behind understanding this flag. Clamped, a
+ * future date means what an operator setting it always meant: clear everything
+ * outstanding, then carry on.
+ */
+function clampToPast(epochMs) {
+    const now = Date.now();
+    if (epochMs <= now)
+        return epochMs;
+    logger.warn(`${env.name(SESSION_EPOCH_ENV)} is in the future - clamping to now`, {
+        configured: new Date(epochMs).toISOString(),
+    });
+    return now;
+}
+/** The cache key for one epoch, so moving the epoch orphans every earlier key. */
+function cacheKey(epochMs) {
+    return `${KEY_PREFIX}${epochMs}`;
+}
+function decode(stored) {
+    return new Uint8Array(Buffer.from(stored.secret, "base64url"));
+}
+/**
+ * Load the signing key for `epochMs` from the cache, minting and storing one when
+ * absent. See the module docs for why the write is followed by a re-read.
+ */
+async function loadFromCache(epochMs) {
+    const cache = CacheManager.getInstanceSync();
+    const key = cacheKey(epochMs);
+    const existing = await cache.get(key);
+    if (existing?.secret) {
+        logger.info("reusing cached signing key", { createdAt: existing.createdAt });
+        return decode(existing);
+    }
+    const minted = {
+        secret: Buffer.from(randomBytes(KEY_BYTES)).toString("base64url"),
+        createdAt: new Date().toISOString(),
+    };
+    await cache.set(key, minted, { ttl: KEY_TTL_SECONDS });
+    // Re-read rather than trusting `minted`: another instance that raced this boot
+    // may have written first, and adopting whatever is stored is what makes the two
+    // converge on one key.
+    const settled = (await cache.get(key)) ?? minted;
+    logger.info("stored a new signing key", {
+        createdAt: settled.createdAt,
+        ttlSeconds: KEY_TTL_SECONDS,
+        adopted: settled.createdAt === minted.createdAt ? "own" : "concurrent-instance",
+    });
+    return decode(settled);
+}
+let pending;
+/**
+ * The signing key for this gate, resolved once per process.
+ *
+ * Resolved ONCE, so `configuredEpoch` is honoured only on the first call - the
+ * plugin's `setup()` passes its resolved value there, before any request can
+ * reach the lazy path.
+ *
+ * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed key. A cache that is
+ * unavailable degrades to an ephemeral per-process key (the previous behaviour)
+ * rather than refusing to sign: the key only validates an ALREADY-issued session,
+ * so losing it costs sessions, never admission - a caller still needs a code
+ * delivered to an allow-listed address.
+ */
+export function signingKey(configuredEpoch) {
+    pending ??= (async () => {
+        const epochMs = resolveSessionEpoch(configuredEpoch);
+        const configured = env.text(JWT_SECRET_ENV);
+        if (configured) {
+            return { key: new TextEncoder().encode(configured), epochMs };
+        }
+        try {
+            return { key: await loadFromCache(epochMs), epochMs };
+        }
+        catch (error) {
+            logger.warn(`no ${env.name(JWT_SECRET_ENV)} and the cache is unavailable - using an ephemeral per-process key; sessions will not survive a restart`, { error });
+            return { key: new Uint8Array(randomBytes(KEY_BYTES)), epochMs };
+        }
+    })();
+    return pending;
+}
+/** Reset the per-process key (tests, or after changing the env in-process). */
+export function resetSigningKey() {
+    pending = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signing-key.js","sourceRoot":"","sources":["../../src/signing-key.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The gate's HS256 session-signing key, persisted in AppKit's cache.\n *\n * The key decides whether a session COOKIE still verifies. Before this module the\n * fallback was `randomBytes(32)` per process, so every restart invalidated every\n * outstanding cookie and each signed-in user had to request a new code - painful\n * for a tunnel, which restarts whenever the app it wraps does. Now the key is\n * stored in the cache AppKit already configured (memory, or Lakebase when the\n * host wires a persistent `CacheStorage`), so with persistent storage a restart\n * keeps sessions alive for {@link KEY_TTL_SECONDS}.\n *\n * An explicitly configured `TUNNEL_AUTH_JWT_SECRET` still wins outright. That is\n * the right answer for a fleet: an operator-held secret needs no shared cache and\n * no convergence, and it survives a cache flush.\n *\n * ## get / generate / get\n *\n * Two instances booting at once both miss, so both would generate - and the loser\n * would sign cookies with a key the winner rejects. Resolution is a re-READ after\n * the write: whatever the cache holds afterwards is the key everyone adopts, so\n * the instances converge on ONE value instead of trusting the one they minted.\n * (`set` is not conditional in the cache API - there is no `setnx` to lean on -\n * and this runs once per process, so the extra round-trip is free.)\n *\n * A pathological interleave can still cost a key: if A writes between B's write\n * and B's re-read, B adopts A's key while A adopts its own. The cost is bounded -\n * a cookie minted in that window fails to verify and the holder signs in again -\n * and it cannot produce a key one instance TRUSTS but another rejects for longer\n * than the window itself. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race\n * entirely.\n *\n * ## Forcing every session to end\n *\n * {@link resolveSessionEpoch} reads a date from `TUNNEL_AUTH_SESSION_EPOCH` (or\n * `--session-epoch`), and that date is part of the cache KEY. Moving it forward\n * makes every prior key unreachable, so every cookie signed against it stops\n * verifying - the log-everyone-out switch, without having to find and flush a\n * cache entry. The epoch is also asserted against each token's `iat`, so a\n * cookie that predates it is refused even if it was signed with the key that is\n * somehow still current.\n *\n * @module\n */\n\nimport { randomBytes } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { env, log } from \"@dbx-tools/shared-core\";\nimport { JWT_SECRET_ENV, SESSION_EPOCH_ENV } from \"./env.ts\";\n\nconst logger = log.logger(\"tunnel:signing-key\");\n\n/**\n * How long a cached signing key lives: 30 days.\n *\n * This is the ceiling on how long a session cookie can stay valid across\n * restarts, so it is deliberately >= the default session TTL - a key that expired\n * before the cookies it signed would log everyone out for no reason.\n */\nexport const KEY_TTL_SECONDS = 30 * 24 * 60 * 60;\n\n/** Cache-key prefix for the signing key, namespaced away from other cache use. */\nconst KEY_PREFIX = \"tunnel:auth:signing-key:\";\n\n/** Bytes of entropy in a generated key (256-bit, matching HS256's hash width). */\nconst KEY_BYTES = 32;\n\n/** What the cache stores: the key plus when it was minted, for observability. */\ninterface StoredKey {\n  /** Base64url of the raw key bytes. */\n  secret: string;\n  /** When this key was generated, ISO-8601. */\n  createdAt: string;\n}\n\n/**\n * Resolve the force-clear epoch as epoch MILLISECONDS, or `0` when unset.\n *\n * Accepts anything `Date` parses (`2026-08-02`, an ISO timestamp) plus a bare\n * epoch-seconds / epoch-millis number, so a value pasted from `date +%s` works.\n * An UNPARSEABLE value is ignored with a warning rather than throwing: this is\n * the switch that logs a fleet back in, and failing to boot over a typo is worse\n * than not rotating.\n */\nexport function resolveSessionEpoch(configured?: string | number | Date): number {\n  const raw = configured ?? env.text(SESSION_EPOCH_ENV) ?? undefined;\n  if (raw === undefined || raw === null || raw === \"\") return 0;\n  return clampToPast(parseEpoch(raw));\n}\n\n/** Parse the accepted epoch spellings to ms, or `0` when unusable. */\nfunction parseEpoch(raw: string | number | Date): number {\n  if (raw instanceof Date) return Number.isNaN(raw.getTime()) ? 0 : raw.getTime();\n\n  const text = String(raw).trim();\n  // A bare number is a timestamp, not a date string: `Date.parse(\"1785...\")`\n  // would read it as a YEAR. Values below ~1e11 are seconds (any millis\n  // timestamp since 1973 is larger), which is what `date +%s` prints.\n  if (/^\\d+$/.test(text)) {\n    const numeric = Number(text);\n    return numeric < 1e11 ? numeric * 1000 : numeric;\n  }\n  const parsed = Date.parse(text);\n  if (Number.isNaN(parsed)) {\n    logger.warn(`ignoring unparseable ${env.name(SESSION_EPOCH_ENV)}`, { value: text });\n    return 0;\n  }\n  return parsed;\n}\n\n/**\n * Hold the cutoff at \"now\", because a FUTURE epoch would refuse the sessions it\n * is about to mint as well as the old ones - an app nobody can sign in to, from a\n * mistyped year, with the fix hidden behind understanding this flag. Clamped, a\n * future date means what an operator setting it always meant: clear everything\n * outstanding, then carry on.\n */\nfunction clampToPast(epochMs: number): number {\n  const now = Date.now();\n  if (epochMs <= now) return epochMs;\n  logger.warn(`${env.name(SESSION_EPOCH_ENV)} is in the future - clamping to now`, {\n    configured: new Date(epochMs).toISOString(),\n  });\n  return now;\n}\n\n/** The cache key for one epoch, so moving the epoch orphans every earlier key. */\nfunction cacheKey(epochMs: number): string {\n  return `${KEY_PREFIX}${epochMs}`;\n}\n\nfunction decode(stored: StoredKey): Uint8Array {\n  return new Uint8Array(Buffer.from(stored.secret, \"base64url\"));\n}\n\n/**\n * Load the signing key for `epochMs` from the cache, minting and storing one when\n * absent. See the module docs for why the write is followed by a re-read.\n */\nasync function loadFromCache(epochMs: number): Promise<Uint8Array> {\n  const cache = CacheManager.getInstanceSync();\n  const key = cacheKey(epochMs);\n\n  const existing = await cache.get<StoredKey>(key);\n  if (existing?.secret) {\n    logger.info(\"reusing cached signing key\", { createdAt: existing.createdAt });\n    return decode(existing);\n  }\n\n  const minted: StoredKey = {\n    secret: Buffer.from(randomBytes(KEY_BYTES)).toString(\"base64url\"),\n    createdAt: new Date().toISOString(),\n  };\n  await cache.set(key, minted, { ttl: KEY_TTL_SECONDS });\n\n  // Re-read rather than trusting `minted`: another instance that raced this boot\n  // may have written first, and adopting whatever is stored is what makes the two\n  // converge on one key.\n  const settled = (await cache.get<StoredKey>(key)) ?? minted;\n  logger.info(\"stored a new signing key\", {\n    createdAt: settled.createdAt,\n    ttlSeconds: KEY_TTL_SECONDS,\n    adopted: settled.createdAt === minted.createdAt ? \"own\" : \"concurrent-instance\",\n  });\n  return decode(settled);\n}\n\n/** A resolved key plus the epoch it is scoped to. */\nexport interface SigningKey {\n  key: Uint8Array;\n  /** Force-clear epoch in ms; `0` when unset. Tokens older than this are refused. */\n  epochMs: number;\n}\n\nlet pending: Promise<SigningKey> | undefined;\n\n/**\n * The signing key for this gate, resolved once per process.\n *\n * Resolved ONCE, so `configuredEpoch` is honoured only on the first call - the\n * plugin's `setup()` passes its resolved value there, before any request can\n * reach the lazy path.\n *\n * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed key. A cache that is\n * unavailable degrades to an ephemeral per-process key (the previous behaviour)\n * rather than refusing to sign: the key only validates an ALREADY-issued session,\n * so losing it costs sessions, never admission - a caller still needs a code\n * delivered to an allow-listed address.\n */\nexport function signingKey(configuredEpoch?: string | number | Date): Promise<SigningKey> {\n  pending ??= (async () => {\n    const epochMs = resolveSessionEpoch(configuredEpoch);\n    const configured = env.text(JWT_SECRET_ENV);\n    if (configured) {\n      return { key: new TextEncoder().encode(configured), epochMs };\n    }\n    try {\n      return { key: await loadFromCache(epochMs), epochMs };\n    } catch (error) {\n      logger.warn(\n        `no ${env.name(JWT_SECRET_ENV)} and the cache is unavailable - using an ephemeral per-process key; sessions will not survive a restart`,\n        { error },\n      );\n      return { key: new Uint8Array(randomBytes(KEY_BYTES)), epochMs };\n    }\n  })();\n  return pending;\n}\n\n/** Reset the per-process key (tests, or after changing the env in-process). */\nexport function resetSigningKey(): void {\n  pending = undefined;\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/allowlist.ts","../src/app.ts","../src/cli.ts","../src/env.ts","../src/headers.ts","../src/otp.ts","../src/plugin.ts","../src/portr.ts","../src/proxy.ts","../src/rate-limit.ts","../index.ts","../bin/dbx-tools-tunnel.ts"],"version":"5.9.3"}
+{"root":["../src/allowlist.ts","../src/app.ts","../src/cli.ts","../src/env.ts","../src/headers.ts","../src/otp.ts","../src/plugin.ts","../src/portr.ts","../src/proxy.ts","../src/rate-limit.ts","../src/signing-key.ts","../index.ts","../bin/dbx-tools-tunnel.ts"],"version":"5.9.3"}

package/package.json

@@ -29,11 +29,11 @@
   "dependencies": {
     "@clack/prompts": "^1.7.0",
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/appkit": "0.6.49",
-    "@dbx-tools/core": "0.6.49",
-    "@dbx-tools/email": "0.6.49",
-    "@dbx-tools/shared-core": "0.6.49",
-    "@dbx-tools/shared-email": "0.6.49",
+    "@dbx-tools/appkit": "0.6.51",
+    "@dbx-tools/core": "0.6.51",
+    "@dbx-tools/email": "0.6.51",
+    "@dbx-tools/shared-core": "0.6.51",
+    "@dbx-tools/shared-email": "0.6.51",
     "commander": "^15.0.0",
     "http-proxy-3": "^1.23.3",
     "jose": "^6.2.3"
@@ -93,10 +93,14 @@
         "types": "./lib/src/rate-limit.d.ts",
         "default": "./lib/src/rate-limit.js"
       },
+      "./signing-key": {
+        "types": "./lib/src/signing-key.d.ts",
+        "default": "./lib/src/signing-key.js"
+      },
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.49",
+  "version": "0.6.51",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
@@ -144,6 +148,10 @@
       "types": "./lib/src/rate-limit.d.ts",
       "default": "./lib/src/rate-limit.js"
     },
+    "./signing-key": {
+      "types": "./lib/src/signing-key.d.ts",
+      "default": "./lib/src/signing-key.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/cli.ts

@@ -52,6 +52,7 @@ interface TunnelOpts {
   message?: string;
   sessionTtl?: string;
   codeTtl?: string;
+  sessionEpoch?: string;
   insecure?: boolean;
   forwardHeaders?: string;
 }
@@ -75,6 +76,10 @@ function program(): Command {
     .option("--message <text>", "Line shown above the code in the email (env TUNNEL_AUTH_MESSAGE)")
     .option("--session-ttl <seconds>", "Session lifetime (env TUNNEL_AUTH_SESSION_TTL)")
     .option("--code-ttl <seconds>", "One-time-code lifetime (env TUNNEL_AUTH_CODE_TTL)")
+    .option(
+      "--session-epoch <date>",
+      "Invalidate sessions issued before this date, signing everyone out: a date, ISO timestamp, or epoch seconds (env TUNNEL_AUTH_SESSION_EPOCH)",
+    )
     .option(
       "--forward-headers <patterns>",
       "Extra x- request headers tunnel traffic may forward: literal / glob / /regex/ (env TUNNEL_FORWARD_HEADERS)",
@@ -135,6 +140,7 @@ export async function runCli(argv: string[]): Promise<void> {
     message: opts.message,
     sessionTtlSeconds: opts.sessionTtl ? Number(opts.sessionTtl) : undefined,
     codeTtlSeconds: opts.codeTtl ? Number(opts.codeTtl) : undefined,
+    sessionEpoch: opts.sessionEpoch,
   };
 
   // 1. Spawn the wrapped app with the PRIVATE port. It binds loopback; only the

package/src/env.ts

@@ -52,6 +52,12 @@ export const CODE_TTL_ENV: EnvKey = ["TUNNEL_AUTH_CODE_TTL", "AUTH_CODE_TTL"];
 /** HS256 signing secret for the session JWT. */
 export const JWT_SECRET_ENV: EnvKey = ["TUNNEL_AUTH_JWT_SECRET", "AUTH_JWT_SECRET"];
 
+/**
+ * Force-clear date for sessions issued before it: every earlier cookie stops
+ * verifying. Any `Date`-parseable value, or bare epoch seconds / millis.
+ */
+export const SESSION_EPOCH_ENV: EnvKey = "TUNNEL_AUTH_SESSION_EPOCH";
+
 /** The public `<subdomain>.<server>` portr should serve on. */
 export const PUBLIC_DOMAIN_ENV: EnvKey = ["TUNNEL_PUBLIC_DOMAIN", "PUBLIC_DOMAIN"];
 

package/src/otp.ts

@@ -8,25 +8,20 @@
  * counter (never the plaintext, never in the JWT); `verify` is constant-time on
  * 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 `TUNNEL_AUTH_JWT_SECRET`; when unset the gate uses an
- * ephemeral per-process key rather than refusing service, so an unset secret
- * degrades to "sessions don't survive a restart", not "nobody can log in". Note
- * what this does NOT weaken: a caller still needs a code delivered to an
- * 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.
+ * The session JWT is an HS256 token (via `jose`) carrying only the email. Its
+ * signing key is resolved by `./signing-key.ts`: `TUNNEL_AUTH_JWT_SECRET` when
+ * set, else a key persisted in the cache for 30 days so cookies survive the
+ * restarts a tunnel sees whenever the app it wraps reloads. A cookie signed
+ * before `TUNNEL_AUTH_SESSION_EPOCH` is refused here as well as being orphaned by
+ * the cache key, so the force-clear switch holds even for a still-current key.
  *
  * @module
  */
 
-import { createHash, randomBytes, randomInt, timingSafeEqual } from "node:crypto";
+import { createHash, randomInt, timingSafeEqual } from "node:crypto";
 import { CacheManager } from "@databricks/appkit";
-import { env, log } from "@dbx-tools/shared-core";
 import { jwtVerify, SignJWT } from "jose";
-import { JWT_SECRET_ENV } from "./env.ts";
-
-const logger = log.logger("tunnel:otp");
+import { signingKey } from "./signing-key.ts";
 
 /** JWT issuer/audience so a token minted for this gate isn't accepted elsewhere. */
 const JWT_AUD = "dbx-tools-tunnel-auth";
@@ -107,46 +102,34 @@ export class CodeStore {
   }
 }
 
-/**
- * Resolve the HS256 signing key. Prefers `TUNNEL_AUTH_JWT_SECRET`; when unset, mints an
- * ephemeral per-process key (fail-open) and warns once. Memoized.
- */
-let cachedKey: Uint8Array | undefined;
-function signingKey(): Uint8Array {
-  if (cachedKey) return cachedKey;
-  const secret = env.text(JWT_SECRET_ENV);
-  if (secret) {
-    cachedKey = new TextEncoder().encode(secret);
-  } else {
-    logger.warn(
-      `${JWT_SECRET_ENV[0]} is not set - using an ephemeral per-process key; sessions will not survive a restart`,
-    );
-    cachedKey = randomBytes(32);
-  }
-  return cachedKey;
-}
-
-/** Reset the memoized key (tests, or after changing the env in-process). */
-export function resetSigningKey(): void {
-  cachedKey = undefined;
-}
-
-/** Mint a short-lived session JWT for `email`, expiring in `ttlSeconds`. */
+/** Mint a session JWT for `email`, expiring in `ttlSeconds`. */
 export async function signSession(email: string, ttlSeconds: number): Promise<string> {
+  const { key } = await signingKey();
   return new SignJWT({ email })
     .setProtectedHeader({ alg: "HS256" })
     .setSubject(email)
     .setAudience(JWT_AUD)
     .setIssuedAt()
     .setExpirationTime(`${ttlSeconds}s`)
-    .sign(signingKey());
+    .sign(key);
 }
 
 /** Validate a session JWT, returning the email it was minted for, or `undefined`. */
 export async function verifySession(token: string | undefined): Promise<string | undefined> {
   if (!token) return undefined;
   try {
-    const { payload } = await jwtVerify(token, signingKey(), { audience: JWT_AUD });
+    const { key, epochMs } = await signingKey();
+    const { payload } = await jwtVerify(token, key, { audience: JWT_AUD });
+    // Belt and braces with the epoch-scoped cache key: that alone already
+    // orphans older keys, but an operator who moved the epoch while
+    // TUNNEL_AUTH_JWT_SECRET is set has no key rotation to rely on, and this
+    // check is what makes the switch work in that case too.
+    // Compared in whole SECONDS because `iat` has no finer resolution: against a
+    // millisecond epoch, a cookie minted in the same second as the cutoff would
+    // be refused depending on sub-second rounding.
+    if (epochMs > 0 && (payload.iat === undefined || payload.iat < Math.floor(epochMs / 1000))) {
+      return undefined;
+    }
     return typeof payload.email === "string" ? payload.email : undefined;
   } catch {
     return undefined;