@dbx-tools/cli-tunnel 0.6.46 → 0.6.47

package/README.md

@@ -1 +1,167 @@
-# replace this
+# @dbx-tools/cli-tunnel
+
+Front an app with a public tunnel and an email one-time-code access gate.
+
+Built on [portr](https://github.com/amalshaji/portr). Run this CLI when an app
+needs to be reachable from outside its network - a stakeholder demo, a webhook
+sender that has to reach a dev build, an OAuth redirect that cannot point at
+`localhost` - without publishing the app to anyone who learns the URL. It is
+shaped for Databricks Apps (it honours the `DATABRICKS_APP_PORT` contract and
+lets the platform's own front door through ungated) but the gate itself is
+platform-neutral. The CLI wraps the app's real start command: it
+moves the app onto a private loopback port, binds the public port with a gate
+proxy, and brings the tunnel up alongside it. Access is granted per email
+address against an allow-list, verified by a code sent over
+[`@dbx-tools/email`](../../node/email).
+
+**Key features:**
+
+- Wraps an unmodified start command - everything after `--` runs as-is, so the
+  app needs no tunnel-specific code:
+  `dbxt-tunnel --allow example.com -- bun src/server.ts`.
+- Branded from the repo-wide brand context: the code email's accent colour, font,
+  logo, and display name come from the app's own `branding/brand.yaml` (via
+  `@dbx-tools/core`'s `loadBrandContext()`), falling back to the dbx-tools
+  default - so the sign-in email looks like the app it fronts with nothing to
+  configure. `--brand-name` overrides just the name.
+- Conventional one-time-code copy, so platform autofill works: the email is
+  `Your verification code is: / <code> / This code expires in N minutes`, and the
+  code input carries `autocomplete="one-time-code"`. iOS, Gmail, Outlook, and
+  Android detect a code from that shape and offer it directly from the
+  notification; novel phrasing is what breaks the detection. Both MIME parts carry
+  the code as visible text, never an image.
+- Email one-time-code gate: a 6-digit code stored as a SHA-256 hash with an
+  attempt counter, verified in constant time, in AppKit's `CacheManager` (memory
+  by default, Lakebase when the app configures persistent `CacheStorage`) so TTL
+  expiry and eviction are the cache's job.
+- Short-lived HS256 session JWT (via `jose`) carrying only the email, signed with
+  `AUTH_JWT_SECRET`.
+- Allow-list patterns in three shapes, matched in order: a domain shortcut
+  (`example.com`, `@example.com`), a shell-style glob (`*@example.com`), or a
+  regex literal (`/^ops-.*@example\.com$/`). An empty list allows nobody.
+- Per-email and per-IP fixed-window rate limiting, plus anti-enumeration: a code
+  request always answers `{ ok: true }`, whether or not the address is allowed.
+- Platform traffic passes through UNGATED. The gate distinguishes the portr
+  client (a loopback source address, same container) from the hosting platform's
+  front door (a non-loopback container-network address), so health checks and the
+  workspace UI keep working while public tunnel traffic is gated.
+- SPA-aware gating: static assets and the login routes stay open so the browser
+  can load the client and render the login form; every other `/api/*` needs a
+  valid session cookie or gets `401`. WebSocket upgrades are gated the same way.
+- Supervised teardown - the app child, the portr child, and this process are tied
+  together, so if any one exits the whole tunnel comes down.
+- Fails fast when email is not configured for SMTP, because a gate that cannot
+  send codes locks everyone out. `--insecure` is the explicit opt-out.
+
+## Why This Over An Ad-Hoc Tunnel
+
+A bare tunnel (`ngrok`, `portr` on its own) makes the app reachable by anyone
+with the URL. This package keeps the tunnel but puts a gate in front of it,
+reusing what the app already has: AppKit's cache for code storage, the
+`@dbx-tools/email` transport for delivery, and the app's own `From` policy. There
+is nothing to add to the app itself - no route, no middleware, no auth library.
+
+## Run It
+
+```sh
+dbxt-tunnel \
+  --allow "example.com, *@partner.example" \
+  --brand-name "Acme Ops" \
+  -- bun src/server.ts
+```
+
+The package installs two equivalent commands, `dbx-tools-tunnel` and the shorter
+`dbxt-tunnel`. Neither matches the package name, so a one-off run has to name the
+command explicitly:
+
+```sh
+npx --package @dbx-tools/cli-tunnel dbx-tools-tunnel --help
+```
+
+Everything after `--` is the real start command. The CLI sets
+`DATABRICKS_APP_PORT` to a random private port for that child and binds the
+original public port itself.
+
+## Options
+
+Every flag has an environment fallback, so a deployment can configure the gate
+with no change to its start command.
+
+| Flag              | Env                | Default                      |
+| ----------------- | ------------------ | ---------------------------- |
+| `--allow`         | `EMAIL_AUTH_ALLOW` | empty (allow nobody)         |
+| `--subject`       | `AUTH_SUBJECT`     | `Your verification code`     |
+| `--brand-name`    | `AUTH_BRAND_NAME`  | the brand context `name`     |
+| `--message`       | `AUTH_MESSAGE`     | `Your verification code is:` |
+| `--session-ttl`   | `AUTH_SESSION_TTL` | `43200` (12 hours)           |
+| `--code-ttl`      | `AUTH_CODE_TTL`    | `600` (10 minutes)           |
+| `--subdomain`     | -                  | derived from `PUBLIC_DOMAIN` |
+| `--public-domain` | `PUBLIC_DOMAIN`    | -                            |
+| `--insecure`      | `TUNNEL_INSECURE`  | off (the gate is required)   |
+
+`--allow` and `EMAIL_AUTH_ALLOW` are UNIONED rather than one overriding the
+other, so a deployment-wide allow-list and a per-invocation addition both grant
+access. Session signing reads `AUTH_JWT_SECRET`; when it is unset the gate mints
+an ephemeral per-process key, so sessions simply do not survive a restart rather
+than the gate refusing to serve.
+
+## Use The Gate As A Plugin
+
+The gate is an AppKit plugin, so an app that wants the OTP flow without the
+tunnel can mount it directly. It registers no routes - it exposes handlers the
+caller invokes - and it takes a `sendCode` callback because delivering mail is
+the one thing it cannot resolve on its own:
+
+```ts
+import { createApp } from "@dbx-tools/appkit";
+import { authGate } from "@dbx-tools/cli-tunnel/plugin";
+import { brand, email, sender, transport } from "@dbx-tools/email";
+
+const handle = await createApp({
+  plugins: [
+    email({ brand: brand.defaultEmailBrand }),
+    authGate({
+      allow: ["example.com"],
+      sendCode: async (to, code, opts) => {
+        const runtime = transport.getEmailRuntime();
+        await transport.sendEmail(
+          {
+            to: [to],
+            subject: opts.subject,
+            body: `${opts.message}\n\n## ${code}`,
+          },
+          // The app's configured sender; a code email has no on-behalf-of user.
+          sender.resolveSenderAddress(runtime.config, undefined),
+        );
+      },
+    }),
+  ],
+});
+
+// The gate exposes handlers rather than routes - call them from your own server.
+const status = await handle.authGate.status(sessionCookieValue);
+```
+
+`sendCode` is the one thing the plugin cannot resolve on its own. When the tunnel
+CLI boots the gate it wires this same callback, and derives the email styling from
+the brand context, so mounting the plugin directly is the only case that needs it
+by hand.
+
+## Modules
+
+- `cli` - argv parsing, the wrapped-command split at `--`, and process
+  supervision.
+- `plugin` - `authGate()`, its config/env resolution, and the `AuthGateApi`
+  handlers the proxy calls in-process.
+- `proxy` - the public-port reverse proxy: loopback-vs-platform classification,
+  open login routes, session enforcement, and WebSocket forwarding.
+- `otp` - the `CacheManager`-backed code store and the session JWT.
+- `allowlist` - domain / glob / regex matching and `looksLikeEmail`.
+- `rate-limit` - the in-memory fixed-window limiter (single-instance only; not
+  distributed).
+- `portr` - portr install, config rendering, and child launch.
+- `app` - boots the minimal gate AppKit app and returns the `AuthGateApi`.
+
+Browser-safe login wire schemas (the request/verify payloads and the session
+cookie name) live in [`@dbx-tools/shared-email`](../../shared/email); the React
+login surface is in [`@dbx-tools/ui-email`](../../ui/email).

package/bin/dbx-tools-tunnel.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * `dbx-tools-tunnel` / `dbxt-tunnel` entry: front a Databricks App with a public
+ * `dbx-tools-tunnel` / `dbxt-tunnel` entry: front an app with a public
  * portr tunnel + email-OTP gate, wrapping the start command after `--`.
  * Delegates to the commander program in `../src/cli`.
  */

package/lib/bin/dbx-tools-tunnel.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * `dbx-tools-tunnel` / `dbxt-tunnel` entry: front a Databricks App with a public
+ * `dbx-tools-tunnel` / `dbxt-tunnel` entry: front an app with a public
  * portr tunnel + email-OTP gate, wrapping the start command after `--`.
  * Delegates to the commander program in `../src/cli`.
  */
@@ -11,4 +11,4 @@ runCli(process.argv).catch((err) => {
     process.stderr.write(`${err instanceof Error ? (err.stack ?? err.message) : String(err)}\n`);
     process.exit(1);
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGJ4LXRvb2xzLXR1bm5lbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2Jpbi9kYngtdG9vbHMtdHVubmVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFDQTs7OztHQUlHO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFdkQsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFZLEVBQUUsRUFBRTtJQUMxQyxJQUFJLEdBQUcsWUFBWSxjQUFjO1FBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUQsT0FBTyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxHQUFHLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxLQUFLLElBQUksR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzdGLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbEIsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIjIS91c3IvYmluL2VudiBub2RlXG4vKipcbiAqIGBkYngtdG9vbHMtdHVubmVsYCAvIGBkYnh0LXR1bm5lbGAgZW50cnk6IGZyb250IGEgRGF0YWJyaWNrcyBBcHAgd2l0aCBhIHB1YmxpY1xuICogcG9ydHIgdHVubmVsICsgZW1haWwtT1RQIGdhdGUsIHdyYXBwaW5nIHRoZSBzdGFydCBjb21tYW5kIGFmdGVyIGAtLWAuXG4gKiBEZWxlZ2F0ZXMgdG8gdGhlIGNvbW1hbmRlciBwcm9ncmFtIGluIGAuLi9zcmMvY2xpYC5cbiAqL1xuaW1wb3J0IHsgQ29tbWFuZGVyRXJyb3IsIHJ1bkNsaSB9IGZyb20gXCIuLi9zcmMvY2xpLnRzXCI7XG5cbnJ1bkNsaShwcm9jZXNzLmFyZ3YpLmNhdGNoKChlcnI6IHVua25vd24pID0+IHtcbiAgaWYgKGVyciBpbnN0YW5jZW9mIENvbW1hbmRlckVycm9yKSBwcm9jZXNzLmV4aXQoZXJyLmV4aXRDb2RlKTtcbiAgcHJvY2Vzcy5zdGRlcnIud3JpdGUoYCR7ZXJyIGluc3RhbmNlb2YgRXJyb3IgPyAoZXJyLnN0YWNrID8/IGVyci5tZXNzYWdlKSA6IFN0cmluZyhlcnIpfVxcbmApO1xuICBwcm9jZXNzLmV4aXQoMSk7XG59KTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGJ4LXRvb2xzLXR1bm5lbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2Jpbi9kYngtdG9vbHMtdHVubmVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFDQTs7OztHQUlHO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFdkQsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFZLEVBQUUsRUFBRTtJQUMxQyxJQUFJLEdBQUcsWUFBWSxjQUFjO1FBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUQsT0FBTyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxHQUFHLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxLQUFLLElBQUksR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzdGLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbEIsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIjIS91c3IvYmluL2VudiBub2RlXG4vKipcbiAqIGBkYngtdG9vbHMtdHVubmVsYCAvIGBkYnh0LXR1bm5lbGAgZW50cnk6IGZyb250IGFuIGFwcCB3aXRoIGEgcHVibGljXG4gKiBwb3J0ciB0dW5uZWwgKyBlbWFpbC1PVFAgZ2F0ZSwgd3JhcHBpbmcgdGhlIHN0YXJ0IGNvbW1hbmQgYWZ0ZXIgYC0tYC5cbiAqIERlbGVnYXRlcyB0byB0aGUgY29tbWFuZGVyIHByb2dyYW0gaW4gYC4uL3NyYy9jbGlgLlxuICovXG5pbXBvcnQgeyBDb21tYW5kZXJFcnJvciwgcnVuQ2xpIH0gZnJvbSBcIi4uL3NyYy9jbGkudHNcIjtcblxucnVuQ2xpKHByb2Nlc3MuYXJndikuY2F0Y2goKGVycjogdW5rbm93bikgPT4ge1xuICBpZiAoZXJyIGluc3RhbmNlb2YgQ29tbWFuZGVyRXJyb3IpIHByb2Nlc3MuZXhpdChlcnIuZXhpdENvZGUpO1xuICBwcm9jZXNzLnN0ZGVyci53cml0ZShgJHtlcnIgaW5zdGFuY2VvZiBFcnJvciA/IChlcnIuc3RhY2sgPz8gZXJyLm1lc3NhZ2UpIDogU3RyaW5nKGVycil9XFxuYCk7XG4gIHByb2Nlc3MuZXhpdCgxKTtcbn0pO1xuIl19

package/lib/src/allowlist.d.ts

@@ -3,11 +3,11 @@
  *
  * Each pattern in the configured list is one of three shapes, tried in order:
  *
- *   - **domain shortcut** - `databricks.com` or `@databricks.com`: matches any
+ *   - **domain shortcut** - `example.com` or `@example.com`: matches any
  *     address whose domain equals it (case-insensitive). The leading `@` is
  *     optional and stripped.
- *   - **glob** - contains `*` or `?`, e.g. `*.databricks.com` or
- *     `*@databricks.com`: matched against the WHOLE address with shell-style
+ *   - **glob** - contains `*` or `?`, e.g. `*.example.com` or
+ *     `*@example.com`: matched against the WHOLE address with shell-style
  *     wildcards (`*` = any run, `?` = one char).
  *   - **regex** - wrapped in slashes, `/.../ [flags]`: compiled and tested
  *     against the whole address. An invalid regex never matches (it is skipped

package/lib/src/allowlist.js

@@ -3,11 +3,11 @@
  *
  * Each pattern in the configured list is one of three shapes, tried in order:
  *
- *   - **domain shortcut** - `databricks.com` or `@databricks.com`: matches any
+ *   - **domain shortcut** - `example.com` or `@example.com`: matches any
  *     address whose domain equals it (case-insensitive). The leading `@` is
  *     optional and stripped.
- *   - **glob** - contains `*` or `?`, e.g. `*.databricks.com` or
- *     `*@databricks.com`: matched against the WHOLE address with shell-style
+ *   - **glob** - contains `*` or `?`, e.g. `*.example.com` or
+ *     `*@example.com`: matched against the WHOLE address with shell-style
  *     wildcards (`*` = any run, `?` = one char).
  *   - **regex** - wrapped in slashes, `/.../ [flags]`: compiled and tested
  *     against the whole address. An invalid regex never matches (it is skipped
@@ -79,4 +79,4 @@ export function matchesAllowlist(email, patterns) {
 export function looksLikeEmail(value) {
     return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim());
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/app.d.ts

@@ -22,6 +22,14 @@
  * @module
  */
 import { type AuthGateApi, type AuthGateConfig } from "./plugin.ts";
+/**
+ * A code TTL as the plain phrase the email states ("10 minutes", "45 seconds").
+ *
+ * Whole minutes read as minutes; anything else stays in seconds rather than
+ * rounding, so a 90-second TTL is not advertised as "1 minute" and a recipient is
+ * never told the code lives longer than it does.
+ */
+export declare function expiresIn(seconds: number): string;
 /**
  * Boot the gate app and return the API the proxy calls. Throws when email is not
  * in SMTP mode (no way to deliver a code) so a misconfigured gate fails fast at

package/lib/src/app.js

@@ -22,13 +22,28 @@
  * @module
  */
 import { createApp as createAppNs } from "@dbx-tools/appkit";
-import { email, sender, transport } from "@dbx-tools/email";
-import { log } from "@dbx-tools/shared-core";
+import { brand as nodeBrand } from "@dbx-tools/core";
+import { brand as emailBrand, email, sender, transport } from "@dbx-tools/email";
+import { log, string } from "@dbx-tools/shared-core";
 import { authGate } from "./plugin.js";
 const logger = log.logger("tunnel:app");
+/**
+ * A code TTL as the plain phrase the email states ("10 minutes", "45 seconds").
+ *
+ * Whole minutes read as minutes; anything else stays in seconds rather than
+ * rounding, so a 90-second TTL is not advertised as "1 minute" and a recipient is
+ * never told the code lives longer than it does.
+ */
+export function expiresIn(seconds) {
+    return seconds >= 60 && seconds % 60 === 0
+        ? string.pluralize(seconds / 60, "minute")
+        : string.pluralize(seconds, "second");
+}
 const { createApp } = createAppNs;
 const { resolveSenderAddress } = sender;
 const { getEmailRuntime, sendEmail } = transport;
+const { emailBrandFromContext } = emailBrand;
+const { loadBrandContext } = nodeBrand;
 /**
  * Boot the gate app and return the API the proxy calls. Throws when email is not
  * in SMTP mode (no way to deliver a code) so a misconfigured gate fails fast at
@@ -36,6 +51,12 @@ const { getEmailRuntime, sendEmail } = transport;
  * fall back to insecure/open mode when the operator opted in.
  */
 export async function startGateApp(config) {
+    // The host app's own brand (`branding/brand.yaml` discovered from cwd) or the
+    // dbx-tools default. This is the ONE brand source for the gate: it styles the
+    // code email (accent band, font, logo) via the email plugin AND supplies the
+    // display name the copy uses, so a deployment that themes its app themes its
+    // sign-in email with it. An explicit `brandName` still wins (see below).
+    const context = await loadBrandContext();
     // `sendCode` delivers the OTP through the email plugin's SHARED transport, which
     // the `email()` plugin primes during its `setup()` (awaited by `createApp`
     // below). Using the module-level `sendEmail` avoids a circular dependency on the
@@ -46,18 +67,40 @@ export async function startGateApp(config) {
         await sendEmail({
             to: [to],
             subject: opts.subject,
+            // Deliberately the conventional one-time-code layout: the prompt line,
+            // then the bare code ALONE on the next line, then the expiry. iOS, Gmail,
+            // Outlook, and Android all detect a code from this shape and offer to
+            // autofill it, and anything more decorative is what breaks that. The code
+            // stays visible TEXT in both MIME parts (the email plugin renders the
+            // HTML and plain-text alternatives from one React Email tree), never an
+            // image, so a client that scrapes the text part still finds it.
             body: [
                 opts.message,
                 "",
                 `## ${code}`,
                 "",
