@dbx-tools/cli 0.9.58 → 0.9.61

package/lib/src/tunnel/cli.js

@@ -0,0 +1,190 @@
+/**
+ * `dbx tunnel` - front a command with a public portr tunnel and passwordless gate.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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 { createServer } from "node:net";
+import { AppKitChildProcess } from "@dbx-tools/appkit/child-process";
+import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import { log } from "@dbx-tools/shared-core";
+import { frp, interceptor, portr } from "@dbx-tools/tunnel";
+import { Command, CommanderError } from "commander";
+import { resolveTunnelOptions, TunnelOptionsSchema } from "./options.js";
+import { startProxy } from "./proxy.js";
+export { CommanderError };
+const logger = log.logger("tunnel");
+/**
+ * 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"))));
+        });
+    });
+}
+/**
+ * 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;
+        stopping = true;
+        void Promise.allSettled(children.map((child) => child.shutdown())).then(() => {
+            process.exit(code);
+        });
+    };
+    for (const child of children) {
+        void child.process?.on("exit", (code) => stop(code ?? 1));
+    }
+    for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+        process.on(signal, () => stop(0));
+    }
+}
+async function run(raw, command) {
+    const [executable, ...args] = command;
+    const resolved = resolveTunnelOptions(raw);
+    const children = [];
+    // Two upstream modes:
+    //   - WRAP: a command after `--`. The wrapper spawns it on a private loopback
+    //     port and is the only thing that talks to it.
+    //   - ATTACH: no command, but `--app-port` names an already-running upstream
+    //     (e.g. a local reverse proxy). The gate fronts it without spawning a
+    //     child. This is what lets the gate sit on an interface in front of a
+    //     separately-supervised stack.
+    let appPort;
+    if (executable) {
+        appPort = resolved.appPort ?? (await freePort());
+        const app = new AppKitChildProcess([
+            executable,
+            args,
+            {
+                env: {
+                    ...process.env,
+                    DATABRICKS_APP_PORT: String(appPort),
+                    PORT: String(appPort),
+                    HOST: "127.0.0.1",
+                },
+                stdin: "inherit",
+                stdout: "inherit",
+                stderr: "inherit",
+            },
+        ], { gracefulTimeoutMs: 10_000 });
+        void app.start();
+        children.push(app);
+    }
+    else if (resolved.appPort) {
+        appPort = resolved.appPort;
+        logger.info("attaching gate to existing upstream", { appPort });
+    }
+    else {
+        throw new CommanderError(1, "tunnel.no-upstream", "no command given (pass it after `--`) and no --app-port to attach to");
+    }
+    // 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,
+            publicDomain: resolved.gate.publicDomain ?? `localhost:${resolved.publicPort}`,
+        });
+    if (!gate)
+        logger.warn("running OPEN - no gate is in front of this tunnel");
+    await startProxy({
+        publicPort: resolved.publicPort,
+        appPort,
+        gate,
+        forwardHeaders: resolved.gate.forwardHeaders,
+        gatePaths: resolved.gate.gatePaths,
+        brandName: resolved.gate.brandName,
+        bindHosts: resolved.bindHosts,
+    });
+    if ((resolved.transport === "portr" || resolved.transport === "both") && resolved.portr) {
+        const portrEnv = await portr.installPortr();
+        await portr.writePortrConfig(resolved.portr, portrEnv);
+        children.push(await portr.startPortr(resolved.portr, portrEnv));
+    }
+    if ((resolved.transport === "frp" || resolved.transport === "both") && resolved.frp) {
+        const frpEnv = await frp.installFrp();
+        const configPath = await frp.writeFrpConfig(resolved.frp, frpEnv);
+        children.push(frp.startFrp(resolved.frp, frpEnv, configPath));
+    }
+    const activeTunnelCount = children.length - (executable ? 1 : 0);
+    if (!activeTunnelCount) {
+        logger.info("no selected public tunnel is configured", {
+            transport: resolved.transport,
+            publicPort: resolved.publicPort,
+        });
+    }
+    supervise(children);
+}
+/** The `dbx tunnel` program. No side effects until parsed. */
+export function buildProgram(name = "dbx tunnel") {
+    const program = addArgs(new Command()
+        .name(name)
+        .description("Front a command with a public tunnel and passwordless auth"), TunnelOptionsSchema);
+    // `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) => {
+        await run(parseArgs(program, TunnelOptionsSchema), command);
+    });
+    const runCommand = addArgs(program.command("run").description("Wrap a command (the default action)"), TunnelOptionsSchema);
+    runCommand
+        .argument("<command...>", "the command to wrap, after `--`")
+        .action(async (command) => {
+        await run(parseArgs(runCommand, TunnelOptionsSchema), 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.
+    const statusCommand = addArgs(program.command("status").description("Resolve the configuration and print it"), TunnelOptionsSchema);
+    statusCommand.action(() => {
+        const resolved = resolveTunnelOptions(parseArgs(statusCommand, TunnelOptionsSchema));
+        process.stdout.write(`${JSON.stringify(resolved, null, 2)}\n`);
+    });
+    program
+        .command("install")
+        .argument("[transport]", "portr, frp, or both", "portr")
+        .description("Install public tunnel client binaries and exit")
+        .action(async (transport) => {
+        const parsed = interceptor.TunnelTransportSchema.parse(transport);
+        if (parsed === "portr" || parsed === "both")
+            await portr.installPortr();
+        if (parsed === "frp" || parsed === "both")
+            await frp.installFrp();
+    });
+    return program;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../../src/tunnel/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEpD,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAsB,MAAM,cAAc,CAAC;AAC7F,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAEpC;;;;GAIG;AACH,SAAS,QAAQ;IACf,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,KAAK,GAAG,YAAY,EAAE,CAAC;QAC7B,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAC1B,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE;YAChC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;YAChC,MAAM,IAAI,GAAG,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YACvE,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;QACpF,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,SAAS,SAAS,CAAC,QAAuC;IACxD,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,MAAM,IAAI,GAAG,CAAC,IAAY,EAAQ,EAAE;QAClC,IAAI,QAAQ;YAAE,OAAO;QACrB,QAAQ,GAAG,IAAI,CAAC;QAChB,KAAK,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAC3E,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,KAAK,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;IACD,KAAK,MAAM,MAAM,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAU,EAAE,CAAC;QAC9D,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC;AACH,CAAC;AAED,KAAK,UAAU,GAAG,CAAC,GAAkB,EAAE,OAA0B;IAC/D,MAAM,CAAC,UAAU,EAAE,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC;IACtC,MAAM,QAAQ,GAAG,oBAAoB,CAAC,GAAG,CAAC,CAAC;IAC3C,MAAM,QAAQ,GAAyB,EAAE,CAAC;IAE1C,sBAAsB;IACtB,8EAA8E;IAC9E,mDAAmD;IACnD,6EAA6E;IAC7E,0EAA0E;IAC1E,0EAA0E;IAC1E,mCAAmC;IACnC,IAAI,OAAe,CAAC;IACpB,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,MAAM,QAAQ,EAAE,CAAC,CAAC;QACjD,MAAM,GAAG,GAAG,IAAI,kBAAkB,CAChC;YACE,UAAU;YACV,IAAI;YACJ;gBACE,GAAG,EAAE;oBACH,GAAG,OAAO,CAAC,GAAG;oBACd,mBAAmB,EAAE,MAAM,CAAC,OAAO,CAAC;oBACpC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC;oBACrB,IAAI,EAAE,WAAW;iBAClB;gBACD,KAAK,EAAE,SAAS;gBAChB,MAAM,EAAE,SAAS;gBACjB,MAAM,EAAE,SAAS;aAClB;SACF,EACD,EAAE,iBAAiB,EAAE,MAAM,EAAE,CAC9B,CAAC;QACF,KAAK,GAAG,CAAC,KAAK,EAAE,CAAC;QACjB,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC;SAAM,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;QAC5B,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;QAC3B,MAAM,CAAC,IAAI,CAAC,qCAAqC,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAClE,CAAC;SAAM,CAAC;QACN,MAAM,IAAI,cAAc,CACtB,CAAC,EACD,oBAAoB,EACpB,sEAAsE,CACvE,CAAC;IACJ,CAAC;IAED,+EAA+E;IAC/E,0CAA0C;IAC1C,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ;QACjC,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,MAAM,CACJ,MAAM,MAAM,CAAC,UAAU,CAAC,CACzB,CAAC,YAAY,CAAC;YACb,GAAG,QAAQ,CAAC,UAAU;YACtB,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,IAAI,aAAa,QAAQ,CAAC,UAAU,EAAE;SAC/E,CAAC,CAAC;IACP,IAAI,CAAC,IAAI;QAAE,MAAM,CAAC,IAAI,CAAC,mDAAmD,CAAC,CAAC;IAE5E,MAAM,UAAU,CAAC;QACf,UAAU,EAAE,QAAQ,CAAC,UAAU;QAC/B,OAAO;QACP,IAAI;QACJ,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC,cAAc;QAC5C,SAAS,EAAE,QAAQ,CAAC,IAAI,CAAC,SAAS;QAClC,SAAS,EAAE,QAAQ,CAAC,IAAI,CAAC,SAAS;QAClC,SAAS,EAAE,QAAQ,CAAC,SAAS;KAC9B,CAAC,CAAC;IAEH,IAAI,CAAC,QAAQ,CAAC,SAAS,KAAK,OAAO,IAAI,QAAQ,CAAC,SAAS,KAAK,MAAM,CAAC,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;QACxF,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,YAAY,EAAE,CAAC;QAC5C,MAAM,KAAK,CAAC,gBAAgB,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACvD,QAAQ,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClE,CAAC;IACD,IAAI,CAAC,QAAQ,CAAC,SAAS,KAAK,KAAK,IAAI,QAAQ,CAAC,SAAS,KAAK,MAAM,CAAC,IAAI,QAAQ,CAAC,GAAG,EAAE,CAAC;QACpF,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,UAAU,EAAE,CAAC;QACtC,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAClE,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IAChE,CAAC;IACD,MAAM,iBAAiB,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACvB,MAAM,CAAC,IAAI,CAAC,yCAAyC,EAAE;YACrD,SAAS,EAAE,QAAQ,CAAC,SAAS;YAC7B,UAAU,EAAE,QAAQ,CAAC,UAAU;SAChC,CAAC,CAAC;IACL,CAAC;IACD,SAAS,CAAC,QAAQ,CAAC,CAAC;AACtB,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,YAAY,CAAC,IAAI,GAAG,YAAY;IAC9C,MAAM,OAAO,GAAG,OAAO,CACrB,IAAI,OAAO,EAAE;SACV,IAAI,CAAC,IAAI,CAAC;SACV,WAAW,CAAC,4DAA4D,CAAC,EAC5E,mBAAmB,CACpB,CAAC;IAEF,gFAAgF;IAChF,2EAA2E;IAC3E,wDAAwD;IACxD,OAAO;SACJ,QAAQ,CAAC,cAAc,EAAE,iCAAiC,CAAC;SAC3D,MAAM,CAAC,KAAK,EAAE,OAAiB,EAAE,EAAE;QAClC,MAAM,GAAG,CAAC,SAAS,CAAC,OAAO,EAAE,mBAAmB,CAAC,EAAE,OAAO,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;IAEL,MAAM,UAAU,GAAG,OAAO,CACxB,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,WAAW,CAAC,qCAAqC,CAAC,EACzE,mBAAmB,CACpB,CAAC;IACF,UAAU;SACP,QAAQ,CAAC,cAAc,EAAE,iCAAiC,CAAC;SAC3D,MAAM,CAAC,KAAK,EAAE,OAAiB,EAAE,EAAE;QAClC,MAAM,GAAG,CAAC,SAAS,CAAC,UAAU,EAAE,mBAAmB,CAAC,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEL,2EAA2E;IAC3E,4EAA4E;IAC5E,+CAA+C;IAC/C,MAAM,aAAa,GAAG,OAAO,CAC3B,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,wCAAwC,CAAC,EAC/E,mBAAmB,CACpB,CAAC;IACF,aAAa,CAAC,MAAM,CAAC,GAAG,EAAE;QACxB,MAAM,QAAQ,GAAG,oBAAoB,CAAC,SAAS,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAAC,CAAC;QACrF,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,OAAO;SACJ,OAAO,CAAC,SAAS,CAAC;SAClB,QAAQ,CAAC,aAAa,EAAE,qBAAqB,EAAE,OAAO,CAAC;SACvD,WAAW,CAAC,gDAAgD,CAAC;SAC7D,MAAM,CAAC,KAAK,EAAE,SAAiB,EAAE,EAAE;QAClC,MAAM,MAAM,GAAG,WAAW,CAAC,qBAAqB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAClE,IAAI,MAAM,KAAK,OAAO,IAAI,MAAM,KAAK,MAAM;YAAE,MAAM,KAAK,CAAC,YAAY,EAAE,CAAC;QACxE,IAAI,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,MAAM;YAAE,MAAM,GAAG,CAAC,UAAU,EAAE,CAAC;IACpE,CAAC,CAAC,CAAC;IAEL,OAAO,OAAO,CAAC;AACjB,CAAC","sourcesContent":["/**\n * `dbx tunnel` - front a command with a public portr tunnel and passwordless 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 { createServer } from \"node:net\";\nimport { AppKitChildProcess } from \"@dbx-tools/appkit/child-process\";\nimport { addArgs, parseArgs } from \"@dbx-tools/cli-args\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { frp, interceptor, portr } from \"@dbx-tools/tunnel\";\nimport { Command, CommanderError } from \"commander\";\n\nimport { resolveTunnelOptions, TunnelOptionsSchema, type TunnelOptions } from \"./options.ts\";\nimport { startProxy } from \"./proxy.ts\";\n\nexport { CommanderError };\n\nconst logger = log.logger(\"tunnel\");\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 * 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 AppKitChildProcess[]): void {\n  let stopping = false;\n  const stop = (code: number): void => {\n    if (stopping) return;\n    stopping = true;\n    void Promise.allSettled(children.map((child) => child.shutdown())).then(() => {\n      process.exit(code);\n    });\n  };\n  for (const child of children) {\n    void child.process?.on(\"exit\", (code) => stop(code ?? 1));\n  }\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  const resolved = resolveTunnelOptions(raw);\n  const children: AppKitChildProcess[] = [];\n\n  // Two upstream modes:\n  //   - WRAP: a command after `--`. The wrapper spawns it on a private loopback\n  //     port and is the only thing that talks to it.\n  //   - ATTACH: no command, but `--app-port` names an already-running upstream\n  //     (e.g. a local reverse proxy). The gate fronts it without spawning a\n  //     child. This is what lets the gate sit on an interface in front of a\n  //     separately-supervised stack.\n  let appPort: number;\n  if (executable) {\n    appPort = resolved.appPort ?? (await freePort());\n    const app = new AppKitChildProcess(\n      [\n        executable,\n        args,\n        {\n          env: {\n            ...process.env,\n            DATABRICKS_APP_PORT: String(appPort),\n            PORT: String(appPort),\n            HOST: \"127.0.0.1\",\n          },\n          stdin: \"inherit\",\n          stdout: \"inherit\",\n          stderr: \"inherit\",\n        },\n      ],\n      { gracefulTimeoutMs: 10_000 },\n    );\n    void app.start();\n    children.push(app);\n  } else if (resolved.appPort) {\n    appPort = resolved.appPort;\n    logger.info(\"attaching gate to existing upstream\", { appPort });\n  } else {\n    throw new CommanderError(\n      1,\n      \"tunnel.no-upstream\",\n      \"no command given (pass it after `--`) and no --app-port to attach to\",\n    );\n  }\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 (\n        await import(\"./app.ts\")\n      ).startGateApp({\n        ...resolved.gateConfig,\n        publicDomain: resolved.gate.publicDomain ?? `localhost:${resolved.publicPort}`,\n      });\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    gatePaths: resolved.gate.gatePaths,\n    brandName: resolved.gate.brandName,\n    bindHosts: resolved.bindHosts,\n  });\n\n  if ((resolved.transport === \"portr\" || resolved.transport === \"both\") && 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  }\n  if ((resolved.transport === \"frp\" || resolved.transport === \"both\") && resolved.frp) {\n    const frpEnv = await frp.installFrp();\n    const configPath = await frp.writeFrpConfig(resolved.frp, frpEnv);\n    children.push(frp.startFrp(resolved.frp, frpEnv, configPath));\n  }\n  const activeTunnelCount = children.length - (executable ? 1 : 0);\n  if (!activeTunnelCount) {\n    logger.info(\"no selected public tunnel is configured\", {\n      transport: resolved.transport,\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 = addArgs(\n    new Command()\n      .name(name)\n      .description(\"Front a command with a public tunnel and passwordless auth\"),\n    TunnelOptionsSchema,\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[]) => {\n      await run(parseArgs(program, TunnelOptionsSchema), command);\n    });\n\n  const runCommand = addArgs(\n    program.command(\"run\").description(\"Wrap a command (the default action)\"),\n    TunnelOptionsSchema,\n  );\n  runCommand\n    .argument(\"<command...>\", \"the command to wrap, after `--`\")\n    .action(async (command: string[]) => {\n      await run(parseArgs(runCommand, TunnelOptionsSchema), 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  const statusCommand = addArgs(\n    program.command(\"status\").description(\"Resolve the configuration and print it\"),\n    TunnelOptionsSchema,\n  );\n  statusCommand.action(() => {\n    const resolved = resolveTunnelOptions(parseArgs(statusCommand, TunnelOptionsSchema));\n    process.stdout.write(`${JSON.stringify(resolved, null, 2)}\\n`);\n  });\n\n  program\n    .command(\"install\")\n    .argument(\"[transport]\", \"portr, frp, or both\", \"portr\")\n    .description(\"Install public tunnel client binaries and exit\")\n    .action(async (transport: string) => {\n      const parsed = interceptor.TunnelTransportSchema.parse(transport);\n      if (parsed === \"portr\" || parsed === \"both\") await portr.installPortr();\n      if (parsed === \"frp\" || parsed === \"both\") await frp.installFrp();\n    });\n\n  return program;\n}\n"]}

package/lib/src/tunnel/options.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 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, frp, interceptor, plugin, portr } from "@dbx-tools/tunnel";
+import { z } from "zod";
+export declare const TunnelOptionsSchema: z.ZodObject<{
+    transport: z.ZodOptional<z.ZodEnum<{
+        both: "both";
+        portr: "portr";
+        frp: "frp";
+    }>>;
+    publicDomain: z.ZodOptional<z.ZodString>;
+    subdomain: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodCoercedNumber<number>>;
+    appPort: z.ZodOptional<z.ZodCoercedNumber<number>>;
+    allow: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+    subject: z.ZodOptional<z.ZodString>;
+    brandName: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    sessionTtlSeconds: z.ZodOptional<z.ZodCoercedNumber<number>>;
+    codeTtlSeconds: z.ZodOptional<z.ZodCoercedNumber<number>>;
+    sessionCutoff: z.ZodOptional<z.ZodString>;
+    storage: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        lakebase: "lakebase";
+        sqlite: "sqlite";
+    }>>;
+    sqlitePath: z.ZodOptional<z.ZodString>;
+    forwardHeaders: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+    gatePaths: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+    bindHosts: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+    insecure: z.ZodOptional<z.ZodBoolean>;
+    frpServer: z.ZodOptional<z.ZodString>;
+    frpPublicDomain: z.ZodOptional<z.ZodString>;
+    frpServerPort: z.ZodOptional<z.ZodCoercedNumber<number>>;
+    frpProtocol: z.ZodOptional<z.ZodString>;
+    frpToken: z.ZodOptional<z.ZodString>;
+    frpProxyName: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TunnelOptions = z.output<typeof TunnelOptionsSchema>;
+/** Fully resolved listener, gate, and transport settings used to start a tunnel. */
+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;
+    /** Interface IPs the gate listens on. Empty means the default (0.0.0.0). */
+    bindHosts: string[];
+    transport: interceptor.TunnelTransport;
+    /**
+     * 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>;
+    frp: ReturnType<typeof frp.resolveFrpConfig>;
+}
+/** Resolve CLI flag values through the owning tunnel and auth-gate configuration rules. */
+export declare function resolveTunnelOptions(options: TunnelOptions): ResolvedTunnelOptions;

package/lib/src/tunnel/options.js

@@ -0,0 +1,138 @@
+/**
+ * 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 { configUtils } from "@dbx-tools/core";
+import { options as sharedOptions, stringUtils } from "@dbx-tools/shared-core";
+import { frp, interceptor, plugin, portr } from "@dbx-tools/tunnel";
+import { z } from "zod";
+const text = (description) => z.string().trim().min(1).optional().describe(description);
+const port = (description) => sharedOptions.tcpPortOrZeroSchema.optional().describe(description);
+const list = (description) => z
+    .preprocess((value) => (typeof value === "string" ? stringUtils.parseList(value) : value), z.array(z.string().trim().min(1)))
+    .optional()
+    .describe(description);
+export const TunnelOptionsSchema = z
+    .object({
+    transport: interceptor.TunnelTransportSchema.optional()
+        .describe("Public tunnel transport.")
+        .meta({ env: "TUNNEL_TRANSPORT" }),
+    publicDomain: text("Public tunnel domain.").meta({ env: "TUNNEL_PUBLIC_DOMAIN" }),
+    subdomain: text("Portr subdomain."),
+    port: port("Public listener port.").meta({
+        env: sharedOptions.databricksEnvironmentNames.appPort,
+    }),
+    appPort: port("Private wrapped application port.").meta({
+        env: ["TUNNEL_APP_PORT", "APP_PORT"],
+    }),
+    allow: list("Email allow-list patterns.").meta({ env: "TUNNEL_AUTH_ALLOW" }),
+    subject: text("Verification email subject.").meta({ env: "TUNNEL_AUTH_SUBJECT" }),
+    brandName: text("Verification email brand name.").meta({ env: "TUNNEL_AUTH_BRAND_NAME" }),
+    message: text("Verification email message.").meta({ env: "TUNNEL_AUTH_MESSAGE" }),
+    sessionTtlSeconds: z.coerce
+        .number()
+        .positive()
+        .optional()
+        .describe("Session lifetime in seconds.")
+        .meta({ env: "TUNNEL_AUTH_SESSION_TTL" }),
+    codeTtlSeconds: z.coerce
+        .number()
+        .positive()
+        .optional()
+        .describe("One-time-code lifetime in seconds.")
+        .meta({ env: "TUNNEL_AUTH_CODE_TTL" }),
+    sessionCutoff: text("Invalidate sessions issued before this value.").meta({
+        env: "TUNNEL_AUTH_SESSION_CUTOFF",
+    }),
+    storage: z
+        .enum(["auto", "lakebase", "sqlite"])
+        .optional()
+        .describe("Authentication database mode.")
+        .meta({ env: "TUNNEL_AUTH_STORAGE" }),
+    sqlitePath: text("Local authentication SQLite file.").meta({
+        env: "TUNNEL_AUTH_SQLITE_PATH",
+    }),
+    forwardHeaders: list("Additional forwarded request header patterns.").meta({
+        env: "TUNNEL_FORWARD_HEADERS",
+    }),
+    gatePaths: list("Additional path prefixes requiring authentication.").meta({
+        env: "TUNNEL_GATE_PATHS",
+    }),
+    bindHosts: list("Interface IPs the gate listens on."),
+    insecure: z
+        .boolean()
+        .optional()
+        .describe("Run without an authentication gate.")
+        .meta({ env: "TUNNEL_INSECURE" }),
+    frpServer: text("FRP control host.").meta({ env: "FRP_SERVER" }),
+    frpPublicDomain: text("FRP public HTTP domain.").meta({
+        env: "TUNNEL_FRP_PUBLIC_DOMAIN",
+    }),
+    frpServerPort: port("FRP control port.").meta({ env: "FRP_SERVER_PORT" }),
+    frpProtocol: text("FRP transport protocol.").meta({ env: "FRP_PROTOCOL" }),
+    frpToken: text("FRP authentication token.").meta({ env: ["FRP_TOKEN", "TUNNEL_TOKEN"] }),
+    frpProxyName: text("FRP proxy registration name.").meta({ env: "FRP_PROXY_NAME" }),
+})
+    .strict()
+    .describe("Public tunnel wrapper command-line options.");
+/** Resolve CLI flag values through the owning tunnel and auth-gate configuration rules. */
+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 = configUtils.port(options.port, "DATABRICKS_APP_PORT", 8000);
+    const appPort = configUtils.port(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: options.sessionTtlSeconds,
+        codeTtlSeconds: options.codeTtlSeconds,
+        sessionCutoff: options.sessionCutoff,
+        storage: options.storage,
+        sqlitePath: options.sqlitePath,
+        forwardHeaders: options.forwardHeaders,
+        gatePaths: options.gatePaths,
+        insecure: options.insecure,
+        publicDomain: options.publicDomain,
+        publicDomains: options.frpPublicDomain ? [options.frpPublicDomain] : undefined,
+    };
+    const gate = plugin.resolveAuthGateConfig(gateConfig);
+    const transport = interceptor.resolveTunnelTransport(options.transport);
+    return {
+        publicPort,
+        ...(appPort > 0 ? { appPort } : {}),
+        bindHosts: options.bindHosts ?? [],
+        transport,
+        gateConfig,
+        gate,
+        portr: portr.resolvePortrConfig({
+            publicDomain: gate.publicDomain,
+            subdomain: options.subdomain,
+            port: publicPort,
+        }),
+        frp: frp.resolveFrpConfig({
+            publicDomain: options.frpPublicDomain,
+            server: options.frpServer,
+            serverPort: options.frpServerPort,
+            protocol: options.frpProtocol,
+            token: options.frpToken,
+            proxyName: options.frpProxyName,
+            port: publicPort,
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../src/tunnel/options.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Flag -> config -> default resolution for `dbx tunnel`.\n *\n * The point of this module is that it does almost NOTHING itself: every gate\n * setting is handed straight to `@dbx-tools/tunnel`'s own\n * `plugin.resolveAuthGateConfig`, which is the same function the in-process\n * plugin path calls. The CLI therefore cannot drift from the plugin on a default,\n * an env name, or a coercion rule - a flag is just a value passed where the\n * plugin's `config` object would go, and `config.*` fills the rest in from the\n * environment, a `.env` file, or `databricks.yml`.\n *\n * @module\n */\n\nimport { configUtils } from \"@dbx-tools/core\";\nimport { options as sharedOptions, stringUtils } from \"@dbx-tools/shared-core\";\nimport { type AuthGateConfig, frp, interceptor, plugin, portr } from \"@dbx-tools/tunnel\";\nimport { z } from \"zod\";\n\nconst text = (description: string) => z.string().trim().min(1).optional().describe(description);\nconst port = (description: string) =>\n  sharedOptions.tcpPortOrZeroSchema.optional().describe(description);\nconst list = (description: string) =>\n  z\n    .preprocess(\n      (value) => (typeof value === \"string\" ? stringUtils.parseList(value) : value),\n      z.array(z.string().trim().min(1)),\n    )\n    .optional()\n    .describe(description);\n\nexport const TunnelOptionsSchema = z\n  .object({\n    transport: interceptor.TunnelTransportSchema.optional()\n      .describe(\"Public tunnel transport.\")\n      .meta({ env: \"TUNNEL_TRANSPORT\" }),\n    publicDomain: text(\"Public tunnel domain.\").meta({ env: \"TUNNEL_PUBLIC_DOMAIN\" }),\n    subdomain: text(\"Portr subdomain.\"),\n    port: port(\"Public listener port.\").meta({\n      env: sharedOptions.databricksEnvironmentNames.appPort,\n    }),\n    appPort: port(\"Private wrapped application port.\").meta({\n      env: [\"TUNNEL_APP_PORT\", \"APP_PORT\"],\n    }),\n    allow: list(\"Email allow-list patterns.\").meta({ env: \"TUNNEL_AUTH_ALLOW\" }),\n    subject: text(\"Verification email subject.\").meta({ env: \"TUNNEL_AUTH_SUBJECT\" }),\n    brandName: text(\"Verification email brand name.\").meta({ env: \"TUNNEL_AUTH_BRAND_NAME\" }),\n    message: text(\"Verification email message.\").meta({ env: \"TUNNEL_AUTH_MESSAGE\" }),\n    sessionTtlSeconds: z.coerce\n      .number<number>()\n      .positive()\n      .optional()\n      .describe(\"Session lifetime in seconds.\")\n      .meta({ env: \"TUNNEL_AUTH_SESSION_TTL\" }),\n    codeTtlSeconds: z.coerce\n      .number<number>()\n      .positive()\n      .optional()\n      .describe(\"One-time-code lifetime in seconds.\")\n      .meta({ env: \"TUNNEL_AUTH_CODE_TTL\" }),\n    sessionCutoff: text(\"Invalidate sessions issued before this value.\").meta({\n      env: \"TUNNEL_AUTH_SESSION_CUTOFF\",\n    }),\n    storage: z\n      .enum([\"auto\", \"lakebase\", \"sqlite\"])\n      .optional()\n      .describe(\"Authentication database mode.\")\n      .meta({ env: \"TUNNEL_AUTH_STORAGE\" }),\n    sqlitePath: text(\"Local authentication SQLite file.\").meta({\n      env: \"TUNNEL_AUTH_SQLITE_PATH\",\n    }),\n    forwardHeaders: list(\"Additional forwarded request header patterns.\").meta({\n      env: \"TUNNEL_FORWARD_HEADERS\",\n    }),\n    gatePaths: list(\"Additional path prefixes requiring authentication.\").meta({\n      env: \"TUNNEL_GATE_PATHS\",\n    }),\n    bindHosts: list(\"Interface IPs the gate listens on.\"),\n    insecure: z\n      .boolean()\n      .optional()\n      .describe(\"Run without an authentication gate.\")\n      .meta({ env: \"TUNNEL_INSECURE\" }),\n    frpServer: text(\"FRP control host.\").meta({ env: \"FRP_SERVER\" }),\n    frpPublicDomain: text(\"FRP public HTTP domain.\").meta({\n      env: \"TUNNEL_FRP_PUBLIC_DOMAIN\",\n    }),\n    frpServerPort: port(\"FRP control port.\").meta({ env: \"FRP_SERVER_PORT\" }),\n    frpProtocol: text(\"FRP transport protocol.\").meta({ env: \"FRP_PROTOCOL\" }),\n    frpToken: text(\"FRP authentication token.\").meta({ env: [\"FRP_TOKEN\", \"TUNNEL_TOKEN\"] }),\n    frpProxyName: text(\"FRP proxy registration name.\").meta({ env: \"FRP_PROXY_NAME\" }),\n  })\n  .strict()\n  .describe(\"Public tunnel wrapper command-line options.\");\n\nexport type TunnelOptions = z.output<typeof TunnelOptionsSchema>;\n\n/** Fully resolved listener, gate, and transport settings used to start a tunnel. */\nexport interface ResolvedTunnelOptions {\n  /** The port the wrapper itself listens on - what portr forwards to. */\n  publicPort: number;\n  /** The private port the wrapped app is told to bind. Unset means \"pick one\". */\n  appPort?: number;\n  /** Interface IPs the gate listens on. Empty means the default (0.0.0.0). */\n  bindHosts: string[];\n  transport: interceptor.TunnelTransport;\n  /**\n   * The gate config as the `authGate` PLUGIN takes it - flags only, nothing\n   * resolved. Passed straight to the plugin so it applies its own fallbacks\n   * exactly once, in the one place that owns them.\n   */\n  gateConfig: AuthGateConfig;\n  /** The same config after the plugin's resolution, for `status` and for routing. */\n  gate: plugin.ResolvedAuthGateConfig;\n  portr: ReturnType<typeof portr.resolvePortrConfig>;\n  frp: ReturnType<typeof frp.resolveFrpConfig>;\n}\n\n/** Resolve CLI flag values through the owning tunnel and auth-gate configuration rules. */\nexport function resolveTunnelOptions(options: TunnelOptions): ResolvedTunnelOptions {\n  // The Databricks Apps runtime contract: the platform routes to\n  // DATABRICKS_APP_PORT, so the WRAPPER claims it and the wrapped app is moved\n  // to a private one.\n  const publicPort = configUtils.port(options.port, \"DATABRICKS_APP_PORT\", 8000);\n  const appPort = configUtils.port(options.appPort, \"APP_PORT\", 0, { prefix: \"TUNNEL\" });\n  const gateConfig: AuthGateConfig = {\n    allow: options.allow,\n    subject: options.subject,\n    brandName: options.brandName,\n    message: options.message,\n    // Coerced, not resolved: the plugin owns the env name and the default for\n    // these, so the flag is passed through as the `config` value it expects and\n    // only needs a string -> number nudge on the way.\n    sessionTtlSeconds: options.sessionTtlSeconds,\n    codeTtlSeconds: options.codeTtlSeconds,\n    sessionCutoff: options.sessionCutoff,\n    storage: options.storage,\n    sqlitePath: options.sqlitePath,\n    forwardHeaders: options.forwardHeaders,\n    gatePaths: options.gatePaths,\n    insecure: options.insecure,\n    publicDomain: options.publicDomain,\n    publicDomains: options.frpPublicDomain ? [options.frpPublicDomain] : undefined,\n  };\n  const gate = plugin.resolveAuthGateConfig(gateConfig);\n  const transport = interceptor.resolveTunnelTransport(options.transport);\n  return {\n    publicPort,\n    ...(appPort > 0 ? { appPort } : {}),\n    bindHosts: options.bindHosts ?? [],\n    transport,\n    gateConfig,\n    gate,\n    portr: portr.resolvePortrConfig({\n      publicDomain: gate.publicDomain,\n      subdomain: options.subdomain,\n      port: publicPort,\n    }),\n    frp: frp.resolveFrpConfig({\n      publicDomain: options.frpPublicDomain,\n      server: options.frpServer,\n      serverPort: options.frpServerPort,\n      protocol: options.frpProtocol,\n      token: options.frpToken,\n      proxyName: options.frpProxyName,\n      port: publicPort,\n    }),\n  };\n}\n"]}

package/lib/src/tunnel/proxy.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The reverse proxy that makes the wrapper path possible.
+ *
+ * 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.
+ *
+ * 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 "@dbx-tools/tunnel";
+/** Listener, upstream application, and optional authentication settings for the wrapper proxy. */
+export interface ProxyOptions {
+    /** The port this proxy listens on - the port portr and the platform route to. */
+    publicPort: number;
+    /** The private loopback port the wrapped app listens on. */
+    appPort: number;
+    /** The gate handlers. Omitted (an `--insecure` run) forwards everything. */
+    gate?: AuthGateApi;
+    /** Extra `x-` headers tunnel traffic may forward. */
+    forwardHeaders?: readonly string[];
+    /** Path prefixes to gate beyond `/api/` (e.g. `/ws` for a WebSocket app). */
+    gatePaths?: readonly string[];
+    /** Brand name for the hosted login page shown on a denied browser navigation. */
+    brandName?: string;
+    /**
+     * Addresses to listen on. Defaults to a single `0.0.0.0` (every interface),
+     * the portr/platform case. Pass specific interface IPs to expose the gate on
+     * only those - e.g. an overlay/LAN address while loopback reaches the upstream
+     * directly and ungated.
+     */
+    bindHosts?: readonly string[];
+}
+/**
+ * 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>;