@dbx-tools/tunnel 0.6.123 → 0.6.125

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/lib/src/supervisor.d.ts

@@ -8,4 +8,5 @@ export declare function superviseProcessForever(options: {
     logger: Logger;
     start: () => ChildProcess | Promise<ChildProcess>;
     retryDelaysMs?: readonly number[];
+    shutdownGraceMs?: number;
 }): ProcessSupervisor;

package/lib/src/supervisor.js

@@ -1,18 +1,25 @@
 import { async as asyncTools } from "@dbx-tools/shared-core";
 const STABLE_CONNECTION_MS = 60_000;
+const DEFAULT_SHUTDOWN_GRACE_MS = 10_000;
 export function superviseProcessForever(options) {
     const controller = new AbortController();
     let child;
+    const terminateChild = () => {
+        const stoppingChild = child;
+        if (!stoppingChild)
+            return;
+        stoppingChild.kill("SIGTERM");
+        setTimeout(() => stoppingChild.kill("SIGKILL"), options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS).unref();
+    };
     const stop = () => {
         if (controller.signal.aborted)
             return;
         controller.abort();
-        if (child && !child.killed)
-            child.kill("SIGTERM");
+        terminateChild();
         process.off("exit", onProcessExit);
     };
     const onProcessExit = () => {
-        if (child && !child.killed)
+        if (child)
             child.kill("SIGTERM");
     };
     process.once("exit", onProcessExit);
@@ -60,13 +67,10 @@ function processOutcome(child, signal) {
         };
         const onExit = (code, exitSignal) => finish({ code, signal: exitSignal });
         const onError = (error) => {
-            if (!child.killed)
-                child.kill("SIGTERM");
+            child.kill("SIGTERM");
             finish({ error });
         };
         const onAbort = () => {
-            if (!child.killed)
-                child.kill("SIGTERM");
             finish({ signal: "SIGTERM" });
         };
         child.once("exit", onExit);
@@ -74,4 +78,4 @@ function processOutcome(child, signal) {
         signal.addEventListener("abort", onAbort, { once: true });
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"supervisor.js","sourceRoot":"","sources":["../../src/supervisor.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ChildProcess } from \"node:child_process\";\nimport { async as asyncTools, type Logger } from \"@dbx-tools/shared-core\";\n\nconst STABLE_CONNECTION_MS = 60_000;\nconst DEFAULT_SHUTDOWN_GRACE_MS = 10_000;\n\nexport interface ProcessSupervisor {\n  stop(): void;\n}\n\ntype ProcessOutcome = {\n  code?: number | null;\n  signal?: NodeJS.Signals | null;\n  error?: unknown;\n};\n\nexport function superviseProcessForever(options: {\n  name: string;\n  logger: Logger;\n  start: () => ChildProcess | Promise<ChildProcess>;\n  retryDelaysMs?: readonly number[];\n  shutdownGraceMs?: number;\n}): ProcessSupervisor {\n  const controller = new AbortController();\n  let child: ChildProcess | undefined;\n\n  const terminateChild = () => {\n    const stoppingChild = child;\n    if (!stoppingChild) return;\n    stoppingChild.kill(\"SIGTERM\");\n    setTimeout(\n      () => stoppingChild.kill(\"SIGKILL\"),\n      options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS,\n    ).unref();\n  };\n\n  const stop = () => {\n    if (controller.signal.aborted) return;\n    controller.abort();\n    terminateChild();\n    process.off(\"exit\", onProcessExit);\n  };\n  const onProcessExit = () => {\n    if (child) child.kill(\"SIGTERM\");\n  };\n  process.once(\"exit\", onProcessExit);\n\n  const run = async () => {\n    let failures = 0;\n    while (!controller.signal.aborted) {\n      const startedAt = Date.now();\n      let outcome: ProcessOutcome;\n      try {\n        child = await options.start();\n        outcome = await processOutcome(child, controller.signal);\n      } catch (error) {\n        outcome = { error };\n      } finally {\n        child = undefined;\n      }\n      if (controller.signal.aborted) return;\n      if (Date.now() - startedAt >= STABLE_CONNECTION_MS) failures = 0;\n      const delayMs = asyncTools.boundedRetryDelay(failures++, options.retryDelaysMs);\n      options.logger.warn(`${options.name} stopped; retrying`, { ...outcome, delayMs });\n      try {\n        await asyncTools.sleep(delayMs, controller.signal);\n      } catch {\n        return;\n      }\n    }\n  };\n\n  void run().catch((error) => options.logger.error(`${options.name} supervisor failed`, { error }));\n  return {\n    stop,\n  };\n}\n\nfunction processOutcome(child: ChildProcess, signal: AbortSignal): Promise<ProcessOutcome> {\n  return new Promise((resolve) => {\n    const finish = (outcome: ProcessOutcome) => {\n      child.off(\"exit\", onExit);\n      child.off(\"error\", onError);\n      signal.removeEventListener(\"abort\", onAbort);\n      resolve(outcome);\n    };\n    const onExit = (code: number | null, exitSignal: NodeJS.Signals | null) =>\n      finish({ code, signal: exitSignal });\n    const onError = (error: Error) => {\n      child.kill(\"SIGTERM\");\n      finish({ error });\n    };\n    const onAbort = () => {\n      finish({ signal: \"SIGTERM\" });\n    };\n    child.once(\"exit\", onExit);\n    child.once(\"error\", onError);\n    signal.addEventListener(\"abort\", onAbort, { once: true });\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.125"
   },
   "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.125",
+    "@dbx-tools/auth": "0.6.125",
+    "@dbx-tools/core": "0.6.125",
+    "@dbx-tools/email": "0.6.125",
+    "@dbx-tools/shared-auth": "0.6.125",
+    "@dbx-tools/shared-core": "0.6.125",
     "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.125",
   "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}`);
   };
 }

