@dbx-tools/tunnel 0.6.214 → 0.6.216

package/README.md

@@ -89,6 +89,11 @@ middleware on the app's OWN Express server (no separate proxy process).
 - Supervised teardown - `tunnelInterceptor` binds portr through the `createApp`
   interceptor context, so the app and the tunnel are tied together: if either
   exits, `bindProcess` brings the whole set down and passes signals through.
+- Public liveness probes - while portr is running, the supervisor HEADs the
+  public URL. An `x-portr-error: unregistered-subdomain` (or any other
+  `x-portr-error`) kills the child so the forever-loop restarts it. Process-exit
+  supervision alone is not enough: portr can stay alive after the edge drops the
+  registration, leaving the subdomain dark until a full app bounce.
 - The gate fails fast when email is not configured for SMTP, because a gate that
   cannot send codes locks everyone out. `@dbx-tools/email` is an OPTIONAL peer
   dependency, imported lazily; the app that mounts the gate provides it.

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/tunnel";
-export const PACKAGE_VERSION = "0.6.214";
+export const PACKAGE_VERSION = "0.6.216";
 export * as allowlist from "./src/allowlist.ts";
 export * as codeEmail from "./src/code-email.ts";
 export * as frp from "./src/frp.ts";
@@ -30,4 +30,4 @@ export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateA
 export type { PortrInstallOptions, PortrConfig } from "./src/portr.ts";
 export { KEY_TTL_SECONDS } from "./src/signing-key.ts";
 export type { SigningKey } from "./src/signing-key.ts";
-export type { ProcessSupervisor } from "./src/supervisor.ts";
+export type { ProcessSupervisor, ProcessSupervisorOptions } from "./src/supervisor.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/tunnel";
-export declare const PACKAGE_VERSION = "0.6.214";
+export declare const PACKAGE_VERSION = "0.6.216";
 export * as allowlist from "./src/allowlist.ts";
 export * as codeEmail from "./src/code-email.ts";
 export * as frp from "./src/frp.ts";
@@ -26,4 +26,4 @@ export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateA
 export type { PortrInstallOptions, PortrConfig } from "./src/portr.ts";
 export { KEY_TTL_SECONDS } from "./src/signing-key.ts";
 export type { SigningKey } from "./src/signing-key.ts";
-export type { ProcessSupervisor } from "./src/supervisor.ts";
+export type { ProcessSupervisor, ProcessSupervisorOptions } from "./src/supervisor.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/tunnel";
-export const PACKAGE_VERSION = "0.6.214";
+export const PACKAGE_VERSION = "0.6.216";
 export * as allowlist from "./src/allowlist.js";
 export * as codeEmail from "./src/code-email.js";
 export * as frp from "./src/frp.js";
@@ -20,4 +20,4 @@ export { AUTH_PREFIX, UNAUTHORIZED_BODY } from "./src/gate.js";
 export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS } from "./src/headers.js";
 export { AuthGatePlugin, authGate } from "./src/plugin.js";
 export { KEY_TTL_SECONDS } from "./src/signing-key.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/portr.d.ts

@@ -45,4 +45,11 @@ export declare function installPortr(options?: PortrInstallOptions): Promise<Nod
 export declare function writePortrConfig(config: PortrConfig, childEnv: NodeJS.ProcessEnv): Promise<void>;
 /** Launch `portr start` as a child process (caller supervises + kills it). */
 export declare function startPortr(config: PortrConfig, childEnv: NodeJS.ProcessEnv): Promise<ReturnType<typeof spawn>>;
+/**
+ * Probe the public portr URL. A registered tunnel is healthy even when the app
+ * returns an auth challenge (401/302) - those prove the edge still has the
+ * subdomain. Only an explicit `unregistered-subdomain` (or any other
+ * `x-portr-error`) means the client must be restarted.
+ */
+export declare function probePortrPublicUrl(publicUrl: string): Promise<boolean>;
 export declare function supervisePortr(config: PortrConfig, childEnv: NodeJS.ProcessEnv): ProcessSupervisor;

package/lib/src/portr.js

@@ -126,11 +126,32 @@ export async function startPortr(config, childEnv) {
     child.stderr?.pipe(normalizedOutput(process.stderr));
     return child;
 }
