@dbx-tools/tunnel 0.6.81 → 0.6.85

package/lib/src/portr.js

@@ -14,9 +14,9 @@ import { writeFile } from "node:fs/promises";
 import os from "node:os";
 import { delimiter, join } from "node:path";
 import { promisify } from "node:util";
-import { bin } from "@dbx-tools/core";
-import { env, log } from "@dbx-tools/shared-core";
-import { PUBLIC_DOMAIN_ENV } from "./env.js";
+import { bin, config } from "@dbx-tools/core";
+import { log } from "@dbx-tools/shared-core";
+import { TUNNEL_CONFIG } from "./_config.js";
 const logger = log.logger("tunnel:portr");
 const PORTR_VERSION = "1.0.15-sse.2";
 const PORTR_RELEASE_URL = `https://github.com/reggie-db/portr/releases/download/v${PORTR_VERSION}`;
@@ -30,8 +30,8 @@ const execFileAsync = promisify(execFile);
  */
 export function resolvePortrConfig(opts) {
     // PORTR_* is upstream portr's own namespace, so it keeps its name.
-    const token = env.string(opts.token, "PORTR_TOKEN");
-    const domain = env.string(opts.publicDomain, PUBLIC_DOMAIN_ENV);
+    const token = config.string(opts.token, "PORTR_TOKEN");
+    const domain = config.string(opts.publicDomain, "PUBLIC_DOMAIN", TUNNEL_CONFIG);
     if (!token)
         return undefined;
     let subdomain = opts.subdomain;
@@ -40,7 +40,7 @@ export function resolvePortrConfig(opts) {
         subdomain ??= domain.split(".")[0];
         server = domain.slice(domain.indexOf(".") + 1);
     }
-    server ??= env.text("PORTR_SERVER") ?? undefined;
+    server ??= config.text("PORTR_SERVER");
     if (!subdomain || !server || server === domain)
         return undefined;
     return { subdomain, server, token, port: opts.port };
@@ -102,4 +102,4 @@ export async function startPortr(config, childEnv) {
     logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);
     return spawn("portr", ["start"], { env: childEnv, stdio: "inherit" });
 }