-                "It expires shortly. If you didn't request this, ignore this email.",
+                `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,
+                "",
+                "If you did not request this code, you can ignore this email.",
             ].join("\n"),
         }, from);
     };
     // `createApp` namespaces each plugin's exports on the handle by manifest name;
     // `handle.authGate` is the in-process gate API the proxy drives.
-    const handle = await createApp({ plugins: [email(), authGate({ ...config, sendCode })] });
+    const handle = await createApp({
+        plugins: [
+            // Brand the code email from the resolved context, the same bridge every
+            // other dbx-tools email surface uses (accent + font inlined, logo only when
+            // it is a fetchable URL - a package-export path cannot load in an inbox).
+            email({ brand: emailBrandFromContext(context) }),
+            // `brandName` falls back to the resolved context's display name, so the
+            // email copy names the app rather than a generic placeholder. Spelled as an
+            // explicit `??` rather than a key before `...config`: commander sets
+            // `brandName` on the options object whether or not the flag was passed, so
+            // spreading it would clobber the context name with `undefined`.
+            authGate({ ...config, brandName: config.brandName ?? context.name, sendCode }),
+        ],
+    });
     // Fail fast: the gate needs SMTP to email codes. `getEmailRuntime()` resolves to
     // `mode: "file"` (outbox) or throws when no SMTP creds are configured - neither
     // can deliver to a real inbox, so refuse to bring up a gate that lets nobody in.
@@ -68,4 +111,4 @@ export async function startGateApp(config) {
     logger.info("gate app ready (no server; proxy-driven)");
     return handle.authGate;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.js","sourceRoot":"","sources":["../../src/app.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The tunnel gate's tiny AppKit \"app\" - `createApp` WITHOUT a `server()` plugin.\n *\n * There is no HTTP server here: the tunnel proxy is the server, and it calls the\n * gate handlers in-process. `createApp` is used only for what it auto-wires:\n *   - `CacheManager` (memory, or Lakebase when the deploy configures persistent\n *     cache storage) - which the OTP `CodeStore` uses for storage + TTL eviction;\n *   - the `email()` transport (SMTP / outbox), primed from env, so `sendCode` can\n *     deliver the one-time code;\n *   - dbx-tools auto-configuration + branding via `@dbx-tools/appkit`.\n *\n * It returns the {@link AuthGateApi} the proxy drives. `sendCode` is wired here\n * (the plugin can't resolve HOW to send on its own) to the email plugin's\n * transport, resolving the `From` from the email runtime config (EMAIL_FROM /\n * EMAIL_DOMAIN) since an OTP request has no on-behalf-of user.\n *\n * FAIL FAST: a gate that can't email a code is useless, so if email does not\n * resolve to SMTP mode (real delivery), this throws - unless `insecure` is set\n * (`--insecure` / `TUNNEL_INSECURE=true`), in which case the caller runs the\n * tunnel OPEN with no gate.\n *\n * @module\n */\n\nimport { createApp as createAppNs } from \"@dbx-tools/appkit\";\nimport { brand as nodeBrand } from \"@dbx-tools/core\";\nimport { brand as emailBrand, email, sender, transport } from \"@dbx-tools/email\";\nimport { log, string } from \"@dbx-tools/shared-core\";\nimport { authGate, type AuthGateApi, type AuthGateConfig } from \"./plugin.ts\";\n\nconst logger = log.logger(\"tunnel:app\");\n\n/**\n * A code TTL as the plain phrase the email states (\"10 minutes\", \"45 seconds\").\n *\n * Whole minutes read as minutes; anything else stays in seconds rather than\n * rounding, so a 90-second TTL is not advertised as \"1 minute\" and a recipient is\n * never told the code lives longer than it does.\n */\nexport function expiresIn(seconds: number): string {\n  return seconds >= 60 && seconds % 60 === 0\n    ? string.pluralize(seconds / 60, \"minute\")\n    : string.pluralize(seconds, \"second\");\n}\n\nconst { createApp } = createAppNs;\nconst { resolveSenderAddress } = sender;\nconst { getEmailRuntime, sendEmail } = transport;\nconst { emailBrandFromContext } = emailBrand;\nconst { loadBrandContext } = nodeBrand;\n\n/**\n * Boot the gate app and return the API the proxy calls. Throws when email is not\n * in SMTP mode (no way to deliver a code) so a misconfigured gate fails fast at\n * startup rather than silently accepting nobody; the caller may catch this and\n * fall back to insecure/open mode when the operator opted in.\n */\nexport async function startGateApp(config: AuthGateConfig): Promise<AuthGateApi> {\n  // The host app's own brand (`branding/brand.yaml` discovered from cwd) or the\n  // dbx-tools default. This is the ONE brand source for the gate: it styles the\n  // code email (accent band, font, logo) via the email plugin AND supplies the\n  // display name the copy uses, so a deployment that themes its app themes its\n  // sign-in email with it. An explicit `brandName` still wins (see below).\n  const context = await loadBrandContext();\n\n  // `sendCode` delivers the OTP through the email plugin's SHARED transport, which\n  // the `email()` plugin primes during its `setup()` (awaited by `createApp`\n  // below). Using the module-level `sendEmail` avoids a circular dependency on the\n  // app handle's inferred type. `From` is the app's configured sender (EMAIL_FROM /\n  // EMAIL_DOMAIN); the code email has no OBO user, so it resolves with `undefined`.\n  const sendCode: NonNullable<AuthGateConfig[\"sendCode\"]> = async (to, code, opts) => {\n    const from = resolveSenderAddress(getEmailRuntime().config, undefined);\n    await sendEmail(\n      {\n        to: [to],\n        subject: opts.subject,\n        // Deliberately the conventional one-time-code layout: the prompt line,\n        // then the bare code ALONE on the next line, then the expiry. iOS, Gmail,\n        // Outlook, and Android all detect a code from this shape and offer to\n        // autofill it, and anything more decorative is what breaks that. The code\n        // stays visible TEXT in both MIME parts (the email plugin renders the\n        // HTML and plain-text alternatives from one React Email tree), never an\n        // image, so a client that scrapes the text part still finds it.\n        body: [\n          opts.message,\n          \"\",\n          `## ${code}`,\n          \"\",\n          `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,\n          \"\",\n          \"If you did not request this code, you can ignore this email.\",\n        ].join(\"\\n\"),\n      },\n      from,\n    );\n  };\n\n  // `createApp` namespaces each plugin's exports on the handle by manifest name;\n  // `handle.authGate` is the in-process gate API the proxy drives.\n  const handle = await createApp({\n    plugins: [\n      // Brand the code email from the resolved context, the same bridge every\n      // other dbx-tools email surface uses (accent + font inlined, logo only when\n      // it is a fetchable URL - a package-export path cannot load in an inbox).\n      email({ brand: emailBrandFromContext(context) }),\n      // `brandName` falls back to the resolved context's display name, so the\n      // email copy names the app rather than a generic placeholder. Spelled as an\n      // explicit `??` rather than a key before `...config`: commander sets\n      // `brandName` on the options object whether or not the flag was passed, so\n      // spreading it would clobber the context name with `undefined`.\n      authGate({ ...config, brandName: config.brandName ?? context.name, sendCode }),\n    ],\n  });\n\n  // Fail fast: the gate needs SMTP to email codes. `getEmailRuntime()` resolves to\n  // `mode: \"file\"` (outbox) or throws when no SMTP creds are configured - neither\n  // can deliver to a real inbox, so refuse to bring up a gate that lets nobody in.\n  if (getEmailRuntime().config.mode !== \"smtp\") {\n    throw new Error(\n      \"email is not configured for SMTP delivery - the OTP gate cannot send codes. \" +\n        \"Set SMTP_HOST/SMTP_USER/SMTP_PASSWORD, or pass --insecure / TUNNEL_INSECURE=true to run the tunnel open.\",\n    );\n  }\n\n  logger.info(\"gate app ready (no server; proxy-driven)\");\n  return handle.authGate as AuthGateApi;\n}\n"]}

