@dbx-tools/tunnel 0.6.65 → 0.6.67

package/README.md

@@ -355,6 +355,19 @@ the cookie, because that request was never going to be gated. So the same runnin
 app shows the OTP screen to a portr visitor and no login at all to a browser on
 `localhost` or the platform front door.
 
+## Verify The Live Portr Install
+
+The normal test task skips the networked portr release download. Run the
+integration test explicitly when validating GitHub release discovery, archive
+selection, executable installation, and the downloaded CLI:
+
+```sh
+RUN_LIVE_INSTALL_TEST=1 bun test packages/node/tunnel/test/portr-install.integration.test.ts
+```
+
+The test installs into an isolated temporary home, runs `portr --version`, logs
+the selected release and executable path, then removes the temporary directory.
+
 ## Modules
 
 - `interceptor` - `tunnelInterceptor()`, the `createApp` interceptor that applies

package/index.ts

@@ -25,7 +25,7 @@ export { CodeStore } from "./src/otp.ts";
 export type { VerifyOutcome } from "./src/otp.ts";
 export { AuthGatePlugin, authGate } from "./src/plugin.ts";
 export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateApi } from "./src/plugin.ts";
-export type { PortrConfig } from "./src/portr.ts";
+export type { PortrInstallOptions, PortrConfig } from "./src/portr.ts";
 export { RateLimiter } from "./src/rate-limit.ts";
 export { KEY_TTL_SECONDS } from "./src/signing-key.ts";
 export type { SigningKey } from "./src/signing-key.ts";

package/lib/index.d.ts

@@ -21,7 +21,7 @@ export { CodeStore } from "./src/otp.ts";
 export type { VerifyOutcome } from "./src/otp.ts";
 export { AuthGatePlugin, authGate } from "./src/plugin.ts";
 export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateApi } from "./src/plugin.ts";
-export type { PortrConfig } from "./src/portr.ts";
+export type { PortrInstallOptions, PortrConfig } from "./src/portr.ts";
 export { RateLimiter } from "./src/rate-limit.ts";
 export { KEY_TTL_SECONDS } from "./src/signing-key.ts";
 export type { SigningKey } from "./src/signing-key.ts";

package/lib/index.js

@@ -20,4 +20,4 @@ export { CodeStore } from "./src/otp.js";
 export { AuthGatePlugin, authGate } from "./src/plugin.js";
 export { RateLimiter } from "./src/rate-limit.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/interceptor.d.ts

@@ -5,16 +5,10 @@
  *
  * This is the in-process replacement for the old `dbxt-tunnel -- <cmd>` wrapper.
  * Instead of the tunnel being the main process that spawns the app as a child, the
- * APP is the main process and hands this interceptor its context. The interceptor:
- *
- *   1. applies the workspace host the context computed to `process.env`
- *      (`DATABRICKS_HOST`), so portr and any later SDK call agree on the workspace;
- *   2. installs + launches portr, pointed at the app's PUBLIC port;
- *   3. `bindProcess`es portr so the app and the tunnel live and die as one -
- *      signals pass through and either death tears the pair down (the
- *      concurrently-style supervision that used to be `superviseExit`);
- *   4. registers an AppKit `shutdown` lifecycle handler so an orderly app shutdown
- *      also stops portr.
+ * APP is the main process and hands this interceptor its context. The interceptor
+ * applies the computed workspace host, installs and launches portr on the app's
+ * public port, binds the child process to the app, and stops portr during an
+ * orderly AppKit shutdown.
  *
  * The email-OTP GATE is a separate concern: it is the `authGate` AppKit plugin,
  * which registers the login routes + a gating middleware on the app's own server.

package/lib/src/interceptor.js

@@ -5,16 +5,10 @@
  *
  * This is the in-process replacement for the old `dbxt-tunnel -- <cmd>` wrapper.
  * Instead of the tunnel being the main process that spawns the app as a child, the
- * APP is the main process and hands this interceptor its context. The interceptor:
- *
- *   1. applies the workspace host the context computed to `process.env`
- *      (`DATABRICKS_HOST`), so portr and any later SDK call agree on the workspace;
- *   2. installs + launches portr, pointed at the app's PUBLIC port;
- *   3. `bindProcess`es portr so the app and the tunnel live and die as one -
- *      signals pass through and either death tears the pair down (the
- *      concurrently-style supervision that used to be `superviseExit`);
- *   4. registers an AppKit `shutdown` lifecycle handler so an orderly app shutdown
- *      also stops portr.
+ * APP is the main process and hands this interceptor its context. The interceptor
+ * applies the computed workspace host, installs and launches portr on the app's
+ * public port, binds the child process to the app, and stops portr during an
+ * orderly AppKit shutdown.
  *
  * The email-OTP GATE is a separate concern: it is the `authGate` AppKit plugin,
  * which registers the login routes + a gating middleware on the app's own server.