-//# 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, and launch support for the tunnel runtime.\n *\n * The binary and config use portr's conventional `$HOME/.portr` tree. The\n * install is idempotent (the installer skips an existing executable). The\n * config is rendered from `TUNNEL_PUBLIC_DOMAIN`\n * (`<subdomain>.<server>`) + `PORTR_TOKEN` and points portr at the PUBLIC port\n * (the proxy listens there).\n *\n * @module\n */\nimport { execFile, spawn } from \"node:child_process\";\nimport { writeFile } from \"node:fs/promises\";\nimport os from \"node:os\";\nimport { delimiter, join } from \"node:path\";\nimport { promisify } from \"node:util\";\n\nimport { bin } from \"@dbx-tools/core\";\nimport { env, log } from \"@dbx-tools/shared-core\";\nimport { PUBLIC_DOMAIN_ENV } from \"./env.ts\";\n\nconst logger = log.logger(\"tunnel:portr\");\nconst PORTR_VERSION = \"1.0.15-sse.2\";\nconst PORTR_RELEASE_URL = `https://github.com/reggie-db/portr/releases/download/v${PORTR_VERSION}`;\nconst PORTR_MIN_VERSION = \"v1.0.15\";\nconst execFileAsync = promisify(execFile);\n\n/** Options for installing the portr executable. */\nexport interface PortrInstallOptions {\n  /** Home directory containing `.portr`; defaults to the OS home directory. */\n  homeDir?: string;\n}\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 `TUNNEL_PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an\n * explicit `subdomain`. The 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  // PORTR_* is upstream portr's own namespace, so it keeps its name.\n  const token = env.string(opts.token, \"PORTR_TOKEN\");\n  const domain = env.string(opts.publicDomain, PUBLIC_DOMAIN_ENV);\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 ??= env.text(\"PORTR_SERVER\") ?? undefined;\n  if (!subdomain || !server || server === domain) return undefined;\n  return { subdomain, server, token, port: opts.port };\n}\n\n/** GitHub release asset name for the current or supplied OS/architecture. */\nexport function portrAssetName(\n  version: string,\n  platform: NodeJS.Platform = process.platform,\n  arch: string = process.arch,\n): string {\n  const osName = platform === \"darwin\" ? \"Darwin\" : platform === \"linux\" ? \"Linux\" : undefined;\n  const archName = arch === \"arm64\" ? \"arm64\" : arch === \"x64\" ? \"x86_64\" : undefined;\n  if (!osName || !archName) {\n    throw new Error(`portr has no supported release asset for ${platform}/${arch}`);\n  }\n  return `portr_${version}_${osName}_${archName}.zip`;\n}\n\nfunction portrDownloadUrl(): string {\n  const assetName = portrAssetName(PORTR_VERSION);\n  logger.info(\"installing portr\", { version: PORTR_VERSION, asset: assetName });\n  return `${PORTR_RELEASE_URL}/${assetName}`;\n}\n\n/** Install portr when absent and return the environment used by its process. */\nexport async function installPortr(options: PortrInstallOptions = {}): Promise<NodeJS.ProcessEnv> {\n  const homeDir = options.homeDir ?? os.homedir();\n  const context = await bin.ensure(\"portr\", portrDownloadUrl, {\n    autoUnpackage: true,\n    homeDir,\n    minVersion: PORTR_MIN_VERSION,\n    selector: ({ source }) => join(source, \"portr\"),\n    versionParser: (output) => {\n      const version = bin.parseVersion(output);\n      return version === PORTR_VERSION ? version : undefined;\n    },\n  });\n  return {\n    ...process.env,\n    HOME: homeDir,\n    PORTR_AUTO_ADD_PATH: \"no\",\n    PATH: [context.binDir, process.env.PATH ?? \"\"].join(delimiter),\n  };\n}\n\n/** Render `~/.portr/config.yaml` for the resolved tunnel. */\nexport async function writePortrConfig(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<void> {\n  const path = join(childEnv.HOME ?? os.homedir(), \".portr\", \"config.yaml\");\n  await writeFile(\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 async function startPortr(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<ReturnType<typeof spawn>> {\n  // Reclaim the subdomain from any portr left by a previous boot in this container.\n  await execFileAsync(\"pkill\", [\"-x\", \"portr\"]).catch(() => undefined);\n\n  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);\n  return spawn(\"portr\", [\"start\"], { env: childEnv, stdio: \"inherit\" });\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, and launch support for the tunnel runtime.\n *\n * The binary and config use portr's conventional `$HOME/.portr` tree. The\n * install is idempotent (the installer skips an existing executable). The\n * config is rendered from `TUNNEL_PUBLIC_DOMAIN`\n * (`<subdomain>.<server>`) + `PORTR_TOKEN` and points portr at the PUBLIC port\n * (the proxy listens there).\n *\n * @module\n */\nimport { execFile, spawn } from \"node:child_process\";\nimport { writeFile } from \"node:fs/promises\";\nimport os from \"node:os\";\nimport { delimiter, join } from \"node:path\";\nimport { promisify } from \"node:util\";\n\nimport { bin, config } from \"@dbx-tools/core\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\n\nconst logger = log.logger(\"tunnel:portr\");\nconst PORTR_VERSION = \"1.0.15-sse.2\";\nconst PORTR_RELEASE_URL = `https://github.com/reggie-db/portr/releases/download/v${PORTR_VERSION}`;\nconst PORTR_MIN_VERSION = \"v1.0.15\";\nconst execFileAsync = promisify(execFile);\n\n/** Options for installing the portr executable. */\nexport interface PortrInstallOptions {\n  /** Home directory containing `.portr`; defaults to the OS home directory. */\n  homeDir?: string;\n}\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 `TUNNEL_PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an\n * explicit `subdomain`. The 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  // PORTR_* is upstream portr's own namespace, so it keeps its name.\n  const token = config.string(opts.token, \"PORTR_TOKEN\");\n  const domain = config.string(opts.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG);\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 ??= config.text(\"PORTR_SERVER\");\n  if (!subdomain || !server || server === domain) return undefined;\n  return { subdomain, server, token, port: opts.port };\n}\n\n/** GitHub release asset name for the current or supplied OS/architecture. */\nexport function portrAssetName(\n  version: string,\n  platform: NodeJS.Platform = process.platform,\n  arch: string = process.arch,\n): string {\n  const osName = platform === \"darwin\" ? \"Darwin\" : platform === \"linux\" ? \"Linux\" : undefined;\n  const archName = arch === \"arm64\" ? \"arm64\" : arch === \"x64\" ? \"x86_64\" : undefined;\n  if (!osName || !archName) {\n    throw new Error(`portr has no supported release asset for ${platform}/${arch}`);\n  }\n  return `portr_${version}_${osName}_${archName}.zip`;\n}\n\nfunction portrDownloadUrl(): string {\n  const assetName = portrAssetName(PORTR_VERSION);\n  logger.info(\"installing portr\", { version: PORTR_VERSION, asset: assetName });\n  return `${PORTR_RELEASE_URL}/${assetName}`;\n}\n\n/** Install portr when absent and return the environment used by its process. */\nexport async function installPortr(options: PortrInstallOptions = {}): Promise<NodeJS.ProcessEnv> {\n  const homeDir = options.homeDir ?? os.homedir();\n  const context = await bin.ensure(\"portr\", portrDownloadUrl, {\n    autoUnpackage: true,\n    homeDir,\n    minVersion: PORTR_MIN_VERSION,\n    selector: ({ source }) => join(source, \"portr\"),\n    versionParser: (output) => {\n      const version = bin.parseVersion(output);\n      return version === PORTR_VERSION ? version : undefined;\n    },\n  });\n  return {\n    ...process.env,\n    HOME: homeDir,\n    PORTR_AUTO_ADD_PATH: \"no\",\n    PATH: [context.binDir, process.env.PATH ?? \"\"].join(delimiter),\n  };\n}\n\n/** Render `~/.portr/config.yaml` for the resolved tunnel. */\nexport async function writePortrConfig(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<void> {\n  const path = join(childEnv.HOME ?? os.homedir(), \".portr\", \"config.yaml\");\n  await writeFile(\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 async function startPortr(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<ReturnType<typeof spawn>> {\n  // Reclaim the subdomain from any portr left by a previous boot in this container.\n  await execFileAsync(\"pkill\", [\"-x\", \"portr\"]).catch(() => undefined);\n\n  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);\n  return spawn(\"portr\", [\"start\"], { env: childEnv, stdio: \"inherit\" });\n}\n"]}

