@dbx-tools/tunnel 0.6.60

package/lib/src/app.d.ts

@@ -0,0 +1,130 @@
+/**
+ * The tunnel gate's tiny AppKit "app" - `createApp` WITHOUT a `server()` plugin.
+ *
+ * There is no HTTP server here: the tunnel proxy is the server, and it calls the
+ * gate handlers in-process. `createApp` is used only for what it auto-wires:
+ *   - `CacheManager` (Lakebase when this process can reach it, else memory) -
+ *     which the OTP `CodeStore` and the session signing key use for storage + TTL
+ *     eviction;
+ *   - the `email()` transport (SMTP / outbox), primed from env, so `sendCode` can
+ *     deliver the one-time code;
+ *   - dbx-tools auto-configuration + branding via `@dbx-tools/appkit`.
+ *
+ * It returns the {@link AuthGateApi} the proxy drives. `sendCode` is wired here
+ * (the plugin can't resolve HOW to send on its own) to the email plugin's
+ * transport. A sign-in code is SYSTEM mail - no on-behalf-of user asked for it
+ * and no reply to it reaches anyone - so it sends from the email config's
+ * do-not-reply address (`no-reply@EMAIL_DOMAIN` unless EMAIL_SYSTEM_FROM names
+ * another).
+ *
+ * FAIL FAST: a gate that can't email a code is useless, so if email does not
+ * resolve to SMTP mode (real delivery), this throws - unless `insecure` is set
+ * (`--insecure` / `TUNNEL_INSECURE=true`), in which case the caller runs the
+ * tunnel OPEN with no gate.
+ *
+ * @module
+ */
+import { type AuthGateApi, type AuthGateConfig, type SendCodeOptions } 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;
+/** The parts of {@link SendCodeOptions} the code email's copy is built from. */
+type CodeCopy = Pick<SendCodeOptions, "message" | "codeTtlSeconds">;
+/**
+ * The HTML part's source: the full branded template, with the code as a large
+ * styled heading (`## ` is what makes it prominent in an inbox).
+ */
+export declare function codeEmailHtmlBody(code: string, opts: CodeCopy): string;
+/**
+ * The `text/plain` part, supplied EXPLICITLY rather than rendered from the tree
+ * above. Both parts say the same thing; only the line layout differs.
+ *
+ * The prompt and the code share ONE line ("Your verification code is: 123456").
+ * That single-line shape is what iOS, Gmail, Outlook, and Android code detection
+ * keys on most reliably - the heuristics look for a code in the same sentence as
+ * a recognized prompt, so splitting them across lines makes detection dependent
+ * on the client, and any blank line between them defeats it outright.
+ *
+ * The GENERATED text part cannot hold that shape at all: it is a rendering of the
+ * HTML, so it carries the brand header/footer and turns the code heading's CSS
+ * margin into blank lines, arriving as `prompt\n\n\ncode`.
+ *
+ * The code is visible text in BOTH parts, never an image, so a client scraping
+ * either one finds it. No trailer line follows the copy - Apple's domain-bound
+ * `@domain #code` footer is deliberately NOT emitted, since it constrains the
+ * code to one origin and is not what the broadly-compatible shape needs.
+ */
+export declare function codeEmailTextBody(code: string, opts: CodeCopy): string;
+/**
+ * The SUBJECT line, with the code in it: `"123456 is your verification code"`.
+ *
+ * The code has to be here, not only in the body, because of what mobile autofill
+ * actually reads. iOS offers a code from an incoming NOTIFICATION - natively for
+ * Messages and Mail, and since iOS 26 for any app's notification text, which is
+ * what finally made Gmail work - and a notification contains the sender, the
+ * subject, and a short snippet. Nothing else. A code that lives in the body is
+ * invisible to it, however cleanly the body is formatted, which is why a perfectly
+ * shaped `text/plain` part still produced no autofill prompt in Gmail.
+ *
+ * `<code> is your <thing>` rather than `<thing>: <code>` because the leading code
+ * survives TRUNCATION: a notification and an inbox list both cut the subject, and
+ * the platform heuristics want the code in the same sentence as a recognized
+ * prompt ("code", "verification"). Putting it first keeps both intact no matter
+ * where the cut lands.
+ *
+ * `subject` is the configured line ("Your verification code"), lower-cased at its
+ * first word so the sentence reads naturally, and left ALONE when it does not look
+ * like the conventional phrasing - an operator who set a deliberate subject gets
+ * theirs with the code prefixed, not a mangled hybrid.
+ */
+export declare function codeEmailSubject(code: string, subject: string): string;
+/**
+ * The PREHEADER: the snippet beside the subject in an inbox list, and the body of
+ * the push notification. Carries the code for the same reason the subject does -
+ * it is the other half of what a notification shows - and repeats the prompt
+ * wording so a heuristic scanning the snippet alone finds a code next to a phrase
+ * it recognizes.
+ */
+export declare function codeEmailPreview(code: string, opts: CodeCopy): string;
+/**
+ * Fill in the Lakebase connection env AppKit's cache needs, so `CacheManager`
+ * chooses PERSISTENT storage instead of memory.
+ *
+ * This is what makes the gate's session signing key and outstanding one-time
+ * codes survive a restart. `applyLakebaseEnv` is the SHARED helper AppKit
+ * auto-configuration uses, so the gate gets exactly the env a pool needs -
+ * `LAKEBASE_ENDPOINT`, `PGHOST`, `PGDATABASE`, and `PGUSER` - rather than a
+ * hand-rolled subset. All four matter: `createLakebasePool()` throws without any
+ * one of them, and a Databricks App `postgres` resource binding supplies only the
+ * first. Without them the pool cannot be built, the cache silently degrades to
+ * in-memory, and every redeploy signs out every user (the exact symptom this
+ * exists to prevent).
+ *
+ * It is called here rather than left to `createApp`'s `autoConfigure` because that
+ * gates on a `lakebase()` plugin being registered - and this app registers none,
+ * having no server to mount Lakebase routes on. Calling the helper directly also
+ * lets the gate be stricter than `autoConfigure` is:
+ *
+ *   - It runs ONLY when a Lakebase env var is present. A tunnel is a wrapper
+ *     around someone else's app and must not invent infrastructure, so with
+ *     nothing bound it skips rather than falling through the resolver's
+ *     list-or-CREATE-a-project path.
+ *   - `autoCreate: false` for the same reason, in case a project happens to exist.
+ *   - Every failure is a WARNING, never a throw. The cache is an optimization for
+ *     session durability; admission still requires a code delivered to an
+ *     allow-listed address, so a gate with a memory cache is safe, just forgetful.
+ */
+export declare function resolveCacheStorageEnv(): Promise<boolean>;
+/**
+ * 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
+ * startup rather than silently accepting nobody; the caller may catch this and
+ * fall back to insecure/open mode when the operator opted in.
+ */
+export declare function startGateApp(config: AuthGateConfig): Promise<AuthGateApi>;
+export {};