package/lib/src/cli.d.ts

@@ -1,14 +1,16 @@
 /**
  * `dbx-tools-tunnel` / `dbxt-tunnel` CLI.
  *
- * Wraps a Databricks App start command with a public portr tunnel and an
- * email-OTP access gate. Everything after `--` is the REAL app start command:
+ * Wraps an app's start command with a public portr tunnel and an email-OTP
+ * access gate. Everything after `--` is the REAL app start command:
  *
- *   dbxt-tunnel --subject "Here's your OTP" --allow databricks.com -- bun src/server.ts
+ *   dbxt-tunnel --subject "Here's your OTP" --allow example.com -- bun src/server.ts
  *
  * Boot sequence:
  *   1. Pick a random PRIVATE port and spawn the app command with
- *      `DATABRICKS_APP_PORT` set to it (so the app binds loopback-private).
+ *      `DATABRICKS_APP_PORT` set to it (so the app binds loopback-private). That
+ *      variable name is the Databricks Apps runtime contract; the gate itself is
+ *      platform-neutral and honours whatever port it finds there.
  *   2. Boot the tiny gate AppKit app (no server): inits `CacheManager` + the
  *      email transport, yields the in-process gate API.
  *   3. Start the gate PROXY on the ORIGINAL public port, forwarding to the app.

package/lib/src/cli.js

@@ -1,14 +1,16 @@
 /**
  * `dbx-tools-tunnel` / `dbxt-tunnel` CLI.
  *
- * Wraps a Databricks App start command with a public portr tunnel and an
- * email-OTP access gate. Everything after `--` is the REAL app start command:
+ * Wraps an app's start command with a public portr tunnel and an email-OTP
+ * access gate. Everything after `--` is the REAL app start command:
  *
- *   dbxt-tunnel --subject "Here's your OTP" --allow databricks.com -- bun src/server.ts
+ *   dbxt-tunnel --subject "Here's your OTP" --allow example.com -- bun src/server.ts
  *
  * Boot sequence:
  *   1. Pick a random PRIVATE port and spawn the app command with
- *      `DATABRICKS_APP_PORT` set to it (so the app binds loopback-private).
+ *      `DATABRICKS_APP_PORT` set to it (so the app binds loopback-private). That
+ *      variable name is the Databricks Apps runtime contract; the gate itself is
+ *      platform-neutral and honours whatever port it finds there.
  *   2. Boot the tiny gate AppKit app (no server): inits `CacheManager` + the
  *      email transport, yields the in-process gate API.
  *   3. Start the gate PROXY on the ORIGINAL public port, forwarding to the app.
@@ -38,12 +40,12 @@ function randomPort() {
 function program() {
     return new Command()
         .name("dbx-tools-tunnel")
-        .description("Front a Databricks App with a public portr tunnel + email-OTP gate")
+        .description("Front an app with a public portr tunnel + email-OTP gate")
         .option("--subject <text>", "Subject line for the code email (env AUTH_SUBJECT)")
         .option("--allow <patterns>", "Comma/space-separated allow-list: domain / glob / /regex/ (env EMAIL_AUTH_ALLOW)")
         .option("--subdomain <name>", "portr subdomain (else derived from PUBLIC_DOMAIN)")
         .option("--public-domain <host>", "portr <subdomain>.<server> (env PUBLIC_DOMAIN)")
-        .option("--brand-name <name>", "Product name in the email + login copy (env AUTH_BRAND_NAME)")
+        .option("--brand-name <name>", "Display name in the code email copy (env AUTH_BRAND_NAME; defaults to the brand context name)")
         .option("--message <text>", "Line shown above the code in the email (env AUTH_MESSAGE)")
         .option("--session-ttl <seconds>", "Session lifetime (env AUTH_SESSION_TTL)")
         .option("--code-ttl <seconds>", "One-time-code lifetime (env AUTH_CODE_TTL)")
@@ -144,4 +146,4 @@ export async function runCli(argv) {
     // Any child exit (or a signal) tears the whole thing down.
     superviseExit(children);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `dbx-tools-tunnel` / `dbxt-tunnel` CLI.\n *\n * Wraps a Databricks App start command with a public portr tunnel and an\n * email-OTP access gate. Everything after `--` is the REAL app start command:\n *\n *   dbxt-tunnel --subject \"Here's your OTP\" --allow databricks.com -- bun src/server.ts\n *\n * Boot sequence:\n *   1. Pick a random PRIVATE port and spawn the app command with\n *      `DATABRICKS_APP_PORT` set to it (so the app binds loopback-private).\n *   2. Boot the tiny gate AppKit app (no server): inits `CacheManager` + the\n *      email transport, yields the in-process gate API.\n *   3. Start the gate PROXY on the ORIGINAL public port, forwarding to the app.\n *   4. Install + run portr pointed at the public port (when a tunnel is\n *      configured; otherwise the proxy still gates nothing and forwards).\n *\n * Supervision: the app child, portr child, and this process are tied together -\n * if ANY exits, everything comes down (concurrently-style `killOthers`).\n *\n * Options come from flags OR env; see the option definitions below.\n *\n * @module\n */\n\nimport { type ChildProcess, spawn } from \"node:child_process\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { Command, CommanderError } from \"commander\";\nimport { startGateApp } from \"./app.ts\";\nimport type { AuthGateConfig } from \"./plugin.ts\";\nimport { installPortr, resolvePortrConfig, startPortr, writePortrConfig } from \"./portr.ts\";\nimport { startProxy } from \"./proxy.ts\";\n\nexport { CommanderError };\n\nconst logger = log.logger(\"tunnel\");\n\n/** A random ephemeral port for the app to bind (the proxy fronts the public one). */\nfunction randomPort(): number {\n  return 20000 + Math.floor(Math.random() * 20000);\n}\n\ninterface TunnelOpts {\n  subject?: string;\n  allow?: string;\n  subdomain?: string;\n  publicDomain?: string;\n  brandName?: string;\n  message?: string;\n  sessionTtl?: string;\n  codeTtl?: string;\n  insecure?: boolean;\n}\n\n/** Build the commander program. `--` separates flags from the app start command. */\nfunction program(): Command {\n  return new Command()\n    .name(\"dbx-tools-tunnel\")\n    .description(\"Front a Databricks App with a public portr tunnel + email-OTP gate\")\n    .option(\"--subject <text>\", \"Subject line for the code email (env AUTH_SUBJECT)\")\n    .option(\n      \"--allow <patterns>\",\n      \"Comma/space-separated allow-list: domain / glob / /regex/ (env EMAIL_AUTH_ALLOW)\",\n    )\n    .option(\"--subdomain <name>\", \"portr subdomain (else derived from PUBLIC_DOMAIN)\")\n    .option(\"--public-domain <host>\", \"portr <subdomain>.<server> (env PUBLIC_DOMAIN)\")\n    .option(\"--brand-name <name>\", \"Product name in the email + login copy (env AUTH_BRAND_NAME)\")\n    .option(\"--message <text>\", \"Line shown above the code in the email (env AUTH_MESSAGE)\")\n    .option(\"--session-ttl <seconds>\", \"Session lifetime (env AUTH_SESSION_TTL)\")\n    .option(\"--code-ttl <seconds>\", \"One-time-code lifetime (env AUTH_CODE_TTL)\")\n    .option(\n      \"--insecure\",\n      \"Run the tunnel OPEN with no gate (env TUNNEL_INSECURE=true). Otherwise the CLI fails fast when email SMTP is not configured.\",\n    )\n    .allowExcessArguments(true)\n    .helpOption(\"-h, --help\", \"Show help\");\n}\n\n/** Tie a child's exit to full teardown: any exit brings the whole tunnel down. */\nfunction superviseExit(children: ChildProcess[]): void {\n  let shuttingDown = false;\n  const shutdown = (code: number): void => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n    for (const child of children) {\n      if (!child.killed) child.kill(\"SIGTERM\");\n    }\n    // Give children a moment, then exit with the first non-zero code seen.\n    setTimeout(() => process.exit(code), 3000).unref();\n  };\n  for (const child of children) {\n    child.on(\"exit\", (code) => {\n      logger.warn(`child exited (${code ?? \"signal\"}); bringing tunnel down`);\n      shutdown(code ?? 1);\n    });\n  }\n  for (const sig of [\"SIGTERM\", \"SIGINT\", \"SIGHUP\"] as const) {\n    process.on(sig, () => shutdown(0));\n  }\n}\n\n/** Parse argv and run the tunnel. */\nexport async function runCli(argv: string[]): Promise<void> {\n  // Split flags from the wrapped command at the first `--`.\n  const sep = argv.indexOf(\"--\");\n  const flags = sep >= 0 ? argv.slice(0, sep) : argv;\n  const command = sep >= 0 ? argv.slice(sep + 1) : [];\n\n  const prog = program();\n  prog.parse(flags);\n  const opts = prog.opts<TunnelOpts>();\n\n  if (command.length === 0) {\n    throw new CommanderError(1, \"tunnel.no-command\", \"no start command given after `--`\");\n  }\n\n  const publicPort = Number(process.env.DATABRICKS_APP_PORT ?? 8000);\n  const appPort = randomPort();\n\n  const gateConfig: AuthGateConfig = {\n    allow: opts.allow,\n    subject: opts.subject,\n    brandName: opts.brandName,\n    message: opts.message,\n    sessionTtlSeconds: opts.sessionTtl ? Number(opts.sessionTtl) : undefined,\n    codeTtlSeconds: opts.codeTtl ? Number(opts.codeTtl) : undefined,\n  };\n\n  // 1. Spawn the wrapped app with the PRIVATE port. It binds loopback; only the\n  //    proxy reaches it.\n  logger.info(`spawning app on private port ${appPort}: ${command.join(\" \")}`);\n  const [cmd, ...args] = command;\n  const app = spawn(cmd!, args, {\n    env: { ...process.env, DATABRICKS_APP_PORT: String(appPort), HOST: \"127.0.0.1\" },\n    stdio: \"inherit\",\n  });\n\n  // 2. Boot the gate app (cache + email transport + gate API). `startGateApp`\n  //    FAILS FAST when email can't send codes (no SMTP). Insecure mode\n  //    (`--insecure` / TUNNEL_INSECURE) skips the gate and runs the tunnel open.\n  const insecure = opts.insecure || /^(1|true|yes|on)$/i.test(process.env.TUNNEL_INSECURE ?? \"\");\n  let gate: Awaited<ReturnType<typeof startGateApp>> | undefined;\n  if (insecure) {\n    logger.warn(\"insecure mode - tunnel runs OPEN with no email-OTP gate\");\n  } else {\n    try {\n      gate = await startGateApp(gateConfig);\n    } catch (error) {\n      // Fail fast: don't silently expose an ungated tunnel. The operator must fix\n      // SMTP or explicitly opt into `--insecure`.\n      logger.error(\"cannot start the OTP gate\", { error: (error as Error).message });\n      throw error;\n    }\n  }\n\n  // 3. Start the gate proxy on the public port (open when `gate` is undefined).\n  await startProxy({ publicPort, appPort, gate });\n\n  // 4. Install + run portr when a tunnel is configured.\n  const portrConfig = resolvePortrConfig({\n    publicDomain: opts.publicDomain,\n    subdomain: opts.subdomain,\n    port: publicPort,\n  });\n  const children: ChildProcess[] = [app];\n  if (portrConfig) {\n    const env = installPortr();\n    writePortrConfig(portrConfig, env);\n    children.push(startPortr(portrConfig, env));\n  } else {\n    logger.info(\"no PORTR_TOKEN/PUBLIC_DOMAIN - serving the gate proxy without a public tunnel\");\n  }\n\n  // Any child exit (or a signal) tears the whole thing down.\n  superviseExit(children);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAqB,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAEpC,qFAAqF;AACrF,SAAS,UAAU;IACjB,OAAO,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC;AACnD,CAAC;AAcD,oFAAoF;AACpF,SAAS,OAAO;IACd,OAAO,IAAI,OAAO,EAAE;SACjB,IAAI,CAAC,kBAAkB,CAAC;SACxB,WAAW,CAAC,0DAA0D,CAAC;SACvE,MAAM,CAAC,kBAAkB,EAAE,oDAAoD,CAAC;SAChF,MAAM,CACL,oBAAoB,EACpB,kFAAkF,CACnF;SACA,MAAM,CAAC,oBAAoB,EAAE,mDAAmD,CAAC;SACjF,MAAM,CAAC,wBAAwB,EAAE,gDAAgD,CAAC;SAClF,MAAM,CACL,qBAAqB,EACrB,+FAA+F,CAChG;SACA,MAAM,CAAC,kBAAkB,EAAE,2DAA2D,CAAC;SACvF,MAAM,CAAC,yBAAyB,EAAE,yCAAyC,CAAC;SAC5E,MAAM,CAAC,sBAAsB,EAAE,4CAA4C,CAAC;SAC5E,MAAM,CACL,YAAY,EACZ,8HAA8H,CAC/H;SACA,oBAAoB,CAAC,IAAI,CAAC;SAC1B,UAAU,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;AAC3C,CAAC;AAED,kFAAkF;AAClF,SAAS,aAAa,CAAC,QAAwB;IAC7C,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAQ,EAAE;QACtC,IAAI,YAAY;YAAE,OAAO;QACzB,YAAY,GAAG,IAAI,CAAC;QACpB,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC;QACD,uEAAuE;QACvE,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;IACrD,CAAC,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;YACxB,MAAM,CAAC,IAAI,CAAC,iBAAiB,IAAI,IAAI,QAAQ,yBAAyB,CAAC,CAAC;YACxE,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAU,EAAE,CAAC;QAC3D,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IACrC,CAAC;AACH,CAAC;AAED,qCAAqC;AACrC,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,IAAc;IACzC,0DAA0D;IAC1D,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACnD,MAAM,OAAO,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEpD,MAAM,IAAI,GAAG,OAAO,EAAE,CAAC;IACvB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAClB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,EAAc,CAAC;IAErC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,cAAc,CAAC,CAAC,EAAE,mBAAmB,EAAE,mCAAmC,CAAC,CAAC;IACxF,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,IAAI,CAAC,CAAC;IACnE,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;IAE7B,MAAM,UAAU,GAAmB;QACjC,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,iBAAiB,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS;QACxE,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS;KAChE,CAAC;IAEF,8EAA8E;IAC9E,uBAAuB;IACvB,MAAM,CAAC,IAAI,CAAC,gCAAgC,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC7E,MAAM,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC;IAC/B,MAAM,GAAG,GAAG,KAAK,CAAC,GAAI,EAAE,IAAI,EAAE;QAC5B,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,mBAAmB,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE;QAChF,KAAK,EAAE,SAAS;KACjB,CAAC,CAAC;IAEH,4EAA4E;IAC5E,qEAAqE;IACrE,+EAA+E;IAC/E,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;IAC/F,IAAI,IAA0D,CAAC;IAC/D,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;IACzE,CAAC;SAAM,CAAC;QACN,IAAI,CAAC;YACH,IAAI,GAAG,MAAM,YAAY,CAAC,UAAU,CAAC,CAAC;QACxC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,4EAA4E;YAC5E,4CAA4C;YAC5C,MAAM,CAAC,KAAK,CAAC,2BAA2B,EAAE,EAAE,KAAK,EAAG,KAAe,CAAC,OAAO,EAAE,CAAC,CAAC;YAC/E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED,8EAA8E;IAC9E,MAAM,UAAU,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAEhD,sDAAsD;IACtD,MAAM,WAAW,GAAG,kBAAkB,CAAC;QACrC,YAAY,EAAE,IAAI,CAAC,YAAY;QAC/B,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,IAAI,EAAE,UAAU;KACjB,CAAC,CAAC;IACH,MAAM,QAAQ,GAAmB,CAAC,GAAG,CAAC,CAAC;IACvC,IAAI,WAAW,EAAE,CAAC;QAChB,MAAM,GAAG,GAAG,YAAY,EAAE,CAAC;QAC3B,gBAAgB,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;QACnC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC;IAC9C,CAAC;SAAM,CAAC;QACN,MAAM,CAAC,IAAI,CAAC,+EAA+E,CAAC,CAAC;IAC/F,CAAC;IAED,2DAA2D;IAC3D,aAAa,CAAC,QAAQ,CAAC,CAAC;AAC1B,CAAC","sourcesContent":["/**\n * `dbx-tools-tunnel` / `dbxt-tunnel` CLI.\n *\n * Wraps an app's start command with a public portr tunnel and an email-OTP\n * access gate. Everything after `--` is the REAL app start command:\n *\n *   dbxt-tunnel --subject \"Here's your OTP\" --allow example.com -- bun src/server.ts\n *\n * Boot sequence:\n *   1. Pick a random PRIVATE port and spawn the app command with\n *      `DATABRICKS_APP_PORT` set to it (so the app binds loopback-private). That\n *      variable name is the Databricks Apps runtime contract; the gate itself is\n *      platform-neutral and honours whatever port it finds there.\n *   2. Boot the tiny gate AppKit app (no server): inits `CacheManager` + the\n *      email transport, yields the in-process gate API.\n *   3. Start the gate PROXY on the ORIGINAL public port, forwarding to the app.\n *   4. Install + run portr pointed at the public port (when a tunnel is\n *      configured; otherwise the proxy still gates nothing and forwards).\n *\n * Supervision: the app child, portr child, and this process are tied together -\n * if ANY exits, everything comes down (concurrently-style `killOthers`).\n *\n * Options come from flags OR env; see the option definitions below.\n *\n * @module\n */\n\nimport { type ChildProcess, spawn } from \"node:child_process\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { Command, CommanderError } from \"commander\";\nimport { startGateApp } from \"./app.ts\";\nimport type { AuthGateConfig } from \"./plugin.ts\";\nimport { installPortr, resolvePortrConfig, startPortr, writePortrConfig } from \"./portr.ts\";\nimport { startProxy } from \"./proxy.ts\";\n\nexport { CommanderError };\n\nconst logger = log.logger(\"tunnel\");\n\n/** A random ephemeral port for the app to bind (the proxy fronts the public one). */\nfunction randomPort(): number {\n  return 20000 + Math.floor(Math.random() * 20000);\n}\n\ninterface TunnelOpts {\n  subject?: string;\n  allow?: string;\n  subdomain?: string;\n  publicDomain?: string;\n  brandName?: string;\n  message?: string;\n  sessionTtl?: string;\n  codeTtl?: string;\n  insecure?: boolean;\n}\n\n/** Build the commander program. `--` separates flags from the app start command. */\nfunction program(): Command {\n  return new Command()\n    .name(\"dbx-tools-tunnel\")\n    .description(\"Front an app with a public portr tunnel + email-OTP gate\")\n    .option(\"--subject <text>\", \"Subject line for the code email (env AUTH_SUBJECT)\")\n    .option(\n      \"--allow <patterns>\",\n      \"Comma/space-separated allow-list: domain / glob / /regex/ (env EMAIL_AUTH_ALLOW)\",\n    )\n    .option(\"--subdomain <name>\", \"portr subdomain (else derived from PUBLIC_DOMAIN)\")\n    .option(\"--public-domain <host>\", \"portr <subdomain>.<server> (env PUBLIC_DOMAIN)\")\n    .option(\n      \"--brand-name <name>\",\n      \"Display name in the code email copy (env AUTH_BRAND_NAME; defaults to the brand context name)\",\n    )\n    .option(\"--message <text>\", \"Line shown above the code in the email (env AUTH_MESSAGE)\")\n    .option(\"--session-ttl <seconds>\", \"Session lifetime (env AUTH_SESSION_TTL)\")\n    .option(\"--code-ttl <seconds>\", \"One-time-code lifetime (env AUTH_CODE_TTL)\")\n    .option(\n      \"--insecure\",\n      \"Run the tunnel OPEN with no gate (env TUNNEL_INSECURE=true). Otherwise the CLI fails fast when email SMTP is not configured.\",\n    )\n    .allowExcessArguments(true)\n    .helpOption(\"-h, --help\", \"Show help\");\n}\n\n/** Tie a child's exit to full teardown: any exit brings the whole tunnel down. */\nfunction superviseExit(children: ChildProcess[]): void {\n  let shuttingDown = false;\n  const shutdown = (code: number): void => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n    for (const child of children) {\n      if (!child.killed) child.kill(\"SIGTERM\");\n    }\n    // Give children a moment, then exit with the first non-zero code seen.\n    setTimeout(() => process.exit(code), 3000).unref();\n  };\n  for (const child of children) {\n    child.on(\"exit\", (code) => {\n      logger.warn(`child exited (${code ?? \"signal\"}); bringing tunnel down`);\n      shutdown(code ?? 1);\n    });\n  }\n  for (const sig of [\"SIGTERM\", \"SIGINT\", \"SIGHUP\"] as const) {\n    process.on(sig, () => shutdown(0));\n  }\n}\n\n/** Parse argv and run the tunnel. */\nexport async function runCli(argv: string[]): Promise<void> {\n  // Split flags from the wrapped command at the first `--`.\n  const sep = argv.indexOf(\"--\");\n  const flags = sep >= 0 ? argv.slice(0, sep) : argv;\n  const command = sep >= 0 ? argv.slice(sep + 1) : [];\n\n  const prog = program();\n  prog.parse(flags);\n  const opts = prog.opts<TunnelOpts>();\n\n  if (command.length === 0) {\n    throw new CommanderError(1, \"tunnel.no-command\", \"no start command given after `--`\");\n  }\n\n  const publicPort = Number(process.env.DATABRICKS_APP_PORT ?? 8000);\n  const appPort = randomPort();\n\n  const gateConfig: AuthGateConfig = {\n    allow: opts.allow,\n    subject: opts.subject,\n    brandName: opts.brandName,\n    message: opts.message,\n    sessionTtlSeconds: opts.sessionTtl ? Number(opts.sessionTtl) : undefined,\n    codeTtlSeconds: opts.codeTtl ? Number(opts.codeTtl) : undefined,\n  };\n\n  // 1. Spawn the wrapped app with the PRIVATE port. It binds loopback; only the\n  //    proxy reaches it.\n  logger.info(`spawning app on private port ${appPort}: ${command.join(\" \")}`);\n  const [cmd, ...args] = command;\n  const app = spawn(cmd!, args, {\n    env: { ...process.env, DATABRICKS_APP_PORT: String(appPort), HOST: \"127.0.0.1\" },\n    stdio: \"inherit\",\n  });\n\n  // 2. Boot the gate app (cache + email transport + gate API). `startGateApp`\n  //    FAILS FAST when email can't send codes (no SMTP). Insecure mode\n  //    (`--insecure` / TUNNEL_INSECURE) skips the gate and runs the tunnel open.\n  const insecure = opts.insecure || /^(1|true|yes|on)$/i.test(process.env.TUNNEL_INSECURE ?? \"\");\n  let gate: Awaited<ReturnType<typeof startGateApp>> | undefined;\n  if (insecure) {\n    logger.warn(\"insecure mode - tunnel runs OPEN with no email-OTP gate\");\n  } else {\n    try {\n      gate = await startGateApp(gateConfig);\n    } catch (error) {\n      // Fail fast: don't silently expose an ungated tunnel. The operator must fix\n      // SMTP or explicitly opt into `--insecure`.\n      logger.error(\"cannot start the OTP gate\", { error: (error as Error).message });\n      throw error;\n    }\n  }\n\n  // 3. Start the gate proxy on the public port (open when `gate` is undefined).\n  await startProxy({ publicPort, appPort, gate });\n\n  // 4. Install + run portr when a tunnel is configured.\n  const portrConfig = resolvePortrConfig({\n    publicDomain: opts.publicDomain,\n    subdomain: opts.subdomain,\n    port: publicPort,\n  });\n  const children: ChildProcess[] = [app];\n  if (portrConfig) {\n    const env = installPortr();\n    writePortrConfig(portrConfig, env);\n    children.push(startPortr(portrConfig, env));\n  } else {\n    logger.info(\"no PORTR_TOKEN/PUBLIC_DOMAIN - serving the gate proxy without a public tunnel\");\n  }\n\n  // Any child exit (or a signal) tears the whole thing down.\n  superviseExit(children);\n}\n"]}

package/lib/src/otp.d.ts

@@ -9,10 +9,13 @@
  * the hash, and the entry is deleted on success or once attempts are exhausted.
  *
  * The session JWT is a short-lived HS256 token (via `jose`) carrying only the
- * email. Its signing key comes from `AUTH_JWT_SECRET`; when unset the gate FAILS
- * OPEN with an ephemeral per-process key (sessions reset on restart) rather than
- * refusing service - a Databricks App is already access-limited, so an unset
- * secret degrades to "sessions don't survive restarts", not "nobody can log in".
+ * email. Its signing key comes from `AUTH_JWT_SECRET`; when unset the gate uses an
+ * ephemeral per-process key rather than refusing service, so an unset secret
+ * degrades to "sessions don't survive a restart", not "nobody can log in". Note
+ * what this does NOT weaken: a caller still needs a code delivered to an
+ * allow-listed address, because the signing key only validates an ALREADY-issued
+ * session. Set it in any deployment running more than one instance, or sessions
+ * minted by one will not verify on another.
  *
  * @module
  */