package/lib/src/signing-key.js

@@ -43,8 +43,9 @@
  */
 import { randomBytes } from "node:crypto";
 import { CacheManager } from "@databricks/appkit";
-import { env, log, object } from "@dbx-tools/shared-core";
-import { JWT_SECRET_ENV, SESSION_CUTOFF_ENV } from "./env.js";
+import { config } from "@dbx-tools/core";
+import { log, object } from "@dbx-tools/shared-core";
+import { TUNNEL_CONFIG } from "./_config.js";
 const logger = log.logger("tunnel:signing-key");
 /**
  * How long a cached signing key lives: 30 days.
@@ -71,12 +72,14 @@ const KEY_BYTES = 32;
  * than not rotating.
  */
 export function resolveSessionCutoff(configured) {
-    const raw = configured ?? env.text(SESSION_CUTOFF_ENV) ?? undefined;
+    const raw = configured ?? config.text(["AUTH_SESSION_CUTOFF", "AUTH_SESSION_EPOCH"], TUNNEL_CONFIG);
     if (raw === undefined || raw === null || raw === "")
         return 0;
     const date = object.toDate(raw);
     if (!date) {
-        logger.warn(`ignoring unparseable ${env.name(SESSION_CUTOFF_ENV)}`, { value: String(raw) });
+        logger.warn(`ignoring unparseable ${config.name("AUTH_SESSION_CUTOFF", TUNNEL_CONFIG)}`, {
+            value: String(raw),
+        });
         return 0;
     }
     return clampToPast(date.getTime());
@@ -92,7 +95,7 @@ function clampToPast(cutoffMs) {
     const now = Date.now();
     if (cutoffMs <= now)
         return cutoffMs;
-    logger.warn(`${env.name(SESSION_CUTOFF_ENV)} is in the future - clamping to now`, {
+    logger.warn(`${config.name("AUTH_SESSION_CUTOFF", TUNNEL_CONFIG)} is in the future - clamping to now`, {
         configured: new Date(cutoffMs).toISOString(),
     });
     return now;
@@ -149,7 +152,7 @@ let pending;
 export function signingKey(configuredCutoff) {
     pending ??= (async () => {
         const cutoffMs = resolveSessionCutoff(configuredCutoff);
-        const configured = env.text(JWT_SECRET_ENV);
+        const configured = config.text("AUTH_JWT_SECRET", TUNNEL_CONFIG);
         if (configured) {
             return { key: new TextEncoder().encode(configured), cutoffMs };
         }
@@ -157,7 +160,7 @@ export function signingKey(configuredCutoff) {
             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 });
+            logger.warn(`no ${config.name("AUTH_JWT_SECRET", TUNNEL_CONFIG)} 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)), cutoffMs };
         }
     })();
@@ -167,4 +170,4 @@ export function signingKey(configuredCutoff) {
 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, so it must OUTLIVE the\n * process: a per-process `randomBytes(32)` would invalidate every outstanding cookie\n * on restart and make each signed-in user request a new code - painful for a tunnel,\n * which restarts whenever the app it wraps does. So the key is stored in the cache\n * AppKit already configured (memory, or Lakebase when the host wires a persistent\n * `CacheStorage`), and with persistent storage a restart keeps sessions alive for\n * {@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"]}
+//# 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, so it must OUTLIVE the\n * process: a per-process `randomBytes(32)` would invalidate every outstanding cookie\n * on restart and make each signed-in user request a new code - painful for a tunnel,\n * which restarts whenever the app it wraps does. So the key is stored in the cache\n * AppKit already configured (memory, or Lakebase when the host wires a persistent\n * `CacheStorage`), and with persistent storage a restart keeps sessions alive for\n * {@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 { config } from \"@dbx-tools/core\";\nimport { log, object } from \"@dbx-tools/shared-core\";\nimport { TUNNEL_CONFIG } from \"./_config.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 =\n    configured ?? config.text([\"AUTH_SESSION_CUTOFF\", \"AUTH_SESSION_EPOCH\"], TUNNEL_CONFIG);\n  if (raw === undefined || raw === null || raw === \"\") return 0;\n\n  const date = object.toDate(raw);\n  if (!date) {\n    logger.warn(`ignoring unparseable ${config.name(\"AUTH_SESSION_CUTOFF\", TUNNEL_CONFIG)}`, {\n      value: String(raw),\n    });\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(\n    `${config.name(\"AUTH_SESSION_CUTOFF\", TUNNEL_CONFIG)} is in the future - clamping to now`,\n    {\n      configured: new Date(cutoffMs).toISOString(),\n    },\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 = config.text(\"AUTH_JWT_SECRET\", TUNNEL_CONFIG);\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 ${config.name(\"AUTH_JWT_SECRET\", TUNNEL_CONFIG)} 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/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/allowlist.ts","../src/code-email.ts","../src/env.ts","../src/gate.ts","../src/headers.ts","../src/interceptor.ts","../src/otp.ts","../src/plugin.ts","../src/portr.ts","../src/rate-limit.ts","../src/send-code.ts","../src/signing-key.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_config.ts","../src/allowlist.ts","../src/code-email.ts","../src/gate.ts","../src/headers.ts","../src/interceptor.ts","../src/otp.ts","../src/plugin.ts","../src/portr.ts","../src/rate-limit.ts","../src/send-code.ts","../src/signing-key.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -18,20 +18,20 @@
     "projen": "projen"
   },
   "devDependencies": {
-    "@dbx-tools/email": "0.6.81",
+    "@dbx-tools/email": "0.6.85",
     "@types/bun": "^1.3.14",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@dbx-tools/email": "0.6.81"
+    "@dbx-tools/email": "0.6.85"
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/appkit": "0.6.81",
-    "@dbx-tools/core": "0.6.81",
-    "@dbx-tools/shared-core": "0.6.81",
-    "@dbx-tools/shared-email": "0.6.81",
+    "@dbx-tools/appkit": "0.6.85",
+    "@dbx-tools/core": "0.6.85",
+    "@dbx-tools/shared-core": "0.6.85",
+    "@dbx-tools/shared-email": "0.6.85",
     "jose": "^6.2.3"
   },
   "main": "./lib/index.js",
@@ -48,7 +48,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.81",
+  "version": "0.6.85",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/_config.ts

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

package/src/gate.ts

@@ -22,10 +22,11 @@
  * @module
  */
 
+import type { IncomingMessage } from "node:http";
 import { http, json, log, token } from "@dbx-tools/shared-core";
 import { authRequestSchema, authVerifySchema, SESSION_COOKIE_NAME } from "@dbx-tools/shared-email";
 import type { Request, RequestHandler, Response } from "express";
-import { toHeaderPolicy } from "./headers.ts";
+import { toHeaderPolicy, type HeaderPolicy } from "./headers.ts";
 import type { AuthGateApi } from "./plugin.ts";
 
 const logger = log.logger("tunnel:gate");
@@ -56,7 +57,7 @@ export interface GateOptions {
  * over portr. Case-insensitive; the optional `:port` is ignored. When no public
  * domain is configured, nothing is tunnel traffic.
  */
-export function isTunnelHost(req: Request, publicDomain: string | undefined): boolean {
+export function isTunnelHost(req: IncomingMessage, publicDomain: string | undefined): boolean {
   if (!publicDomain) return false;
   const host = (req.headers.host ?? "").toLowerCase().split(":")[0];
   return host === publicDomain.toLowerCase().split(":")[0];
@@ -84,7 +85,7 @@ function sessionCookie(value: string, maxAgeSeconds: number): string {
  * rightmost, not the leftmost, stops a caller minting a fresh rate-limit bucket by
  * varying the header. Called before {@link stripHeaders}.
  */
-function clientIp(req: Request): string {
+export function clientIp(req: IncomingMessage): string {
   const forwarded = req.headers["x-forwarded-for"];
   const chain = (Array.isArray(forwarded) ? forwarded.join(",") : (forwarded ?? ""))
     .split(",")
@@ -98,7 +99,7 @@ function clientIp(req: Request): string {
  * handlers run, so the app never sees `dbx_auth` (it is the gate's concern).
  * Preserves other cookies; deletes the header when it becomes empty.
  */
-function stripSessionCookie(req: Request): void {
+function stripSessionCookie(req: IncomingMessage): void {
   const raw = req.headers.cookie;
   if (!raw) return;
   const kept = raw
@@ -120,7 +121,7 @@ function stripSessionCookie(req: Request): void {
  * `@dbx-tools/appkit`'s `identity: "auto"` detects, so a gated request runs as the
  * app service principal instead of throwing.
  */
-function injectIdentity(req: Request, email: string): void {
+function injectIdentity(req: IncomingMessage, email: string): void {
   req.headers[token.USER_ID_HEADER] = email;
   req.headers[token.USER_EMAIL_HEADER] = email;
 }
@@ -145,6 +146,80 @@ function readBody(req: Request): Promise<string> {
   });
 }
 
+/**
+ * What the caller should do with a request, from {@link gateRequest}.
+ *
+ *   - `pass` - not tunnel traffic, or an open login route. Forward untouched.
+ *   - `allow` - tunnel traffic that is authorized. The request's headers have
+ *     ALREADY been rewritten (policy applied, identity injected, session cookie
+ *     stripped), so forward it as it now stands.
+ *   - `deny` - tunnel traffic with no valid session. Answer `401` with
+ *     {@link AUTH_PREFIX} as the login path.
+ */
+export type GateAction = "pass" | "allow" | "deny";
+
+/**
+ * THE gating decision, for one request, independent of how it will be answered.
+ *
+ * Both paths call this: the Express middleware below (where the app is the
+ * process) and `@dbx-tools/cli-tunnel`'s reverse proxy (where the app is a child
+ * process on a private port). A divergence between them would be a security bug
+ * the second path could not be tested into agreement - one path forgetting to
+ * strip `x-forwarded-access-token` is enough - so the decision, the header
+ * rewriting, and the identity injection live here once and the transports only
+ * differ in how they WRITE the outcome.
+ *
+ * Mutates `req.headers` on the `allow`/`pass`-with-cookie paths, which is exactly
+ * what both callers want: Express hands the same object to the app's handlers, and
+ * the proxy forwards it upstream.
+ */
+export async function gateRequest(
+  req: IncomingMessage,
+  options: GateOptions & { headerPolicy?: HeaderPolicy },
+): Promise<GateAction> {
+  const { gate, publicDomain } = options;
+  // Not tunnel traffic (platform front door, or any other local caller): the
+  // request is already authenticated, or is not ours to gate.
+  if (!isTunnelHost(req, publicDomain)) return "pass";
+
+  const path = (req.url ?? "/").split("?")[0] ?? "/";
+  // The login flow is open so the browser can render <AuthGate> and sign in.
+  if (path.startsWith(AUTH_PREFIX)) return "pass";
+
+  // Anti-spoof: only the gate may assert identity on tunnel traffic.
+  const policy = options.headerPolicy ?? toHeaderPolicy(options.forwardHeaders);
+  const removed = policy.apply(req.headers as Record<string, unknown>);
+  if (removed.length) logger.debug("stripped inbound headers", { removed });
+
+  // Static (non-API) loads freely so the SPA can render; drop the gate cookie.
+  if (!path.startsWith("/api/")) {
+    stripSessionCookie(req);
+    return "pass";
+  }
+
+  // Every other /api/* needs a valid OTP session.
+  const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
+  const email = await gate.session(cookie);
+  if (!email) return "deny";
+  injectIdentity(req, email);
+  stripSessionCookie(req);
+  return "allow";
+}
+
+/** The body of a `deny`, shared so both paths answer a 401 identically. */
+export const UNAUTHORIZED_BODY = {
+  error: "authentication required",
+  loginPath: AUTH_PREFIX,
+} as const;
+
+/** The `Set-Cookie` value that issues a verified session. */
+export function sessionSetCookie(sessionToken: string, maxAgeSeconds: number): string {
+  return sessionCookie(sessionToken, maxAgeSeconds);
+}
+
+/** The `Set-Cookie` value that clears the session. */
+export const LOGOUT_SET_COOKIE = `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`;
+
 /**
  * Register the login routes and the gating middleware on the app's Express
  * instance. Called from {@link AuthGatePlugin} with the router AppKit hands
@@ -163,11 +238,6 @@ export function mountGate(
   const headerPolicy = toHeaderPolicy(forwardHeaders);
   logger.debug("gate mounted", { publicDomain, forward: headerPolicy.patterns });
 
-  const applyHeaderPolicy = (req: Request): void => {
-    const removed = headerPolicy.apply(req.headers as Record<string, unknown>);
-    if (removed.length) logger.debug("stripped inbound headers", { removed });
-  };
-
   // --- Login routes (open on tunnel traffic; answered in-process) ---
 
   const statusHandler = (async (req, res) => {
@@ -216,7 +286,7 @@ export function mountGate(
       sendJson(res, 404, { error: "not found" });
       return;
     }
-    sendJson(res, 200, { ok: true }, `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; Max-Age=0`);
+    sendJson(res, 200, { ok: true }, LOGOUT_SET_COOKIE);
   }) as RequestHandler;
 
   addRoute("get", `${AUTH_PREFIX}/status`, statusHandler);
@@ -227,34 +297,9 @@ export function mountGate(
   // --- The gate middleware (runs before static + the app's /api handlers) ---
 
   const gateMiddleware = (async (req, res, next) => {
-    // Not tunnel traffic (platform front door, or any other local caller): the
-    // request is already authenticated (or is not ours to gate). Pass through.
-    if (!isTunnelHost(req, publicDomain)) return next();
-
-    const path = (req.url ?? "/").split("?")[0] ?? "/";
-
-    // The login flow is open so the browser can render <AuthGate> and sign in.
-    if (path.startsWith(AUTH_PREFIX)) return next();
-
-    // Anti-spoof: only the gate may assert identity on tunnel traffic.
-    applyHeaderPolicy(req);
-
-    // Static (non-API) loads freely so the SPA can render; drop the gate cookie.
-    if (!path.startsWith("/api/")) {
-      stripSessionCookie(req);
-      return next();
-    }
-
-    // Every other /api/* needs a valid OTP session.
-    const cookie = http.parseCookies(req.headers.cookie ?? null)[SESSION_COOKIE_NAME];
-    const email = await gate.session(cookie);
-    if (!email) {
-      sendJson(res, 401, { error: "authentication required", loginPath: AUTH_PREFIX });
-      return;
-    }
-    injectIdentity(req, email);
-    stripSessionCookie(req);
-    next();
+    const action = await gateRequest(req, { gate, publicDomain, headerPolicy });
+    if (action === "deny") sendJson(res, 401, UNAUTHORIZED_BODY);
+    else next();
   }) as RequestHandler;
 
   addMiddleware("/", gateMiddleware);

package/src/plugin.ts

@@ -17,21 +17,12 @@
  */
 
 import { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from "@databricks/appkit";
-import { brand, env, log, object, string } from "@dbx-tools/shared-core";
+import { config as configModule } from "@dbx-tools/core";
+import { brand, log, object, string } from "@dbx-tools/shared-core";
 import type { AuthStatus } from "@dbx-tools/shared-email";
 import type { RequestHandler } from "express";
+import { TUNNEL_CONFIG } from "./_config.ts";
 import { looksLikeEmail, matchesAllowlist } from "./allowlist.ts";
-import {
-  ALLOW_ENV,
-  BRAND_NAME_ENV,
-  CODE_TTL_ENV,
-  FORWARD_HEADERS_ENV,
-  INSECURE_ENV,
-  MESSAGE_ENV,
-  PUBLIC_DOMAIN_ENV,
-  SESSION_TTL_ENV,
-  SUBJECT_ENV,
-} from "./env.ts";
 import { mountGate, type GateOptions } from "./gate.ts";
 import { CodeStore, signSession, verifySession } from "./otp.ts";
 import { RateLimiter } from "./rate-limit.ts";
@@ -216,26 +207,36 @@ export function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateC
   return {
     // Both sources are unioned rather than one overriding: a deployment-wide
     // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.
-    // Hence `parseList` on each rather than `env.list`, which stops at the first
-    // source that yields anything.
-    allow: [...string.parseList(config.allow), ...string.parseList(env.text(ALLOW_ENV))],
-    subject: env.string(config.subject, SUBJECT_ENV) ?? DEFAULTS.subject,
-    brandName: env.string(config.brandName, BRAND_NAME_ENV) ?? DEFAULTS.brandName,
-    message: env.string(config.message, MESSAGE_ENV) ?? DEFAULTS.message,
-    sessionTtlSeconds: env.positiveInt(
+    // Hence `parseList` on each rather than `config.list`, which stops at the
+    // first source that yields anything.
+    allow: [
+      ...string.parseList(config.allow),
+      ...string.parseList(configModule.text(["AUTH_ALLOW", "EMAIL_AUTH_ALLOW"], TUNNEL_CONFIG)),
+    ],
+    subject: configModule.string(config.subject, "AUTH_SUBJECT", TUNNEL_CONFIG) ?? DEFAULTS.subject,
+    brandName:
+      configModule.string(config.brandName, "AUTH_BRAND_NAME", TUNNEL_CONFIG) ?? DEFAULTS.brandName,
+    message: configModule.string(config.message, "AUTH_MESSAGE", TUNNEL_CONFIG) ?? DEFAULTS.message,
+    sessionTtlSeconds: configModule.positiveInt(
       config.sessionTtlSeconds,
-      SESSION_TTL_ENV,
+      "AUTH_SESSION_TTL",
       DEFAULTS.sessionTtlSeconds,
+      TUNNEL_CONFIG,
+    ),
+    codeTtlSeconds: configModule.positiveInt(
+      config.codeTtlSeconds,
+      "AUTH_CODE_TTL",
+      DEFAULTS.codeTtlSeconds,
+      TUNNEL_CONFIG,
     ),
-    codeTtlSeconds: env.positiveInt(config.codeTtlSeconds, CODE_TTL_ENV, DEFAULTS.codeTtlSeconds),
     maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,
     sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),
-    publicDomain: env.string(config.publicDomain, PUBLIC_DOMAIN_ENV) ?? undefined,
+    publicDomain: configModule.string(config.publicDomain, "PUBLIC_DOMAIN", TUNNEL_CONFIG),
     forwardHeaders: [
       ...string.parseList(config.forwardHeaders),
-      ...string.parseList(env.text(FORWARD_HEADERS_ENV)),
+      ...string.parseList(configModule.text("FORWARD_HEADERS", TUNNEL_CONFIG)),
     ],
-    insecure: env.boolean(config.insecure, INSECURE_ENV) ?? false,
+    insecure: configModule.boolean(config.insecure, "INSECURE", TUNNEL_CONFIG) ?? false,
   };
 }
 

package/src/portr.ts

@@ -15,9 +15,9 @@ import os from "node:os";
 import { delimiter, join } from "node:path";
 import { promisify } from "node:util";
 
-import { bin } from "@dbx-tools/core";
-import { env, log } from "@dbx-tools/shared-core";
-import { PUBLIC_DOMAIN_ENV } from "./env.ts";
+import { bin, config } from "@dbx-tools/core";
+import { log } from "@dbx-tools/shared-core";
+import { TUNNEL_CONFIG } from "./_config.ts";
 
 const logger = log.logger("tunnel:portr");
 const PORTR_VERSION = "1.0.15-sse.2";
@@ -52,8 +52,8 @@ export function resolvePortrConfig(opts: {
   port: number;
 }): PortrConfig | undefined {
   // PORTR_* is upstream portr's own namespace, so it keeps its name.
-  const token = env.string(opts.token, "PORTR_TOKEN");
-  const domain = env.string(opts.publicDomain, PUBLIC_DOMAIN_ENV);
+  const token = config.string(opts.token, "PORTR_TOKEN");
+  const domain = config.string(opts.publicDomain, "PUBLIC_DOMAIN", TUNNEL_CONFIG);
   if (!token) return undefined;
   let subdomain = opts.subdomain;
   let server: string | undefined;
@@ -61,7 +61,7 @@ export function resolvePortrConfig(opts: {
     subdomain ??= domain.split(".")[0];
     server = domain.slice(domain.indexOf(".") + 1);
   }
-  server ??= env.text("PORTR_SERVER") ?? undefined;
+  server ??= config.text("PORTR_SERVER");
   if (!subdomain || !server || server === domain) return undefined;
   return { subdomain, server, token, port: opts.port };
 }

package/src/signing-key.ts

@@ -44,8 +44,9 @@
 
 import { randomBytes } from "node:crypto";
 import { CacheManager } from "@databricks/appkit";
-import { env, log, object } from "@dbx-tools/shared-core";
-import { JWT_SECRET_ENV, SESSION_CUTOFF_ENV } from "./env.ts";
+import { config } from "@dbx-tools/core";
+import { log, object } from "@dbx-tools/shared-core";
+import { TUNNEL_CONFIG } from "./_config.ts";
 
 const logger = log.logger("tunnel:signing-key");
 
@@ -85,12 +86,15 @@ interface StoredKey {
  * than not rotating.
  */
 export function resolveSessionCutoff(configured?: string | number | Date): number {
-  const raw = configured ?? env.text(SESSION_CUTOFF_ENV) ?? undefined;
+  const raw =
+    configured ?? config.text(["AUTH_SESSION_CUTOFF", "AUTH_SESSION_EPOCH"], TUNNEL_CONFIG);
   if (raw === undefined || raw === null || raw === "") return 0;
 
   const date = object.toDate(raw);
   if (!date) {
-    logger.warn(`ignoring unparseable ${env.name(SESSION_CUTOFF_ENV)}`, { value: String(raw) });
+    logger.warn(`ignoring unparseable ${config.name("AUTH_SESSION_CUTOFF", TUNNEL_CONFIG)}`, {
+      value: String(raw),
+    });
     return 0;
   }
   return clampToPast(date.getTime());
@@ -106,9 +110,12 @@ export function resolveSessionCutoff(configured?: string | number | Date): numbe
 function clampToPast(cutoffMs: number): number {
   const now = Date.now();
   if (cutoffMs <= now) return cutoffMs;
-  logger.warn(`${env.name(SESSION_CUTOFF_ENV)} is in the future - clamping to now`, {
-    configured: new Date(cutoffMs).toISOString(),
-  });
+  logger.warn(
+    `${config.name("AUTH_SESSION_CUTOFF", TUNNEL_CONFIG)} is in the future - clamping to now`,
+    {
+      configured: new Date(cutoffMs).toISOString(),
+    },
+  );
   return now;
 }
 
@@ -178,7 +185,7 @@ let pending: Promise<SigningKey> | undefined;
 export function signingKey(configuredCutoff?: string | number | Date): Promise<SigningKey> {
   pending ??= (async () => {
     const cutoffMs = resolveSessionCutoff(configuredCutoff);
-    const configured = env.text(JWT_SECRET_ENV);
+    const configured = config.text("AUTH_JWT_SECRET", TUNNEL_CONFIG);
     if (configured) {
       return { key: new TextEncoder().encode(configured), cutoffMs };
     }
@@ -186,7 +193,7 @@ export function signingKey(configuredCutoff?: string | number | Date): Promise<S
       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`,
+        `no ${config.name("AUTH_JWT_SECRET", TUNNEL_CONFIG)} 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)), cutoffMs };