+/**
+ * Probe the public portr URL. A registered tunnel is healthy even when the app
+ * returns an auth challenge (401/302) - those prove the edge still has the
+ * subdomain. Only an explicit `unregistered-subdomain` (or any other
+ * `x-portr-error`) means the client must be restarted.
+ */
+export async function probePortrPublicUrl(publicUrl) {
+    const response = await fetch(publicUrl, {
+        method: "HEAD",
+        redirect: "manual",
+        signal: AbortSignal.timeout(5_000),
+    });
+    if (response.headers.get("x-portr-error") === "true")
+        return false;
+    return true;
+}
 export function supervisePortr(config, childEnv) {
+    const publicUrl = `https://${config.subdomain}.${config.server}`;
     return superviseProcessForever({
         name: "portr",
         logger,
         start: () => startPortr(config, childEnv),
+        // Kill + restart when the edge drops the registration while the local
+        // process is still alive. Without this, lensiq.apps.dbx.tools (and any
+        // other in-process tunnel) stays unregistered until a full app bounce.
+        isHealthy: () => probePortrPublicUrl(publicUrl),
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portr.js","sourceRoot":"","sources":["../../src/portr.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * portr install, config, and launch support for the tunnel runtime.\n *\n * The binary and config use portr's conventional `$HOME/.portr` tree. The\n * install is idempotent (the installer skips an existing executable). The\n * config is rendered from `TUNNEL_PUBLIC_DOMAIN`\n * (`<subdomain>.<server>`) + `PORTR_TOKEN` and points portr at the PUBLIC port\n * (the proxy listens there).\n *\n * @module\n */\nimport { execFile, spawn } from \"node:child_process\";\nimport { writeFile } from \"node:fs/promises\";\nimport os from \"node:os\";\nimport { delimiter, join } from \"node:path\";\nimport { Transform } from \"node:stream\";\nimport { StringDecoder } from \"node:string_decoder\";\nimport { promisify } from \"node:util\";\n\nimport { bin, config } from \"@dbx-tools/core\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { superviseProcessForever, type ProcessSupervisor } from \"./supervisor.ts\";\n\nconst logger = log.logger(\"tunnel:portr\");\nconst PORTR_VERSION = \"1.0.15-sse.2\";\nconst PORTR_RELEASE_URL = `https://github.com/reggie-db/portr/releases/download/v${PORTR_VERSION}`;\nconst PORTR_MIN_VERSION = \"v1.0.15\";\nconst execFileAsync = promisify(execFile);\n\nconst EMOJI = /\\p{Extended_Pictographic}\\uFE0F?/gu;\n\n/** Remove pictographs from third-party process output before forwarding it. */\nexport function normalizePortrOutput(value: string): string {\n  return value.replace(EMOJI, \"\").replace(/^[ \\t]+/gm, \"\");\n}\n\nfunction normalizedOutput(destination: NodeJS.WriteStream): Transform {\n  const decoder = new StringDecoder(\"utf8\");\n  return new Transform({\n    transform(chunk, _encoding, callback) {\n      destination.write(normalizePortrOutput(decoder.write(chunk)));\n      callback();\n    },\n    flush(callback) {\n      destination.write(normalizePortrOutput(decoder.end()));\n      callback();\n    },\n  });\n}\n\n/** Options for installing the portr executable. */\nexport interface PortrInstallOptions {\n  /** Home directory containing `.portr`; defaults to the OS home directory. */\n  homeDir?: string;\n}\n\n/** Resolved portr wiring, or `undefined` when no tunnel is configured. */\nexport interface PortrConfig {\n  subdomain: string;\n  server: string;\n  token: string;\n  port: number;\n}\n\n/**\n * Resolve portr config from `TUNNEL_PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an\n * explicit `subdomain`. The domain is `<subdomain>.<server>` (e.g.\n * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a\n * usable domain is absent.\n */\nexport function resolvePortrConfig(opts: {\n  publicDomain?: string;\n  subdomain?: string;\n  token?: string;\n  port: number;\n}): PortrConfig | undefined {\n  // PORTR_* is upstream portr's own namespace, so it keeps its name.\n  const token = config.string(opts.token, \"PORTR_TOKEN\");\n  const domain = config.string(opts.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG);\n  if (!token) return undefined;\n  let subdomain = opts.subdomain;\n  let server: string | undefined;\n  if (domain) {\n    subdomain ??= domain.split(\".\")[0];\n    server = domain.slice(domain.indexOf(\".\") + 1);\n  }\n  server ??= config.text(\"PORTR_SERVER\");\n  if (!subdomain || !server || server === domain) return undefined;\n  return { subdomain, server, token, port: opts.port };\n}\n\n/** GitHub release asset name for the current or supplied OS/architecture. */\nexport function portrAssetName(\n  version: string,\n  platform: NodeJS.Platform = process.platform,\n  arch: string = process.arch,\n): string {\n  const osName = platform === \"darwin\" ? \"Darwin\" : platform === \"linux\" ? \"Linux\" : undefined;\n  const archName = arch === \"arm64\" ? \"arm64\" : arch === \"x64\" ? \"x86_64\" : undefined;\n  if (!osName || !archName) {\n    throw new Error(`portr has no supported release asset for ${platform}/${arch}`);\n  }\n  return `portr_${version}_${osName}_${archName}.zip`;\n}\n\nfunction portrDownloadUrl(): string {\n  const assetName = portrAssetName(PORTR_VERSION);\n  logger.info(\"installing portr\", { version: PORTR_VERSION, asset: assetName });\n  return `${PORTR_RELEASE_URL}/${assetName}`;\n}\n\n/** Install portr when absent and return the environment used by its process. */\nexport async function installPortr(options: PortrInstallOptions = {}): Promise<NodeJS.ProcessEnv> {\n  const homeDir = options.homeDir ?? os.homedir();\n  const context = await bin.ensure(\"portr\", portrDownloadUrl, {\n    autoUnpackage: true,\n    homeDir,\n    minVersion: PORTR_MIN_VERSION,\n    selector: ({ source }) => join(source, \"portr\"),\n    versionParser: (output) => {\n      const version = bin.parseVersion(output);\n      return version === PORTR_VERSION ? version : undefined;\n    },\n  });\n  return {\n    ...process.env,\n    HOME: homeDir,\n    PORTR_AUTO_ADD_PATH: \"no\",\n    PATH: [context.binDir, process.env.PATH ?? \"\"].join(delimiter),\n  };\n}\n\n/** Render `~/.portr/config.yaml` for the resolved tunnel. */\nexport async function writePortrConfig(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<void> {\n  const path = join(childEnv.HOME ?? os.homedir(), \".portr\", \"config.yaml\");\n  await writeFile(\n    path,\n    [\n      `server_url: ${config.server}`,\n      `ssh_url: ${config.server}:4444`,\n      `secret_key: ${config.token}`,\n      \"disable_dashboard: true\",\n      \"disable_tui: true\",\n      \"tunnels:\",\n      `  - name: ${config.subdomain}`,\n      `    subdomain: ${config.subdomain}`,\n      `    port: ${config.port}`,\n      \"\",\n    ].join(\"\\n\"),\n  );\n}\n\n/** Launch `portr start` as a child process (caller supervises + kills it). */\nexport async function startPortr(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<ReturnType<typeof spawn>> {\n  // Reclaim the subdomain from any portr left by a previous boot in this container.\n  await execFileAsync(\"pkill\", [\"-x\", \"portr\"]).catch(() => undefined);\n\n  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);\n  const child = spawn(\"portr\", [\"start\"], { env: childEnv, stdio: [\"inherit\", \"pipe\", \"pipe\"] });\n  child.stdout?.pipe(normalizedOutput(process.stdout));\n  child.stderr?.pipe(normalizedOutput(process.stderr));\n  return child;\n}\n\nexport function supervisePortr(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): ProcessSupervisor {\n  return superviseProcessForever({\n    name: \"portr\",\n    logger,\n    start: () => startPortr(config, childEnv),\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portr.js","sourceRoot":"","sources":["../../src/portr.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * portr install, config, and launch support for the tunnel runtime.\n *\n * The binary and config use portr's conventional `$HOME/.portr` tree. The\n * install is idempotent (the installer skips an existing executable). The\n * config is rendered from `TUNNEL_PUBLIC_DOMAIN`\n * (`<subdomain>.<server>`) + `PORTR_TOKEN` and points portr at the PUBLIC port\n * (the proxy listens there).\n *\n * @module\n */\nimport { execFile, spawn } from \"node:child_process\";\nimport { writeFile } from \"node:fs/promises\";\nimport os from \"node:os\";\nimport { delimiter, join } from \"node:path\";\nimport { Transform } from \"node:stream\";\nimport { StringDecoder } from \"node:string_decoder\";\nimport { promisify } from \"node:util\";\n\nimport { bin, config } from \"@dbx-tools/core\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { superviseProcessForever, type ProcessSupervisor } from \"./supervisor.ts\";\n\nconst logger = log.logger(\"tunnel:portr\");\nconst PORTR_VERSION = \"1.0.15-sse.2\";\nconst PORTR_RELEASE_URL = `https://github.com/reggie-db/portr/releases/download/v${PORTR_VERSION}`;\nconst PORTR_MIN_VERSION = \"v1.0.15\";\nconst execFileAsync = promisify(execFile);\n\nconst EMOJI = /\\p{Extended_Pictographic}\\uFE0F?/gu;\n\n/** Remove pictographs from third-party process output before forwarding it. */\nexport function normalizePortrOutput(value: string): string {\n  return value.replace(EMOJI, \"\").replace(/^[ \\t]+/gm, \"\");\n}\n\nfunction normalizedOutput(destination: NodeJS.WriteStream): Transform {\n  const decoder = new StringDecoder(\"utf8\");\n  return new Transform({\n    transform(chunk, _encoding, callback) {\n      destination.write(normalizePortrOutput(decoder.write(chunk)));\n      callback();\n    },\n    flush(callback) {\n      destination.write(normalizePortrOutput(decoder.end()));\n      callback();\n    },\n  });\n}\n\n/** Options for installing the portr executable. */\nexport interface PortrInstallOptions {\n  /** Home directory containing `.portr`; defaults to the OS home directory. */\n  homeDir?: string;\n}\n\n/** Resolved portr wiring, or `undefined` when no tunnel is configured. */\nexport interface PortrConfig {\n  subdomain: string;\n  server: string;\n  token: string;\n  port: number;\n}\n\n/**\n * Resolve portr config from `TUNNEL_PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an\n * explicit `subdomain`. The domain is `<subdomain>.<server>` (e.g.\n * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a\n * usable domain is absent.\n */\nexport function resolvePortrConfig(opts: {\n  publicDomain?: string;\n  subdomain?: string;\n  token?: string;\n  port: number;\n}): PortrConfig | undefined {\n  // PORTR_* is upstream portr's own namespace, so it keeps its name.\n  const token = config.string(opts.token, \"PORTR_TOKEN\");\n  const domain = config.string(opts.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG);\n  if (!token) return undefined;\n  let subdomain = opts.subdomain;\n  let server: string | undefined;\n  if (domain) {\n    subdomain ??= domain.split(\".\")[0];\n    server = domain.slice(domain.indexOf(\".\") + 1);\n  }\n  server ??= config.text(\"PORTR_SERVER\");\n  if (!subdomain || !server || server === domain) return undefined;\n  return { subdomain, server, token, port: opts.port };\n}\n\n/** GitHub release asset name for the current or supplied OS/architecture. */\nexport function portrAssetName(\n  version: string,\n  platform: NodeJS.Platform = process.platform,\n  arch: string = process.arch,\n): string {\n  const osName = platform === \"darwin\" ? \"Darwin\" : platform === \"linux\" ? \"Linux\" : undefined;\n  const archName = arch === \"arm64\" ? \"arm64\" : arch === \"x64\" ? \"x86_64\" : undefined;\n  if (!osName || !archName) {\n    throw new Error(`portr has no supported release asset for ${platform}/${arch}`);\n  }\n  return `portr_${version}_${osName}_${archName}.zip`;\n}\n\nfunction portrDownloadUrl(): string {\n  const assetName = portrAssetName(PORTR_VERSION);\n  logger.info(\"installing portr\", { version: PORTR_VERSION, asset: assetName });\n  return `${PORTR_RELEASE_URL}/${assetName}`;\n}\n\n/** Install portr when absent and return the environment used by its process. */\nexport async function installPortr(options: PortrInstallOptions = {}): Promise<NodeJS.ProcessEnv> {\n  const homeDir = options.homeDir ?? os.homedir();\n  const context = await bin.ensure(\"portr\", portrDownloadUrl, {\n    autoUnpackage: true,\n    homeDir,\n    minVersion: PORTR_MIN_VERSION,\n    selector: ({ source }) => join(source, \"portr\"),\n    versionParser: (output) => {\n      const version = bin.parseVersion(output);\n      return version === PORTR_VERSION ? version : undefined;\n    },\n  });\n  return {\n    ...process.env,\n    HOME: homeDir,\n    PORTR_AUTO_ADD_PATH: \"no\",\n    PATH: [context.binDir, process.env.PATH ?? \"\"].join(delimiter),\n  };\n}\n\n/** Render `~/.portr/config.yaml` for the resolved tunnel. */\nexport async function writePortrConfig(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<void> {\n  const path = join(childEnv.HOME ?? os.homedir(), \".portr\", \"config.yaml\");\n  await writeFile(\n    path,\n    [\n      `server_url: ${config.server}`,\n      `ssh_url: ${config.server}:4444`,\n      `secret_key: ${config.token}`,\n      \"disable_dashboard: true\",\n      \"disable_tui: true\",\n      \"tunnels:\",\n      `  - name: ${config.subdomain}`,\n      `    subdomain: ${config.subdomain}`,\n      `    port: ${config.port}`,\n      \"\",\n    ].join(\"\\n\"),\n  );\n}\n\n/** Launch `portr start` as a child process (caller supervises + kills it). */\nexport async function startPortr(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<ReturnType<typeof spawn>> {\n  // Reclaim the subdomain from any portr left by a previous boot in this container.\n  await execFileAsync(\"pkill\", [\"-x\", \"portr\"]).catch(() => undefined);\n\n  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);\n  const child = spawn(\"portr\", [\"start\"], { env: childEnv, stdio: [\"inherit\", \"pipe\", \"pipe\"] });\n  child.stdout?.pipe(normalizedOutput(process.stdout));\n  child.stderr?.pipe(normalizedOutput(process.stderr));\n  return child;\n}\n\n/**\n * Probe the public portr URL. A registered tunnel is healthy even when the app\n * returns an auth challenge (401/302) - those prove the edge still has the\n * subdomain. Only an explicit `unregistered-subdomain` (or any other\n * `x-portr-error`) means the client must be restarted.\n */\nexport async function probePortrPublicUrl(publicUrl: string): Promise<boolean> {\n  const response = await fetch(publicUrl, {\n    method: \"HEAD\",\n    redirect: \"manual\",\n    signal: AbortSignal.timeout(5_000),\n  });\n  if (response.headers.get(\"x-portr-error\") === \"true\") return false;\n  return true;\n}\n\nexport function supervisePortr(\n  config: PortrConfig,\n  childEnv: NodeJS.ProcessEnv,\n): ProcessSupervisor {\n  const publicUrl = `https://${config.subdomain}.${config.server}`;\n  return superviseProcessForever({\n    name: \"portr\",\n    logger,\n    start: () => startPortr(config, childEnv),\n    // Kill + restart when the edge drops the registration while the local\n    // process is still alive. Without this, lensiq.apps.dbx.tools (and any\n    // other in-process tunnel) stays unregistered until a full app bounce.\n    isHealthy: () => probePortrPublicUrl(publicUrl),\n  });\n}\n"]}

package/lib/src/supervisor.d.ts

@@ -3,10 +3,22 @@ import { type Logger } from "@dbx-tools/shared-core";
 export interface ProcessSupervisor {
     stop(): void;
 }
-export declare function superviseProcessForever(options: {
+export interface ProcessSupervisorOptions {
     name: string;
     logger: Logger;
     start: () => ChildProcess | Promise<ChildProcess>;
     retryDelaysMs?: readonly number[];
     shutdownGraceMs?: number;
-}): ProcessSupervisor;
+    /**
+     * Optional public liveness probe. When it returns `false` while the child is
+     * still running, the supervisor kills the child so the forever-loop restarts
+     * it. Used by portr to recover from an edge that dropped the subdomain
+     * registration while the local process kept running (see
+     * `x-portr-error-reason: unregistered-subdomain`).
+     */
+    isHealthy?: () => boolean | Promise<boolean>;
+    healthCheckGraceMs?: number;
+    healthCheckIntervalMs?: number;
+    healthCheckFailures?: number;
+}
+export declare function superviseProcessForever(options: ProcessSupervisorOptions): ProcessSupervisor;

package/lib/src/supervisor.js

@@ -1,6 +1,12 @@
 import { async as asyncTools } from "@dbx-tools/shared-core";
 const STABLE_CONNECTION_MS = 60_000;
 const DEFAULT_SHUTDOWN_GRACE_MS = 10_000;
+/** How long to wait after a child start before the first public liveness probe. */
+const DEFAULT_HEALTH_CHECK_GRACE_MS = 45_000;
+/** Interval between public liveness probes while a child is running. */
+const DEFAULT_HEALTH_CHECK_INTERVAL_MS = 30_000;
+/** Consecutive failed probes required before killing a still-running child. */
+const DEFAULT_HEALTH_CHECK_FAILURES = 2;
 export function superviseProcessForever(options) {
     const controller = new AbortController();
     let child;
@@ -30,7 +36,7 @@ export function superviseProcessForever(options) {
             let outcome;
             try {
                 child = await options.start();
-                outcome = await processOutcome(child, controller.signal);
+                outcome = await processOutcome(child, controller.signal, options);
             }
             catch (error) {
                 outcome = { error };
@@ -57,9 +63,17 @@ export function superviseProcessForever(options) {
         stop,
     };
 }
-function processOutcome(child, signal) {
+function processOutcome(child, signal, options) {
     return new Promise((resolve) => {
+        let settled = false;
+        let healthTimer;
+        let consecutiveFailures = 0;
         const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            if (healthTimer)
+                clearTimeout(healthTimer);
             child.off("exit", onExit);
             child.off("error", onError);
             signal.removeEventListener("abort", onAbort);
@@ -73,9 +87,53 @@ function processOutcome(child, signal) {
         const onAbort = () => {
             finish({ signal: "SIGTERM" });
         };
+        const scheduleHealthCheck = (delayMs) => {
+            if (!options.isHealthy || settled || signal.aborted)
+                return;
+            healthTimer = setTimeout(() => {
+                void runHealthCheck();
+            }, delayMs);
+            healthTimer.unref?.();
+        };
+        const runHealthCheck = async () => {
+            if (!options.isHealthy || settled || signal.aborted)
+                return;
+            let healthy = true;
+            try {
+                healthy = await options.isHealthy();
+            }
+            catch (error) {
+                // Probe errors (DNS blips, timeouts) are not proof the tunnel is dead;
+                // only an explicit unhealthy result triggers a restart.
+                options.logger.debug(`${options.name} health probe errored; ignoring`, { error });
+                healthy = true;
+            }
+            if (settled || signal.aborted)
+                return;
+            if (healthy) {
+                consecutiveFailures = 0;
+            }
+            else {
+                consecutiveFailures += 1;
+                const threshold = options.healthCheckFailures ?? DEFAULT_HEALTH_CHECK_FAILURES;
+                options.logger.warn(`${options.name} public endpoint unhealthy`, {
+                    consecutiveFailures,
+                    threshold,
+                });
+                if (consecutiveFailures >= threshold) {
+                    options.logger.warn(`${options.name} restarting after failed public liveness probes`);
+                    child.kill("SIGTERM");
+                    setTimeout(() => child.kill("SIGKILL"), options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS).unref();
+                    finish({ unhealthy: true, signal: "SIGTERM" });
+                    return;
+                }
+            }
+            scheduleHealthCheck(options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS);
+        };
         child.once("exit", onExit);
         child.once("error", onError);
         signal.addEventListener("abort", onAbort, { once: true });
+        scheduleHealthCheck(options.healthCheckGraceMs ?? DEFAULT_HEALTH_CHECK_GRACE_MS);
     });
 }
-//# 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"]}
+//# 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/** How long to wait after a child start before the first public liveness probe. */\nconst DEFAULT_HEALTH_CHECK_GRACE_MS = 45_000;\n/** Interval between public liveness probes while a child is running. */\nconst DEFAULT_HEALTH_CHECK_INTERVAL_MS = 30_000;\n/** Consecutive failed probes required before killing a still-running child. */\nconst DEFAULT_HEALTH_CHECK_FAILURES = 2;\n\nexport interface ProcessSupervisor {\n  stop(): void;\n}\n\ntype ProcessOutcome = {\n  code?: number | null;\n  signal?: NodeJS.Signals | null;\n  error?: unknown;\n  /** Set when the supervisor killed the child after a failed liveness probe. */\n  unhealthy?: true;\n};\n\nexport interface ProcessSupervisorOptions {\n  name: string;\n  logger: Logger;\n  start: () => ChildProcess | Promise<ChildProcess>;\n  retryDelaysMs?: readonly number[];\n  shutdownGraceMs?: number;\n  /**\n   * Optional public liveness probe. When it returns `false` while the child is\n   * still running, the supervisor kills the child so the forever-loop restarts\n   * it. Used by portr to recover from an edge that dropped the subdomain\n   * registration while the local process kept running (see\n   * `x-portr-error-reason: unregistered-subdomain`).\n   */\n  isHealthy?: () => boolean | Promise<boolean>;\n  healthCheckGraceMs?: number;\n  healthCheckIntervalMs?: number;\n  healthCheckFailures?: number;\n}\n\nexport function superviseProcessForever(options: ProcessSupervisorOptions): 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, options);\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(\n  child: ChildProcess,\n  signal: AbortSignal,\n  options: ProcessSupervisorOptions,\n): Promise<ProcessOutcome> {\n  return new Promise((resolve) => {\n    let settled = false;\n    let healthTimer: ReturnType<typeof setTimeout> | undefined;\n    let consecutiveFailures = 0;\n\n    const finish = (outcome: ProcessOutcome) => {\n      if (settled) return;\n      settled = true;\n      if (healthTimer) clearTimeout(healthTimer);\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\n    const scheduleHealthCheck = (delayMs: number) => {\n      if (!options.isHealthy || settled || signal.aborted) return;\n      healthTimer = setTimeout(() => {\n        void runHealthCheck();\n      }, delayMs);\n      healthTimer.unref?.();\n    };\n\n    const runHealthCheck = async () => {\n      if (!options.isHealthy || settled || signal.aborted) return;\n      let healthy = true;\n      try {\n        healthy = await options.isHealthy();\n      } catch (error) {\n        // Probe errors (DNS blips, timeouts) are not proof the tunnel is dead;\n        // only an explicit unhealthy result triggers a restart.\n        options.logger.debug(`${options.name} health probe errored; ignoring`, { error });\n        healthy = true;\n      }\n      if (settled || signal.aborted) return;\n      if (healthy) {\n        consecutiveFailures = 0;\n      } else {\n        consecutiveFailures += 1;\n        const threshold = options.healthCheckFailures ?? DEFAULT_HEALTH_CHECK_FAILURES;\n        options.logger.warn(`${options.name} public endpoint unhealthy`, {\n          consecutiveFailures,\n          threshold,\n        });\n        if (consecutiveFailures >= threshold) {\n          options.logger.warn(`${options.name} restarting after failed public liveness probes`);\n          child.kill(\"SIGTERM\");\n          setTimeout(\n            () => child.kill(\"SIGKILL\"),\n            options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS,\n          ).unref();\n          finish({ unhealthy: true, signal: \"SIGTERM\" });\n          return;\n        }\n      }\n      scheduleHealthCheck(options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS);\n    };\n\n    child.once(\"exit\", onExit);\n    child.once(\"error\", onError);\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n    scheduleHealthCheck(options.healthCheckGraceMs ?? DEFAULT_HEALTH_CHECK_GRACE_MS);\n  });\n}\n"]}

package/package.json

@@ -19,21 +19,21 @@
     "projen": "projen"
   },
   "devDependencies": {
-    "@dbx-tools/email": "0.6.214",
+    "@dbx-tools/email": "0.6.216",
     "@types/bun": "1.3.14",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@dbx-tools/email": "0.6.214"
+    "@dbx-tools/email": "0.6.216"
   },
   "dependencies": {
     "@databricks/appkit": "^0.60.0",
-    "@dbx-tools/appkit": "0.6.214",
-    "@dbx-tools/auth-gate": "0.6.214",
-    "@dbx-tools/core": "0.6.214",
-    "@dbx-tools/shared-auth": "0.6.214",
-    "@dbx-tools/shared-core": "0.6.214",
+    "@dbx-tools/appkit": "0.6.216",
+    "@dbx-tools/auth-gate": "0.6.216",
+    "@dbx-tools/core": "0.6.216",
+    "@dbx-tools/shared-auth": "0.6.216",
+    "@dbx-tools/shared-core": "0.6.216",
     "@types/express": "^5.0.5",
     "http-proxy-3": "^1.23.1"
   },
@@ -51,7 +51,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.214",
+  "version": "0.6.216",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/portr.ts

@@ -169,13 +169,34 @@ export async function startPortr(
   return child;
 }
 
+/**
+ * Probe the public portr URL. A registered tunnel is healthy even when the app
+ * returns an auth challenge (401/302) - those prove the edge still has the
+ * subdomain. Only an explicit `unregistered-subdomain` (or any other
+ * `x-portr-error`) means the client must be restarted.
+ */
+export async function probePortrPublicUrl(publicUrl: string): Promise<boolean> {
+  const response = await fetch(publicUrl, {
+    method: "HEAD",
+    redirect: "manual",
+    signal: AbortSignal.timeout(5_000),
+  });
+  if (response.headers.get("x-portr-error") === "true") return false;
+  return true;
+}
+
 export function supervisePortr(
   config: PortrConfig,
   childEnv: NodeJS.ProcessEnv,
 ): ProcessSupervisor {
+  const publicUrl = `https://${config.subdomain}.${config.server}`;
   return superviseProcessForever({
     name: "portr",
     logger,
     start: () => startPortr(config, childEnv),
+    // Kill + restart when the edge drops the registration while the local
+    // process is still alive. Without this, lensiq.apps.dbx.tools (and any
+    // other in-process tunnel) stays unregistered until a full app bounce.
+    isHealthy: () => probePortrPublicUrl(publicUrl),
   });
 }

package/src/supervisor.ts

@@ -3,6 +3,12 @@ import { async as asyncTools, type Logger } from "@dbx-tools/shared-core";
 
 const STABLE_CONNECTION_MS = 60_000;
 const DEFAULT_SHUTDOWN_GRACE_MS = 10_000;
+/** How long to wait after a child start before the first public liveness probe. */
+const DEFAULT_HEALTH_CHECK_GRACE_MS = 45_000;
+/** Interval between public liveness probes while a child is running. */
+const DEFAULT_HEALTH_CHECK_INTERVAL_MS = 30_000;
+/** Consecutive failed probes required before killing a still-running child. */
+const DEFAULT_HEALTH_CHECK_FAILURES = 2;
 
 export interface ProcessSupervisor {
   stop(): void;
@@ -12,15 +18,30 @@ type ProcessOutcome = {
   code?: number | null;
   signal?: NodeJS.Signals | null;
   error?: unknown;
+  /** Set when the supervisor killed the child after a failed liveness probe. */
+  unhealthy?: true;
 };
 
-export function superviseProcessForever(options: {
+export interface ProcessSupervisorOptions {
   name: string;
   logger: Logger;
   start: () => ChildProcess | Promise<ChildProcess>;
   retryDelaysMs?: readonly number[];
   shutdownGraceMs?: number;
-}): ProcessSupervisor {
+  /**
+   * Optional public liveness probe. When it returns `false` while the child is
+   * still running, the supervisor kills the child so the forever-loop restarts
+   * it. Used by portr to recover from an edge that dropped the subdomain
+   * registration while the local process kept running (see
+   * `x-portr-error-reason: unregistered-subdomain`).
+   */
+  isHealthy?: () => boolean | Promise<boolean>;
+  healthCheckGraceMs?: number;
+  healthCheckIntervalMs?: number;
+  healthCheckFailures?: number;
+}
+
+export function superviseProcessForever(options: ProcessSupervisorOptions): ProcessSupervisor {
   const controller = new AbortController();
   let child: ChildProcess | undefined;
 
@@ -52,7 +73,7 @@ export function superviseProcessForever(options: {
       let outcome: ProcessOutcome;
       try {
         child = await options.start();
-        outcome = await processOutcome(child, controller.signal);
+        outcome = await processOutcome(child, controller.signal, options);
       } catch (error) {
         outcome = { error };
       } finally {
@@ -76,9 +97,20 @@ export function superviseProcessForever(options: {
   };
 }
 
-function processOutcome(child: ChildProcess, signal: AbortSignal): Promise<ProcessOutcome> {
+function processOutcome(
+  child: ChildProcess,
+  signal: AbortSignal,
+  options: ProcessSupervisorOptions,
+): Promise<ProcessOutcome> {
   return new Promise((resolve) => {
+    let settled = false;
+    let healthTimer: ReturnType<typeof setTimeout> | undefined;
+    let consecutiveFailures = 0;
+
     const finish = (outcome: ProcessOutcome) => {
+      if (settled) return;
+      settled = true;
+      if (healthTimer) clearTimeout(healthTimer);
       child.off("exit", onExit);
       child.off("error", onError);
       signal.removeEventListener("abort", onAbort);
@@ -93,8 +125,53 @@ function processOutcome(child: ChildProcess, signal: AbortSignal): Promise<Proce
     const onAbort = () => {
       finish({ signal: "SIGTERM" });
     };
+
+    const scheduleHealthCheck = (delayMs: number) => {
+      if (!options.isHealthy || settled || signal.aborted) return;
+      healthTimer = setTimeout(() => {
+        void runHealthCheck();
+      }, delayMs);
+      healthTimer.unref?.();
+    };
+
+    const runHealthCheck = async () => {
+      if (!options.isHealthy || settled || signal.aborted) return;
+      let healthy = true;
+      try {
+        healthy = await options.isHealthy();
+      } catch (error) {
+        // Probe errors (DNS blips, timeouts) are not proof the tunnel is dead;
+        // only an explicit unhealthy result triggers a restart.
+        options.logger.debug(`${options.name} health probe errored; ignoring`, { error });
+        healthy = true;
+      }
+      if (settled || signal.aborted) return;
+      if (healthy) {
+        consecutiveFailures = 0;
+      } else {
+        consecutiveFailures += 1;
+        const threshold = options.healthCheckFailures ?? DEFAULT_HEALTH_CHECK_FAILURES;
+        options.logger.warn(`${options.name} public endpoint unhealthy`, {
+          consecutiveFailures,
+          threshold,
+        });
+        if (consecutiveFailures >= threshold) {
+          options.logger.warn(`${options.name} restarting after failed public liveness probes`);
+          child.kill("SIGTERM");
+          setTimeout(
+            () => child.kill("SIGKILL"),
+            options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS,
+          ).unref();
+          finish({ unhealthy: true, signal: "SIGTERM" });
+          return;
+        }
+      }
+      scheduleHealthCheck(options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS);
+    };
+
     child.once("exit", onExit);
     child.once("error", onError);
     signal.addEventListener("abort", onAbort, { once: true });
+    scheduleHealthCheck(options.healthCheckGraceMs ?? DEFAULT_HEALTH_CHECK_GRACE_MS);
   });
 }