@dbx-tools/tunnel 0.6.123 → 0.6.124

package/lib/src/interceptor.d.ts

@@ -16,7 +16,9 @@
  *
  * @module
  */
-import type { Interceptor } from "@dbx-tools/appkit";
+import type { Interceptor, InterceptorContext } from "@dbx-tools/appkit";
+import { resolveFrpConfig } from "./frp.ts";
+import { resolvePortrConfig } from "./portr.ts";
 /** Options for {@link tunnelInterceptor} (each also resolvable from env). */
 export interface TunnelInterceptorOptions {
     /** Tunnel clients to run. Env `DBX_TOOLS_TUNNEL_TRANSPORT`; defaults to `portr`. */
@@ -50,6 +52,13 @@ export interface TunnelInterceptorOptions {
 }
 /** Public tunnel clients supported by the interceptor and CLI. */
 export type TunnelTransport = "portr" | "frp" | "both";
+interface TunnelAuxiliary {
+    stop(): void;
+}
+interface TunnelRuntime {
+    startPortr(config: NonNullable<ReturnType<typeof resolvePortrConfig>>): Promise<TunnelAuxiliary>;
+    startFrp(config: NonNullable<ReturnType<typeof resolveFrpConfig>>, ctx: InterceptorContext): Promise<TunnelAuxiliary>;
+}
 /** Resolve and validate the tunnel transport selector. */
 export declare function resolveTunnelTransport(transport?: string): TunnelTransport;
 /**
@@ -67,4 +76,5 @@ export declare function resolveTunnelTransport(transport?: string): TunnelTransp
  *   interceptor: tunnelInterceptor(),
  * });
  */
-export declare function tunnelInterceptor(options?: TunnelInterceptorOptions): Interceptor;
+export declare function tunnelInterceptor(options?: TunnelInterceptorOptions, runtime?: TunnelRuntime): Interceptor;
+export {};

package/lib/src/interceptor.js

@@ -21,12 +21,34 @@ import { installFrp, resolveFrpConfig, superviseFrp, writeFrpConfig } from "./fr
 import { installPortr, resolvePortrConfig, supervisePortr, writePortrConfig } from "./portr.js";
 import { startPathProxy } from "./path-proxy.js";
 const logger = log.logger("tunnel:interceptor");
+const defaultRuntime = {
+    async startPortr(config) {
+        const portrEnv = await installPortr();
+        await writePortrConfig(config, portrEnv);
+        return supervisePortr(config, portrEnv);
+    },
+    async startFrp(config, ctx) {
+        const pathProxy = config.stripPrefix && config.path !== "/"
+            ? await startPathProxy(config.targetPort, config.path)
+            : undefined;
+        if (pathProxy) {
+            config.targetPort = pathProxy.port;
+            ctx.onLifecycle("shutdown", () => void pathProxy.close());
+        }
+        const frpEnv = await installFrp();
+        const configPath = await writeFrpConfig(config, frpEnv);
+        const supervisor = superviseFrp(config, frpEnv, configPath);
+        return {
+            stop() {
+                supervisor.stop();
+                void pathProxy?.close();
+            },
+        };
+    },
+};
 /** Resolve and validate the tunnel transport selector. */
 export function resolveTunnelTransport(transport) {
-    const resolved = transport ??
-        process.env.DBX_TOOLS_TUNNEL_TRANSPORT ??
-        process.env.TUNNEL_TRANSPORT ??
-        "portr";
+    const resolved = transport ?? process.env.DBX_TOOLS_TUNNEL_TRANSPORT ?? process.env.TUNNEL_TRANSPORT ?? "portr";
     if (resolved === "portr" || resolved === "frp" || resolved === "both")
         return resolved;
     throw new TypeError(`invalid tunnel transport: ${resolved} (expected portr, frp, or both)`);
@@ -50,14 +72,14 @@ function resolvePublicPort(port) {
  *   interceptor: tunnelInterceptor(),
  * });
  */
-export function tunnelInterceptor(options = {}) {
+export function tunnelInterceptor(options = {}, runtime = defaultRuntime) {
     return async (ctx) => {
         if (ctx.env.databricksHost) {
             process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;
         }
         const port = resolvePublicPort(options.port);
         const transport = resolveTunnelTransport(options.transport);
-        const auxiliaries = [];
+        const initializers = [];
         if (transport === "portr" || transport === "both") {
             const portrConfig = resolvePortrConfig({
                 publicDomain: options.publicDomain,
@@ -65,9 +87,7 @@ export function tunnelInterceptor(options = {}) {
                 port,
             });
             if (portrConfig) {
-                const portrEnv = await installPortr();
-                await writePortrConfig(portrConfig, portrEnv);
-                auxiliaries.push(supervisePortr(portrConfig, portrEnv));
+                initializers.push(runtime.startPortr(portrConfig));
             }
             else {
                 logger.info("portr not configured (requires PORTR_TOKEN and TUNNEL_PUBLIC_DOMAIN)");
@@ -86,32 +106,38 @@ export function tunnelInterceptor(options = {}) {
                 port,
             });
             if (frpConfig) {
-                const pathProxy = frpConfig.stripPrefix && frpConfig.path !== "/"
-                    ? await startPathProxy(port, frpConfig.path)
-                    : undefined;
-                if (pathProxy) {
-                    frpConfig.targetPort = pathProxy.port;
-                    ctx.onLifecycle("shutdown", () => void pathProxy.close());
-                }
-                const frpEnv = await installFrp();
-                const configPath = await writeFrpConfig(frpConfig, frpEnv);
-                auxiliaries.push(superviseFrp(frpConfig, frpEnv, configPath));
+                initializers.push(runtime.startFrp(frpConfig, ctx));
             }
             else {
                 logger.info("frp not configured (requires TUNNEL_PUBLIC_DOMAIN)");
             }
         }
-        if (!auxiliaries.length)
+        if (!initializers.length)
             return;
-        ctx.onTeardown(() => {
-            for (const auxiliary of auxiliaries)
-                auxiliary.stop();
-        });
-        ctx.onLifecycle("shutdown", () => {
+        const auxiliaries = [];
+        let stopped = false;
+        const stop = () => {
+            stopped = true;
             for (const auxiliary of auxiliaries)
                 auxiliary.stop();
+        };
+        ctx.onTeardown(stop);
+        ctx.onLifecycle("shutdown", stop);
+        void Promise.allSettled(initializers).then((results) => {
+            for (const result of results) {
+                if (result.status === "rejected") {
+                    logger.error("tunnel failed to start", { error: result.reason });
+                    continue;
+                }
+                if (stopped)
+                    result.value.stop();
+                else
+                    auxiliaries.push(result.value);
+            }
+            if (!stopped && auxiliaries.length)
+                logger.info(`tunnel bound: ${transport} -> :${port}`);
         });
-        logger.info(`tunnel bound: ${transport} -> :${port}`);
+        logger.info(`tunnel initialization scheduled: ${transport} -> :${port}`);
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `tunnelInterceptor()` - the {@link Interceptor} that fronts an app with a public\n * portr and/or frp tunnel, consuming the {@link InterceptorContext} `@dbx-tools/appkit`'s\n * `createApp` hands it.\n *\n * The tunnel runs IN-PROCESS: the APP is the main process and hands this interceptor\n * its context, rather than a wrapper process spawning the app as a child. The\n * interceptor applies the computed workspace host, installs and launches portr on the\n * app's public port, binds the child process to the app, and stops portr during an\n * orderly AppKit shutdown.\n *\n * The passwordless GATE is a separate concern: it is the `authGate` AppKit plugin,\n * which registers the login routes + a gating middleware on the app's own server.\n * Register it in the app's `plugins` for gated traffic. This interceptor is only\n * the portr half - \"update the host, bind portr\" - the smallest useful unit.\n *\n * @module\n */\n\nimport type { Interceptor, InterceptorContext } from \"@dbx-tools/appkit\";\nimport { log, object } from \"@dbx-tools/shared-core\";\nimport { installFrp, resolveFrpConfig, superviseFrp, writeFrpConfig } from \"./frp.ts\";\nimport { installPortr, resolvePortrConfig, supervisePortr, writePortrConfig } from \"./portr.ts\";\nimport { startPathProxy } from \"./path-proxy.ts\";\n\nconst logger = log.logger(\"tunnel:interceptor\");\n\n/** Options for {@link tunnelInterceptor} (each also resolvable from env). */\nexport interface TunnelInterceptorOptions {\n  /** Tunnel clients to run. Env `DBX_TOOLS_TUNNEL_TRANSPORT`; defaults to `portr`. */\n  transport?: TunnelTransport;\n  /** Public host to serve on. Env `TUNNEL_PUBLIC_DOMAIN`. */\n  publicDomain?: string;\n  /** portr subdomain (else derived from {@link publicDomain}). */\n  subdomain?: string;\n  /**\n   * The PUBLIC port portr forwards to - the port the app itself listens on.\n   * Defaults to the Databricks Apps runtime contract `DATABRICKS_APP_PORT`\n   * (then `8000`), which is the port the platform routes to.\n   */\n  port?: number;\n  /** frps control host; defaults to the FRP public domain. Env `FRP_SERVER`. */\n  frpServer?: string;\n  /** FRP public HTTP host. Env `TUNNEL_FRP_PUBLIC_DOMAIN`. */\n  frpPublicDomain?: string;\n  /** frps control port. Env `FRP_SERVER_PORT`; defaults to `443`. */\n  frpServerPort?: number;\n  /** frpc transport protocol. Env `FRP_PROTOCOL`; defaults to `wss`. */\n  frpProtocol?: string;\n  /** frps auth token. Env `FRP_TOKEN` (or `TUNNEL_TOKEN`). */\n  frpToken?: string;\n  /** frp proxy registration name. Env `FRP_PROXY_NAME`. */\n  frpProxyName?: string;\n  /** FRP path location. Env `FRP_PATH`; defaults to `DATABRICKS_APP_NAME`. */\n  frpPath?: string;\n  /** Strip the FRP path before forwarding. Env `FRP_STRIP_PREFIX`; defaults true for non-root paths. */\n  frpStripPrefix?: boolean;\n}\n\n/** Public tunnel clients supported by the interceptor and CLI. */\nexport type TunnelTransport = \"portr\" | \"frp\" | \"both\";\n\n/** Resolve and validate the tunnel transport selector. */\nexport function resolveTunnelTransport(transport?: string): TunnelTransport {\n  const resolved =\n    transport ??\n    process.env.DBX_TOOLS_TUNNEL_TRANSPORT ??\n    process.env.TUNNEL_TRANSPORT ??\n    \"portr\";\n  if (resolved === \"portr\" || resolved === \"frp\" || resolved === \"both\") return resolved;\n  throw new TypeError(`invalid tunnel transport: ${resolved} (expected portr, frp, or both)`);\n}\n\n/** Resolve the public port portr should target: explicit, else the Apps contract. */\nfunction resolvePublicPort(port?: number): number {\n  return port ?? object.toNumber(process.env.DATABRICKS_APP_PORT) ?? 8000;\n}\n\n/**\n * Build the tunnel {@link Interceptor}. Pass it to `createApp({ interceptor })`.\n *\n * A no-op (logs and returns) when none of the selected tunnel clients resolve\n * usable configuration, so an app can register it unconditionally.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n * import { tunnelInterceptor } from \"@dbx-tools/tunnel\";\n *\n * await appkit.createApp({\n *   plugins: [server({ host, staticPath })],\n *   interceptor: tunnelInterceptor(),\n * });\n */\nexport function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Interceptor {\n  return async (ctx: InterceptorContext): Promise<void> => {\n    if (ctx.env.databricksHost) {\n      process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;\n    }\n\n    const port = resolvePublicPort(options.port);\n    const transport = resolveTunnelTransport(options.transport);\n    const auxiliaries: Array<{ stop(): void }> = [];\n    if (transport === \"portr\" || transport === \"both\") {\n      const portrConfig = resolvePortrConfig({\n        publicDomain: options.publicDomain,\n        subdomain: options.subdomain,\n        port,\n      });\n      if (portrConfig) {\n        const portrEnv = await installPortr();\n        await writePortrConfig(portrConfig, portrEnv);\n        auxiliaries.push(supervisePortr(portrConfig, portrEnv));\n      } else {\n        logger.info(\"portr not configured (requires PORTR_TOKEN and TUNNEL_PUBLIC_DOMAIN)\");\n      }\n    }\n    if (transport === \"frp\" || transport === \"both\") {\n      const frpConfig = 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        path: options.frpPath,\n        stripPrefix: options.frpStripPrefix,\n        port,\n      });\n      if (frpConfig) {\n        const pathProxy =\n          frpConfig.stripPrefix && frpConfig.path !== \"/\"\n            ? await startPathProxy(port, frpConfig.path)\n            : undefined;\n        if (pathProxy) {\n          frpConfig.targetPort = pathProxy.port;\n          ctx.onLifecycle(\"shutdown\", () => void pathProxy.close());\n        }\n        const frpEnv = await installFrp();\n        const configPath = await writeFrpConfig(frpConfig, frpEnv);\n        auxiliaries.push(superviseFrp(frpConfig, frpEnv, configPath));\n      } else {\n        logger.info(\"frp not configured (requires TUNNEL_PUBLIC_DOMAIN)\");\n      }\n    }\n    if (!auxiliaries.length) return;\n    ctx.onTeardown(() => {\n      for (const auxiliary of auxiliaries) auxiliary.stop();\n    });\n    ctx.onLifecycle(\"shutdown\", () => {\n      for (const auxiliary of auxiliaries) auxiliary.stop();\n    });\n    logger.info(`tunnel bound: ${transport} -> :${port}`);\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `tunnelInterceptor()` - the {@link Interceptor} that fronts an app with a public\n * portr and/or frp tunnel, consuming the {@link InterceptorContext} `@dbx-tools/appkit`'s\n * `createApp` hands it.\n *\n * The tunnel runs IN-PROCESS: the APP is the main process and hands this interceptor\n * its context, rather than a wrapper process spawning the app as a child. The\n * interceptor applies the computed workspace host, installs and launches portr on the\n * app's public port, binds the child process to the app, and stops portr during an\n * orderly AppKit shutdown.\n *\n * The passwordless GATE is a separate concern: it is the `authGate` AppKit plugin,\n * which registers the login routes + a gating middleware on the app's own server.\n * Register it in the app's `plugins` for gated traffic. This interceptor is only\n * the portr half - \"update the host, bind portr\" - the smallest useful unit.\n *\n * @module\n */\n\nimport type { Interceptor, InterceptorContext } from \"@dbx-tools/appkit\";\nimport { log, object } from \"@dbx-tools/shared-core\";\nimport { installFrp, resolveFrpConfig, superviseFrp, writeFrpConfig } from \"./frp.ts\";\nimport { installPortr, resolvePortrConfig, supervisePortr, writePortrConfig } from \"./portr.ts\";\nimport { startPathProxy } from \"./path-proxy.ts\";\n\nconst logger = log.logger(\"tunnel:interceptor\");\n\n/** Options for {@link tunnelInterceptor} (each also resolvable from env). */\nexport interface TunnelInterceptorOptions {\n  /** Tunnel clients to run. Env `DBX_TOOLS_TUNNEL_TRANSPORT`; defaults to `portr`. */\n  transport?: TunnelTransport;\n  /** Public host to serve on. Env `TUNNEL_PUBLIC_DOMAIN`. */\n  publicDomain?: string;\n  /** portr subdomain (else derived from {@link publicDomain}). */\n  subdomain?: string;\n  /**\n   * The PUBLIC port portr forwards to - the port the app itself listens on.\n   * Defaults to the Databricks Apps runtime contract `DATABRICKS_APP_PORT`\n   * (then `8000`), which is the port the platform routes to.\n   */\n  port?: number;\n  /** frps control host; defaults to the FRP public domain. Env `FRP_SERVER`. */\n  frpServer?: string;\n  /** FRP public HTTP host. Env `TUNNEL_FRP_PUBLIC_DOMAIN`. */\n  frpPublicDomain?: string;\n  /** frps control port. Env `FRP_SERVER_PORT`; defaults to `443`. */\n  frpServerPort?: number;\n  /** frpc transport protocol. Env `FRP_PROTOCOL`; defaults to `wss`. */\n  frpProtocol?: string;\n  /** frps auth token. Env `FRP_TOKEN` (or `TUNNEL_TOKEN`). */\n  frpToken?: string;\n  /** frp proxy registration name. Env `FRP_PROXY_NAME`. */\n  frpProxyName?: string;\n  /** FRP path location. Env `FRP_PATH`; defaults to `DATABRICKS_APP_NAME`. */\n  frpPath?: string;\n  /** Strip the FRP path before forwarding. Env `FRP_STRIP_PREFIX`; defaults true for non-root paths. */\n  frpStripPrefix?: boolean;\n}\n\n/** Public tunnel clients supported by the interceptor and CLI. */\nexport type TunnelTransport = \"portr\" | \"frp\" | \"both\";\n\ninterface TunnelAuxiliary {\n  stop(): void;\n}\n\ninterface TunnelRuntime {\n  startPortr(config: NonNullable<ReturnType<typeof resolvePortrConfig>>): Promise<TunnelAuxiliary>;\n  startFrp(\n    config: NonNullable<ReturnType<typeof resolveFrpConfig>>,\n    ctx: InterceptorContext,\n  ): Promise<TunnelAuxiliary>;\n}\n\nconst defaultRuntime: TunnelRuntime = {\n  async startPortr(config) {\n    const portrEnv = await installPortr();\n    await writePortrConfig(config, portrEnv);\n    return supervisePortr(config, portrEnv);\n  },\n  async startFrp(config, ctx) {\n    const pathProxy =\n      config.stripPrefix && config.path !== \"/\"\n        ? await startPathProxy(config.targetPort, config.path)\n        : undefined;\n    if (pathProxy) {\n      config.targetPort = pathProxy.port;\n      ctx.onLifecycle(\"shutdown\", () => void pathProxy.close());\n    }\n    const frpEnv = await installFrp();\n    const configPath = await writeFrpConfig(config, frpEnv);\n    const supervisor = superviseFrp(config, frpEnv, configPath);\n    return {\n      stop() {\n        supervisor.stop();\n        void pathProxy?.close();\n      },\n    };\n  },\n};\n\n/** Resolve and validate the tunnel transport selector. */\nexport function resolveTunnelTransport(transport?: string): TunnelTransport {\n  const resolved =\n    transport ?? process.env.DBX_TOOLS_TUNNEL_TRANSPORT ?? process.env.TUNNEL_TRANSPORT ?? \"portr\";\n  if (resolved === \"portr\" || resolved === \"frp\" || resolved === \"both\") return resolved;\n  throw new TypeError(`invalid tunnel transport: ${resolved} (expected portr, frp, or both)`);\n}\n\n/** Resolve the public port portr should target: explicit, else the Apps contract. */\nfunction resolvePublicPort(port?: number): number {\n  return port ?? object.toNumber(process.env.DATABRICKS_APP_PORT) ?? 8000;\n}\n\n/**\n * Build the tunnel {@link Interceptor}. Pass it to `createApp({ interceptor })`.\n *\n * A no-op (logs and returns) when none of the selected tunnel clients resolve\n * usable configuration, so an app can register it unconditionally.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n * import { tunnelInterceptor } from \"@dbx-tools/tunnel\";\n *\n * await appkit.createApp({\n *   plugins: [server({ host, staticPath })],\n *   interceptor: tunnelInterceptor(),\n * });\n */\nexport function tunnelInterceptor(\n  options: TunnelInterceptorOptions = {},\n  runtime: TunnelRuntime = defaultRuntime,\n): Interceptor {\n  return async (ctx: InterceptorContext): Promise<void> => {\n    if (ctx.env.databricksHost) {\n      process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;\n    }\n\n    const port = resolvePublicPort(options.port);\n    const transport = resolveTunnelTransport(options.transport);\n    const initializers: Array<Promise<TunnelAuxiliary>> = [];\n    if (transport === \"portr\" || transport === \"both\") {\n      const portrConfig = resolvePortrConfig({\n        publicDomain: options.publicDomain,\n        subdomain: options.subdomain,\n        port,\n      });\n      if (portrConfig) {\n        initializers.push(runtime.startPortr(portrConfig));\n      } else {\n        logger.info(\"portr not configured (requires PORTR_TOKEN and TUNNEL_PUBLIC_DOMAIN)\");\n      }\n    }\n    if (transport === \"frp\" || transport === \"both\") {\n      const frpConfig = 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        path: options.frpPath,\n        stripPrefix: options.frpStripPrefix,\n        port,\n      });\n      if (frpConfig) {\n        initializers.push(runtime.startFrp(frpConfig, ctx));\n      } else {\n        logger.info(\"frp not configured (requires TUNNEL_PUBLIC_DOMAIN)\");\n      }\n    }\n    if (!initializers.length) return;\n    const auxiliaries: TunnelAuxiliary[] = [];\n    let stopped = false;\n    const stop = () => {\n      stopped = true;\n      for (const auxiliary of auxiliaries) auxiliary.stop();\n    };\n    ctx.onTeardown(stop);\n    ctx.onLifecycle(\"shutdown\", stop);\n    void Promise.allSettled(initializers).then((results) => {\n      for (const result of results) {\n        if (result.status === \"rejected\") {\n          logger.error(\"tunnel failed to start\", { error: result.reason });\n          continue;\n        }\n        if (stopped) result.value.stop();\n        else auxiliaries.push(result.value);\n      }\n      if (!stopped && auxiliaries.length) logger.info(`tunnel bound: ${transport} -> :${port}`);\n    });\n    logger.info(`tunnel initialization scheduled: ${transport} -> :${port}`);\n  };\n}\n"]}

package/package.json

@@ -23,16 +23,16 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@dbx-tools/email": "0.6.123"
+    "@dbx-tools/email": "0.6.124"
   },
   "dependencies": {
     "@databricks/appkit": "^0.60.0",
-    "@dbx-tools/appkit": "0.6.123",
-    "@dbx-tools/auth": "0.6.123",
-    "@dbx-tools/core": "0.6.123",
-    "@dbx-tools/email": "0.6.123",
-    "@dbx-tools/shared-auth": "0.6.123",
-    "@dbx-tools/shared-core": "0.6.123",
+    "@dbx-tools/appkit": "0.6.124",
+    "@dbx-tools/auth": "0.6.124",
+    "@dbx-tools/core": "0.6.124",
+    "@dbx-tools/email": "0.6.124",
+    "@dbx-tools/shared-auth": "0.6.124",
+    "@dbx-tools/shared-core": "0.6.124",
     "http-proxy-3": "^1.23.1"
   },
   "main": "./lib/index.js",
@@ -49,7 +49,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.123",
+  "version": "0.6.124",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/interceptor.ts

@@ -60,13 +60,49 @@ export interface TunnelInterceptorOptions {
 /** Public tunnel clients supported by the interceptor and CLI. */
 export type TunnelTransport = "portr" | "frp" | "both";
 
+interface TunnelAuxiliary {
+  stop(): void;
+}
+
+interface TunnelRuntime {
+  startPortr(config: NonNullable<ReturnType<typeof resolvePortrConfig>>): Promise<TunnelAuxiliary>;
+  startFrp(
+    config: NonNullable<ReturnType<typeof resolveFrpConfig>>,
+    ctx: InterceptorContext,
+  ): Promise<TunnelAuxiliary>;
+}
+
+const defaultRuntime: TunnelRuntime = {
+  async startPortr(config) {
+    const portrEnv = await installPortr();
+    await writePortrConfig(config, portrEnv);
+    return supervisePortr(config, portrEnv);
+  },
+  async startFrp(config, ctx) {
+    const pathProxy =
+      config.stripPrefix && config.path !== "/"
+        ? await startPathProxy(config.targetPort, config.path)
+        : undefined;
+    if (pathProxy) {
+      config.targetPort = pathProxy.port;
+      ctx.onLifecycle("shutdown", () => void pathProxy.close());
+    }
+    const frpEnv = await installFrp();
+    const configPath = await writeFrpConfig(config, frpEnv);
+    const supervisor = superviseFrp(config, frpEnv, configPath);
+    return {
+      stop() {
+        supervisor.stop();
+        void pathProxy?.close();
+      },
+    };
+  },
+};
+
 /** Resolve and validate the tunnel transport selector. */
 export function resolveTunnelTransport(transport?: string): TunnelTransport {
   const resolved =
-    transport ??
-    process.env.DBX_TOOLS_TUNNEL_TRANSPORT ??
-    process.env.TUNNEL_TRANSPORT ??
-    "portr";
+    transport ?? process.env.DBX_TOOLS_TUNNEL_TRANSPORT ?? process.env.TUNNEL_TRANSPORT ?? "portr";
   if (resolved === "portr" || resolved === "frp" || resolved === "both") return resolved;
   throw new TypeError(`invalid tunnel transport: ${resolved} (expected portr, frp, or both)`);
 }
@@ -91,7 +127,10 @@ function resolvePublicPort(port?: number): number {
  *   interceptor: tunnelInterceptor(),
  * });
  */
-export function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Interceptor {
+export function tunnelInterceptor(
+  options: TunnelInterceptorOptions = {},
+  runtime: TunnelRuntime = defaultRuntime,
+): Interceptor {
   return async (ctx: InterceptorContext): Promise<void> => {
     if (ctx.env.databricksHost) {
       process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;
@@ -99,7 +138,7 @@ export function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Inter
 
     const port = resolvePublicPort(options.port);
     const transport = resolveTunnelTransport(options.transport);
-    const auxiliaries: Array<{ stop(): void }> = [];
+    const initializers: Array<Promise<TunnelAuxiliary>> = [];
     if (transport === "portr" || transport === "both") {
       const portrConfig = resolvePortrConfig({
         publicDomain: options.publicDomain,
@@ -107,9 +146,7 @@ export function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Inter
         port,
       });
       if (portrConfig) {
-        const portrEnv = await installPortr();
-        await writePortrConfig(portrConfig, portrEnv);
-        auxiliaries.push(supervisePortr(portrConfig, portrEnv));
+        initializers.push(runtime.startPortr(portrConfig));
       } else {
         logger.info("portr not configured (requires PORTR_TOKEN and TUNNEL_PUBLIC_DOMAIN)");
       }
@@ -127,28 +164,31 @@ export function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Inter
         port,
       });
       if (frpConfig) {
-        const pathProxy =
-          frpConfig.stripPrefix && frpConfig.path !== "/"
-            ? await startPathProxy(port, frpConfig.path)
-            : undefined;
-        if (pathProxy) {
-          frpConfig.targetPort = pathProxy.port;
-          ctx.onLifecycle("shutdown", () => void pathProxy.close());
-        }
-        const frpEnv = await installFrp();
-        const configPath = await writeFrpConfig(frpConfig, frpEnv);
-        auxiliaries.push(superviseFrp(frpConfig, frpEnv, configPath));
+        initializers.push(runtime.startFrp(frpConfig, ctx));
       } else {
         logger.info("frp not configured (requires TUNNEL_PUBLIC_DOMAIN)");
       }
     }
-    if (!auxiliaries.length) return;
-    ctx.onTeardown(() => {
-      for (const auxiliary of auxiliaries) auxiliary.stop();
-    });
-    ctx.onLifecycle("shutdown", () => {
+    if (!initializers.length) return;
+    const auxiliaries: TunnelAuxiliary[] = [];
+    let stopped = false;
+    const stop = () => {
+      stopped = true;
       for (const auxiliary of auxiliaries) auxiliary.stop();
+    };
+    ctx.onTeardown(stop);
+    ctx.onLifecycle("shutdown", stop);
+    void Promise.allSettled(initializers).then((results) => {
+      for (const result of results) {
+        if (result.status === "rejected") {
+          logger.error("tunnel failed to start", { error: result.reason });
+          continue;
+        }
+        if (stopped) result.value.stop();
+        else auxiliaries.push(result.value);
+      }
+      if (!stopped && auxiliaries.length) logger.info(`tunnel bound: ${transport} -> :${port}`);
     });
-    logger.info(`tunnel bound: ${transport} -> :${port}`);
+    logger.info(`tunnel initialization scheduled: ${transport} -> :${port}`);
   };
 }