@dbx-tools/tunnel 0.6.105 → 0.6.106

package/lib/src/interceptor.js

@@ -1,6 +1,6 @@
 /**
  * `tunnelInterceptor()` - the {@link Interceptor} that fronts an app with a public
- * portr tunnel, consuming the {@link InterceptorContext} `@dbx-tools/appkit`'s
+ * portr and/or frp tunnel, consuming the {@link InterceptorContext} `@dbx-tools/appkit`'s
  * `createApp` hands it.
  *
  * The tunnel runs IN-PROCESS: the APP is the main process and hands this interceptor
@@ -17,8 +17,19 @@
  * @module
  */
 import { log, object } from "@dbx-tools/shared-core";
+import { installFrp, resolveFrpConfig, startFrp, writeFrpConfig } from "./frp.js";
 import { installPortr, resolvePortrConfig, startPortr, writePortrConfig } from "./portr.js";
 const logger = log.logger("tunnel:interceptor");
+/** Resolve and validate the tunnel transport selector. */
+export function resolveTunnelTransport(transport) {
+    const resolved = transport ??
+        process.env.DBX_TOOLS_TUNNEL_TRANSPORT ??
+        process.env.TUNNEL_TRANSPORT ??
+        "portr";
+    if (resolved === "portr" || resolved === "frp" || resolved === "both")
+        return resolved;
+    throw new TypeError(`invalid tunnel transport: ${resolved} (expected portr, frp, or both)`);
+}
 /** Resolve the public port portr should target: explicit, else the Apps contract. */
 function resolvePublicPort(port) {
     return port ?? object.toNumber(process.env.DATABRICKS_APP_PORT) ?? 8000;
@@ -26,9 +37,8 @@ function resolvePublicPort(port) {
 /**
  * Build the tunnel {@link Interceptor}. Pass it to `createApp({ interceptor })`.
  *
- * A no-op (logs and returns) when no portr tunnel is configured - no `PORTR_TOKEN`
- * or no resolvable `<subdomain>.<server>` - so an app can register it
- * unconditionally and only actually tunnels where the deployment wired portr.
+ * A no-op (logs and returns) when none of the selected tunnel clients resolve
+ * usable configuration, so an app can register it unconditionally.
  *
  * @example
  * import { appkit } from "@dbx-tools/appkit";
@@ -45,24 +55,52 @@ export function tunnelInterceptor(options = {}) {
             process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;
         }
         const port = resolvePublicPort(options.port);
-        const portrConfig = resolvePortrConfig({
-            publicDomain: options.publicDomain,
-            subdomain: options.subdomain,
-            port,
-        });
-        if (!portrConfig) {
-            logger.info("no PORTR_TOKEN/TUNNEL_PUBLIC_DOMAIN - the app runs without a public tunnel");
-            return;
+        const transport = resolveTunnelTransport(options.transport);
+        const children = [];
+        if (transport === "portr" || transport === "both") {
+            const portrConfig = resolvePortrConfig({
+                publicDomain: options.publicDomain,
+                subdomain: options.subdomain,
+                port,
+            });
+            if (portrConfig) {
+                const portrEnv = await installPortr();
+                await writePortrConfig(portrConfig, portrEnv);
+                children.push(await startPortr(portrConfig, portrEnv));
+            }
+            else {
+                logger.info("portr not configured (requires PORTR_TOKEN and TUNNEL_PUBLIC_DOMAIN)");
+            }
         }
-        const portrEnv = await installPortr();
-        await writePortrConfig(portrConfig, portrEnv);
-        const portr = await startPortr(portrConfig, portrEnv);
-        ctx.bindProcess(portr);
+        if (transport === "frp" || transport === "both") {
+            const frpConfig = resolveFrpConfig({
+                publicDomain: options.frpPublicDomain,
+                server: options.frpServer,
+                serverPort: options.frpServerPort,
+                protocol: options.frpProtocol,
+                token: options.frpToken,
+                proxyName: options.frpProxyName,
+                port,
+            });
+            if (frpConfig) {
+                const frpEnv = await installFrp();
+                const configPath = await writeFrpConfig(frpConfig, frpEnv);
+                children.push(startFrp(frpConfig, frpEnv, configPath));
+            }
+            else {
+                logger.info("frp not configured (requires TUNNEL_PUBLIC_DOMAIN)");
+            }
+        }
+        if (!children.length)
+            return;
+        for (const child of children)
+            ctx.bindProcess(child);
         ctx.onLifecycle("shutdown", () => {
-            if (!portr.killed)
-                portr.kill("SIGTERM");
+            for (const child of children)
+                if (!child.killed)
+                    child.kill("SIGTERM");
         });
-        logger.info(`tunnel bound: portr -> :${port} (${portrConfig.subdomain}.${portrConfig.server})`);
+        logger.info(`tunnel bound: ${transport} -> :${port}`);
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `tunnelInterceptor()` - the {@link Interceptor} that fronts an app with a public\n * portr and/or frp tunnel, consuming the {@link InterceptorContext} `@dbx-tools/appkit`'s\n * `createApp` hands it.\n *\n * The tunnel runs IN-PROCESS: the APP is the main process and hands this interceptor\n * its context, rather than a wrapper process spawning the app as a child. The\n * interceptor applies the computed workspace host, installs and launches portr on the\n * app's public port, binds the child process to the app, and stops portr during an\n * orderly AppKit shutdown.\n *\n * The passwordless GATE is a separate concern: it is the `authGate` AppKit plugin,\n * which registers the login routes + a gating middleware on the app's own server.\n * Register it in the app's `plugins` for gated traffic. This interceptor is only\n * the portr half - \"update the host, bind portr\" - the smallest useful unit.\n *\n * @module\n */\n\nimport type { ChildProcess } from \"node:child_process\";\nimport type { Interceptor, InterceptorContext } from \"@dbx-tools/appkit\";\nimport { log, object } from \"@dbx-tools/shared-core\";\nimport { installFrp, resolveFrpConfig, startFrp, writeFrpConfig } from \"./frp.ts\";\nimport { installPortr, resolvePortrConfig, startPortr, writePortrConfig } from \"./portr.ts\";\n\nconst logger = log.logger(\"tunnel:interceptor\");\n\n/** Options for {@link tunnelInterceptor} (each also resolvable from env). */\nexport interface TunnelInterceptorOptions {\n  /** Tunnel clients to run. Env `DBX_TOOLS_TUNNEL_TRANSPORT`; defaults to `portr`. */\n  transport?: TunnelTransport;\n  /** Public host to serve on. Env `TUNNEL_PUBLIC_DOMAIN`. */\n  publicDomain?: string;\n  /** portr subdomain (else derived from {@link publicDomain}). */\n  subdomain?: string;\n  /**\n   * The PUBLIC port portr forwards to - the port the app itself listens on.\n   * Defaults to the Databricks Apps runtime contract `DATABRICKS_APP_PORT`\n   * (then `8000`), which is the port the platform routes to.\n   */\n  port?: number;\n  /** frps control host; defaults to the FRP public domain. Env `FRP_SERVER`. */\n  frpServer?: string;\n  /** FRP public HTTP host. Env `TUNNEL_FRP_PUBLIC_DOMAIN`. */\n  frpPublicDomain?: string;\n  /** frps control port. Env `FRP_SERVER_PORT`; defaults to `443`. */\n  frpServerPort?: number;\n  /** frpc transport protocol. Env `FRP_PROTOCOL`; defaults to `wss`. */\n  frpProtocol?: string;\n  /** frps auth token. Env `FRP_TOKEN` (or `TUNNEL_TOKEN`). */\n  frpToken?: string;\n  /** frp proxy registration name. Env `FRP_PROXY_NAME`. */\n  frpProxyName?: string;\n}\n\n/** Public tunnel clients supported by the interceptor and CLI. */\nexport type TunnelTransport = \"portr\" | \"frp\" | \"both\";\n\n/** Resolve and validate the tunnel transport selector. */\nexport function resolveTunnelTransport(transport?: string): TunnelTransport {\n  const resolved =\n    transport ??\n    process.env.DBX_TOOLS_TUNNEL_TRANSPORT ??\n    process.env.TUNNEL_TRANSPORT ??\n    \"portr\";\n  if (resolved === \"portr\" || resolved === \"frp\" || resolved === \"both\") return resolved;\n  throw new TypeError(`invalid tunnel transport: ${resolved} (expected portr, frp, or both)`);\n}\n\n/** Resolve the public port portr should target: explicit, else the Apps contract. */\nfunction resolvePublicPort(port?: number): number {\n  return port ?? object.toNumber(process.env.DATABRICKS_APP_PORT) ?? 8000;\n}\n\n/**\n * Build the tunnel {@link Interceptor}. Pass it to `createApp({ interceptor })`.\n *\n * A no-op (logs and returns) when none of the selected tunnel clients resolve\n * usable configuration, so an app can register it unconditionally.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n * import { tunnelInterceptor } from \"@dbx-tools/tunnel\";\n *\n * await appkit.createApp({\n *   plugins: [server({ host, staticPath })],\n *   interceptor: tunnelInterceptor(),\n * });\n */\nexport function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Interceptor {\n  return async (ctx: InterceptorContext): Promise<void> => {\n    if (ctx.env.databricksHost) {\n      process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;\n    }\n\n    const port = resolvePublicPort(options.port);\n    const transport = resolveTunnelTransport(options.transport);\n    const children: ChildProcess[] = [];\n    if (transport === \"portr\" || transport === \"both\") {\n      const portrConfig = resolvePortrConfig({\n        publicDomain: options.publicDomain,\n        subdomain: options.subdomain,\n        port,\n      });\n      if (portrConfig) {\n        const portrEnv = await installPortr();\n        await writePortrConfig(portrConfig, portrEnv);\n        children.push(await startPortr(portrConfig, portrEnv));\n      } else {\n        logger.info(\"portr not configured (requires PORTR_TOKEN and TUNNEL_PUBLIC_DOMAIN)\");\n      }\n    }\n    if (transport === \"frp\" || transport === \"both\") {\n      const frpConfig = resolveFrpConfig({\n        publicDomain: options.frpPublicDomain,\n        server: options.frpServer,\n        serverPort: options.frpServerPort,\n        protocol: options.frpProtocol,\n        token: options.frpToken,\n        proxyName: options.frpProxyName,\n        port,\n      });\n      if (frpConfig) {\n        const frpEnv = await installFrp();\n        const configPath = await writeFrpConfig(frpConfig, frpEnv);\n        children.push(startFrp(frpConfig, frpEnv, configPath));\n      } else {\n        logger.info(\"frp not configured (requires TUNNEL_PUBLIC_DOMAIN)\");\n      }\n    }\n    if (!children.length) return;\n    for (const child of children) ctx.bindProcess(child);\n    ctx.onLifecycle(\"shutdown\", () => {\n      for (const child of children) if (!child.killed) child.kill(\"SIGTERM\");\n    });\n    logger.info(`tunnel bound: ${transport} -> :${port}`);\n  };\n}\n"]}