@@ -47,16 +41,10 @@ function resolvePublicPort(port) {
  * });
  */
 export function tunnelInterceptor(options = {}) {
-    return (ctx) => {
-        // 1. Apply the computed workspace host so portr + the SDK agree. The context
-        //    already resolved it (from the env / auto-config); set it only when it is
-        //    known and not already present, so an explicit env wins.
+    return async (ctx) => {
         if (ctx.env.databricksHost) {
             process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;
         }
-        // 2. Resolve portr wiring. No token / domain -> no tunnel; leave the app alone.
-        //    `resolvePortrConfig` already falls back to TUNNEL_PUBLIC_DOMAIN itself, so
-        //    the explicit option is passed straight through.
         const port = resolvePublicPort(options.port);
         const portrConfig = resolvePortrConfig({
             publicDomain: options.publicDomain,
@@ -67,13 +55,10 @@ export function tunnelInterceptor(options = {}) {
             logger.info("no PORTR_TOKEN/TUNNEL_PUBLIC_DOMAIN - the app runs without a public tunnel");
             return;
         }
-        // 3. Install + launch portr, then bind it: the app and portr now share a fate.
-        const portrEnv = installPortr();
-        writePortrConfig(portrConfig, portrEnv);
-        const portr = startPortr(portrConfig, portrEnv);
+        const portrEnv = await installPortr();
+        await writePortrConfig(portrConfig, portrEnv);
+        const portr = await startPortr(portrConfig, portrEnv);
         ctx.bindProcess(portr);
-        // 4. An orderly AppKit shutdown also stops portr (belt-and-suspenders with the
-        //    signal pass-through `bindProcess` already installed).
         ctx.onLifecycle("shutdown", () => {
             if (!portr.killed)
                 portr.kill("SIGTERM");
@@ -81,4 +66,4 @@ export function tunnelInterceptor(options = {}) {
         logger.info(`tunnel bound: portr -> :${port} (${portrConfig.subdomain}.${portrConfig.server})`);
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE5F,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAgBhD,qFAAqF;AACrF,SAAS,iBAAiB,CAAC,IAAa;IACtC,OAAO,IAAI,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,IAAI,IAAI,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAAC,UAAoC,EAAE;IACtE,OAAO,CAAC,GAAuB,EAAQ,EAAE;QACvC,6EAA6E;QAC7E,8EAA8E;QAC9E,6DAA6D;QAC7D,IAAI,GAAG,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;YAC3B,OAAO,CAAC,GAAG,CAAC,eAAe,KAAK,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC;QACzD,CAAC;QAED,gFAAgF;QAChF,gFAAgF;QAChF,qDAAqD;QACrD,MAAM,IAAI,GAAG,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7C,MAAM,WAAW,GAAG,kBAAkB,CAAC;YACrC,YAAY,EAAE,OAAO,CAAC,YAAY;YAClC,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,IAAI;SACL,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,CAAC,IAAI,CAAC,4EAA4E,CAAC,CAAC;YAC1F,OAAO;QACT,CAAC;QAED,+EAA+E;QAC/E,MAAM,QAAQ,GAAG,YAAY,EAAE,CAAC;QAChC,gBAAgB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QACxC,MAAM,KAAK,GAAG,UAAU,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QAChD,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAEvB,+EAA+E;QAC/E,2DAA2D;QAC3D,GAAG,CAAC,WAAW,CAAC,UAAU,EAAE,GAAG,EAAE;YAC/B,IAAI,CAAC,KAAK,CAAC,MAAM;gBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,IAAI,CAAC,2BAA2B,IAAI,KAAK,WAAW,CAAC,SAAS,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;IAClG,CAAC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * `tunnelInterceptor()` - the {@link Interceptor} that fronts an app with a public\n * portr tunnel, consuming the {@link InterceptorContext} `@dbx-tools/appkit`'s\n * `createApp` hands it.\n *\n * This is the in-process replacement for the old `dbxt-tunnel -- <cmd>` wrapper.\n * Instead of the tunnel being the main process that spawns the app as a child, the\n * APP is the main process and hands this interceptor its context. The interceptor:\n *\n *   1. applies the workspace host the context computed to `process.env`\n *      (`DATABRICKS_HOST`), so portr and any later SDK call agree on the workspace;\n *   2. installs + launches portr, pointed at the app's PUBLIC port;\n *   3. `bindProcess`es portr so the app and the tunnel live and die as one -\n *      signals pass through and either death tears the pair down (the\n *      concurrently-style supervision that used to be `superviseExit`);\n *   4. registers an AppKit `shutdown` lifecycle handler so an orderly app shutdown\n *      also stops portr.\n *\n * The email-OTP 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 { installPortr, resolvePortrConfig, startPortr, writePortrConfig } from \"./portr.ts\";\n\nconst logger = log.logger(\"tunnel:interceptor\");\n\n/** Options for {@link tunnelInterceptor} (each also resolvable from env). */\nexport interface TunnelInterceptorOptions {\n  /** portr `<subdomain>.<server>` 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}\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 no portr tunnel is configured - no `PORTR_TOKEN`\n * or no resolvable `<subdomain>.<server>` - so an app can register it\n * unconditionally and only actually tunnels where the deployment wired portr.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n * import { tunnelInterceptor } from \"@dbx-tools/tunnel\";\n *\n * await createApp({\n *   plugins: [server({ host, staticPath })],\n *   interceptor: tunnelInterceptor(),\n * });\n */\nexport function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Interceptor {\n  return (ctx: InterceptorContext): void => {\n    // 1. Apply the computed workspace host so portr + the SDK agree. The context\n    //    already resolved it (from the env / auto-config); set it only when it is\n    //    known and not already present, so an explicit env wins.\n    if (ctx.env.databricksHost) {\n      process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;\n    }\n\n    // 2. Resolve portr wiring. No token / domain -> no tunnel; leave the app alone.\n    //    `resolvePortrConfig` already falls back to TUNNEL_PUBLIC_DOMAIN itself, so\n    //    the explicit option is passed straight through.\n    const port = resolvePublicPort(options.port);\n    const portrConfig = resolvePortrConfig({\n      publicDomain: options.publicDomain,\n      subdomain: options.subdomain,\n      port,\n    });\n    if (!portrConfig) {\n      logger.info(\"no PORTR_TOKEN/TUNNEL_PUBLIC_DOMAIN - the app runs without a public tunnel\");\n      return;\n    }\n\n    // 3. Install + launch portr, then bind it: the app and portr now share a fate.\n    const portrEnv = installPortr();\n    writePortrConfig(portrConfig, portrEnv);\n    const portr = startPortr(portrConfig, portrEnv);\n    ctx.bindProcess(portr);\n\n    // 4. An orderly AppKit shutdown also stops portr (belt-and-suspenders with the\n    //    signal pass-through `bindProcess` already installed).\n    ctx.onLifecycle(\"shutdown\", () => {\n      if (!portr.killed) portr.kill(\"SIGTERM\");\n    });\n\n    logger.info(`tunnel bound: portr -> :${port} (${portrConfig.subdomain}.${portrConfig.server})`);\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/portr.d.ts

@@ -1,16 +1,20 @@
 /**
- * portr install + config + launch for the tunnel CLI.
+ * portr install, config, and launch support for the tunnel runtime.
  *
- * Some hosts (Databricks Apps among them) mount the container's `$HOME` read-only
- * on cold start, so the portr binary and its config are placed under a writable,
- * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.
- * The install is idempotent (the installer skips when the on-PATH binary is
- * current). The config is rendered from `TUNNEL_PUBLIC_DOMAIN` (`<subdomain>.<server>`)
- * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).
+ * The binary and config use portr's conventional `$HOME/.portr` tree. The
+ * install is idempotent (the installer skips an existing executable). The
+ * config is rendered from `TUNNEL_PUBLIC_DOMAIN`
+ * (`<subdomain>.<server>`) + `PORTR_TOKEN` and points portr at the PUBLIC port
+ * (the proxy listens there).
  *
  * @module
  */
 import { spawn } from "node:child_process";
+/** Options for installing the portr executable. */
+export interface PortrInstallOptions {
+    /** Home directory containing `.portr`; defaults to the OS home directory. */
+    homeDir?: string;
+}
 /** Resolved portr wiring, or `undefined` when no tunnel is configured. */
 export interface PortrConfig {
     subdomain: string;
@@ -30,11 +34,11 @@ export declare function resolvePortrConfig(opts: {
     token?: string;
     port: number;
 }): PortrConfig | undefined;
-/** Install portr (idempotent) into the cwd-rooted home and return the child env. */
-export declare function installPortr(): NodeJS.ProcessEnv;
+/** GitHub release asset name for the current or supplied OS/architecture. */
+export declare function portrAssetName(version: string, platform?: NodeJS.Platform, arch?: string): string;
+/** Install portr when absent and return the environment used by its process. */
+export declare function installPortr(options?: PortrInstallOptions): Promise<NodeJS.ProcessEnv>;
 /** Render `~/.portr/config.yaml` for the resolved tunnel. */
-export declare function writePortrConfig(config: PortrConfig, env: NodeJS.ProcessEnv): void;
+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, env: NodeJS.ProcessEnv): ReturnType<typeof spawn>;
-/** True when the installed portr binary path exists (post-install sanity). */
-export declare function portrInstalled(env: NodeJS.ProcessEnv): boolean;
+export declare function startPortr(config: PortrConfig, childEnv: NodeJS.ProcessEnv): Promise<ReturnType<typeof spawn>>;

package/lib/src/portr.js

@@ -1,21 +1,26 @@
 /**
- * portr install + config + launch for the tunnel CLI.
+ * portr install, config, and launch support for the tunnel runtime.
  *
- * Some hosts (Databricks Apps among them) mount the container's `$HOME` read-only
- * on cold start, so the portr binary and its config are placed under a writable,
- * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.
- * The install is idempotent (the installer skips when the on-PATH binary is
- * current). The config is rendered from `TUNNEL_PUBLIC_DOMAIN` (`<subdomain>.<server>`)
- * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).
+ * The binary and config use portr's conventional `$HOME/.portr` tree. The
+ * install is idempotent (the installer skips an existing executable). The
+ * config is rendered from `TUNNEL_PUBLIC_DOMAIN`
+ * (`<subdomain>.<server>`) + `PORTR_TOKEN` and points portr at the PUBLIC port
+ * (the proxy listens there).
  *
  * @module
  */
-import { spawn, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { execFile, spawn } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import os from "node:os";
 import { delimiter, join } from "node:path";
+import { promisify } from "node:util";
+import { bin } from "@dbx-tools/core";
 import { env, log } from "@dbx-tools/shared-core";
 import { PUBLIC_DOMAIN_ENV } from "./env.js";
 const logger = log.logger("tunnel:portr");
+const PORTR_LATEST_RELEASE_URL = "https://api.github.com/repos/amalshaji/portr/releases/latest";
+const PORTR_MIN_VERSION = "v1.0.15";
+const execFileAsync = promisify(execFile);
 /**
  * Resolve portr config from `TUNNEL_PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an
  * explicit `subdomain`. The domain is `<subdomain>.<server>` (e.g.
@@ -39,34 +44,54 @@ export function resolvePortrConfig(opts) {
         return undefined;
     return { subdomain, server, token, port: opts.port };
 }
-/** The writable home portr installs + configures under (Apps `$HOME` is read-only). */
-function portrHome() {
-    const home = join(process.cwd(), ".home");
-    mkdirSync(join(home, ".portr", "bin"), { recursive: true });
-    return home;
+/** GitHub release asset name for the current or supplied OS/architecture. */
+export function portrAssetName(version, platform = process.platform, arch = process.arch) {
+    const osName = platform === "darwin" ? "Darwin" : platform === "linux" ? "Linux" : undefined;
+    const archName = arch === "arm64" ? "arm64" : arch === "x64" ? "x86_64" : undefined;
+    if (!osName || !archName) {
+        throw new Error(`portr has no supported release asset for ${platform}/${arch}`);
+    }
+    return `portr_${version}_${osName}_${archName}.zip`;
+}
+async function portrDownloadUrl() {
+    const releaseResponse = await fetch(PORTR_LATEST_RELEASE_URL, {
+        headers: {
+            accept: "application/vnd.github+json",
+            "user-agent": "@dbx-tools/tunnel",
+        },
+    });
+    if (!releaseResponse.ok) {
+        throw new Error(`portr release lookup failed (${releaseResponse.status})`);
+    }
+    const release = (await releaseResponse.json());
+    const version = release.tag_name.replace(/^v/, "");
+    const assetName = portrAssetName(version);
+    const asset = release.assets.find((candidate) => candidate.name === assetName);
+    if (!asset)
+        throw new Error(`portr release ${release.tag_name} has no ${assetName}`);
+    logger.info("installing portr", { version, asset: assetName });
+    return asset.browser_download_url;
 }
-/** Install portr (idempotent) into the cwd-rooted home and return the child env. */
-export function installPortr() {
-    const home = portrHome();
-    const env = {
+/** Install portr when absent and return the environment used by its process. */
+export async function installPortr(options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const context = await bin.ensure("portr", portrDownloadUrl, {
+        autoUnpackage: true,
+        homeDir,
+        minVersion: PORTR_MIN_VERSION,
+        selector: ({ source }) => join(source, "portr"),
+    });
+    return {
         ...process.env,
-        HOME: home,
+        HOME: homeDir,
         PORTR_AUTO_ADD_PATH: "no",
-        PATH: [join(home, ".portr", "bin"), process.env.PATH ?? ""].join(delimiter),
+        PATH: [context.binDir, process.env.PATH ?? ""].join(delimiter),
     };
-    logger.info("installing portr (idempotent)");
-    const res = spawnSync("bash", ["-c", "curl -sSf https://install.portr.dev | sh"], {
-        env,
-        stdio: "inherit",
-    });
-    if (res.status !== 0)
-        throw new Error("portr install failed");
-    return env;
 }
 /** Render `~/.portr/config.yaml` for the resolved tunnel. */
-export function writePortrConfig(config, env) {
-    const path = join(env.HOME, ".portr", "config.yaml");
-    writeFileSync(path, [
+export async function writePortrConfig(config, childEnv) {
+    const path = join(childEnv.HOME ?? os.homedir(), ".portr", "config.yaml");
+    await writeFile(path, [
         `server_url: ${config.server}`,
         `ssh_url: ${config.server}:4444`,
         `secret_key: ${config.token}`,
@@ -80,14 +105,10 @@ export function writePortrConfig(config, env) {
     ].join("\n"));
 }
 /** Launch `portr start` as a child process (caller supervises + kills it). */
-export function startPortr(config, env) {
+export async function startPortr(config, childEnv) {
     // Reclaim the subdomain from any portr left by a previous boot in this container.
-    spawnSync("pkill", ["-x", "portr"], { stdio: "ignore" });
+    await execFileAsync("pkill", ["-x", "portr"]).catch(() => undefined);
     logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);
-    return spawn("portr", ["start"], { env, stdio: "inherit" });
-}
-/** True when the installed portr binary path exists (post-install sanity). */
-export function portrInstalled(env) {
-    return existsSync(join(env.HOME, ".portr", "bin", "portr"));
+    return spawn("portr", ["start"], { env: childEnv, stdio: "inherit" });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portr.js","sourceRoot":"","sources":["../../src/portr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;AAU1C;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAKlC;IACC,mEAAmE;IACnE,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;IACpD,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC;IAChE,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,IAAI,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;IAC/B,IAAI,MAA0B,CAAC;IAC/B,IAAI,MAAM,EAAE,CAAC;QACX,SAAS,KAAK,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACjD,CAAC;IACD,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,SAAS,CAAC;IACjD,IAAI,CAAC,SAAS,IAAI,CAAC,MAAM,IAAI,MAAM,KAAK,MAAM;QAAE,OAAO,SAAS,CAAC;IACjE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;AACvD,CAAC;AAED,uFAAuF;AACvF,SAAS,SAAS;IAChB,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC;IAC1C,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5D,OAAO,IAAI,CAAC;AACd,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,YAAY;IAC1B,MAAM,IAAI,GAAG,SAAS,EAAE,CAAC;IACzB,MAAM,GAAG,GAAsB;QAC7B,GAAG,OAAO,CAAC,GAAG;QACd,IAAI,EAAE,IAAI;QACV,mBAAmB,EAAE,IAAI;QACzB,IAAI,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;KAC5E,CAAC;IACF,MAAM,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC;IAC7C,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,0CAA0C,CAAC,EAAE;QAChF,GAAG;QACH,KAAK,EAAE,SAAS;KACjB,CAAC,CAAC;IACH,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC9D,OAAO,GAAG,CAAC;AACb,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,gBAAgB,CAAC,MAAmB,EAAE,GAAsB;IAC1E,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAK,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC;IACtD,aAAa,CACX,IAAI,EACJ;QACE,eAAe,MAAM,CAAC,MAAM,EAAE;QAC9B,YAAY,MAAM,CAAC,MAAM,OAAO;QAChC,eAAe,MAAM,CAAC,KAAK,EAAE;QAC7B,yBAAyB;QACzB,mBAAmB;QACnB,UAAU;QACV,aAAa,MAAM,CAAC,SAAS,EAAE;QAC/B,kBAAkB,MAAM,CAAC,SAAS,EAAE;QACpC,aAAa,MAAM,CAAC,IAAI,EAAE;QAC1B,EAAE;KACH,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,UAAU,CAAC,MAAmB,EAAE,GAAsB;IACpE,kFAAkF;IAClF,SAAS,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;IACzD,MAAM,CAAC,IAAI,CAAC,2BAA2B,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,MAAM,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAC/F,OAAO,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;AAC9D,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,cAAc,CAAC,GAAsB;IACnD,OAAO,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,IAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;AAC/D,CAAC","sourcesContent":["/**\n * portr install + config + launch for the tunnel CLI.\n *\n * Some hosts (Databricks Apps among them) mount the container's `$HOME` read-only\n * on cold start, so the portr binary and its config are placed under a writable,\n * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.\n * The install is idempotent (the installer skips when the on-PATH binary is\n * current). The config is rendered from `TUNNEL_PUBLIC_DOMAIN` (`<subdomain>.<server>`)\n * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).\n *\n * @module\n */\n\nimport { spawn, spawnSync } from \"node:child_process\";\nimport { existsSync, mkdirSync, writeFileSync } from \"node:fs\";\nimport { delimiter, join } from \"node:path\";\nimport { env, log } from \"@dbx-tools/shared-core\";\nimport { PUBLIC_DOMAIN_ENV } from \"./env.ts\";\n\nconst logger = log.logger(\"tunnel:portr\");\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 = env.string(opts.token, \"PORTR_TOKEN\");\n  const domain = env.string(opts.publicDomain, PUBLIC_DOMAIN_ENV);\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 ??= env.text(\"PORTR_SERVER\") ?? undefined;\n  if (!subdomain || !server || server === domain) return undefined;\n  return { subdomain, server, token, port: opts.port };\n}\n\n/** The writable home portr installs + configures under (Apps `$HOME` is read-only). */\nfunction portrHome(): string {\n  const home = join(process.cwd(), \".home\");\n  mkdirSync(join(home, \".portr\", \"bin\"), { recursive: true });\n  return home;\n}\n\n/** Install portr (idempotent) into the cwd-rooted home and return the child env. */\nexport function installPortr(): NodeJS.ProcessEnv {\n  const home = portrHome();\n  const env: NodeJS.ProcessEnv = {\n    ...process.env,\n    HOME: home,\n    PORTR_AUTO_ADD_PATH: \"no\",\n    PATH: [join(home, \".portr\", \"bin\"), process.env.PATH ?? \"\"].join(delimiter),\n  };\n  logger.info(\"installing portr (idempotent)\");\n  const res = spawnSync(\"bash\", [\"-c\", \"curl -sSf https://install.portr.dev | sh\"], {\n    env,\n    stdio: \"inherit\",\n  });\n  if (res.status !== 0) throw new Error(\"portr install failed\");\n  return env;\n}\n\n/** Render `~/.portr/config.yaml` for the resolved tunnel. */\nexport function writePortrConfig(config: PortrConfig, env: NodeJS.ProcessEnv): void {\n  const path = join(env.HOME!, \".portr\", \"config.yaml\");\n  writeFileSync(\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 function startPortr(config: PortrConfig, env: NodeJS.ProcessEnv): ReturnType<typeof spawn> {\n  // Reclaim the subdomain from any portr left by a previous boot in this container.\n  spawnSync(\"pkill\", [\"-x\", \"portr\"], { stdio: \"ignore\" });\n  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);\n  return spawn(\"portr\", [\"start\"], { env, stdio: \"inherit\" });\n}\n\n/** True when the installed portr binary path exists (post-install sanity). */\nexport function portrInstalled(env: NodeJS.ProcessEnv): boolean {\n  return existsSync(join(env.HOME!, \".portr\", \"bin\", \"portr\"));\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 { promisify } from \"node:util\";\n\nimport { bin } from \"@dbx-tools/core\";\nimport { env, log } from \"@dbx-tools/shared-core\";\nimport { PUBLIC_DOMAIN_ENV } from \"./env.ts\";\n\nconst logger = log.logger(\"tunnel:portr\");\nconst PORTR_LATEST_RELEASE_URL = \"https://api.github.com/repos/amalshaji/portr/releases/latest\";\nconst PORTR_MIN_VERSION = \"v1.0.15\";\nconst execFileAsync = promisify(execFile);\n\ninterface PortrRelease {\n  tag_name: string;\n  assets: Array<{ name: string; browser_download_url: string }>;\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 = env.string(opts.token, \"PORTR_TOKEN\");\n  const domain = env.string(opts.publicDomain, PUBLIC_DOMAIN_ENV);\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 ??= env.text(\"PORTR_SERVER\") ?? undefined;\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\nasync function portrDownloadUrl(): Promise<string> {\n  const releaseResponse = await fetch(PORTR_LATEST_RELEASE_URL, {\n    headers: {\n      accept: \"application/vnd.github+json\",\n      \"user-agent\": \"@dbx-tools/tunnel\",\n    },\n  });\n  if (!releaseResponse.ok) {\n    throw new Error(`portr release lookup failed (${releaseResponse.status})`);\n  }\n  const release = (await releaseResponse.json()) as PortrRelease;\n  const version = release.tag_name.replace(/^v/, \"\");\n\n  const assetName = portrAssetName(version);\n  const asset = release.assets.find((candidate) => candidate.name === assetName);\n  if (!asset) throw new Error(`portr release ${release.tag_name} has no ${assetName}`);\n\n  logger.info(\"installing portr\", { version, asset: assetName });\n  return asset.browser_download_url;\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  });\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  return spawn(\"portr\", [\"start\"], { env: childEnv, stdio: \"inherit\" });\n}\n"]}

package/package.json

@@ -18,19 +18,20 @@
     "projen": "projen"
   },
   "devDependencies": {
-    "@dbx-tools/email": "0.6.65",
+    "@dbx-tools/email": "0.6.67",
     "@types/bun": "^1.3.14",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@dbx-tools/email": "0.6.65"
+    "@dbx-tools/email": "0.6.67"
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/appkit": "0.6.65",
-    "@dbx-tools/shared-core": "0.6.65",
-    "@dbx-tools/shared-email": "0.6.65",
+    "@dbx-tools/appkit": "0.6.67",
+    "@dbx-tools/core": "0.6.67",
+    "@dbx-tools/shared-core": "0.6.67",
+    "@dbx-tools/shared-email": "0.6.67",
     "jose": "^6.2.3"
   },
   "main": "./lib/index.js",
@@ -47,7 +48,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.65",
+  "version": "0.6.67",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/interceptor.ts

@@ -5,16 +5,10 @@
  *
  * This is the in-process replacement for the old `dbxt-tunnel -- <cmd>` wrapper.
  * Instead of the tunnel being the main process that spawns the app as a child, the
- * APP is the main process and hands this interceptor its context. The interceptor:
- *
- *   1. applies the workspace host the context computed to `process.env`
- *      (`DATABRICKS_HOST`), so portr and any later SDK call agree on the workspace;
- *   2. installs + launches portr, pointed at the app's PUBLIC port;
- *   3. `bindProcess`es portr so the app and the tunnel live and die as one -
- *      signals pass through and either death tears the pair down (the
- *      concurrently-style supervision that used to be `superviseExit`);
- *   4. registers an AppKit `shutdown` lifecycle handler so an orderly app shutdown
- *      also stops portr.
+ * APP is the main process and hands this interceptor its context. The interceptor
+ * applies the computed workspace host, installs and launches portr on the app's
+ * public port, binds the child process to the app, and stops portr during an
+ * orderly AppKit shutdown.
  *
  * The email-OTP GATE is a separate concern: it is the `authGate` AppKit plugin,
  * which registers the login routes + a gating middleware on the app's own server.
@@ -66,17 +60,11 @@ function resolvePublicPort(port?: number): number {
  * });
  */
 export function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Interceptor {
-  return (ctx: InterceptorContext): void => {
-    // 1. Apply the computed workspace host so portr + the SDK agree. The context
-    //    already resolved it (from the env / auto-config); set it only when it is
-    //    known and not already present, so an explicit env wins.
+  return async (ctx: InterceptorContext): Promise<void> => {
     if (ctx.env.databricksHost) {
       process.env.DATABRICKS_HOST ??= ctx.env.databricksHost;
     }
 
-    // 2. Resolve portr wiring. No token / domain -> no tunnel; leave the app alone.
-    //    `resolvePortrConfig` already falls back to TUNNEL_PUBLIC_DOMAIN itself, so
-    //    the explicit option is passed straight through.
     const port = resolvePublicPort(options.port);
     const portrConfig = resolvePortrConfig({
       publicDomain: options.publicDomain,
@@ -88,14 +76,11 @@ export function tunnelInterceptor(options: TunnelInterceptorOptions = {}): Inter
       return;
     }
 
-    // 3. Install + launch portr, then bind it: the app and portr now share a fate.
-    const portrEnv = installPortr();
-    writePortrConfig(portrConfig, portrEnv);
-    const portr = startPortr(portrConfig, portrEnv);
+    const portrEnv = await installPortr();
+    await writePortrConfig(portrConfig, portrEnv);
+    const portr = await startPortr(portrConfig, portrEnv);
     ctx.bindProcess(portr);
 
-    // 4. An orderly AppKit shutdown also stops portr (belt-and-suspenders with the
-    //    signal pass-through `bindProcess` already installed).
     ctx.onLifecycle("shutdown", () => {
       if (!portr.killed) portr.kill("SIGTERM");
     });

package/src/portr.ts

@@ -1,23 +1,39 @@
 /**
- * portr install + config + launch for the tunnel CLI.
+ * portr install, config, and launch support for the tunnel runtime.
  *
- * Some hosts (Databricks Apps among them) mount the container's `$HOME` read-only
- * on cold start, so the portr binary and its config are placed under a writable,
- * cwd-rooted `.home` unconditionally - it costs nothing where `$HOME` is writable.
- * The install is idempotent (the installer skips when the on-PATH binary is
- * current). The config is rendered from `TUNNEL_PUBLIC_DOMAIN` (`<subdomain>.<server>`)
- * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).
+ * The binary and config use portr's conventional `$HOME/.portr` tree. The
+ * install is idempotent (the installer skips an existing executable). The
+ * config is rendered from `TUNNEL_PUBLIC_DOMAIN`
+ * (`<subdomain>.<server>`) + `PORTR_TOKEN` and points portr at the PUBLIC port
+ * (the proxy listens there).
  *
  * @module
  */
-
-import { spawn, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { execFile, spawn } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import os from "node:os";
 import { delimiter, join } from "node:path";
+import { promisify } from "node:util";
+
+import { bin } from "@dbx-tools/core";
 import { env, log } from "@dbx-tools/shared-core";
 import { PUBLIC_DOMAIN_ENV } from "./env.ts";
 
 const logger = log.logger("tunnel:portr");
+const PORTR_LATEST_RELEASE_URL = "https://api.github.com/repos/amalshaji/portr/releases/latest";
+const PORTR_MIN_VERSION = "v1.0.15";
+const execFileAsync = promisify(execFile);
+
+interface PortrRelease {
+  tag_name: string;
+  assets: Array<{ name: string; browser_download_url: string }>;
+}
+
+/** Options for installing the portr executable. */
+export interface PortrInstallOptions {
+  /** Home directory containing `.portr`; defaults to the OS home directory. */
+  homeDir?: string;
+}
 
 /** Resolved portr wiring, or `undefined` when no tunnel is configured. */
 export interface PortrConfig {
@@ -54,35 +70,65 @@ export function resolvePortrConfig(opts: {
   return { subdomain, server, token, port: opts.port };
 }
 
-/** The writable home portr installs + configures under (Apps `$HOME` is read-only). */
-function portrHome(): string {
-  const home = join(process.cwd(), ".home");
-  mkdirSync(join(home, ".portr", "bin"), { recursive: true });
-  return home;
+/** GitHub release asset name for the current or supplied OS/architecture. */
+export function portrAssetName(
+  version: string,
+  platform: NodeJS.Platform = process.platform,
+  arch: string = process.arch,
+): string {
+  const osName = platform === "darwin" ? "Darwin" : platform === "linux" ? "Linux" : undefined;
+  const archName = arch === "arm64" ? "arm64" : arch === "x64" ? "x86_64" : undefined;
+  if (!osName || !archName) {
+    throw new Error(`portr has no supported release asset for ${platform}/${arch}`);
+  }
+  return `portr_${version}_${osName}_${archName}.zip`;
+}
+
+async function portrDownloadUrl(): Promise<string> {
+  const releaseResponse = await fetch(PORTR_LATEST_RELEASE_URL, {
+    headers: {
+      accept: "application/vnd.github+json",
+      "user-agent": "@dbx-tools/tunnel",
+    },
+  });
+  if (!releaseResponse.ok) {
+    throw new Error(`portr release lookup failed (${releaseResponse.status})`);
+  }
+  const release = (await releaseResponse.json()) as PortrRelease;
+  const version = release.tag_name.replace(/^v/, "");
+
+  const assetName = portrAssetName(version);
+  const asset = release.assets.find((candidate) => candidate.name === assetName);
+  if (!asset) throw new Error(`portr release ${release.tag_name} has no ${assetName}`);
+
+  logger.info("installing portr", { version, asset: assetName });
+  return asset.browser_download_url;
 }
 
-/** Install portr (idempotent) into the cwd-rooted home and return the child env. */
-export function installPortr(): NodeJS.ProcessEnv {
-  const home = portrHome();
-  const env: NodeJS.ProcessEnv = {
+/** Install portr when absent and return the environment used by its process. */
+export async function installPortr(options: PortrInstallOptions = {}): Promise<NodeJS.ProcessEnv> {
+  const homeDir = options.homeDir ?? os.homedir();
+  const context = await bin.ensure("portr", portrDownloadUrl, {
+    autoUnpackage: true,
+    homeDir,
+    minVersion: PORTR_MIN_VERSION,
+    selector: ({ source }) => join(source, "portr"),
+  });
+  return {
     ...process.env,
-    HOME: home,
+    HOME: homeDir,
     PORTR_AUTO_ADD_PATH: "no",
-    PATH: [join(home, ".portr", "bin"), process.env.PATH ?? ""].join(delimiter),
+    PATH: [context.binDir, process.env.PATH ?? ""].join(delimiter),
   };
-  logger.info("installing portr (idempotent)");
-  const res = spawnSync("bash", ["-c", "curl -sSf https://install.portr.dev | sh"], {
-    env,
-    stdio: "inherit",
-  });
-  if (res.status !== 0) throw new Error("portr install failed");
-  return env;
 }
 
 /** Render `~/.portr/config.yaml` for the resolved tunnel. */
-export function writePortrConfig(config: PortrConfig, env: NodeJS.ProcessEnv): void {
-  const path = join(env.HOME!, ".portr", "config.yaml");
-  writeFileSync(
+export async function writePortrConfig(
+  config: PortrConfig,
+  childEnv: NodeJS.ProcessEnv,
+): Promise<void> {
+  const path = join(childEnv.HOME ?? os.homedir(), ".portr", "config.yaml");
+  await writeFile(
     path,
     [
       `server_url: ${config.server}`,
@@ -100,14 +146,13 @@ export function writePortrConfig(config: PortrConfig, env: NodeJS.ProcessEnv): v
 }
 
 /** Launch `portr start` as a child process (caller supervises + kills it). */
-export function startPortr(config: PortrConfig, env: NodeJS.ProcessEnv): ReturnType<typeof spawn> {
+export async function startPortr(
+  config: PortrConfig,
+  childEnv: NodeJS.ProcessEnv,
+): Promise<ReturnType<typeof spawn>> {
   // Reclaim the subdomain from any portr left by a previous boot in this container.
-  spawnSync("pkill", ["-x", "portr"], { stdio: "ignore" });
-  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);
-  return spawn("portr", ["start"], { env, stdio: "inherit" });
-}
+  await execFileAsync("pkill", ["-x", "portr"]).catch(() => undefined);
 
-/** True when the installed portr binary path exists (post-install sanity). */
-export function portrInstalled(env: NodeJS.ProcessEnv): boolean {
-  return existsSync(join(env.HOME!, ".portr", "bin", "portr"));
+  logger.info(`portr tunneling https://${config.subdomain}.${config.server} -> :${config.port}`);
+  return spawn("portr", ["start"], { env: childEnv, stdio: "inherit" });
 }