@dbx-tools/cli-tunnel 0.6.59 → 0.6.85

package/lib/src/cli.js

@@ -1,159 +1,174 @@
 /**
- * `dbx-tools-tunnel` / `dbxt-tunnel` CLI.
+ * `dbx tunnel` - front a command with a public portr tunnel and an email-OTP gate.
  *
- * 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:
+ * This is the WRAPPER path, and it exists for one case: a project that does not
+ * use `@dbx-tools/appkit`'s `createApp`, and therefore cannot register
+ * `tunnelInterceptor()` + the `authGate` plugin in-process. An AppKit app should
+ * still take the plugin path - one process, no proxy hop, no duplicated header
+ * handling.
  *
- *   dbxt-tunnel --subject "Here's your OTP" --allow example.com -- bun src/server.ts
+ * The wrapper claims the PUBLIC port (`DATABRICKS_APP_PORT`, the port the
+ * platform and portr route to), moves the wrapped app to a private one, and
+ * reverse-proxies between them so the gate sits in front of traffic it would
+ * otherwise have no way to intercept. Everything else is delegated: the gate
+ * config comes from `plugin.resolveAuthGateConfig`, the portr lifecycle from
+ * `portr.*` - both the same functions the in-process path uses.
  *
- * 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). 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.
- *   4. Install + run portr pointed at the public port (when a tunnel is
- *      configured; otherwise the proxy still gates nothing and forwards).
- *
- * Supervision: the app child, portr child, and this process are tied together -
- * if ANY exits, everything comes down (concurrently-style `killOthers`).
- *
- * Options come from flags OR env; see the option definitions below.
+ * Ships no bin. `@dbx-tools/cli` mounts `buildProgram()` as `dbx tunnel` lazily,
+ * so `dbx dev` pays for none of this, and `--insecure` / `status` / `install`
+ * never load AppKit or the SMTP stack either (the gate app is behind a dynamic
+ * import).
  *
  * @module
  */
 import { spawn } from "node:child_process";
-import { env, log } from "@dbx-tools/shared-core";
+import { createServer } from "node:net";
+import { log } from "@dbx-tools/shared-core";
+import { portr } from "@dbx-tools/tunnel";
 import { Command, CommanderError } from "commander";
-import { startGateApp } from "./app.js";
-import { FORWARD_HEADERS_ENV, INSECURE_ENV } from "./env.js";
-import { installPortr, resolvePortrConfig, startPortr, writePortrConfig } from "./portr.js";
+import { resolveTunnelOptions } from "./options.js";
 import { startProxy } from "./proxy.js";
 export { CommanderError };
 const logger = log.logger("tunnel");
