@dbx-tools/cli-tunnel 0.6.51 → 0.6.52

package/lib/src/signing-key.d.ts

@@ -31,11 +31,11 @@
  *
  * ## 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
+ * {@link resolveSessionCutoff} reads a date from `TUNNEL_AUTH_SESSION_CUTOFF` (or
+ * `--session-cutoff`), 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
+ * cache entry. The cutoff 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.
  *
@@ -50,25 +50,28 @@
  */
 export declare const KEY_TTL_SECONDS: number;
 /**
- * Resolve the force-clear epoch as epoch MILLISECONDS, or `0` when unset.
+ * Resolve the force-clear cutoff as epoch MILLISECONDS, or `0` when unset.
+ *
+ * Accepts whatever `object.toDate` accepts - a `Date`, `2026-08-02`, an ISO
+ * instant, epoch seconds or millis from `date +%s`, or a relative duration
+ * (`-30d`, `7 days ago`), which is the spelling an operator reaching for this
+ * usually wants: sign out everyone who signed in more than a month ago.
  *
- * 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 declare function resolveSessionCutoff(configured?: string | number | Date): number;
+/** A resolved key plus the cutoff 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;
+    /** Force-clear cutoff in ms; `0` when unset. Tokens older than this are refused. */
+    cutoffMs: number;
 }
 /**
  * The signing key for this gate, resolved once per process.
  *
- * Resolved ONCE, so `configuredEpoch` is honoured only on the first call - the
+ * Resolved ONCE, so `configuredCutoff` is honoured only on the first call - the
  * plugin's `setup()` passes its resolved value there, before any request can
  * reach the lazy path.
  *
@@ -78,6 +81,6 @@ export interface SigningKey {
  * 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>;
+export declare function signingKey(configuredCutoff?: 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

@@ -31,11 +31,11 @@
  *
  * ## 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
+ * {@link resolveSessionCutoff} reads a date from `TUNNEL_AUTH_SESSION_CUTOFF` (or
+ * `--session-cutoff`), 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
+ * cache entry. The cutoff 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.
  *
@@ -43,8 +43,8 @@
  */
 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";