package/src/supervisor.ts

@@ -2,6 +2,7 @@ import type { ChildProcess } from "node:child_process";
 import { async as asyncTools, type Logger } from "@dbx-tools/shared-core";
 
 const STABLE_CONNECTION_MS = 60_000;
+const DEFAULT_SHUTDOWN_GRACE_MS = 10_000;
 
 export interface ProcessSupervisor {
   stop(): void;
@@ -18,18 +19,29 @@ export function superviseProcessForever(options: {
   logger: Logger;
   start: () => ChildProcess | Promise<ChildProcess>;
   retryDelaysMs?: readonly number[];
+  shutdownGraceMs?: number;
 }): ProcessSupervisor {
   const controller = new AbortController();
   let child: ChildProcess | undefined;
 
+  const terminateChild = () => {
+    const stoppingChild = child;
+    if (!stoppingChild) return;
+    stoppingChild.kill("SIGTERM");
+    setTimeout(
+      () => stoppingChild.kill("SIGKILL"),
+      options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS,
+    ).unref();
+  };
+
   const stop = () => {
     if (controller.signal.aborted) return;
     controller.abort();
-    if (child && !child.killed) child.kill("SIGTERM");
+    terminateChild();
     process.off("exit", onProcessExit);
   };
   const onProcessExit = () => {
-    if (child && !child.killed) child.kill("SIGTERM");
+    if (child) child.kill("SIGTERM");
   };
   process.once("exit", onProcessExit);
 
@@ -75,11 +87,10 @@ function processOutcome(child: ChildProcess, signal: AbortSignal): Promise<Proce
     const onExit = (code: number | null, exitSignal: NodeJS.Signals | null) =>
       finish({ code, signal: exitSignal });
     const onError = (error: Error) => {
-      if (!child.killed) child.kill("SIGTERM");
+      child.kill("SIGTERM");
       finish({ error });
     };
     const onAbort = () => {
-      if (!child.killed) child.kill("SIGTERM");
       finish({ signal: "SIGTERM" });
     };
     child.once("exit", onExit);