package/lib/src/plugin.d.ts

@@ -105,6 +105,8 @@ export interface AuthGateConfig extends BasePluginConfig, AuthStorageConfig {
      * traffic).
      */
     publicDomain?: string;
+    /** Additional public tunnel domains accepted by the gate. */
+    publicDomains?: string | string[];
     /**
      * Extra `x-` request headers tunnel traffic may forward (literal / glob /
      * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.
@@ -150,8 +152,10 @@ export interface ResolvedAuthGateConfig {
     sessionCutoffMs: number;
     /** Same-origin path returned after logout. */
     logoutRedirectPath: string;
-    /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */
+    /** Primary public domain; `undefined` when Portr is not configured. */
     publicDomain?: string;
+    /** All public tunnel domains accepted by the gate. */
+    publicDomains: string[];
     /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */
     forwardHeaders: string[];
     /** Path prefixes to gate beyond `/api/` (e.g. `/ws`). */

package/lib/src/plugin.js

@@ -65,6 +65,8 @@ export function resolveAuthGateConfig(config) {
             coreConfig.text("AUTH_STORAGE", TUNNEL_CONFIG),
         sqlitePath: config.sqlitePath ?? coreConfig.text("AUTH_SQLITE_PATH", TUNNEL_CONFIG),
     });