+import { env, log, object } from "@dbx-tools/shared-core";
+import { JWT_SECRET_ENV, SESSION_CUTOFF_ENV } from "./env.js";
 const logger = log.logger("tunnel:signing-key");
 /**
  * How long a cached signing key lives: 30 days.
@@ -59,69 +59,58 @@ 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.
+ * Resolve the force-clear cutoff as epoch MILLISECONDS, or `0` when unset.
+ *
+ * Accepts whatever `object.toDate` accepts - a `Date`, `2026-08-02`, an ISO
+ * instant, epoch seconds or millis from `date +%s`, or a relative duration
+ * (`-30d`, `7 days ago`), which is the spelling an operator reaching for this
+ * usually wants: sign out everyone who signed in more than a month ago.
  *
- * 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;
+export function resolveSessionCutoff(configured) {
+    const raw = configured ?? env.text(SESSION_CUTOFF_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 });
+    const date = object.toDate(raw);
+    if (!date) {
+        logger.warn(`ignoring unparseable ${env.name(SESSION_CUTOFF_ENV)}`, { value: String(raw) });
         return 0;
     }
-    return parsed;
+    return clampToPast(date.getTime());
 }
 /**
- * Hold the cutoff at "now", because a FUTURE epoch would refuse the sessions it
+ * Hold the cutoff at "now", because a FUTURE cutoff 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) {
+function clampToPast(cutoffMs) {
     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(),
+    if (cutoffMs <= now)
+        return cutoffMs;
+    logger.warn(`${env.name(SESSION_CUTOFF_ENV)} is in the future - clamping to now`, {
+        configured: new Date(cutoffMs).toISOString(),
     });
     return now;
 }
-/** The cache key for one epoch, so moving the epoch orphans every earlier key. */
-function cacheKey(epochMs) {
-    return `${KEY_PREFIX}${epochMs}`;
+/** The cache key for one cutoff, so moving the cutoff orphans every earlier key. */
+function cacheKey(cutoffMs) {
+    return `${KEY_PREFIX}${cutoffMs}`;
 }
 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.
+ * Load the signing key for `cutoffMs` 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) {
+async function loadFromCache(cutoffMs) {
     const cache = CacheManager.getInstanceSync();
-    const key = cacheKey(epochMs);
+    const key = cacheKey(cutoffMs);
     const existing = await cache.get(key);
     if (existing?.secret) {
         logger.info("reusing cached signing key", { createdAt: existing.createdAt });
@@ -147,7 +136,7 @@ let pending;
 /**
  * The signing key for this gate, resolved once per process.
  *
- * Resolved ONCE, so `configuredEpoch` is honoured only on the first call - the
+ * Resolved ONCE, so `configuredCutoff` is honoured only on the first call - the
  * plugin's `setup()` passes its resolved value there, before any request can
  * reach the lazy path.
  *
@@ -157,19 +146,19 @@ let pending;
  * so losing it costs sessions, never admission - a caller still needs a code
  * delivered to an allow-listed address.
  */
-export function signingKey(configuredEpoch) {
+export function signingKey(configuredCutoff) {
     pending ??= (async () => {
-        const epochMs = resolveSessionEpoch(configuredEpoch);
+        const cutoffMs = resolveSessionCutoff(configuredCutoff);
         const configured = env.text(JWT_SECRET_ENV);
         if (configured) {
-            return { key: new TextEncoder().encode(configured), epochMs };
+            return { key: new TextEncoder().encode(configured), cutoffMs };
         }
         try {
-            return { key: await loadFromCache(epochMs), epochMs };
+            return { key: await loadFromCache(cutoffMs), cutoffMs };
         }
         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 { key: new Uint8Array(randomBytes(KEY_BYTES)), cutoffMs };
         }
     })();
     return pending;
@@ -178,4 +167,4 @@ export function signingKey(configuredEpoch) {
 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"]}
+//# 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 resolveSessionCutoff} reads a date from `TUNNEL_AUTH_SESSION_CUTOFF` (or\n * `--session-cutoff`), 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 cutoff 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, object } from \"@dbx-tools/shared-core\";\nimport { JWT_SECRET_ENV, SESSION_CUTOFF_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 cutoff as epoch MILLISECONDS, or `0` when unset.\n *\n * Accepts whatever `object.toDate` accepts - a `Date`, `2026-08-02`, an ISO\n * instant, epoch seconds or millis from `date +%s`, or a relative duration\n * (`-30d`, `7 days ago`), which is the spelling an operator reaching for this\n * usually wants: sign out everyone who signed in more than a month ago.\n *\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 resolveSessionCutoff(configured?: string | number | Date): number {\n  const raw = configured ?? env.text(SESSION_CUTOFF_ENV) ?? undefined;\n  if (raw === undefined || raw === null || raw === \"\") return 0;\n\n  const date = object.toDate(raw);\n  if (!date) {\n    logger.warn(`ignoring unparseable ${env.name(SESSION_CUTOFF_ENV)}`, { value: String(raw) });\n    return 0;\n  }\n  return clampToPast(date.getTime());\n}\n\n/**\n * Hold the cutoff at \"now\", because a FUTURE cutoff 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(cutoffMs: number): number {\n  const now = Date.now();\n  if (cutoffMs <= now) return cutoffMs;\n  logger.warn(`${env.name(SESSION_CUTOFF_ENV)} is in the future - clamping to now`, {\n    configured: new Date(cutoffMs).toISOString(),\n  });\n  return now;\n}\n\n/** The cache key for one cutoff, so moving the cutoff orphans every earlier key. */\nfunction cacheKey(cutoffMs: number): string {\n  return `${KEY_PREFIX}${cutoffMs}`;\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 `cutoffMs` from the cache, minting and storing one\n * when absent. See the module docs for why the write is followed by a re-read.\n */\nasync function loadFromCache(cutoffMs: number): Promise<Uint8Array> {\n  const cache = CacheManager.getInstanceSync();\n  const key = cacheKey(cutoffMs);\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 cutoff it is scoped to. */\nexport interface SigningKey {\n  key: Uint8Array;\n  /** Force-clear cutoff in ms; `0` when unset. Tokens older than this are refused. */\n  cutoffMs: 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 `configuredCutoff` 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(configuredCutoff?: string | number | Date): Promise<SigningKey> {\n  pending ??= (async () => {\n    const cutoffMs = resolveSessionCutoff(configuredCutoff);\n    const configured = env.text(JWT_SECRET_ENV);\n    if (configured) {\n      return { key: new TextEncoder().encode(configured), cutoffMs };\n    }\n    try {\n      return { key: await loadFromCache(cutoffMs), cutoffMs };\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)), cutoffMs };\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/package.json

@@ -29,11 +29,11 @@
   "dependencies": {
     "@clack/prompts": "^1.7.0",
     "@databricks/appkit": "^0.43.0",
-    "@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",
+    "@dbx-tools/appkit": "0.6.52",
+    "@dbx-tools/core": "0.6.52",
+    "@dbx-tools/email": "0.6.52",
+    "@dbx-tools/shared-core": "0.6.52",
+    "@dbx-tools/shared-email": "0.6.52",
     "commander": "^15.0.0",
     "http-proxy-3": "^1.23.3",
     "jose": "^6.2.3"
@@ -100,7 +100,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.51",
+  "version": "0.6.52",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/cli.ts

@@ -52,7 +52,7 @@ interface TunnelOpts {
   message?: string;
   sessionTtl?: string;
   codeTtl?: string;
-  sessionEpoch?: string;
+  sessionCutoff?: string;
   insecure?: boolean;
   forwardHeaders?: string;
 }
@@ -77,8 +77,8 @@ function program(): Command {
     .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)",
+      "--session-cutoff <when>",
+      "Invalidate sessions issued before this point, signing everyone out: a date, ISO instant, epoch seconds, or relative duration like -30d (env TUNNEL_AUTH_SESSION_CUTOFF)",
     )
     .option(
       "--forward-headers <patterns>",
@@ -140,7 +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,
+    sessionCutoff: opts.sessionCutoff,
   };
 
   // 1. Spawn the wrapped app with the PRIVATE port. It binds loopback; only the

package/src/env.ts

@@ -53,10 +53,14 @@ export const CODE_TTL_ENV: EnvKey = ["TUNNEL_AUTH_CODE_TTL", "AUTH_CODE_TTL"];
 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.
+ * Force-clear cutoff: every session issued BEFORE it stops verifying. Anything
+ * `object.toDate` accepts - a date, an ISO instant, epoch seconds/millis, or a
+ * relative duration (`-30d`, `7 days ago`).
  */
-export const SESSION_EPOCH_ENV: EnvKey = "TUNNEL_AUTH_SESSION_EPOCH";
+export const SESSION_CUTOFF_ENV: EnvKey = [
+  "TUNNEL_AUTH_SESSION_CUTOFF",
+  "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

@@ -12,8 +12,8 @@
  * 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.
+ * before `TUNNEL_AUTH_SESSION_CUTOFF` 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
  */
@@ -118,16 +118,16 @@ export async function signSession(email: string, ttlSeconds: number): Promise<st
 export async function verifySession(token: string | undefined): Promise<string | undefined> {
   if (!token) return undefined;
   try {
-    const { key, epochMs } = await signingKey();
+    const { key, cutoffMs } = 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
+    // Belt and braces with the cutoff-scoped cache key: that alone already
+    // orphans older keys, but an operator who moved the cutoff 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))) {
+    // millisecond cutoff, a cookie minted in the same second as it would be
+    // refused depending on sub-second rounding.
+    if (cutoffMs > 0 && (payload.iat === undefined || payload.iat < Math.floor(cutoffMs / 1000))) {
       return undefined;
     }
     return typeof payload.email === "string" ? payload.email : undefined;

package/src/plugin.ts

@@ -17,7 +17,7 @@
  */
 
 import { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from "@databricks/appkit";
-import { brand, env, log, string } from "@dbx-tools/shared-core";
+import { brand, env, log, object, string } from "@dbx-tools/shared-core";
 import type { AuthStatus } from "@dbx-tools/shared-email";
 import { looksLikeEmail, matchesAllowlist } from "./allowlist.ts";
 import {
@@ -30,7 +30,7 @@ import {
 } from "./env.ts";
 import { CodeStore, signSession, verifySession } from "./otp.ts";
 import { RateLimiter } from "./rate-limit.ts";
-import { KEY_TTL_SECONDS, resolveSessionEpoch, signingKey } from "./signing-key.ts";
+import { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from "./signing-key.ts";
 
 const logger = log.logger("tunnel:auth");
 
@@ -76,13 +76,14 @@ export interface AuthGateConfig extends BasePluginConfig {
   /** Max verify attempts per issued code. Default 5. */
   maxAttempts?: number;
   /**
-   * Force-clear date: every session issued BEFORE it stops verifying, so moving
-   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_EPOCH.
+   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving
+   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.
    *
-   * Any `Date`-parseable value (`2026-08-02`, an ISO timestamp) or bare epoch
-   * seconds / millis. Unset means no cutoff.
+   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,
+   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset
+   * means no cutoff.
    */
-  sessionEpoch?: string | number | Date;
+  sessionCutoff?: string | number | Date;
   /** Deliver a code to an address. Wired by the app to the email plugin. */
   sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;
 }
@@ -111,7 +112,7 @@ export interface ResolvedAuthGateConfig {
   codeTtlSeconds: number;
   maxAttempts: number;
   /** Force-clear cutoff in epoch ms; `0` when unset. */
-  sessionEpochMs: number;
+  sessionCutoffMs: number;
 }
 
 const DEFAULTS = {
@@ -148,7 +149,7 @@ export function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateC
     ),
     codeTtlSeconds: env.positiveInt(config.codeTtlSeconds, CODE_TTL_ENV, DEFAULTS.codeTtlSeconds),
     maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,
-    sessionEpochMs: resolveSessionEpoch(config.sessionEpoch),
+    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),
   };
 }
 
@@ -193,11 +194,11 @@ export class AuthGatePlugin extends Plugin<AuthGateConfig> {
     // 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);
+    const { cutoffMs } = await signingKey(this.resolved.sessionCutoffMs);
     logger.info("ready", {
       patterns: this.resolved.allow.length,
       sessionTtlSeconds: this.resolved.sessionTtlSeconds,
-      ...(epochMs > 0 ? { sessionEpoch: new Date(epochMs).toISOString() } : {}),
+      ...object.optional("sessionCutoff", cutoffMs > 0 ? new Date(cutoffMs).toISOString() : null),
     });
   }