package/lib/src/app.js

@@ -0,0 +1,258 @@
+/**
+ * The tunnel gate's tiny AppKit "app" - `createApp` WITHOUT a `server()` plugin.
+ *
+ * There is no HTTP server here: the tunnel proxy is the server, and it calls the
+ * gate handlers in-process. `createApp` is used only for what it auto-wires:
+ *   - `CacheManager` (Lakebase when this process can reach it, else memory) -
+ *     which the OTP `CodeStore` and the session signing key use for storage + TTL
+ *     eviction;
+ *   - the `email()` transport (SMTP / outbox), primed from env, so `sendCode` can
+ *     deliver the one-time code;
+ *   - dbx-tools auto-configuration + branding via `@dbx-tools/appkit`.
+ *
+ * It returns the {@link AuthGateApi} the proxy drives. `sendCode` is wired here
+ * (the plugin can't resolve HOW to send on its own) to the email plugin's
+ * transport. A sign-in code is SYSTEM mail - no on-behalf-of user asked for it
+ * and no reply to it reaches anyone - so it sends from the email config's
+ * do-not-reply address (`no-reply@EMAIL_DOMAIN` unless EMAIL_SYSTEM_FROM names
+ * another).
+ *
+ * FAIL FAST: a gate that can't email a code is useless, so if email does not
+ * resolve to SMTP mode (real delivery), this throws - unless `insecure` is set
+ * (`--insecure` / `TUNNEL_INSECURE=true`), in which case the caller runs the
+ * tunnel OPEN with no gate.
+ *
+ * @module
+ */
+import { createApp as createAppNs, lakebaseResolver } from "@dbx-tools/appkit";
+import { brand as nodeBrand } from "@dbx-tools/core";
+import { brand as emailBrand, email, sender, transport } from "@dbx-tools/email";
+import { env, 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");
+}
+/** The reassurance line closing both parts. */
+const IGNORE_LINE = "If you did not request this code, you can ignore this email.";
+/**
+ * The HTML part's source: the full branded template, with the code as a large
+ * styled heading (`## ` is what makes it prominent in an inbox).
+ */
+export function codeEmailHtmlBody(code, opts) {
+    return [
+        opts.message,
+        "",
+        `## ${code}`,
+        "",
+        `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,
+        "",
+        IGNORE_LINE,
+    ].join("\n");
+}
+/**
+ * The `text/plain` part, supplied EXPLICITLY rather than rendered from the tree
+ * above. Both parts say the same thing; only the line layout differs.
+ *
+ * The prompt and the code share ONE line ("Your verification code is: 123456").
+ * That single-line shape is what iOS, Gmail, Outlook, and Android code detection
+ * keys on most reliably - the heuristics look for a code in the same sentence as
+ * a recognized prompt, so splitting them across lines makes detection dependent
+ * on the client, and any blank line between them defeats it outright.
+ *
+ * The GENERATED text part cannot hold that shape at all: it is a rendering of the
+ * HTML, so it carries the brand header/footer and turns the code heading's CSS
+ * margin into blank lines, arriving as `prompt\n\n\ncode`.
+ *
+ * The code is visible text in BOTH parts, never an image, so a client scraping
+ * either one finds it. No trailer line follows the copy - Apple's domain-bound
+ * `@domain #code` footer is deliberately NOT emitted, since it constrains the
+ * code to one origin and is not what the broadly-compatible shape needs.
+ */
+export function codeEmailTextBody(code, opts) {
+    return [
+        `${opts.message} ${code}`,
+        `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,
+        "",
+        IGNORE_LINE,
+    ].join("\n");
+}
+/**
+ * The SUBJECT line, with the code in it: `"123456 is your verification code"`.
+ *
+ * The code has to be here, not only in the body, because of what mobile autofill
+ * actually reads. iOS offers a code from an incoming NOTIFICATION - natively for
+ * Messages and Mail, and since iOS 26 for any app's notification text, which is
+ * what finally made Gmail work - and a notification contains the sender, the
+ * subject, and a short snippet. Nothing else. A code that lives in the body is
+ * invisible to it, however cleanly the body is formatted, which is why a perfectly
+ * shaped `text/plain` part still produced no autofill prompt in Gmail.
+ *
+ * `<code> is your <thing>` rather than `<thing>: <code>` because the leading code
+ * survives TRUNCATION: a notification and an inbox list both cut the subject, and
+ * the platform heuristics want the code in the same sentence as a recognized
+ * prompt ("code", "verification"). Putting it first keeps both intact no matter
+ * where the cut lands.
+ *
+ * `subject` is the configured line ("Your verification code"), lower-cased at its
+ * first word so the sentence reads naturally, and left ALONE when it does not look
+ * like the conventional phrasing - an operator who set a deliberate subject gets
+ * theirs with the code prefixed, not a mangled hybrid.
+ */
+export function codeEmailSubject(code, subject) {
+    const trimmed = subject.trim();
+    const conventional = /^your\s+/i.exec(trimmed);
+    const rest = conventional ? trimmed.slice(conventional[0].length) : trimmed;
+    return conventional ? `${code} is your ${rest}` : `${code} - ${trimmed}`;
+}
+/**
+ * The PREHEADER: the snippet beside the subject in an inbox list, and the body of
+ * the push notification. Carries the code for the same reason the subject does -
+ * it is the other half of what a notification shows - and repeats the prompt
+ * wording so a heuristic scanning the snippet alone finds a code next to a phrase
+ * it recognizes.
+ */
+export function codeEmailPreview(code, opts) {
+    return `${opts.message} ${code}`;
+}
+const { createApp } = createAppNs;
+const { applyLakebaseEnv } = lakebaseResolver;
+const { resolveSystemSenderAddress } = sender;
+const { getEmailRuntime, sendEmail } = transport;
+const { emailBrandFromContext } = emailBrand;
+const { loadBrandContext } = nodeBrand;
+/**
+ * Env vars whose presence means a Lakebase database was bound to this deployment.
+ * `LAKEBASE_ENDPOINT` is what a Databricks App `postgres` resource binding sets;
+ * `PGHOST` is the local/manual spelling.
+ */
+const LAKEBASE_ENV = ["LAKEBASE_ENDPOINT", "PGHOST"];
+/**
+ * Upper bound on resolving the Lakebase connection. The gate is in the request
+ * path for every visitor, so a slow workspace API must not hold up boot
+ * indefinitely; a memory cache is a degraded gate, an unbooted one is no gate.
+ */
+const LAKEBASE_RESOLVE_TIMEOUT_MS = 60_000;
+/**
+ * Fill in the Lakebase connection env AppKit's cache needs, so `CacheManager`
+ * chooses PERSISTENT storage instead of memory.
+ *
+ * This is what makes the gate's session signing key and outstanding one-time
+ * codes survive a restart. `applyLakebaseEnv` is the SHARED helper AppKit
+ * auto-configuration uses, so the gate gets exactly the env a pool needs -
+ * `LAKEBASE_ENDPOINT`, `PGHOST`, `PGDATABASE`, and `PGUSER` - rather than a
+ * hand-rolled subset. All four matter: `createLakebasePool()` throws without any
+ * one of them, and a Databricks App `postgres` resource binding supplies only the
+ * first. Without them the pool cannot be built, the cache silently degrades to
+ * in-memory, and every redeploy signs out every user (the exact symptom this
+ * exists to prevent).
+ *
+ * It is called here rather than left to `createApp`'s `autoConfigure` because that
+ * gates on a `lakebase()` plugin being registered - and this app registers none,
+ * having no server to mount Lakebase routes on. Calling the helper directly also
+ * lets the gate be stricter than `autoConfigure` is:
+ *
+ *   - It runs ONLY when a Lakebase env var is present. A tunnel is a wrapper
+ *     around someone else's app and must not invent infrastructure, so with
+ *     nothing bound it skips rather than falling through the resolver's
+ *     list-or-CREATE-a-project path.
+ *   - `autoCreate: false` for the same reason, in case a project happens to exist.
+ *   - Every failure is a WARNING, never a throw. The cache is an optimization for
+ *     session durability; admission still requires a code delivered to an
+ *     allow-listed address, so a gate with a memory cache is safe, just forgetful.
+ */
+export async function resolveCacheStorageEnv() {
+    if (!env.text(LAKEBASE_ENV)) {
+        logger.info(`no ${env.name(LAKEBASE_ENV)} - the gate cache stays in memory; sessions and codes will not survive a restart`);
+        return false;
+    }
+    try {
+        const { resolved, user } = await applyLakebaseEnv({ autoCreate: false }, AbortSignal.timeout(LAKEBASE_RESOLVE_TIMEOUT_MS));
+        logger.info("lakebase resolved for the gate cache", {
+            host: resolved.host,
+            database: resolved.database,
+            endpoint: resolved.endpoint,
+            user,
+        });
+        return true;
+    }
+    catch (error) {
+        logger.warn("could not resolve lakebase - the gate cache stays in memory; sessions and codes will not survive a restart", { error });
+        return false;
+    }
+}
+/**
+ * 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
+ * startup rather than silently accepting nobody; the caller may catch this and
+ * 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();
+    // Before `createApp`, because AppKit resolves the cache's storage during it and
+    // reads the connection out of `process.env` when it does. See the function's
+    // docs for why the gate resolves this itself.
+    await resolveCacheStorageEnv();
+    // `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
+    // app handle's inferred type. The `From` is the SYSTEM sender: a verification
+    // code is machine-generated and unanswerable, so it must not arrive from a
+    // person's address inviting a reply.
+    const sendCode = async (to, code, opts) => {
+        const from = resolveSystemSenderAddress(getEmailRuntime().config);
+        await sendEmail({
+            to: [to],
+            // The code rides in the SUBJECT and the preheader, not just the body:
+            // those two strings are the whole of a push notification, and a
+            // notification is what mobile autofill reads. See `codeEmailSubject`.
+            subject: codeEmailSubject(code, opts.subject),
+            body: codeEmailHtmlBody(code, opts),
+        }, from, undefined, { text: codeEmailTextBody(code, opts), preview: codeEmailPreview(code, opts) });
+    };
+    // `createApp` namespaces each plugin's exports on the handle by manifest name;
+    // `handle.authGate` is the in-process gate API the proxy drives.
+    //
+    // `autoConfigure: false` because {@link resolveCacheStorageEnv} above already
+    // ran the one piece of it this app wants (`applyLakebaseEnv`), on this app's
+    // terms - no auto-create, and a warning instead of a throw.
+    const handle = await createApp({
+        autoConfigure: false,
+        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.
+    if (getEmailRuntime().config.mode !== "smtp") {
+        throw new Error("email is not configured for SMTP delivery - the OTP gate cannot send codes. " +
+            "Set SMTP_HOST/SMTP_USER/SMTP_PASSWORD, or pass --insecure / TUNNEL_INSECURE=true to run the tunnel open.");
+    }
+    logger.info("gate app ready (no server; proxy-driven)");
+    return handle.authGate;
+}
+//# 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` (Lakebase when this process can reach it, else memory) -\n *     which the OTP `CodeStore` and the session signing key use for storage + TTL\n *     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. A sign-in code is SYSTEM mail - no on-behalf-of user asked for it\n * and no reply to it reaches anyone - so it sends from the email config's\n * do-not-reply address (`no-reply@EMAIL_DOMAIN` unless EMAIL_SYSTEM_FROM names\n * another).\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, lakebaseResolver } from \"@dbx-tools/appkit\";\nimport { brand as nodeBrand } from \"@dbx-tools/core\";\nimport { brand as emailBrand, email, sender, transport } from \"@dbx-tools/email\";\nimport { env, log, string } from \"@dbx-tools/shared-core\";\nimport { authGate, type AuthGateApi, type AuthGateConfig, type SendCodeOptions } 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\n/** The parts of {@link SendCodeOptions} the code email's copy is built from. */\ntype CodeCopy = Pick<SendCodeOptions, \"message\" | \"codeTtlSeconds\">;\n\n/** The reassurance line closing both parts. */\nconst IGNORE_LINE = \"If you did not request this code, you can ignore this email.\";\n\n/**\n * The HTML part's source: the full branded template, with the code as a large\n * styled heading (`## ` is what makes it prominent in an inbox).\n */\nexport function codeEmailHtmlBody(code: string, opts: CodeCopy): string {\n  return [\n    opts.message,\n    \"\",\n    `## ${code}`,\n    \"\",\n    `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,\n    \"\",\n    IGNORE_LINE,\n  ].join(\"\\n\");\n}\n\n/**\n * The `text/plain` part, supplied EXPLICITLY rather than rendered from the tree\n * above. Both parts say the same thing; only the line layout differs.\n *\n * The prompt and the code share ONE line (\"Your verification code is: 123456\").\n * That single-line shape is what iOS, Gmail, Outlook, and Android code detection\n * keys on most reliably - the heuristics look for a code in the same sentence as\n * a recognized prompt, so splitting them across lines makes detection dependent\n * on the client, and any blank line between them defeats it outright.\n *\n * The GENERATED text part cannot hold that shape at all: it is a rendering of the\n * HTML, so it carries the brand header/footer and turns the code heading's CSS\n * margin into blank lines, arriving as `prompt\\n\\n\\ncode`.\n *\n * The code is visible text in BOTH parts, never an image, so a client scraping\n * either one finds it. No trailer line follows the copy - Apple's domain-bound\n * `@domain #code` footer is deliberately NOT emitted, since it constrains the\n * code to one origin and is not what the broadly-compatible shape needs.\n */\nexport function codeEmailTextBody(code: string, opts: CodeCopy): string {\n  return [\n    `${opts.message} ${code}`,\n    `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,\n    \"\",\n    IGNORE_LINE,\n  ].join(\"\\n\");\n}\n\n/**\n * The SUBJECT line, with the code in it: `\"123456 is your verification code\"`.\n *\n * The code has to be here, not only in the body, because of what mobile autofill\n * actually reads. iOS offers a code from an incoming NOTIFICATION - natively for\n * Messages and Mail, and since iOS 26 for any app's notification text, which is\n * what finally made Gmail work - and a notification contains the sender, the\n * subject, and a short snippet. Nothing else. A code that lives in the body is\n * invisible to it, however cleanly the body is formatted, which is why a perfectly\n * shaped `text/plain` part still produced no autofill prompt in Gmail.\n *\n * `<code> is your <thing>` rather than `<thing>: <code>` because the leading code\n * survives TRUNCATION: a notification and an inbox list both cut the subject, and\n * the platform heuristics want the code in the same sentence as a recognized\n * prompt (\"code\", \"verification\"). Putting it first keeps both intact no matter\n * where the cut lands.\n *\n * `subject` is the configured line (\"Your verification code\"), lower-cased at its\n * first word so the sentence reads naturally, and left ALONE when it does not look\n * like the conventional phrasing - an operator who set a deliberate subject gets\n * theirs with the code prefixed, not a mangled hybrid.\n */\nexport function codeEmailSubject(code: string, subject: string): string {\n  const trimmed = subject.trim();\n  const conventional = /^your\\s+/i.exec(trimmed);\n  const rest = conventional ? trimmed.slice(conventional[0].length) : trimmed;\n  return conventional ? `${code} is your ${rest}` : `${code} - ${trimmed}`;\n}\n\n/**\n * The PREHEADER: the snippet beside the subject in an inbox list, and the body of\n * the push notification. Carries the code for the same reason the subject does -\n * it is the other half of what a notification shows - and repeats the prompt\n * wording so a heuristic scanning the snippet alone finds a code next to a phrase\n * it recognizes.\n */\nexport function codeEmailPreview(code: string, opts: CodeCopy): string {\n  return `${opts.message} ${code}`;\n}\n\nconst { createApp } = createAppNs;\nconst { applyLakebaseEnv } = lakebaseResolver;\nconst { resolveSystemSenderAddress } = sender;\nconst { getEmailRuntime, sendEmail } = transport;\nconst { emailBrandFromContext } = emailBrand;\nconst { loadBrandContext } = nodeBrand;\n\n/**\n * Env vars whose presence means a Lakebase database was bound to this deployment.\n * `LAKEBASE_ENDPOINT` is what a Databricks App `postgres` resource binding sets;\n * `PGHOST` is the local/manual spelling.\n */\nconst LAKEBASE_ENV = [\"LAKEBASE_ENDPOINT\", \"PGHOST\"] as const;\n\n/**\n * Upper bound on resolving the Lakebase connection. The gate is in the request\n * path for every visitor, so a slow workspace API must not hold up boot\n * indefinitely; a memory cache is a degraded gate, an unbooted one is no gate.\n */\nconst LAKEBASE_RESOLVE_TIMEOUT_MS = 60_000;\n\n/**\n * Fill in the Lakebase connection env AppKit's cache needs, so `CacheManager`\n * chooses PERSISTENT storage instead of memory.\n *\n * This is what makes the gate's session signing key and outstanding one-time\n * codes survive a restart. `applyLakebaseEnv` is the SHARED helper AppKit\n * auto-configuration uses, so the gate gets exactly the env a pool needs -\n * `LAKEBASE_ENDPOINT`, `PGHOST`, `PGDATABASE`, and `PGUSER` - rather than a\n * hand-rolled subset. All four matter: `createLakebasePool()` throws without any\n * one of them, and a Databricks App `postgres` resource binding supplies only the\n * first. Without them the pool cannot be built, the cache silently degrades to\n * in-memory, and every redeploy signs out every user (the exact symptom this\n * exists to prevent).\n *\n * It is called here rather than left to `createApp`'s `autoConfigure` because that\n * gates on a `lakebase()` plugin being registered - and this app registers none,\n * having no server to mount Lakebase routes on. Calling the helper directly also\n * lets the gate be stricter than `autoConfigure` is:\n *\n *   - It runs ONLY when a Lakebase env var is present. A tunnel is a wrapper\n *     around someone else's app and must not invent infrastructure, so with\n *     nothing bound it skips rather than falling through the resolver's\n *     list-or-CREATE-a-project path.\n *   - `autoCreate: false` for the same reason, in case a project happens to exist.\n *   - Every failure is a WARNING, never a throw. The cache is an optimization for\n *     session durability; admission still requires a code delivered to an\n *     allow-listed address, so a gate with a memory cache is safe, just forgetful.\n */\nexport async function resolveCacheStorageEnv(): Promise<boolean> {\n  if (!env.text(LAKEBASE_ENV)) {\n    logger.info(\n      `no ${env.name(LAKEBASE_ENV)} - the gate cache stays in memory; sessions and codes will not survive a restart`,\n    );\n    return false;\n  }\n  try {\n    const { resolved, user } = await applyLakebaseEnv(\n      { autoCreate: false },\n      AbortSignal.timeout(LAKEBASE_RESOLVE_TIMEOUT_MS),\n    );\n    logger.info(\"lakebase resolved for the gate cache\", {\n      host: resolved.host,\n      database: resolved.database,\n      endpoint: resolved.endpoint,\n      user,\n    });\n    return true;\n  } catch (error) {\n    logger.warn(\n      \"could not resolve lakebase - the gate cache stays in memory; sessions and codes will not survive a restart\",\n      { error },\n    );\n    return false;\n  }\n}\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  // Before `createApp`, because AppKit resolves the cache's storage during it and\n  // reads the connection out of `process.env` when it does. See the function's\n  // docs for why the gate resolves this itself.\n  await resolveCacheStorageEnv();\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. The `From` is the SYSTEM sender: a verification\n  // code is machine-generated and unanswerable, so it must not arrive from a\n  // person's address inviting a reply.\n  const sendCode: NonNullable<AuthGateConfig[\"sendCode\"]> = async (to, code, opts) => {\n    const from = resolveSystemSenderAddress(getEmailRuntime().config);\n    await sendEmail(\n      {\n        to: [to],\n        // The code rides in the SUBJECT and the preheader, not just the body:\n        // those two strings are the whole of a push notification, and a\n        // notification is what mobile autofill reads. See `codeEmailSubject`.\n        subject: codeEmailSubject(code, opts.subject),\n        body: codeEmailHtmlBody(code, opts),\n      },\n      from,\n      undefined,\n      { text: codeEmailTextBody(code, opts), preview: codeEmailPreview(code, opts) },\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  //\n  // `autoConfigure: false` because {@link resolveCacheStorageEnv} above already\n  // ran the one piece of it this app wants (`applyLakebaseEnv`), on this app's\n  // terms - no auto-create, and a warning instead of a throw.\n  const handle = await createApp({\n    autoConfigure: false,\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/env.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Environment-variable names the tunnel reads.
+ *
+ * Every setting is `TUNNEL_`-prefixed, matching the repo convention of naming a
+ * variable after the package that owns it (`MASTRA_*`, `TEAMS_*`,
+ * `WEB_SEARCH_*`). The gate's original names were unprefixed (`AUTH_SUBJECT`,
+ * `PUBLIC_DOMAIN`, ...), which is a real hazard for a package that runs as a
+ * WRAPPER: the tunnel and the app it wraps share one environment, so a generic
+ * name is one the wrapped app may already use for something else, and
+ * `PUBLIC_DOMAIN` in particular reads like an app-wide setting rather than a
+ * portr detail. `EMAIL_AUTH_ALLOW` was worse than generic - it sat in
+ * `@dbx-tools/email`'s `EMAIL_*` namespace while configuring the gate, not email.
+ *
+ * Each entry is an {@link EnvKey} list, EARLIEST-WINS, whose first element is the
+ * current name and whose remaining elements are the deprecated originals. A
+ * deployment set up against the old names keeps working; nothing needs a
+ * coordinated rename. Read them through `env.string` / `env.positiveInt` /
+ * `env.list`, which accept the list directly.
+ *
+ * Not renamed:
+ *
+ *   - `DATABRICKS_APP_PORT` - the Databricks Apps runtime contract. The platform
+ *     sets it; the gate honours it.
+ *   - `PORTR_TOKEN` / `PORTR_SERVER` / `PORTR_AUTO_ADD_PATH` - upstream
+ *     [portr](https://github.com/amalshaji/portr)'s own namespace, and
+ *     `PORTR_AUTO_ADD_PATH` is passed straight to that binary. Renaming these
+ *     would rename someone else's contract.
+ *
+ * @module
+ */
+import type { EnvKey } from "@dbx-tools/shared-core";
+/** Access allow-list patterns (domain / glob / `/regex/`). */
+export declare const ALLOW_ENV: EnvKey;
+/** Subject line for the code email. */
+export declare const SUBJECT_ENV: EnvKey;
+/** Display name used in the code email copy. */
+export declare const BRAND_NAME_ENV: EnvKey;
+/** Line shown immediately above the code in the email. */
+export declare const MESSAGE_ENV: EnvKey;
+/** Session lifetime, in seconds. */
+export declare const SESSION_TTL_ENV: EnvKey;
+/** One-time-code lifetime, in seconds. */
+export declare const CODE_TTL_ENV: EnvKey;
+/** HS256 signing secret for the session JWT. */
+export declare const JWT_SECRET_ENV: EnvKey;
+/**
+ * Force-clear cutoff: every session issued BEFORE it stops verifying. Anything
+ * `object.toDate` accepts - a date, an ISO instant, epoch seconds/millis, or a
+ * relative duration (`-30d`, `7 days ago`).
+ */
+export declare const SESSION_CUTOFF_ENV: EnvKey;
+/** The public `<subdomain>.<server>` portr should serve on. */
+export declare const PUBLIC_DOMAIN_ENV: EnvKey;
+/** Run the tunnel OPEN, with no gate. Ignored unless truthy. */
+export declare const INSECURE_ENV: EnvKey;
+/** Extra `x-` request headers tunnel traffic may forward. */
+export declare const FORWARD_HEADERS_ENV: EnvKey;

package/lib/src/env.js

@@ -0,0 +1,60 @@
+/**
+ * Environment-variable names the tunnel reads.
+ *
+ * Every setting is `TUNNEL_`-prefixed, matching the repo convention of naming a
+ * variable after the package that owns it (`MASTRA_*`, `TEAMS_*`,
+ * `WEB_SEARCH_*`). The gate's original names were unprefixed (`AUTH_SUBJECT`,
+ * `PUBLIC_DOMAIN`, ...), which is a real hazard for a package that runs as a
+ * WRAPPER: the tunnel and the app it wraps share one environment, so a generic
+ * name is one the wrapped app may already use for something else, and
+ * `PUBLIC_DOMAIN` in particular reads like an app-wide setting rather than a
+ * portr detail. `EMAIL_AUTH_ALLOW` was worse than generic - it sat in
+ * `@dbx-tools/email`'s `EMAIL_*` namespace while configuring the gate, not email.
+ *
+ * Each entry is an {@link EnvKey} list, EARLIEST-WINS, whose first element is the
+ * current name and whose remaining elements are the deprecated originals. A
+ * deployment set up against the old names keeps working; nothing needs a
+ * coordinated rename. Read them through `env.string` / `env.positiveInt` /
+ * `env.list`, which accept the list directly.
+ *
+ * Not renamed:
+ *
+ *   - `DATABRICKS_APP_PORT` - the Databricks Apps runtime contract. The platform
+ *     sets it; the gate honours it.
+ *   - `PORTR_TOKEN` / `PORTR_SERVER` / `PORTR_AUTO_ADD_PATH` - upstream
+ *     [portr](https://github.com/amalshaji/portr)'s own namespace, and
+ *     `PORTR_AUTO_ADD_PATH` is passed straight to that binary. Renaming these
+ *     would rename someone else's contract.
+ *
+ * @module
+ */
+/** Access allow-list patterns (domain / glob / `/regex/`). */
+export const ALLOW_ENV = ["TUNNEL_AUTH_ALLOW", "EMAIL_AUTH_ALLOW"];
+/** Subject line for the code email. */
+export const SUBJECT_ENV = ["TUNNEL_AUTH_SUBJECT", "AUTH_SUBJECT"];
+/** Display name used in the code email copy. */
+export const BRAND_NAME_ENV = ["TUNNEL_AUTH_BRAND_NAME", "AUTH_BRAND_NAME"];
+/** Line shown immediately above the code in the email. */
+export const MESSAGE_ENV = ["TUNNEL_AUTH_MESSAGE", "AUTH_MESSAGE"];
+/** Session lifetime, in seconds. */
+export const SESSION_TTL_ENV = ["TUNNEL_AUTH_SESSION_TTL", "AUTH_SESSION_TTL"];
+/** One-time-code lifetime, in seconds. */
+export const CODE_TTL_ENV = ["TUNNEL_AUTH_CODE_TTL", "AUTH_CODE_TTL"];
+/** HS256 signing secret for the session JWT. */
+export const JWT_SECRET_ENV = ["TUNNEL_AUTH_JWT_SECRET", "AUTH_JWT_SECRET"];
+/**
+ * Force-clear cutoff: every session issued BEFORE it stops verifying. Anything
+ * `object.toDate` accepts - a date, an ISO instant, epoch seconds/millis, or a
+ * relative duration (`-30d`, `7 days ago`).
+ */
+export const SESSION_CUTOFF_ENV = [
+    "TUNNEL_AUTH_SESSION_CUTOFF",
+    "TUNNEL_AUTH_SESSION_EPOCH",
+];
+/** The public `<subdomain>.<server>` portr should serve on. */
+export const PUBLIC_DOMAIN_ENV = ["TUNNEL_PUBLIC_DOMAIN", "PUBLIC_DOMAIN"];
+/** Run the tunnel OPEN, with no gate. Ignored unless truthy. */
+export const INSECURE_ENV = "TUNNEL_INSECURE";
+/** Extra `x-` request headers tunnel traffic may forward. */
+export const FORWARD_HEADERS_ENV = "TUNNEL_FORWARD_HEADERS";
+//# sourceMappingURL=data:application/json;base64,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