+    const publicDomain = coreConfig.string(config.publicDomain, "PUBLIC_DOMAIN", TUNNEL_CONFIG);
+    const frpPublicDomain = coreConfig.text("FRP_PUBLIC_DOMAIN", TUNNEL_CONFIG);
     return {
         // Both sources are unioned rather than one overriding: a deployment-wide
         // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.
@@ -83,7 +85,14 @@ export function resolveAuthGateConfig(config) {
         sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),
         logoutRedirectPath: passwordlessAuth.normalizeLogoutRedirectPath(coreConfig.string(config.logoutRedirectPath, "AUTH_LOGOUT_REDIRECT", TUNNEL_CONFIG) ??
             DEFAULTS.logoutRedirectPath),
-        publicDomain: coreConfig.string(config.publicDomain, "PUBLIC_DOMAIN", TUNNEL_CONFIG),
+        publicDomain,
+        publicDomains: [
+            ...new Set([
+                publicDomain,
+                frpPublicDomain,
+                ...string.parseList(config.publicDomains),
+            ].filter((value) => !!value)),
+        ],
         forwardHeaders: [
             ...string.parseList(config.forwardHeaders),
             ...string.parseList(coreConfig.text("FORWARD_HEADERS", TUNNEL_CONFIG)),
@@ -187,7 +196,7 @@ export class AuthGatePlugin extends Plugin {
         logger.info("ready", {
             patterns: this.resolved.allow.length,
             sessionTtlSeconds: this.resolved.sessionTtlSeconds,
-            publicDomain: this.resolved.publicDomain ?? null,
+            publicDomains: this.resolved.publicDomains,
             insecure: this.resolved.insecure,
             storage: this.resolved.storage,
             logoutRedirectPath: this.resolved.logoutRedirectPath,
@@ -214,7 +223,7 @@ export class AuthGatePlugin extends Plugin {
         }
         mountGateOnContext(context, {
             gate: this.exports(),
-            publicDomain: this.resolved.publicDomain,
+            publicDomain: this.resolved.publicDomains,
             forwardHeaders: this.resolved.forwardHeaders,
             gatePaths: this.resolved.gatePaths,
         });
@@ -252,4 +261,4 @@ function authOrigin(publicDomain) {
 }
 /** 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":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,QAAQ,EACR,MAAM,EACN,QAAQ,EAIR,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EACL,IAAI,IAAI,gBAAgB,EACxB,OAAO,IAAI,WAAW,GAKvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAE5D,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,SAAS,EAAoB,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAErF,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;AAczC,SAAS,iBAAiB,CAAC,OAAyB;IAClD,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,QAAQ,CACoB,CAAC;IACrE,MAAM,WAAW,GAAG,MAAM,EAAE,iBAAiB,CAAC;IAC9C,OAAO,WAAW;QAChB,OAAO,WAAW,CAAC,GAAG,KAAK,UAAU;QACrC,OAAO,WAAW,CAAC,IAAI,KAAK,UAAU;QACtC,OAAO,WAAW,CAAC,GAAG,KAAK,UAAU;QACrC,CAAC,CAAE,WAAqC;QACxC,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,OAAyB,EAAE,OAAoB;IAChF,MAAM,WAAW,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAC/C,IAAI,WAAW,EAAE,CAAC;QAChB,SAAS,CACP,OAAO,EACP,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,EAC7D,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAClD,CAAC;QACF,OAAO;IACT,CAAC;IACD,SAAS,CACP,OAAO,EACP,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,EAClE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CACxD,CAAC;AACJ,CAAC;AA6ID,MAAM,QAAQ,GAAG;IACf,OAAO,EAAE,wBAAwB;IACjC,8EAA8E;IAC9E,+EAA+E;IAC/E,kEAAkE;IAClE,gFAAgF;IAChF,8CAA8C;IAC9C,SAAS,EAAE,KAAK,CAAC,mBAAmB,CAAC,IAAI;IACzC,OAAO,EAAE,4BAA4B;IACrC,uEAAuE;IACvE,iBAAiB,EAAE,eAAe;IAClC,cAAc,EAAE,GAAG;IACnB,WAAW,EAAE,CAAC;IACd,kBAAkB,EAAE,GAAG;CACxB,CAAC;AAEF,kFAAkF;AAClF,MAAM,UAAU,qBAAqB,CAAC,MAAsB;IAC1D,MAAM,OAAO,GAAG,WAAW,CAAC,wBAAwB,CAAC;QACnD,OAAO,EACL,MAAM,CAAC,OAAO;YACb,UAAU,CAAC,IAAI,CAAC,cAAc,EAAE,aAAa,CAAiC;QACjF,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,UAAU,CAAC,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC;KACpF,CAAC,CAAC;IACH,OAAO;QACL,yEAAyE;QACzE,6EAA6E;QAC7E,0EAA0E;QAC1E,qCAAqC;QACrC,KAAK,EAAE;YACL,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC;YACjC,GAAG,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,kBAAkB,CAAC,EAAE,aAAa,CAAC,CAAC;SACxF;QACD,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,EAAE,aAAa,CAAC,IAAI,QAAQ,CAAC,OAAO;QAC7F,SAAS,EACP,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,iBAAiB,EAAE,aAAa,CAAC,IAAI,QAAQ,CAAC,SAAS;QAC7F,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,EAAE,aAAa,CAAC,IAAI,QAAQ,CAAC,OAAO;QAC7F,iBAAiB,EAAE,UAAU,CAAC,WAAW,CACvC,MAAM,CAAC,iBAAiB,EACxB,kBAAkB,EAClB,QAAQ,CAAC,iBAAiB,EAC1B,aAAa,CACd;QACD,cAAc,EAAE,UAAU,CAAC,WAAW,CACpC,MAAM,CAAC,cAAc,EACrB,eAAe,EACf,QAAQ,CAAC,cAAc,EACvB,aAAa,CACd;QACD,WAAW,EAAE,MAAM,CAAC,WAAW,IAAI,QAAQ,CAAC,WAAW;QACvD,eAAe,EAAE,oBAAoB,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3D,kBAAkB,EAAE,gBAAgB,CAAC,2BAA2B,CAC9D,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,sBAAsB,EAAE,aAAa,CAAC;YACjF,QAAQ,CAAC,kBAAkB,CAC9B;QACD,YAAY,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,eAAe,EAAE,aAAa,CAAC;QACpF,cAAc,EAAE;YACd,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC;YAC1C,GAAG,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,iBAAiB,EAAE,aAAa,CAAC,CAAC;SACvE;QACD,SAAS,EAAE;YACT,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC;YACrC,GAAG,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;SAClE;QACD,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,aAAa,CAAC,IAAI,KAAK;QACjF,OAAO,EAAE,OAAO,CAAC,IAAI;QACrB,UAAU,EAAE,OAAO,CAAC,UAAU;KAC/B,CAAC;AACJ,CAAC;AAgBD;;;;;;GAMG;AACH,MAAM,OAAO,cAAe,SAAQ,MAAsB;IACxD,MAAM,CAAC,QAAQ,GAAG;QAChB,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,WAAW;QACxB,WAAW,EAAE,oEAAoE;QACjF,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE;YACT,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,YAAY,CAAC,QAAQ;oBAC3B,KAAK,EAAE,MAAM;oBACb,WAAW,EAAE,eAAe;oBAC5B,WAAW,EAAE,qDAAqD;oBAClE,UAAU,EAAE,wBAAwB;oBACpC,MAAM,EAAE;wBACN,aAAa,EAAE,EAAE,GAAG,EAAE,wBAAwB,EAAE;wBAChD,aAAa,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE;qBACrC;iBACF;aACF;SACF;KACmC,CAAC;IAE/B,QAAQ,CAA0B;IAClC,OAAO,CAA2B;IAE1C,MAAM,CAAC,uBAAuB,CAAC,MAAsB;QACnD,IAAI,WAAW,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC,IAAI,KAAK,UAAU;YAAE,OAAO,EAAE,CAAC;QAChF,OAAO;YACL;gBACE,IAAI,EAAE,YAAY,CAAC,QAAQ;gBAC3B,KAAK,EAAE,MAAM;gBACb,WAAW,EAAE,eAAe;gBAC5B,WAAW,EAAE,qDAAqD;gBAClE,UAAU,EAAE,wBAAwB;gBACpC,MAAM,EAAE;oBACN,aAAa,EAAE,EAAE,GAAG,EAAE,wBAAwB,EAAE;oBAChD,aAAa,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE;iBACrC;gBACD,QAAQ,EAAE,IAAI;aACf;SACF,CAAC;IACJ,CAAC;IAEQ,KAAK,CAAC,KAAK;QAClB,IAAI,CAAC,QAAQ,GAAG,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEnD,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;QACxE,CAAC;aAAM,CAAC;YACN,MAAM,cAAc,GAAG,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YACrE,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,iBAAiB,CACjD,IAAI,CAAC,QAAQ,EACb,cAAc,EAAE,OAAO,EAAE,CAAC,IAAI,CAC/B,CAAC;YACF,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;YAChE,IAAI,CAAC,OAAO,GAAG,MAAM,gBAAgB,CAAC,sBAAsB,CAAC;gBAC3D,OAAO;gBACP,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC;gBAC/C,QAAQ,EAAE,iBAAiB;gBAC3B,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;gBAChC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;gBAC9C,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,iBAAiB;gBAClD,eAAe,EAAE,IAAI,CAAC,QAAQ,CAAC,eAAe;gBAC9C,kBAAkB,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB;gBACpD,cAAc,EAAE,IAAI,CAAC,QAAQ,CAAC,cAAc;gBAC5C,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW;gBACtC,iBAAiB,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;gBAC3D,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC;gBACvE,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO;gBAC9B,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO;aAC/B,CAAC,CAAC;YACH,2EAA2E;YAC3E,yEAAyE;YACzE,2EAA2E;YAC3E,kCAAkC;YAClC,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE;gBACrD,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,sEAAsE;gBACtE,gDAAgD;gBAChD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ;oBAAE,MAAM,oBAAoB,EAAE,CAAC;YAC1D,CAAC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM;YACpC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,iBAAiB;YAClD,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,YAAY,IAAI,IAAI;YAChD,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ;YAChC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO;YAC9B,kBAAkB,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB;YACpD,aAAa,EACX,IAAI,CAAC,QAAQ,CAAC,eAAe,GAAG,CAAC;gBAC/B,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,WAAW,EAAE;gBACvD,CAAC,CAAC,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,MAAM,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC;IAC9B,CAAC;IAED;;;;;;OAMG;IACK,eAAe;QACrB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,2DAA2D,CAAC,CAAC;YACzE,OAAO;QACT,CAAC;QACD,kBAAkB,CAAC,OAAO,EAAE;YAC1B,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE;YACpB,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,YAAY;YACxC,cAAc,EAAE,IAAI,CAAC,QAAQ,CAAC,cAAc;YAC5C,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;SACnC,CAAC,CAAC;IACL,CAAC;IAED,qFAAqF;IACrF,IAAY,QAAQ;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,eAAe,CAAC;IACjD,CAAC;IAEO,iBAAiB,CAAC,KAAa;QACrC,IAAI,IAAI,CAAC,MAAM,CAAC,iBAAiB;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC/E,OAAO,cAAc,CAAC,KAAK,CAAC,IAAI,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/E,CAAC;IAEQ,OAAO;QACd,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,OAAO;YACL,eAAe,EAAE,OAAO,EAAE,eAAe,IAAI,KAAK;YAClD,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE,CACnB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,IAAI,QAAQ,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;YAC1F,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;YAC7E,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAClB,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC;gBACxB,OAAO,CAAC,OAAO,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC;YACnF,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,OAAO,CAAC,OAAO,EAAE;SACnD,CAAC;IACJ,CAAC;;AAGH,SAAS,UAAU,CAAC,YAAqB;IACvC,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IAC9C,IAAI,CAAC,KAAK;QAAE,OAAO,kBAAkB,CAAC;IACtC,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;IAC9D,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC;IAClC,MAAM,KAAK,GAAG,IAAI,KAAK,WAAW,IAAI,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IACpE,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,MAAM,IAAI,EAAE,CAAC;AACjD,CAAC;AAED,kFAAkF;AAClF,MAAM,CAAC,MAAM,QAAQ,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC","sourcesContent":["/**\n * `authGate()` - the AppKit adapter around `@dbx-tools/auth`.\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 tunnel authorization, AppKit Lakebase discovery, email delivery, and\n * transport mounting. Better Auth owns users, OTPs, sessions, rate limits, and\n * passkeys. `createApp` can run this plugin with or without `server()`.\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 {\n  lakebase,\n  Plugin,\n  toPlugin,\n  type BasePluginConfig,\n  type PluginManifest,\n  type ResourceRequirement,\n  ResourceType,\n} from \"@databricks/appkit\";\nimport { plugin as appkitPlugin } from \"@dbx-tools/appkit\";\nimport {\n  auth as passwordlessAuth,\n  storage as authStorage,\n  type AuthorizeIdentity,\n  type AuthStorageConfig,\n  type AuthStorageMode,\n  type PasswordlessAuthRuntime,\n} from \"@dbx-tools/auth\";\nimport { config as coreConfig } from \"@dbx-tools/core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-auth\";\nimport { brand, log, string } from \"@dbx-tools/shared-core\";\nimport type { RequestHandler } from \"express\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { mountGate, type GateOptions } from \"./gate.ts\";\nimport { ensureEmailAvailable, sendCode as defaultSendCode } from \"./send-code.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\ninterface GateServerApplication {\n  get(path: string, handler: RequestHandler): unknown;\n  post(path: string, handler: RequestHandler): unknown;\n  use(path: string, handler: RequestHandler): unknown;\n}\n\ninterface GateMountContext {\n  addRoute(method: string, path: string, handler: RequestHandler): void;\n  addMiddleware(path: string, handler: RequestHandler): void;\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\nfunction serverApplication(context: GateMountContext): GateServerApplication | undefined {\n  const server = context.getPlugins().get(\"server\") as\n    { serverApplication?: Partial<GateServerApplication> } | undefined;\n  const application = server?.serverApplication;\n  return application &&\n    typeof application.get === \"function\" &&\n    typeof application.post === \"function\" &&\n    typeof application.use === \"function\"\n    ? (application as GateServerApplication)\n    : undefined;\n}\n\nexport function mountGateOnContext(context: GateMountContext, options: GateOptions): void {\n  const application = serverApplication(context);\n  if (application) {\n    mountGate(\n      options,\n      (method, path, handler) => application[method](path, handler),\n      (path, handler) => application.use(path, handler),\n    );\n    return;\n  }\n  mountGate(\n    options,\n    (method, path, handler) => context.addRoute(method, path, handler),\n    (path, handler) => context.addMiddleware(path, handler),\n  );\n}\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig, AuthStorageConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   *\n   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./code-email.ts`.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /**\n   * Same-origin path returned after a successful logout. Env\n   * `TUNNEL_AUTH_LOGOUT_REDIRECT`. Defaults to `/`, where the AuthGate presents\n   * login again.\n   */\n  logoutRedirectPath?: string;\n  /**\n   * Deliver a code to an address. Defaults to sending through the host app's\n   * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a\n   * different delivery path.\n   */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n  /**\n   * Identity authorization independent of authentication. Defaults to the\n   * configured allow-list and is re-evaluated for every accepted session.\n   */\n  authorizeIdentity?: AuthorizeIdentity;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`\n   * header. Only requests whose `Host` matches this are gated; everything else\n   * (the platform front door, other local callers) passes through. Env\n   * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel\n   * traffic).\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (literal / glob /\n   * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.\n   */\n  forwardHeaders?: string | string[];\n  /**\n   * Path prefixes to gate beyond the built-in `/api/` (literal prefixes, comma-\n   * or space-separated as a string). For an app whose privileged surface is not\n   * under `/api/` — e.g. a WebSocket at `/ws` — list those prefixes so they\n   * require a session too. Env `TUNNEL_GATE_PATHS`.\n   */\n  gatePaths?: string | string[];\n  /**\n   * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate\n   * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when\n   * the tunnel is deliberately public.\n   */\n  insecure?: boolean;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n  /** Same-origin path returned after logout. */\n  logoutRedirectPath: string;\n  /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */\n  publicDomain?: string;\n  /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */\n  forwardHeaders: string[];\n  /** Path prefixes to gate beyond `/api/` (e.g. `/ws`). */\n  gatePaths: string[];\n  /** Run OPEN with no gate. */\n  insecure: boolean;\n  storage: AuthStorageMode;\n  sqlitePath?: string;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName`; the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n  logoutRedirectPath: \"/\",\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  const storage = authStorage.resolveAuthStorageConfig({\n    storage:\n      config.storage ??\n      (coreConfig.text(\"AUTH_STORAGE\", TUNNEL_CONFIG) as AuthStorageMode | undefined),\n    sqlitePath: config.sqlitePath ?? coreConfig.text(\"AUTH_SQLITE_PATH\", TUNNEL_CONFIG),\n  });\n  return {\n    // Both sources are unioned rather than one overriding: a deployment-wide\n    // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.\n    // Hence `parseList` on each rather than `config.list`, which stops at the\n    // first source that yields anything.\n    allow: [\n      ...string.parseList(config.allow),\n      ...string.parseList(coreConfig.text([\"AUTH_ALLOW\", \"EMAIL_AUTH_ALLOW\"], TUNNEL_CONFIG)),\n    ],\n    subject: coreConfig.string(config.subject, \"AUTH_SUBJECT\", TUNNEL_CONFIG) ?? DEFAULTS.subject,\n    brandName:\n      coreConfig.string(config.brandName, \"AUTH_BRAND_NAME\", TUNNEL_CONFIG) ?? DEFAULTS.brandName,\n    message: coreConfig.string(config.message, \"AUTH_MESSAGE\", TUNNEL_CONFIG) ?? DEFAULTS.message,\n    sessionTtlSeconds: coreConfig.positiveInt(\n      config.sessionTtlSeconds,\n      \"AUTH_SESSION_TTL\",\n      DEFAULTS.sessionTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    codeTtlSeconds: coreConfig.positiveInt(\n      config.codeTtlSeconds,\n      \"AUTH_CODE_TTL\",\n      DEFAULTS.codeTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n    logoutRedirectPath: passwordlessAuth.normalizeLogoutRedirectPath(\n      coreConfig.string(config.logoutRedirectPath, \"AUTH_LOGOUT_REDIRECT\", TUNNEL_CONFIG) ??\n        DEFAULTS.logoutRedirectPath,\n    ),\n    publicDomain: coreConfig.string(config.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG),\n    forwardHeaders: [\n      ...string.parseList(config.forwardHeaders),\n      ...string.parseList(coreConfig.text(\"FORWARD_HEADERS\", TUNNEL_CONFIG)),\n    ],\n    gatePaths: [\n      ...string.parseList(config.gatePaths),\n      ...string.parseList(coreConfig.text(\"GATE_PATHS\", TUNNEL_CONFIG)),\n    ],\n    insecure: coreConfig.boolean(config.insecure, \"INSECURE\", TUNNEL_CONFIG) ?? false,\n    storage: storage.mode,\n    sqlitePath: storage.sqlitePath,\n  };\n}\n\n/** The handlers the gate middleware calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Better Auth and compatibility routes under `/api/email/auth/*`. */\n  handler(request: Request): Promise<Response>;\n  /** Resolve the authorized email for request headers, or undefined. */\n  session(headers: Headers): Promise<string | undefined>;\n  /** The gate status payload. */\n  status(headers: Headers): Promise<AuthStatus>;\n  /** Whether the runtime exposes passkey enrollment and authentication. */\n  readonly passkeysEnabled: boolean;\n  /** Close auth storage owned by this runtime. */\n  close(): Promise<void>;\n}\n\n/**\n * AppKit plugin adapting `@dbx-tools/auth` to tunnel traffic. On `setup()` it registers the login\n * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express\n * server via `this.context`, so a public portr caller must prove an email before\n * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and\n * other local callers pass through untouched (the gate keys on the `Host` header).\n */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Better Auth email OTP and passkey access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [\n        {\n          type: ResourceType.POSTGRES,\n          alias: \"auth\",\n          resourceKey: \"auth-database\",\n          description: \"Durable users, sessions, OTP records, and passkeys.\",\n          permission: \"CAN_CONNECT_AND_CREATE\",\n          fields: {\n            instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n            database_name: { env: \"PGDATABASE\" },\n          },\n        },\n      ],\n    },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private runtime?: PasswordlessAuthRuntime;\n\n  static getResourceRequirements(config: AuthGateConfig): ResourceRequirement[] {\n    if (authStorage.resolveAuthStorageConfig(config).mode !== \"lakebase\") return [];\n    return [\n      {\n        type: ResourceType.POSTGRES,\n        alias: \"auth\",\n        resourceKey: \"auth-database\",\n        description: \"Durable users, sessions, OTP records, and passkeys.\",\n        permission: \"CAN_CONNECT_AND_CREATE\",\n        fields: {\n          instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n          database_name: { env: \"PGDATABASE\" },\n        },\n        required: true,\n      },\n    ];\n  }\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n\n    if (this.resolved.insecure) {\n      logger.warn(\"insecure mode - the tunnel runs OPEN with no auth gate\");\n    } else {\n      const lakebasePlugin = appkitPlugin.instance(this.context, lakebase);\n      const storage = await authStorage.createAuthStorage(\n        this.resolved,\n        lakebasePlugin?.exports().pool,\n      );\n      const { key } = await signingKey(this.resolved.sessionCutoffMs);\n      this.runtime = await passwordlessAuth.createPasswordlessAuth({\n        storage,\n        baseURL: authOrigin(this.resolved.publicDomain),\n        basePath: \"/api/email/auth\",\n        appName: this.resolved.brandName,\n        secret: Buffer.from(key).toString(\"base64url\"),\n        sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n        sessionCutoffMs: this.resolved.sessionCutoffMs,\n        logoutRedirectPath: this.resolved.logoutRedirectPath,\n        codeTtlSeconds: this.resolved.codeTtlSeconds,\n        maxAttempts: this.resolved.maxAttempts,\n        authorizeIdentity: (email) => this.authorizeIdentity(email),\n        sendCode: (email, code, options) => this.sendCode(email, code, options),\n        subject: this.resolved.subject,\n        message: this.resolved.message,\n      });\n      // `server()` is deferred, so it does not exist during this plugin's setup.\n      // At `setup:complete` the Express app exists but has not injected plugin\n      // routes or static handling yet, which is the one point the gate can mount\n      // ahead of every protected route.\n      this.context?.onLifecycle(\"setup:complete\", async () => {\n        this.mountGateRoutes();\n        // Fail fast once the sibling email plugin has primed its transport: a\n        // gate that cannot email a code lets nobody in.\n        if (!this.config.sendCode) await ensureEmailAvailable();\n      });\n    }\n\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      publicDomain: this.resolved.publicDomain ?? null,\n      insecure: this.resolved.insecure,\n      storage: this.resolved.storage,\n      logoutRedirectPath: this.resolved.logoutRedirectPath,\n      sessionCutoff:\n        this.resolved.sessionCutoffMs > 0\n          ? new Date(this.resolved.sessionCutoffMs).toISOString()\n          : null,\n    });\n  }\n\n  async shutdown(): Promise<void> {\n    await this.runtime?.close();\n  }\n\n  /**\n   * Register the login routes (`/api/email/auth/*`) and the gating middleware on\n   * the app's OWN Express server. At `setup:complete`, the deferred server plugin\n   * has constructed its Express app but has not injected plugin routes or static\n   * handling, so direct registration puts the gate first. The context's buffered\n   * route API remains a fallback for compatible non-standard server plugins.\n   */\n  private mountGateRoutes(): void {\n    const context = this.context;\n    if (!context) {\n      logger.warn(\"no plugin context - the auth gate cannot mount its routes\");\n      return;\n    }\n    mountGateOnContext(context, {\n      gate: this.exports(),\n      publicDomain: this.resolved.publicDomain,\n      forwardHeaders: this.resolved.forwardHeaders,\n      gatePaths: this.resolved.gatePaths,\n    });\n  }\n\n  /** The code sender: the configured `sendCode`, else the shared-transport default. */\n  private get sendCode(): NonNullable<AuthGateConfig[\"sendCode\"]> {\n    return this.config.sendCode ?? defaultSendCode;\n  }\n\n  private authorizeIdentity(email: string): boolean | Promise<boolean> {\n    if (this.config.authorizeIdentity) return this.config.authorizeIdentity(email);\n    return looksLikeEmail(email) && matchesAllowlist(email, this.resolved.allow);\n  }\n\n  override exports(): AuthGateApi {\n    const runtime = this.runtime;\n    return {\n      passkeysEnabled: runtime?.passkeysEnabled ?? false,\n      handler: (request) =>\n        runtime?.handler(request) ?? Promise.resolve(new Response(\"Not Found\", { status: 404 })),\n      session: (headers) => runtime?.session(headers) ?? Promise.resolve(undefined),\n      status: (headers) =>\n        runtime?.status(headers) ??\n        Promise.resolve({ authenticated: false, enabled: false, passkeysEnabled: false }),\n      close: () => runtime?.close() ?? Promise.resolve(),\n    };\n  }\n}\n\nfunction authOrigin(publicDomain?: string): string {\n  const value = string.trimToNull(publicDomain);\n  if (!value) return \"http://localhost\";\n  if (/^https?:\\/\\//i.test(value)) return new URL(value).origin;\n  const host = value.split(\"/\")[0]!;\n  const local = host === \"localhost\" || host.startsWith(\"localhost:\");\n  return `${local ? \"http\" : \"https\"}://${host}`;\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 adapter around `@dbx-tools/auth`.\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 tunnel authorization, AppKit Lakebase discovery, email delivery, and\n * transport mounting. Better Auth owns users, OTPs, sessions, rate limits, and\n * passkeys. `createApp` can run this plugin with or without `server()`.\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 {\n  lakebase,\n  Plugin,\n  toPlugin,\n  type BasePluginConfig,\n  type PluginManifest,\n  type ResourceRequirement,\n  ResourceType,\n} from \"@databricks/appkit\";\nimport { plugin as appkitPlugin } from \"@dbx-tools/appkit\";\nimport {\n  auth as passwordlessAuth,\n  storage as authStorage,\n  type AuthorizeIdentity,\n  type AuthStorageConfig,\n  type AuthStorageMode,\n  type PasswordlessAuthRuntime,\n} from \"@dbx-tools/auth\";\nimport { config as coreConfig } from \"@dbx-tools/core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-auth\";\nimport { brand, log, string } from \"@dbx-tools/shared-core\";\nimport type { RequestHandler } from \"express\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { mountGate, type GateOptions } from \"./gate.ts\";\nimport { ensureEmailAvailable, sendCode as defaultSendCode } from \"./send-code.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\ninterface GateServerApplication {\n  get(path: string, handler: RequestHandler): unknown;\n  post(path: string, handler: RequestHandler): unknown;\n  use(path: string, handler: RequestHandler): unknown;\n}\n\ninterface GateMountContext {\n  addRoute(method: string, path: string, handler: RequestHandler): void;\n  addMiddleware(path: string, handler: RequestHandler): void;\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\nfunction serverApplication(context: GateMountContext): GateServerApplication | undefined {\n  const server = context.getPlugins().get(\"server\") as\n    { serverApplication?: Partial<GateServerApplication> } | undefined;\n  const application = server?.serverApplication;\n  return application &&\n    typeof application.get === \"function\" &&\n    typeof application.post === \"function\" &&\n    typeof application.use === \"function\"\n    ? (application as GateServerApplication)\n    : undefined;\n}\n\nexport function mountGateOnContext(context: GateMountContext, options: GateOptions): void {\n  const application = serverApplication(context);\n  if (application) {\n    mountGate(\n      options,\n      (method, path, handler) => application[method](path, handler),\n      (path, handler) => application.use(path, handler),\n    );\n    return;\n  }\n  mountGate(\n    options,\n    (method, path, handler) => context.addRoute(method, path, handler),\n    (path, handler) => context.addMiddleware(path, handler),\n  );\n}\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig, AuthStorageConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   *\n   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./code-email.ts`.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /**\n   * Same-origin path returned after a successful logout. Env\n   * `TUNNEL_AUTH_LOGOUT_REDIRECT`. Defaults to `/`, where the AuthGate presents\n   * login again.\n   */\n  logoutRedirectPath?: string;\n  /**\n   * Deliver a code to an address. Defaults to sending through the host app's\n   * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a\n   * different delivery path.\n   */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n  /**\n   * Identity authorization independent of authentication. Defaults to the\n   * configured allow-list and is re-evaluated for every accepted session.\n   */\n  authorizeIdentity?: AuthorizeIdentity;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`\n   * header. Only requests whose `Host` matches this are gated; everything else\n   * (the platform front door, other local callers) passes through. Env\n   * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel\n   * traffic).\n   */\n  publicDomain?: string;\n  /** Additional public tunnel domains accepted by the gate. */\n  publicDomains?: string | string[];\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (literal / glob /\n   * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.\n   */\n  forwardHeaders?: string | string[];\n  /**\n   * Path prefixes to gate beyond the built-in `/api/` (literal prefixes, comma-\n   * or space-separated as a string). For an app whose privileged surface is not\n   * under `/api/` — e.g. a WebSocket at `/ws` — list those prefixes so they\n   * require a session too. Env `TUNNEL_GATE_PATHS`.\n   */\n  gatePaths?: string | string[];\n  /**\n   * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate\n   * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when\n   * the tunnel is deliberately public.\n   */\n  insecure?: boolean;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n  /** Same-origin path returned after logout. */\n  logoutRedirectPath: string;\n  /** Primary public domain; `undefined` when Portr is not configured. */\n  publicDomain?: string;\n  /** All public tunnel domains accepted by the gate. */\n  publicDomains: string[];\n  /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */\n  forwardHeaders: string[];\n  /** Path prefixes to gate beyond `/api/` (e.g. `/ws`). */\n  gatePaths: string[];\n  /** Run OPEN with no gate. */\n  insecure: boolean;\n  storage: AuthStorageMode;\n  sqlitePath?: string;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName`; the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n  logoutRedirectPath: \"/\",\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  const storage = authStorage.resolveAuthStorageConfig({\n    storage:\n      config.storage ??\n      (coreConfig.text(\"AUTH_STORAGE\", TUNNEL_CONFIG) as AuthStorageMode | undefined),\n    sqlitePath: config.sqlitePath ?? coreConfig.text(\"AUTH_SQLITE_PATH\", TUNNEL_CONFIG),\n  });\n  const publicDomain = coreConfig.string(config.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG);\n  const frpPublicDomain = coreConfig.text(\"FRP_PUBLIC_DOMAIN\", TUNNEL_CONFIG);\n  return {\n    // Both sources are unioned rather than one overriding: a deployment-wide\n    // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.\n    // Hence `parseList` on each rather than `config.list`, which stops at the\n    // first source that yields anything.\n    allow: [\n      ...string.parseList(config.allow),\n      ...string.parseList(coreConfig.text([\"AUTH_ALLOW\", \"EMAIL_AUTH_ALLOW\"], TUNNEL_CONFIG)),\n    ],\n    subject: coreConfig.string(config.subject, \"AUTH_SUBJECT\", TUNNEL_CONFIG) ?? DEFAULTS.subject,\n    brandName:\n      coreConfig.string(config.brandName, \"AUTH_BRAND_NAME\", TUNNEL_CONFIG) ?? DEFAULTS.brandName,\n    message: coreConfig.string(config.message, \"AUTH_MESSAGE\", TUNNEL_CONFIG) ?? DEFAULTS.message,\n    sessionTtlSeconds: coreConfig.positiveInt(\n      config.sessionTtlSeconds,\n      \"AUTH_SESSION_TTL\",\n      DEFAULTS.sessionTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    codeTtlSeconds: coreConfig.positiveInt(\n      config.codeTtlSeconds,\n      \"AUTH_CODE_TTL\",\n      DEFAULTS.codeTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n    logoutRedirectPath: passwordlessAuth.normalizeLogoutRedirectPath(\n      coreConfig.string(config.logoutRedirectPath, \"AUTH_LOGOUT_REDIRECT\", TUNNEL_CONFIG) ??\n        DEFAULTS.logoutRedirectPath,\n    ),\n    publicDomain,\n    publicDomains: [\n      ...new Set(\n        [\n          publicDomain,\n          frpPublicDomain,\n          ...string.parseList(config.publicDomains),\n        ].filter((value): value is string => !!value),\n      ),\n    ],\n    forwardHeaders: [\n      ...string.parseList(config.forwardHeaders),\n      ...string.parseList(coreConfig.text(\"FORWARD_HEADERS\", TUNNEL_CONFIG)),\n    ],\n    gatePaths: [\n      ...string.parseList(config.gatePaths),\n      ...string.parseList(coreConfig.text(\"GATE_PATHS\", TUNNEL_CONFIG)),\n    ],\n    insecure: coreConfig.boolean(config.insecure, \"INSECURE\", TUNNEL_CONFIG) ?? false,\n    storage: storage.mode,\n    sqlitePath: storage.sqlitePath,\n  };\n}\n\n/** The handlers the gate middleware calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Better Auth and compatibility routes under `/api/email/auth/*`. */\n  handler(request: Request): Promise<Response>;\n  /** Resolve the authorized email for request headers, or undefined. */\n  session(headers: Headers): Promise<string | undefined>;\n  /** The gate status payload. */\n  status(headers: Headers): Promise<AuthStatus>;\n  /** Whether the runtime exposes passkey enrollment and authentication. */\n  readonly passkeysEnabled: boolean;\n  /** Close auth storage owned by this runtime. */\n  close(): Promise<void>;\n}\n\n/**\n * AppKit plugin adapting `@dbx-tools/auth` to tunnel traffic. On `setup()` it registers the login\n * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express\n * server via `this.context`, so a public portr caller must prove an email before\n * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and\n * other local callers pass through untouched (the gate keys on the `Host` header).\n */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Better Auth email OTP and passkey access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [\n        {\n          type: ResourceType.POSTGRES,\n          alias: \"auth\",\n          resourceKey: \"auth-database\",\n          description: \"Durable users, sessions, OTP records, and passkeys.\",\n          permission: \"CAN_CONNECT_AND_CREATE\",\n          fields: {\n            instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n            database_name: { env: \"PGDATABASE\" },\n          },\n        },\n      ],\n    },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private runtime?: PasswordlessAuthRuntime;\n\n  static getResourceRequirements(config: AuthGateConfig): ResourceRequirement[] {\n    if (authStorage.resolveAuthStorageConfig(config).mode !== \"lakebase\") return [];\n    return [\n      {\n        type: ResourceType.POSTGRES,\n        alias: \"auth\",\n        resourceKey: \"auth-database\",\n        description: \"Durable users, sessions, OTP records, and passkeys.\",\n        permission: \"CAN_CONNECT_AND_CREATE\",\n        fields: {\n          instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n          database_name: { env: \"PGDATABASE\" },\n        },\n        required: true,\n      },\n    ];\n  }\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n\n    if (this.resolved.insecure) {\n      logger.warn(\"insecure mode - the tunnel runs OPEN with no auth gate\");\n    } else {\n      const lakebasePlugin = appkitPlugin.instance(this.context, lakebase);\n      const storage = await authStorage.createAuthStorage(\n        this.resolved,\n        lakebasePlugin?.exports().pool,\n      );\n      const { key } = await signingKey(this.resolved.sessionCutoffMs);\n      this.runtime = await passwordlessAuth.createPasswordlessAuth({\n        storage,\n        baseURL: authOrigin(this.resolved.publicDomain),\n        basePath: \"/api/email/auth\",\n        appName: this.resolved.brandName,\n        secret: Buffer.from(key).toString(\"base64url\"),\n        sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n        sessionCutoffMs: this.resolved.sessionCutoffMs,\n        logoutRedirectPath: this.resolved.logoutRedirectPath,\n        codeTtlSeconds: this.resolved.codeTtlSeconds,\n        maxAttempts: this.resolved.maxAttempts,\n        authorizeIdentity: (email) => this.authorizeIdentity(email),\n        sendCode: (email, code, options) => this.sendCode(email, code, options),\n        subject: this.resolved.subject,\n        message: this.resolved.message,\n      });\n      // `server()` is deferred, so it does not exist during this plugin's setup.\n      // At `setup:complete` the Express app exists but has not injected plugin\n      // routes or static handling yet, which is the one point the gate can mount\n      // ahead of every protected route.\n      this.context?.onLifecycle(\"setup:complete\", async () => {\n        this.mountGateRoutes();\n        // Fail fast once the sibling email plugin has primed its transport: a\n        // gate that cannot email a code lets nobody in.\n        if (!this.config.sendCode) await ensureEmailAvailable();\n      });\n    }\n\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      publicDomains: this.resolved.publicDomains,\n      insecure: this.resolved.insecure,\n      storage: this.resolved.storage,\n      logoutRedirectPath: this.resolved.logoutRedirectPath,\n      sessionCutoff:\n        this.resolved.sessionCutoffMs > 0\n          ? new Date(this.resolved.sessionCutoffMs).toISOString()\n          : null,\n    });\n  }\n\n  async shutdown(): Promise<void> {\n    await this.runtime?.close();\n  }\n\n  /**\n   * Register the login routes (`/api/email/auth/*`) and the gating middleware on\n   * the app's OWN Express server. At `setup:complete`, the deferred server plugin\n   * has constructed its Express app but has not injected plugin routes or static\n   * handling, so direct registration puts the gate first. The context's buffered\n   * route API remains a fallback for compatible non-standard server plugins.\n   */\n  private mountGateRoutes(): void {\n    const context = this.context;\n    if (!context) {\n      logger.warn(\"no plugin context - the auth gate cannot mount its routes\");\n      return;\n    }\n    mountGateOnContext(context, {\n      gate: this.exports(),\n      publicDomain: this.resolved.publicDomains,\n      forwardHeaders: this.resolved.forwardHeaders,\n      gatePaths: this.resolved.gatePaths,\n    });\n  }\n\n  /** The code sender: the configured `sendCode`, else the shared-transport default. */\n  private get sendCode(): NonNullable<AuthGateConfig[\"sendCode\"]> {\n    return this.config.sendCode ?? defaultSendCode;\n  }\n\n  private authorizeIdentity(email: string): boolean | Promise<boolean> {\n    if (this.config.authorizeIdentity) return this.config.authorizeIdentity(email);\n    return looksLikeEmail(email) && matchesAllowlist(email, this.resolved.allow);\n  }\n\n  override exports(): AuthGateApi {\n    const runtime = this.runtime;\n    return {\n      passkeysEnabled: runtime?.passkeysEnabled ?? false,\n      handler: (request) =>\n        runtime?.handler(request) ?? Promise.resolve(new Response(\"Not Found\", { status: 404 })),\n      session: (headers) => runtime?.session(headers) ?? Promise.resolve(undefined),\n      status: (headers) =>\n        runtime?.status(headers) ??\n        Promise.resolve({ authenticated: false, enabled: false, passkeysEnabled: false }),\n      close: () => runtime?.close() ?? Promise.resolve(),\n    };\n  }\n}\n\nfunction authOrigin(publicDomain?: string): string {\n  const value = string.trimToNull(publicDomain);\n  if (!value) return \"http://localhost\";\n  if (/^https?:\\/\\//i.test(value)) return new URL(value).origin;\n  const host = value.split(\"/\")[0]!;\n  const local = host === \"localhost\" || host.startsWith(\"localhost:\");\n  return `${local ? \"http\" : \"https\"}://${host}`;\n}\n\n/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */\nexport const authGate = toPlugin(AuthGatePlugin);\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/_config.ts","../src/allowlist.ts","../src/code-email.ts","../src/gate.ts","../src/headers.ts","../src/interceptor.ts","../src/login-page.ts","../src/plugin.ts","../src/portr.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/frp.ts","../src/gate.ts","../src/headers.ts","../src/interceptor.ts","../src/login-page.ts","../src/plugin.ts","../src/portr.ts","../src/send-code.ts","../src/signing-key.ts","../index.ts"],"version":"5.9.3"}

package/package.json

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

package/src/frp.ts

@@ -0,0 +1,183 @@
+/**
+ * Install and run an frp client (`frpc`) for a public HTTP tunnel.
+ *
+ * The defaults match the deployment shape used by inspire-mediamix: a single
+ * TLS-terminating host is both the WSS control endpoint and the HTTP custom
+ * domain. Callers may point `server` somewhere else when frps is exposed on a
+ * separate control host.
+ *
+ * @module
+ */
+
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import { delimiter, join } from "node:path";
+
+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:frp");
+const FRP_VERSION = "0.68.1";
+const FRP_RELEASE_URL = `https://github.com/fatedier/frp/releases/download/v${FRP_VERSION}`;
+
+/** Options for installing the frpc executable. */
+export interface FrpInstallOptions {
+  /** Home directory containing `.frpc`; defaults to the OS home directory. */
+  homeDir?: string;
+}
+
+/** Resolved frpc wiring, or `undefined` when no FRP tunnel is configured. */
+export interface FrpConfig {
+  publicDomain: string;
+  server: string;
+  serverPort: number;
+  protocol: string;
+  token?: string;
+  proxyName: string;
+  port: number;
+}
+
+function bareHost(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const normalized = value.replace(/^https?:\/\//, "").split("/")[0]?.trim();
+  return normalized || undefined;
+}
+
+/** Resolve frpc config from the public domain and FRP-specific environment. */
+export function resolveFrpConfig(opts: {
+  publicDomain?: string;
+  server?: string;
+  serverPort?: string | number;
+  protocol?: string;
+  token?: string;
+  proxyName?: string;
+  port: number;
+}): FrpConfig | undefined {
+  const publicDomain = bareHost(
+    config.string(
+      opts.publicDomain,
+      ["FRP_PUBLIC_DOMAIN", "PUBLIC_DOMAIN"],
+      TUNNEL_CONFIG,
+    ),
+  );
+  if (!publicDomain) return undefined;
+  const server = bareHost(config.string(opts.server, "FRP_SERVER")) ?? publicDomain;
+  const serverPort = config.port(opts.serverPort, "FRP_SERVER_PORT", 443);
+  const protocol = config.string(opts.protocol, "FRP_PROTOCOL") ?? "wss";
+  const token = config.string(opts.token, ["FRP_TOKEN", "TUNNEL_TOKEN"]);
+  const proxyName =
+    config.string(opts.proxyName, "FRP_PROXY_NAME") ?? publicDomain.split(".")[0] ?? "app";
+  return {
+    publicDomain,
+    server,
+    serverPort,
+    protocol,
+    ...(token ? { token } : {}),
+    proxyName,
+    port: opts.port,
+  };
+}
+
+/** GitHub release asset name for the current or supplied OS/architecture. */
+export function frpAssetName(
+  version: string,
+  platform: NodeJS.Platform = process.platform,
+  arch: string = process.arch,
+): string {
+  const osName = platform === "darwin" ? "darwin" : platform === "linux" ? "linux" : undefined;
+  const archName = arch === "arm64" ? "arm64" : arch === "x64" ? "amd64" : undefined;
+  if (!osName || !archName) {
+    throw new Error(`frp has no supported release asset for ${platform}/${arch}`);
+  }
+  return `frp_${version}_${osName}_${archName}.tar.gz`;
+}
+
+function frpDownloadUrl(): string {
+  const assetName = frpAssetName(FRP_VERSION);
+  logger.info("installing frpc", { version: FRP_VERSION, asset: assetName });
+  return `${FRP_RELEASE_URL}/${assetName}`;
+}
+
+async function selectFrpc(source: string): Promise<string> {
+  const path = join(source, frpArchiveDirectory(), "frpc");
+  if (process.platform === "darwin") {
+    await new Promise<void>((resolve, reject) => {
+      const signer = spawn("codesign", ["--force", "--sign", "-", path], { stdio: "ignore" });
+      signer.once("error", reject);
+      signer.once("exit", (code) =>
+        code === 0 ? resolve() : reject(new Error(`codesign exited with code ${code}`)),
+      );
+    });
+  }
+  return path;
+}
+
+/** Install frpc when absent and return the environment used by its process. */
+export async function installFrp(options: FrpInstallOptions = {}): Promise<NodeJS.ProcessEnv> {
+  const homeDir = options.homeDir ?? os.homedir();
+  const context = await bin.ensure("frpc", frpDownloadUrl, {
+    autoUnpackage: true,
+    homeDir,
+    minVersion: FRP_VERSION,
+    selector: ({ source }) => selectFrpc(source),
+    versionParser: ({ stdout, stderr }) => {
+      const version = bin.parseVersion({ stdout, stderr });
+      return version === FRP_VERSION ? version : undefined;
+    },
+  });
+  return {
+    ...process.env,
+    HOME: homeDir,
+    PATH: [context.binDir, process.env.PATH ?? ""].join(delimiter),
+  };
+}
+
+function frpArchiveDirectory(
+  platform: NodeJS.Platform = process.platform,
+  arch: string = process.arch,
+): string {
+  return frpAssetName(FRP_VERSION, platform, arch).replace(/\.tar\.gz$/, "");
+}
+
+function tomlString(value: string): string {
+  return JSON.stringify(value);
+}
+
+/** Render `~/.frpc/frpc.toml` for the resolved tunnel. */
+export async function writeFrpConfig(
+  resolved: FrpConfig,
+  childEnv: NodeJS.ProcessEnv,
+): Promise<string> {
+  const directory = join(childEnv.HOME ?? os.homedir(), ".frpc");
+  const path = join(directory, "frpc.toml");
+  await mkdir(directory, { recursive: true });
+  const lines = [
+    `serverAddr = ${tomlString(resolved.server)}`,
+    `serverPort = ${resolved.serverPort}`,
+    `transport.protocol = ${tomlString(resolved.protocol)}`,
+  ];
+  if (resolved.token) lines.push(`auth.token = ${tomlString(resolved.token)}`);
+  lines.push(
+    "",
+    "[[proxies]]",
+    `name = ${tomlString(resolved.proxyName)}`,
+    'type = "http"',
+    `localPort = ${resolved.port}`,
+    `customDomains = [${tomlString(resolved.publicDomain)}]`,
+    "",
+  );
+  await writeFile(path, lines.join("\n"));
+  return path;
+}
+
+/** Launch frpc as a child process (caller supervises and terminates it). */
+export function startFrp(
+  resolved: FrpConfig,
+  childEnv: NodeJS.ProcessEnv,
+  configPath: string,
+): ReturnType<typeof spawn> {
+  logger.info(`frpc tunneling https://${resolved.publicDomain} -> :${resolved.port}`);
+  return spawn("frpc", ["-c", configPath], { env: childEnv, stdio: "inherit" });
+}