-/** A random ephemeral port for the app to bind (the proxy fronts the public one). */
-function randomPort() {
-    return 20000 + Math.floor(Math.random() * 20000);
+/** How long a child gets to exit on SIGTERM before the wrapper leaves anyway. */
+const SHUTDOWN_GRACE_MS = 3_000;
+/**
+ * A free loopback port, from the OS rather than a random guess: binding `0` and
+ * reading back what was assigned is the only way to know the port is actually
+ * available, so two tunnels can run side by side without colliding.
+ */
+function freePort() {
+    return new Promise((resolve, reject) => {
+        const probe = createServer();
+        probe.on("error", reject);
+        probe.listen(0, "127.0.0.1", () => {
+            const address = probe.address();
+            const port = typeof address === "object" && address ? address.port : 0;
+            probe.close(() => (port > 0 ? resolve(port) : reject(new Error("no free port"))));
+        });
+    });
 }
-/** Build the commander program. `--` separates flags from the app start command. */
-function program() {
-    return new Command()
-        .name("dbx-tools-tunnel")
-        .description("Front an app with a public portr tunnel + email-OTP gate")
-        .option("--subject <text>", "Subject line for the code email (env TUNNEL_AUTH_SUBJECT)")
-        .option("--allow <patterns>", "Comma/space-separated allow-list: domain / glob / /regex/ (env TUNNEL_AUTH_ALLOW)")
-        .option("--subdomain <name>", "portr subdomain (else derived from TUNNEL_PUBLIC_DOMAIN)")
-        .option("--public-domain <host>", "portr <subdomain>.<server> (env TUNNEL_PUBLIC_DOMAIN)")
-        .option("--brand-name <name>", "Display name in the code email copy (env TUNNEL_AUTH_BRAND_NAME; defaults to the brand context name)")
-        .option("--message <text>", "Line shown above the code in the email (env TUNNEL_AUTH_MESSAGE)")
-        .option("--session-ttl <seconds>", "Session lifetime (env TUNNEL_AUTH_SESSION_TTL)")
-        .option("--code-ttl <seconds>", "One-time-code lifetime (env TUNNEL_AUTH_CODE_TTL)")
-        .option("--session-cutoff <when>", "Invalidate sessions issued before this point, signing everyone out: a date, ISO instant, epoch seconds, or relative duration like -30d (env TUNNEL_AUTH_SESSION_CUTOFF)")
-        .option("--forward-headers <patterns>", "Extra x- request headers tunnel traffic may forward: literal / glob / /regex/ (env TUNNEL_FORWARD_HEADERS)")
-        .option("--insecure", "Run the tunnel OPEN with no gate (env TUNNEL_INSECURE=true). Otherwise the CLI fails fast when email SMTP is not configured.")
-        .allowExcessArguments(true)
-        .helpOption("-h, --help", "Show help");
+/**
+ * Every gate/portr flag. Declared on the root command AND on `run`/`status` so
+ * `dbx tunnel --allow x -- cmd` and `dbx tunnel run --allow x -- cmd` behave
+ * identically - commander does not inherit options downward.
+ */
+function addOptions(command) {
+    return command
+        .option("--public-domain <host>", "portr public domain (<subdomain>.<server>)")
+        .option("--subdomain <name>", "portr subdomain (else derived from the public domain)")
+        .option("--port <port>", "public port the wrapper listens on")
+        .option("--app-port <port>", "private port the wrapped app is told to bind")
+        .option("--allow <patterns...>", "email allow-list (domain / glob / /regex/)")
+        .option("--subject <text>", "verification email subject")
+        .option("--brand-name <name>", "verification email brand name")
+        .option("--message <text>", "verification email message")
+        .option("--session-ttl <seconds>", "session lifetime")
+        .option("--code-ttl <seconds>", "one-time-code lifetime")
+        .option("--session-cutoff <when>", "invalidate every session issued before this")
+        .option("--forward-headers <patterns...>", "extra x- headers tunnel traffic may forward")
+        .option("--insecure", "run open, with no gate");
 }
-/** Tie a child's exit to full teardown: any exit brings the whole tunnel down. */
-function superviseExit(children) {
-    let shuttingDown = false;
-    const shutdown = (code) => {
-        if (shuttingDown)
+/**
+ * Tie the wrapper's lifetime to its children's, in both directions: a child that
+ * exits takes the wrapper down with its code, and a signal to the wrapper is
+ * forwarded before it leaves. Without this a crashed app leaves a portr tunnel
+ * serving a dead port, which looks like a hang rather than a failure.
+ */
+function supervise(children) {
+    let stopping = false;
+    const stop = (code) => {
+        if (stopping)
             return;
-        shuttingDown = true;
-        for (const child of children) {
+        stopping = true;
+        for (const child of children)
             if (!child.killed)
                 child.kill("SIGTERM");
-        }
-        // Give children a moment, then exit with the first non-zero code seen.
-        setTimeout(() => process.exit(code), 3000).unref();
+        setTimeout(() => process.exit(code), SHUTDOWN_GRACE_MS).unref();
     };
-    for (const child of children) {
-        child.on("exit", (code) => {
-            logger.warn(`child exited (${code ?? "signal"}); bringing tunnel down`);
-            shutdown(code ?? 1);
-        });
-    }
-    for (const sig of ["SIGTERM", "SIGINT", "SIGHUP"]) {
-        process.on(sig, () => shutdown(0));
+    for (const child of children)
+        child.on("exit", (code) => stop(code ?? 1));
+    for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+        process.on(signal, () => stop(0));
     }
 }
-/** Parse argv and run the tunnel. */
-export async function runCli(argv) {
-    // Split flags from the wrapped command at the first `--`.
-    const sep = argv.indexOf("--");
-    const flags = sep >= 0 ? argv.slice(0, sep) : argv;
-    const command = sep >= 0 ? argv.slice(sep + 1) : [];
-    const prog = program();
-    prog.parse(flags);
-    const opts = prog.opts();
-    if (command.length === 0) {
-        throw new CommanderError(1, "tunnel.no-command", "no start command given after `--`");
+async function run(raw, command) {
+    const [executable, ...args] = command;
+    if (!executable) {
+        throw new CommanderError(1, "tunnel.no-command", "no command given - pass it after `--`");
     }
-    const publicPort = Number(process.env.DATABRICKS_APP_PORT ?? 8000);
-    const appPort = randomPort();
-    const gateConfig = {
-        allow: opts.allow,
-        subject: opts.subject,
-        brandName: opts.brandName,
-        message: opts.message,
-        sessionTtlSeconds: opts.sessionTtl ? Number(opts.sessionTtl) : undefined,
-        codeTtlSeconds: opts.codeTtl ? Number(opts.codeTtl) : undefined,
-        sessionCutoff: opts.sessionCutoff,
-    };
-    // 1. Spawn the wrapped app with the PRIVATE port. It binds loopback; only the
-    //    proxy reaches it.
-    logger.info(`spawning app on private port ${appPort}: ${command.join(" ")}`);
-    const [cmd, ...args] = command;
-    const app = spawn(cmd, args, {
-        env: { ...process.env, DATABRICKS_APP_PORT: String(appPort), HOST: "127.0.0.1" },
+    const resolved = resolveTunnelOptions(raw);
+    // The wrapped app must not be reachable from outside: it binds loopback on a
+    // private port, and the wrapper is the only thing that talks to it. An
+    // unresolved `--app-port` becomes a free ephemeral port rather than a fixed
+    // guess, so two tunnels can run side by side.
+    const appPort = resolved.appPort ?? (await freePort());
+    const app = spawn(executable, args, {
+        env: {
+            ...process.env,
+            DATABRICKS_APP_PORT: String(appPort),
+            PORT: String(appPort),
+            HOST: "127.0.0.1",
+        },
         stdio: "inherit",
     });
-    // 2. Boot the gate app (cache + email transport + gate API). `startGateApp`
-    //    FAILS FAST when email can't send codes (no SMTP). Insecure mode
-    //    (`--insecure` / TUNNEL_INSECURE) skips the gate and runs the tunnel open.
-    const insecure = env.boolean(opts.insecure, INSECURE_ENV) ?? false;
-    let gate;
-    if (insecure) {
-        logger.warn("insecure mode - tunnel runs OPEN with no email-OTP gate");
-    }
-    else {
-        try {
-            gate = await startGateApp(gateConfig);
-        }
-        catch (error) {
-            // Fail fast: don't silently expose an ungated tunnel. The operator must fix
-            // SMTP or explicitly opt into `--insecure`.
-            logger.error("cannot start the OTP gate", { error: error.message });
-            throw error;
-        }
-    }
-    // 3. Start the gate proxy on the public port (open when `gate` is undefined).
-    //    `forwardHeaders` only ADDS to the built-in allow-list; see `./headers.ts`.
+    const children = [app];
+    // Dynamic import: the gate is the only thing here that needs AppKit + SMTP, so
+    // an `--insecure` run never loads either.
+    const gate = resolved.gate.insecure
+        ? undefined
+        : await (await import("./app.js")).startGateApp(resolved.gateConfig);
+    if (!gate)
+        logger.warn("running OPEN - no gate is in front of this tunnel");
     await startProxy({
-        publicPort,
+        publicPort: resolved.publicPort,
         appPort,
         gate,
-        forwardHeaders: env.list(opts.forwardHeaders, FORWARD_HEADERS_ENV),
-    });
-    // 4. Install + run portr when a tunnel is configured.
-    const portrConfig = resolvePortrConfig({
-        publicDomain: opts.publicDomain,
-        subdomain: opts.subdomain,
-        port: publicPort,
+        forwardHeaders: resolved.gate.forwardHeaders,
     });
-    const children = [app];
-    if (portrConfig) {
-        const portrEnv = installPortr();
-        writePortrConfig(portrConfig, portrEnv);
-        children.push(startPortr(portrConfig, portrEnv));
+    if (resolved.portr) {
+        const portrEnv = await portr.installPortr();
+        await portr.writePortrConfig(resolved.portr, portrEnv);
+        children.push(await portr.startPortr(resolved.portr, portrEnv));
     }
     else {
-        logger.info("no PORTR_TOKEN/TUNNEL_PUBLIC_DOMAIN - serving the gate proxy without a public tunnel");
+        logger.info("no PORTR_TOKEN / TUNNEL_PUBLIC_DOMAIN - serving locally only", {
+            publicPort: resolved.publicPort,
+        });
     }
-    // Any child exit (or a signal) tears the whole thing down.
-    superviseExit(children);
+    supervise(children);
+}
+/** The `dbx tunnel` program. No side effects until parsed. */
+export function buildProgram(name = "dbx tunnel") {
+    const program = addOptions(new Command()
+        .name(name)
+        .description("Front a command with a portr tunnel and an email-OTP gate"));
+    // `run` is the DEFAULT action as well as a named subcommand, preserving the old
+    // wrapper's ergonomics (`dbx tunnel --allow x -- bun src/server.ts`) while
+    // leaving somewhere for `status` and `install` to live.
+    program
+        .argument("[command...]", "the command to wrap, after `--`")
+        .action(async (command, _options, cmd) => {
+        await run(cmd.opts(), command);
+    });
+    addOptions(program.command("run").description("Wrap a command (the default action)"))
+        .argument("<command...>", "the command to wrap, after `--`")
+        .action(async (command, _options, cmd) => {
+        await run(cmd.opts(), command);
+    });
+    // Worth its own command: the most common failure is a tunnel that silently
+    // does nothing because no token or domain resolved, and this prints exactly
+    // what would happen without starting anything.
+    addOptions(program.command("status").description("Resolve the configuration and print it")).action((_options, cmd) => {
+        const resolved = resolveTunnelOptions(cmd.opts());
+        process.stdout.write(`${JSON.stringify(resolved, null, 2)}\n`);
+    });
+    program
+        .command("install")
+        .description("Install the portr binary and exit")
+        .action(async () => {
+        await portr.installPortr();
+    });
+    return program;
 }
-//# 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 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 { env, log } from \"@dbx-tools/shared-core\";\nimport { Command, CommanderError } from \"commander\";\nimport { startGateApp } from \"./app.ts\";\nimport { FORWARD_HEADERS_ENV, INSECURE_ENV } from \"./env.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  sessionCutoff?: string;\n  insecure?: boolean;\n  forwardHeaders?: string;\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 TUNNEL_AUTH_SUBJECT)\")\n    .option(\n      \"--allow <patterns>\",\n      \"Comma/space-separated allow-list: domain / glob / /regex/ (env TUNNEL_AUTH_ALLOW)\",\n    )\n    .option(\"--subdomain <name>\", \"portr subdomain (else derived from TUNNEL_PUBLIC_DOMAIN)\")\n    .option(\"--public-domain <host>\", \"portr <subdomain>.<server> (env TUNNEL_PUBLIC_DOMAIN)\")\n    .option(\n      \"--brand-name <name>\",\n      \"Display name in the code email copy (env TUNNEL_AUTH_BRAND_NAME; defaults to the brand context name)\",\n    )\n    .option(\"--message <text>\", \"Line shown above the code in the email (env TUNNEL_AUTH_MESSAGE)\")\n    .option(\"--session-ttl <seconds>\", \"Session lifetime (env TUNNEL_AUTH_SESSION_TTL)\")\n    .option(\"--code-ttl <seconds>\", \"One-time-code lifetime (env TUNNEL_AUTH_CODE_TTL)\")\n    .option(\n      \"--session-cutoff <when>\",\n      \"Invalidate sessions issued before this point, signing everyone out: a date, ISO instant, epoch seconds, or relative duration like -30d (env TUNNEL_AUTH_SESSION_CUTOFF)\",\n    )\n    .option(\n      \"--forward-headers <patterns>\",\n      \"Extra x- request headers tunnel traffic may forward: literal / glob / /regex/ (env TUNNEL_FORWARD_HEADERS)\",\n    )\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    sessionCutoff: opts.sessionCutoff,\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 = env.boolean(opts.insecure, INSECURE_ENV) ?? false;\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  //    `forwardHeaders` only ADDS to the built-in allow-list; see `./headers.ts`.\n  await startProxy({\n    publicPort,\n    appPort,\n    gate,\n    forwardHeaders: env.list(opts.forwardHeaders, FORWARD_HEADERS_ENV),\n  });\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 portrEnv = installPortr();\n    writePortrConfig(portrConfig, portrEnv);\n    children.push(startPortr(portrConfig, portrEnv));\n  } else {\n    logger.info(\n      \"no PORTR_TOKEN/TUNNEL_PUBLIC_DOMAIN - serving the gate proxy without a public tunnel\",\n    );\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":"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","sourcesContent":["/**\n * `dbx tunnel` - front a command with a public portr tunnel and an email-OTP gate.\n *\n * This is the WRAPPER path, and it exists for one case: a project that does not\n * use `@dbx-tools/appkit`'s `createApp`, and therefore cannot register\n * `tunnelInterceptor()` + the `authGate` plugin in-process. An AppKit app should\n * still take the plugin path - one process, no proxy hop, no duplicated header\n * handling.\n *\n * The wrapper claims the PUBLIC port (`DATABRICKS_APP_PORT`, the port the\n * platform and portr route to), moves the wrapped app to a private one, and\n * reverse-proxies between them so the gate sits in front of traffic it would\n * otherwise have no way to intercept. Everything else is delegated: the gate\n * config comes from `plugin.resolveAuthGateConfig`, the portr lifecycle from\n * `portr.*` - both the same functions the in-process path uses.\n *\n * Ships no bin. `@dbx-tools/cli` mounts `buildProgram()` as `dbx tunnel` lazily,\n * so `dbx dev` pays for none of this, and `--insecure` / `status` / `install`\n * never load AppKit or the SMTP stack either (the gate app is behind a dynamic\n * import).\n *\n * @module\n */\n\nimport { type ChildProcess, spawn } from \"node:child_process\";\nimport { createServer } from \"node:net\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { portr } from \"@dbx-tools/tunnel\";\nimport { Command, CommanderError } from \"commander\";\nimport { resolveTunnelOptions, type TunnelOptions } from \"./options.ts\";\nimport { startProxy } from \"./proxy.ts\";\n\nexport { CommanderError };\n\nconst logger = log.logger(\"tunnel\");\n\n/** How long a child gets to exit on SIGTERM before the wrapper leaves anyway. */\nconst SHUTDOWN_GRACE_MS = 3_000;\n\n/**\n * A free loopback port, from the OS rather than a random guess: binding `0` and\n * reading back what was assigned is the only way to know the port is actually\n * available, so two tunnels can run side by side without colliding.\n */\nfunction freePort(): Promise<number> {\n  return new Promise((resolve, reject) => {\n    const probe = createServer();\n    probe.on(\"error\", reject);\n    probe.listen(0, \"127.0.0.1\", () => {\n      const address = probe.address();\n      const port = typeof address === \"object\" && address ? address.port : 0;\n      probe.close(() => (port > 0 ? resolve(port) : reject(new Error(\"no free port\"))));\n    });\n  });\n}\n\n/**\n * Every gate/portr flag. Declared on the root command AND on `run`/`status` so\n * `dbx tunnel --allow x -- cmd` and `dbx tunnel run --allow x -- cmd` behave\n * identically - commander does not inherit options downward.\n */\nfunction addOptions(command: Command): Command {\n  return command\n    .option(\"--public-domain <host>\", \"portr public domain (<subdomain>.<server>)\")\n    .option(\"--subdomain <name>\", \"portr subdomain (else derived from the public domain)\")\n    .option(\"--port <port>\", \"public port the wrapper listens on\")\n    .option(\"--app-port <port>\", \"private port the wrapped app is told to bind\")\n    .option(\"--allow <patterns...>\", \"email allow-list (domain / glob / /regex/)\")\n    .option(\"--subject <text>\", \"verification email subject\")\n    .option(\"--brand-name <name>\", \"verification email brand name\")\n    .option(\"--message <text>\", \"verification email message\")\n    .option(\"--session-ttl <seconds>\", \"session lifetime\")\n    .option(\"--code-ttl <seconds>\", \"one-time-code lifetime\")\n    .option(\"--session-cutoff <when>\", \"invalidate every session issued before this\")\n    .option(\"--forward-headers <patterns...>\", \"extra x- headers tunnel traffic may forward\")\n    .option(\"--insecure\", \"run open, with no gate\");\n}\n\n/**\n * Tie the wrapper's lifetime to its children's, in both directions: a child that\n * exits takes the wrapper down with its code, and a signal to the wrapper is\n * forwarded before it leaves. Without this a crashed app leaves a portr tunnel\n * serving a dead port, which looks like a hang rather than a failure.\n */\nfunction supervise(children: readonly ChildProcess[]): void {\n  let stopping = false;\n  const stop = (code: number): void => {\n    if (stopping) return;\n    stopping = true;\n    for (const child of children) if (!child.killed) child.kill(\"SIGTERM\");\n    setTimeout(() => process.exit(code), SHUTDOWN_GRACE_MS).unref();\n  };\n  for (const child of children) child.on(\"exit\", (code) => stop(code ?? 1));\n  for (const signal of [\"SIGTERM\", \"SIGINT\", \"SIGHUP\"] as const) {\n    process.on(signal, () => stop(0));\n  }\n}\n\nasync function run(raw: TunnelOptions, command: readonly string[]): Promise<void> {\n  const [executable, ...args] = command;\n  if (!executable) {\n    throw new CommanderError(1, \"tunnel.no-command\", \"no command given - pass it after `--`\");\n  }\n  const resolved = resolveTunnelOptions(raw);\n\n  // The wrapped app must not be reachable from outside: it binds loopback on a\n  // private port, and the wrapper is the only thing that talks to it. An\n  // unresolved `--app-port` becomes a free ephemeral port rather than a fixed\n  // guess, so two tunnels can run side by side.\n  const appPort = resolved.appPort ?? (await freePort());\n  const app = spawn(executable, args, {\n    env: {\n      ...process.env,\n      DATABRICKS_APP_PORT: String(appPort),\n      PORT: String(appPort),\n      HOST: \"127.0.0.1\",\n    },\n    stdio: \"inherit\",\n  });\n  const children: ChildProcess[] = [app];\n\n  // Dynamic import: the gate is the only thing here that needs AppKit + SMTP, so\n  // an `--insecure` run never loads either.\n  const gate = resolved.gate.insecure\n    ? undefined\n    : await (await import(\"./app.ts\")).startGateApp(resolved.gateConfig);\n  if (!gate) logger.warn(\"running OPEN - no gate is in front of this tunnel\");\n\n  await startProxy({\n    publicPort: resolved.publicPort,\n    appPort,\n    gate,\n    forwardHeaders: resolved.gate.forwardHeaders,\n  });\n\n  if (resolved.portr) {\n    const portrEnv = await portr.installPortr();\n    await portr.writePortrConfig(resolved.portr, portrEnv);\n    children.push(await portr.startPortr(resolved.portr, portrEnv));\n  } else {\n    logger.info(\"no PORTR_TOKEN / TUNNEL_PUBLIC_DOMAIN - serving locally only\", {\n      publicPort: resolved.publicPort,\n    });\n  }\n  supervise(children);\n}\n\n/** The `dbx tunnel` program. No side effects until parsed. */\nexport function buildProgram(name = \"dbx tunnel\"): Command {\n  const program = addOptions(\n    new Command()\n      .name(name)\n      .description(\"Front a command with a portr tunnel and an email-OTP gate\"),\n  );\n\n  // `run` is the DEFAULT action as well as a named subcommand, preserving the old\n  // wrapper's ergonomics (`dbx tunnel --allow x -- bun src/server.ts`) while\n  // leaving somewhere for `status` and `install` to live.\n  program\n    .argument(\"[command...]\", \"the command to wrap, after `--`\")\n    .action(async (command: string[], _options: TunnelOptions, cmd: Command) => {\n      await run(cmd.opts<TunnelOptions>(), command);\n    });\n\n  addOptions(\n    program.command(\"run\").description(\"Wrap a command (the default action)\"),\n  )\n    .argument(\"<command...>\", \"the command to wrap, after `--`\")\n    .action(async (command: string[], _options: TunnelOptions, cmd: Command) => {\n      await run(cmd.opts<TunnelOptions>(), command);\n    });\n\n  // Worth its own command: the most common failure is a tunnel that silently\n  // does nothing because no token or domain resolved, and this prints exactly\n  // what would happen without starting anything.\n  addOptions(\n    program.command(\"status\").description(\"Resolve the configuration and print it\"),\n  ).action((_options: TunnelOptions, cmd: Command) => {\n    const resolved = resolveTunnelOptions(cmd.opts<TunnelOptions>());\n    process.stdout.write(`${JSON.stringify(resolved, null, 2)}\\n`);\n  });\n\n  program\n    .command(\"install\")\n    .description(\"Install the portr binary and exit\")\n    .action(async () => {\n      await portr.installPortr();\n    });\n\n  return program;\n}\n"]}

package/lib/src/options.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Flag -> config -> default resolution for `dbx tunnel`.
+ *
+ * The point of this module is that it does almost NOTHING itself: every gate
+ * setting is handed straight to `@dbx-tools/tunnel`'s own
+ * `plugin.resolveAuthGateConfig`, which is the same function the in-process
+ * plugin path calls. The CLI therefore cannot drift from the plugin on a default,
+ * an env name, or a coercion rule - a flag is just a value passed where the
+ * plugin's `config` object would go, and `config.*` fills the rest in from the
+ * environment, a `.env` file, or `databricks.yml`.
+ *
+ * @module
+ */
+import { type AuthGateConfig, plugin, portr } from "@dbx-tools/tunnel";
+/** Raw commander flag values (every numeric flag arrives as a string). */
+export interface TunnelOptions {
+    publicDomain?: string;
+    subdomain?: string;
+    port?: string | number;
+    appPort?: string | number;
+    allow?: string[];
+    subject?: string;
+    brandName?: string;
+    message?: string;
+    sessionTtl?: string | number;
+    codeTtl?: string | number;
+    sessionCutoff?: string;
+    forwardHeaders?: string[];
+    insecure?: boolean;
+}
+export interface ResolvedTunnelOptions {
+    /** The port the wrapper itself listens on - what portr forwards to. */
+    publicPort: number;
+    /** The private port the wrapped app is told to bind. Unset means "pick one". */
+    appPort?: number;
+    /**
+     * The gate config as the `authGate` PLUGIN takes it - flags only, nothing
+     * resolved. Passed straight to the plugin so it applies its own fallbacks
+     * exactly once, in the one place that owns them.
+     */
+    gateConfig: AuthGateConfig;
+    /** The same config after the plugin's resolution, for `status` and for routing. */
+    gate: plugin.ResolvedAuthGateConfig;
+    portr: ReturnType<typeof portr.resolvePortrConfig>;
+}
+export declare function resolveTunnelOptions(options: TunnelOptions): ResolvedTunnelOptions;

package/lib/src/options.js

@@ -0,0 +1,51 @@
+/**
+ * Flag -> config -> default resolution for `dbx tunnel`.
+ *
+ * The point of this module is that it does almost NOTHING itself: every gate
+ * setting is handed straight to `@dbx-tools/tunnel`'s own
+ * `plugin.resolveAuthGateConfig`, which is the same function the in-process
+ * plugin path calls. The CLI therefore cannot drift from the plugin on a default,
+ * an env name, or a coercion rule - a flag is just a value passed where the
+ * plugin's `config` object would go, and `config.*` fills the rest in from the
+ * environment, a `.env` file, or `databricks.yml`.
+ *
+ * @module
+ */
+import { config } from "@dbx-tools/core";
+import { object } from "@dbx-tools/shared-core";
+import { plugin, portr } from "@dbx-tools/tunnel";
+export function resolveTunnelOptions(options) {
+    // The Databricks Apps runtime contract: the platform routes to
+    // DATABRICKS_APP_PORT, so the WRAPPER claims it and the wrapped app is moved
+    // to a private one.
+    const publicPort = config.positiveInt(options.port, "DATABRICKS_APP_PORT", 8000);
+    const appPort = config.positiveInt(options.appPort, "APP_PORT", 0, { prefix: "TUNNEL" });
+    const gateConfig = {
+        allow: options.allow,
+        subject: options.subject,
+        brandName: options.brandName,
+        message: options.message,
+        // Coerced, not resolved: the plugin owns the env name and the default for
+        // these, so the flag is passed through as the `config` value it expects and
+        // only needs a string -> number nudge on the way.
+        sessionTtlSeconds: object.toNumber(options.sessionTtl),
+        codeTtlSeconds: object.toNumber(options.codeTtl),
+        sessionCutoff: options.sessionCutoff,
+        forwardHeaders: options.forwardHeaders,
+        insecure: options.insecure,
+        publicDomain: options.publicDomain,
+    };
+    const gate = plugin.resolveAuthGateConfig(gateConfig);
+    return {
+        publicPort,
+        ...(appPort > 0 ? { appPort } : {}),
+        gateConfig,
+        gate,
+        portr: portr.resolvePortrConfig({
+            publicDomain: gate.publicDomain,
+            subdomain: options.subdomain,
+            port: publicPort,
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/proxy.d.ts

@@ -1,49 +1,39 @@
 /**
- * The tunnel gate reverse-proxy.
+ * The reverse proxy that makes the wrapper path possible.
  *
- * Binds the PUBLIC port (the container's `DATABRICKS_APP_PORT`) and forwards to
- * the real app on a private loopback port. It is the single front door for both
- * traffic paths into the container:
+ * The wrapper claims the PUBLIC port and the wrapped app runs as a child process
+ * on a private loopback port, so - unlike the in-process plugin - there is no
+ * middleware chain to insert the gate into. This proxy is that insertion point: it
+ * answers the login routes itself, applies the gate to everything else, and
+ * forwards what survives to the child.
  *
- *   - **portr client** (same container, connects over LOOPBACK) - the public
- *     tunnel. This is what the gate protects.
- *   - **the hosting platform's front door** (Databricks Apps' control plane, or
- *     any other host reaching the `0.0.0.0` port from a NON-loopback
- *     container-network address) - passed through UNGATED, per the rule "if it's
- *     not from the portr client, let it in". The platform already authenticates
- *     that path; the gate exists for the tunnel, which nothing else protects.
- *
- * The distinguisher is the connection's source address: a loopback
- * `req.socket.remoteAddress` is the portr client; anything else is the platform.
- *
- * For portr traffic the gate is a standard SPA gate: static assets + the login
- * flow (`/api/email/auth/*`, answered IN-PROCESS by this proxy via the
- * {@link AuthGateApi}) are open so the browser can load the client and render the
- * `<AuthGate>`; every other `/api/*` needs a valid session cookie or gets 401.
- * WebSocket upgrades are gated the same way and forwarded with `http-proxy-3`.
+ * The gating DECISION is not reimplemented here. `@dbx-tools/tunnel`'s
+ * `gate.gateRequest` makes it - the same function the Express middleware calls -
+ * and this module only differs in how the outcome is written: a proxied request
+ * instead of `next()`, a `writeHead` instead of `res.json`. That is deliberate:
+ * two independent implementations of "which requests are gated and which headers
+ * are stripped" is the one way this package could become a security bug.
  *
  * @module
  */
-import type { AuthGateApi } from "./plugin.ts";
-/** Options for {@link startProxy}. */
+import { type AuthGateApi } from "@dbx-tools/tunnel";
 export interface ProxyOptions {
-    /** Public port to listen on (the container's DATABRICKS_APP_PORT). */
+    /** The port this proxy listens on - the port portr and the platform route to. */
     publicPort: number;
-    /** Private port the real app listens on (loopback). */
+    /** The private loopback port the wrapped app listens on. */
     appPort: number;
-    /**
-     * The in-process gate API, or `undefined` to run OPEN (insecure mode): every
-     * request - including portr traffic - is forwarded ungated. Used when the
-     * operator passed `--insecure` / `TUNNEL_INSECURE=true`.
-     */
+    /** The gate handlers. Omitted (an `--insecure` run) forwards everything. */
     gate?: AuthGateApi;
-    /**
-     * Extra `x-` request headers tunnel traffic may forward, as literals, globs, or
-     * `/regex/`es - unioned with {@link DEFAULT_FORWARD_HEADERS}. Every other `x-`
-     * header is stripped, and {@link PROTECTED_HEADERS} is stripped regardless. See
-     * `./headers.ts` for why the policy is an allow-list.
-     */
+    /** Extra `x-` headers tunnel traffic may forward. */
     forwardHeaders?: readonly string[];
 }
-/** Start the gate proxy. Resolves once it is listening. */
-export declare function startProxy({ publicPort, appPort, gate, forwardHeaders, }: ProxyOptions): Promise<void>;
+/**
+ * Start the proxy and resolve once it is listening.
+ *
+ * `publicDomain` is intentionally NOT passed to `gateRequest`: on this path every
+ * request arrived on the public port, so it IS tunnel traffic by construction -
+ * whereas the in-process gate shares a port with the platform front door and has
+ * to tell them apart by `Host`. Passing the request's own host keeps the shared
+ * decision function's contract satisfied without weakening it.
+ */
+export declare function startProxy(options: ProxyOptions): Promise<void>;