@dbx-tools/cli-tunnel 0.6.54 → 0.6.55

package/README.md

@@ -29,7 +29,19 @@ address against an allow-list, verified by a code sent over
   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.
+  the code as visible text, never an image, and no trailer follows the copy.
+- The two MIME parts are built separately, on purpose. The HTML part is the full
+  branded template with the code as a large styled heading; the `text/plain` part
+  is authored directly, keeping the prompt and the code on ONE line
+  (`Your verification code is: 123456`) because that is the shape client code
+  detection reads most reliably. A generated text part cannot hold it - the text
+  part is a rendering of the HTML, so the heading's CSS margin arrives as blank
+  lines and autofill stops being offered while the HTML still looks perfect. See
+  `codeEmailTextBody` in the `app` module.
+- The sign-in code is SYSTEM mail: it sends from `no-reply@EMAIL_DOMAIN` (or
+  `EMAIL_SYSTEM_FROM`), never a person's address, since a reply to a
+  machine-generated code reaches nobody. `EMAIL_FROM` is not required - see
+  [`@dbx-tools/email`](../../node/email#sender-addresses).
 - 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

package/lib/src/app.d.ts

@@ -11,8 +11,10 @@
  *
  * 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, resolving the `From` from the email runtime config (EMAIL_FROM /
- * EMAIL_DOMAIN) since an OTP request has no on-behalf-of user.
+ * 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
@@ -21,7 +23,7 @@
  *
  * @module
  */
-import { type AuthGateApi, type AuthGateConfig } from "./plugin.ts";
+import { type AuthGateApi, type AuthGateConfig, type SendCodeOptions } from "./plugin.ts";
 /**
  * A code TTL as the plain phrase the email states ("10 minutes", "45 seconds").
  *
@@ -30,6 +32,33 @@ import { type AuthGateApi, type AuthGateConfig } from "./plugin.ts";
  * 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;
 /**
  * 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
@@ -37,3 +66,4 @@ export declare function expiresIn(seconds: number): string;
  * 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

@@ -11,8 +11,10 @@
  *
  * 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, resolving the `From` from the email runtime config (EMAIL_FROM /
- * EMAIL_DOMAIN) since an OTP request has no on-behalf-of user.
+ * 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
@@ -39,8 +41,52 @@ export function expiresIn(seconds) {
         ? 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");
+}
 const { createApp } = createAppNs;
-const { resolveSenderAddress } = sender;
+const { resolveSystemSenderAddress } = sender;
 const { getEmailRuntime, sendEmail } = transport;
 const { emailBrandFromContext } = emailBrand;
 const { loadBrandContext } = nodeBrand;
@@ -60,30 +106,16 @@ export async function startGateApp(config) {
     // `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. `From` is the app's configured sender (EMAIL_FROM /
-    // EMAIL_DOMAIN); the code email has no OBO user, so it resolves with `undefined`.
+    // 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 = resolveSenderAddress(getEmailRuntime().config, undefined);
+        const from = resolveSystemSenderAddress(getEmailRuntime().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}`,
-                "",
-                `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,
-                "",
-                "If you did not request this code, you can ignore this email.",
-            ].join("\n"),
-        }, from);
+            body: codeEmailHtmlBody(code, opts),
+        }, from, undefined, { text: codeEmailTextBody(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.
@@ -111,4 +143,4 @@ export async function startGateApp(config) {
     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` (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"]}
+//# 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. 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 } 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, 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\nconst { createApp } = createAppNs;\nconst { resolveSystemSenderAddress } = 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. 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        subject: opts.subject,\n        body: codeEmailHtmlBody(code, opts),\n      },\n      from,\n      undefined,\n      { text: codeEmailTextBody(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  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/package.json

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

package/src/app.ts

@@ -11,8 +11,10 @@
  *
  * 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, resolving the `From` from the email runtime config (EMAIL_FROM /
- * EMAIL_DOMAIN) since an OTP request has no on-behalf-of user.
+ * 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
@@ -26,7 +28,7 @@ import { createApp as createAppNs } from "@dbx-tools/appkit";
 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, type AuthGateApi, type AuthGateConfig } from "./plugin.ts";
+import { authGate, type AuthGateApi, type AuthGateConfig, type SendCodeOptions } from "./plugin.ts";
 
 const logger = log.logger("tunnel:app");
 
@@ -43,8 +45,58 @@ export function expiresIn(seconds: number): string {
     : string.pluralize(seconds, "second");
 }
 
+/** The parts of {@link SendCodeOptions} the code email's copy is built from. */
+type CodeCopy = Pick<SendCodeOptions, "message" | "codeTtlSeconds">;
+
+/** 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: string, opts: CodeCopy): string {
+  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: string, opts: CodeCopy): string {
+  return [
+    `${opts.message} ${code}`,
+    `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,
+    "",
+    IGNORE_LINE,
+  ].join("\n");
+}
+
 const { createApp } = createAppNs;
-const { resolveSenderAddress } = sender;
+const { resolveSystemSenderAddress } = sender;
 const { getEmailRuntime, sendEmail } = transport;
 const { emailBrandFromContext } = emailBrand;
 const { loadBrandContext } = nodeBrand;
@@ -66,32 +118,20 @@ export async function startGateApp(config: AuthGateConfig): Promise<AuthGateApi>
   // `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. `From` is the app's configured sender (EMAIL_FROM /
-  // EMAIL_DOMAIN); the code email has no OBO user, so it resolves with `undefined`.
+  // 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: NonNullable<AuthGateConfig["sendCode"]> = async (to, code, opts) => {
-    const from = resolveSenderAddress(getEmailRuntime().config, undefined);
+    const from = resolveSystemSenderAddress(getEmailRuntime().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}`,
-          "",
-          `This code expires in ${expiresIn(opts.codeTtlSeconds)}.`,
-          "",
-          "If you did not request this code, you can ignore this email.",
-        ].join("\n"),
+        body: codeEmailHtmlBody(code, opts),
       },
       from,
+      undefined,
+      { text: codeEmailTextBody(code, opts) },
     );
   };