@dbx-tools/cli-tunnel 0.6.45

package/lib/src/otp.js

@@ -0,0 +1,134 @@
+/**
+ * One-time-code store + session JWT for the email-OTP tunnel gate.
+ *
+ * The code store is backed by AppKit's `CacheManager` (auto-configured to memory,
+ * or Lakebase when the app wires a persistent `CacheStorage`), so TTL EXPIRY and
+ * eviction are the cache's job - no hand-rolled Map or timers. A 6-digit code is
+ * generated with `crypto.randomInt` and stored as a SHA-256 hash with an attempt
+ * counter (never the plaintext, never in the JWT); `verify` is constant-time on
+ * the hash, and the entry is deleted on success or once attempts are exhausted.
+ *
+ * The session JWT is a short-lived HS256 token (via `jose`) carrying only the
+ * email. Its signing key comes from `AUTH_JWT_SECRET`; when unset the gate FAILS
+ * OPEN with an ephemeral per-process key (sessions reset on restart) rather than
+ * refusing service - a Databricks App is already access-limited, so an unset
+ * secret degrades to "sessions don't survive restarts", not "nobody can log in".
+ *
+ * @module
+ */
+import { createHash, randomBytes, randomInt, timingSafeEqual } from "node:crypto";
+import { CacheManager } from "@databricks/appkit";
+import { log } from "@dbx-tools/shared-core";
+import { jwtVerify, SignJWT } from "jose";
+const logger = log.logger("tunnel:otp");
+/** JWT issuer/audience so a token minted for this gate isn't accepted elsewhere. */
+const JWT_AUD = "dbx-tools-tunnel-auth";
+/** Cache-key prefix for pending codes, namespaced away from any other cache use. */
+const CODE_PREFIX = "tunnel:otp:";
+/** SHA-256 hex of a value. */
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+/** Constant-time compare of two equal-length hex digests. */
+function safeEqualHex(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+}
+/**
+ * Pending one-time codes, stored in AppKit's cache keyed by lowercased email.
+ * Expiry is the cache's TTL (no manual clock); a miss means expired-or-never.
+ */
+export class CodeStore {
+    ttlSeconds;
+    maxAttempts;
+    constructor(ttlSeconds, maxAttempts) {
+        this.ttlSeconds = ttlSeconds;
+        this.maxAttempts = maxAttempts;
+    }
+    cache() {
+        return CacheManager.getInstanceSync();
+    }
+    key(email) {
+        return `${CODE_PREFIX}${email.toLowerCase()}`;
+    }
+    /**
+     * Generate, store (hashed, with the cache TTL), and RETURN a fresh 6-digit
+     * code. The caller emails the returned plaintext; only the hash is retained.
+     * Replaces any pending code for the address.
+     */
+    async issue(email) {
+        const code = String(randomInt(0, 1_000_000)).padStart(6, "0");
+        const entry = { hash: sha256(code), attempts: 0 };
+        await this.cache().set(this.key(email), entry, { ttl: this.ttlSeconds });
+        return code;
+    }
+    /**
+     * Check `code` for `email`. A cache miss is `expired` (TTL elapsed or never
+     * issued). Deletes the entry on success or when attempts are exhausted, so a
+     * code is single-use and can't be brute-forced past the cap. An attempt
+     * increments the stored counter (re-persisted with a fresh TTL window).
+     */
+    async verify(email, code) {
+        const key = this.key(email);
+        const entry = await this.cache().get(key);
+        if (!entry)
+            return "expired";
+        const attempts = entry.attempts + 1;
+        if (safeEqualHex(entry.hash, sha256(code))) {
+            await this.cache().delete(key);
+            return "ok";
+        }
+        if (attempts >= this.maxAttempts) {
+            await this.cache().delete(key);
+            return "too-many-attempts";
+        }
+        await this.cache().set(key, { ...entry, attempts }, { ttl: this.ttlSeconds });
+        return "invalid";
+    }
+}
+/**
+ * Resolve the HS256 signing key. Prefers `AUTH_JWT_SECRET`; when unset, mints an
+ * ephemeral per-process key (fail-open) and warns once. Memoized.
+ */
+let cachedKey;
+function signingKey() {
+    if (cachedKey)
+        return cachedKey;
+    const secret = process.env.AUTH_JWT_SECRET?.trim();
+    if (secret) {
+        cachedKey = new TextEncoder().encode(secret);
+    }
+    else {
+        logger.warn("AUTH_JWT_SECRET is not set - using an ephemeral per-process key; sessions will not survive a restart");
+        cachedKey = randomBytes(32);
+    }
+    return cachedKey;
+}
+/** Reset the memoized key (tests, or after changing the env in-process). */
+export function resetSigningKey() {
+    cachedKey = undefined;
+}
+/** Mint a short-lived session JWT for `email`, expiring in `ttlSeconds`. */
+export async function signSession(email, ttlSeconds) {
+    return new SignJWT({ email })
+        .setProtectedHeader({ alg: "HS256" })
+        .setSubject(email)
+        .setAudience(JWT_AUD)
+        .setIssuedAt()
+        .setExpirationTime(`${ttlSeconds}s`)
+        .sign(signingKey());
+}
+/** Validate a session JWT, returning the email it was minted for, or `undefined`. */
+export async function verifySession(token) {
+    if (!token)
+        return undefined;
+    try {
+        const { payload } = await jwtVerify(token, signingKey(), { audience: JWT_AUD });
+        return typeof payload.email === "string" ? payload.email : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"otp.js","sourceRoot":"","sources":["../../src/otp.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * One-time-code store + session JWT for the email-OTP tunnel gate.\n *\n * The code store is backed by AppKit's `CacheManager` (auto-configured to memory,\n * or Lakebase when the app wires a persistent `CacheStorage`), so TTL EXPIRY and\n * eviction are the cache's job - no hand-rolled Map or timers. A 6-digit code is\n * generated with `crypto.randomInt` and stored as a SHA-256 hash with an attempt\n * counter (never the plaintext, never in the JWT); `verify` is constant-time on\n * the hash, and the entry is deleted on success or once attempts are exhausted.\n *\n * The session JWT is a short-lived HS256 token (via `jose`) carrying only the\n * email. Its signing key comes from `AUTH_JWT_SECRET`; when unset the gate FAILS\n * OPEN with an ephemeral per-process key (sessions reset on restart) rather than\n * refusing service - a Databricks App is already access-limited, so an unset\n * secret degrades to \"sessions don't survive restarts\", not \"nobody can log in\".\n *\n * @module\n */\n\nimport { createHash, randomBytes, randomInt, timingSafeEqual } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { jwtVerify, SignJWT } from \"jose\";\n\nconst logger = log.logger(\"tunnel:otp\");\n\n/** JWT issuer/audience so a token minted for this gate isn't accepted elsewhere. */\nconst JWT_AUD = \"dbx-tools-tunnel-auth\";\n\n/** Cache-key prefix for pending codes, namespaced away from any other cache use. */\nconst CODE_PREFIX = \"tunnel:otp:\";\n\n/** SHA-256 hex of a value. */\nfunction sha256(value: string): string {\n  return createHash(\"sha256\").update(value).digest(\"hex\");\n}\n\n/** Constant-time compare of two equal-length hex digests. */\nfunction safeEqualHex(a: string, b: string): boolean {\n  if (a.length !== b.length) return false;\n  return timingSafeEqual(Buffer.from(a, \"hex\"), Buffer.from(b, \"hex\"));\n}\n\ninterface CodeEntry {\n  hash: string;\n  attempts: number;\n}\n\n/** Result of {@link CodeStore.verify}. */\nexport type VerifyOutcome = \"ok\" | \"invalid\" | \"expired\" | \"too-many-attempts\";\n\n/**\n * Pending one-time codes, stored in AppKit's cache keyed by lowercased email.\n * Expiry is the cache's TTL (no manual clock); a miss means expired-or-never.\n */\nexport class CodeStore {\n  constructor(\n    private readonly ttlSeconds: number,\n    private readonly maxAttempts: number,\n  ) {}\n\n  private cache(): CacheManager {\n    return CacheManager.getInstanceSync();\n  }\n\n  private key(email: string): string {\n    return `${CODE_PREFIX}${email.toLowerCase()}`;\n  }\n\n  /**\n   * Generate, store (hashed, with the cache TTL), and RETURN a fresh 6-digit\n   * code. The caller emails the returned plaintext; only the hash is retained.\n   * Replaces any pending code for the address.\n   */\n  async issue(email: string): Promise<string> {\n    const code = String(randomInt(0, 1_000_000)).padStart(6, \"0\");\n    const entry: CodeEntry = { hash: sha256(code), attempts: 0 };\n    await this.cache().set(this.key(email), entry, { ttl: this.ttlSeconds });\n    return code;\n  }\n\n  /**\n   * Check `code` for `email`. A cache miss is `expired` (TTL elapsed or never\n   * issued). Deletes the entry on success or when attempts are exhausted, so a\n   * code is single-use and can't be brute-forced past the cap. An attempt\n   * increments the stored counter (re-persisted with a fresh TTL window).\n   */\n  async verify(email: string, code: string): Promise<VerifyOutcome> {\n    const key = this.key(email);\n    const entry = await this.cache().get<CodeEntry>(key);\n    if (!entry) return \"expired\";\n    const attempts = entry.attempts + 1;\n    if (safeEqualHex(entry.hash, sha256(code))) {\n      await this.cache().delete(key);\n      return \"ok\";\n    }\n    if (attempts >= this.maxAttempts) {\n      await this.cache().delete(key);\n      return \"too-many-attempts\";\n    }\n    await this.cache().set(key, { ...entry, attempts }, { ttl: this.ttlSeconds });\n    return \"invalid\";\n  }\n}\n\n/**\n * Resolve the HS256 signing key. Prefers `AUTH_JWT_SECRET`; when unset, mints an\n * ephemeral per-process key (fail-open) and warns once. Memoized.\n */\nlet cachedKey: Uint8Array | undefined;\nfunction signingKey(): Uint8Array {\n  if (cachedKey) return cachedKey;\n  const secret = process.env.AUTH_JWT_SECRET?.trim();\n  if (secret) {\n    cachedKey = new TextEncoder().encode(secret);\n  } else {\n    logger.warn(\n      \"AUTH_JWT_SECRET is not set - using an ephemeral per-process key; sessions will not survive a restart\",\n    );\n    cachedKey = randomBytes(32);\n  }\n  return cachedKey;\n}\n\n/** Reset the memoized key (tests, or after changing the env in-process). */\nexport function resetSigningKey(): void {\n  cachedKey = undefined;\n}\n\n/** Mint a short-lived session JWT for `email`, expiring in `ttlSeconds`. */\nexport async function signSession(email: string, ttlSeconds: number): Promise<string> {\n  return new SignJWT({ email })\n    .setProtectedHeader({ alg: \"HS256\" })\n    .setSubject(email)\n    .setAudience(JWT_AUD)\n    .setIssuedAt()\n    .setExpirationTime(`${ttlSeconds}s`)\n    .sign(signingKey());\n}\n\n/** Validate a session JWT, returning the email it was minted for, or `undefined`. */\nexport async function verifySession(token: string | undefined): Promise<string | undefined> {\n  if (!token) return undefined;\n  try {\n    const { payload } = await jwtVerify(token, signingKey(), { audience: JWT_AUD });\n    return typeof payload.email === \"string\" ? payload.email : undefined;\n  } catch {\n    return undefined;\n  }\n}\n"]}

package/lib/src/plugin.d.ts

@@ -0,0 +1,99 @@
+/**
+ * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.
+ *
+ * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the
+ * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin
+ * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed
+ * one-time-code store, and the session JWT. `createApp` (with no `server()`) is
+ * used only to auto-init `CacheManager` + prime the sibling `email` transport;
+ * this plugin is where the gate logic lives.
+ *
+ * Options come from CLI flags OR env, with sensible defaults - see
+ * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't
+ * resolve itself is HOW to email the code, so it takes a `sendCode` callback the
+ * app wires to the email plugin.
+ *
+ * @module
+ */
+import { Plugin, type BasePluginConfig } from "@databricks/appkit";
+import type { AuthStatus } from "@dbx-tools/shared-email";
+/** Options for the {@link authGate} plugin (all resolvable from env - see below). */
+export interface AuthGateConfig extends BasePluginConfig {
+    /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env EMAIL_AUTH_ALLOW. */
+    allow?: string | string[];
+    /** Subject line for the code email. Env AUTH_SUBJECT. */
+    subject?: string;
+    /** Product/brand name used in the email + login copy. Env AUTH_BRAND_NAME. */
+    brandName?: string;
+    /** One-line message shown above the code in the email. Env AUTH_MESSAGE. */
+    message?: string;
+    /** Session lifetime (seconds). Env AUTH_SESSION_TTL. Default 43200 (12h). */
+    sessionTtlSeconds?: number;
+    /** One-time-code lifetime (seconds). Env AUTH_CODE_TTL. Default 600 (10m). */
+    codeTtlSeconds?: number;
+    /** Max verify attempts per issued code. Default 5. */
+    maxAttempts?: number;
+    /** Deliver a code to an address. Wired by the app to the email plugin. */
+    sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;
+}
+/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */
+export interface SendCodeOptions {
+    subject: string;
+    brandName: string;
+    message: string;
+}
+/** Resolved gate config with env fallbacks + defaults applied. */
+export interface ResolvedAuthGateConfig {
+    allow: string[];
+    subject: string;
+    brandName: string;
+    message: string;
+    sessionTtlSeconds: number;
+    codeTtlSeconds: number;
+    maxAttempts: number;
+}
+/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */
+export declare function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig;
+/** The handlers the proxy calls in-process (returned by {@link AuthGatePlugin.exports}). */
+export interface AuthGateApi {
+    /** Handle a code request. Always resolves `{ ok: true }` (anti-enumeration). */
+    request(email: string, ip: string): Promise<{
+        ok: true;
+        retryAfter?: number;
+    }>;
+    /** Handle a code verification. On success returns the session token to cookie. */
+    verify(email: string, code: string, ip: string): Promise<{
+        ok: boolean;
+        token?: string;
+        retryAfter?: number;
+    }>;
+    /** Resolve the authenticated email for a session token, or undefined. */
+    session(token: string | undefined): Promise<string | undefined>;
+    /** Session TTL in seconds (for the cookie Max-Age). */
+    readonly sessionTtlSeconds: number;
+    /** The gate status payload (`enabled` is always true when this plugin runs). */
+    status(token: string | undefined): Promise<AuthStatus>;
+}
+/** AppKit plugin owning the email-OTP gate's logic (no HTTP routes; proxy-driven). */
+export declare class AuthGatePlugin extends Plugin<AuthGateConfig> {
+    static manifest: {
+        name: "authGate";
+        displayName: string;
+        description: string;
+        stability: "beta";
+        resources: {
+            required: never[];
+            optional: never[];
+        };
+    };
+    private resolved;
+    private codes;
+    private readonly requestLimiter;
+    private readonly verifyLimiter;
+    setup(): Promise<void>;
+    exports(): AuthGateApi;
+    private handleRequest;
+    private handleVerify;
+}
+/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */
+export declare const authGate: import("@databricks/appkit").ToPlugin<typeof AuthGatePlugin, AuthGateConfig, "authGate">;

package/lib/src/plugin.js

@@ -0,0 +1,123 @@
+/**
+ * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.
+ *
+ * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the
+ * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin
+ * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed
+ * one-time-code store, and the session JWT. `createApp` (with no `server()`) is
+ * used only to auto-init `CacheManager` + prime the sibling `email` transport;
+ * this plugin is where the gate logic lives.
+ *
+ * Options come from CLI flags OR env, with sensible defaults - see
+ * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't
+ * resolve itself is HOW to email the code, so it takes a `sendCode` callback the
+ * app wires to the email plugin.
+ *
+ * @module
+ */
+import { Plugin, toPlugin } from "@databricks/appkit";
+import { log, string } from "@dbx-tools/shared-core";
+import { looksLikeEmail, matchesAllowlist } from "./allowlist.js";
+import { CodeStore, signSession, verifySession } from "./otp.js";
+import { RateLimiter } from "./rate-limit.js";
+const logger = log.logger("tunnel:auth");
+const DEFAULTS = {
+    subject: "Your sign-in code",
+    brandName: "This app",
+    message: "Your one-time sign-in code is:",
+    sessionTtlSeconds: 43200,
+    codeTtlSeconds: 600,
+    maxAttempts: 5,
+};
+/** Positive finite number from a value / env string, else the fallback. */
+function num(value, env, fallback) {
+    const raw = value ?? (env ? Number(env) : undefined);
+    return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : fallback;
+}
+/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */
+export function resolveAuthGateConfig(config) {
+    return {
+        allow: [...string.parseList(config.allow), ...string.parseList(process.env.EMAIL_AUTH_ALLOW)],
+        subject: config.subject ?? process.env.AUTH_SUBJECT?.trim() ?? DEFAULTS.subject,
+        brandName: config.brandName ?? process.env.AUTH_BRAND_NAME?.trim() ?? DEFAULTS.brandName,
+        message: config.message ?? process.env.AUTH_MESSAGE?.trim() ?? DEFAULTS.message,
+        sessionTtlSeconds: num(config.sessionTtlSeconds, process.env.AUTH_SESSION_TTL, DEFAULTS.sessionTtlSeconds),
+        codeTtlSeconds: num(config.codeTtlSeconds, process.env.AUTH_CODE_TTL, DEFAULTS.codeTtlSeconds),
+        maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,
+    };
+}
+/** AppKit plugin owning the email-OTP gate's logic (no HTTP routes; proxy-driven). */
+export class AuthGatePlugin extends Plugin {
+    static manifest = {
+        name: "authGate",
+        displayName: "Auth Gate",
+        description: "Email one-time-password access gate for a public tunnel.",
+        stability: "beta",
+        resources: { required: [], optional: [] },
+    };
+    resolved;
+    codes;
+    // Requesting a code is email-spam-prone; verifying is a brute-force surface.
+    // Per-email AND per-IP so neither axis alone is a bypass.
+    requestLimiter = new RateLimiter(5, 15 * 60 * 1000);
+    verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);
+    async setup() {
+        this.resolved = resolveAuthGateConfig(this.config);
+        this.codes = new CodeStore(this.resolved.codeTtlSeconds, this.resolved.maxAttempts);
+        logger.info("ready", {
+            patterns: this.resolved.allow.length,
+            sessionTtlSeconds: this.resolved.sessionTtlSeconds,
+        });
+    }
+    exports() {
+        return {
+            sessionTtlSeconds: this.resolved.sessionTtlSeconds,
+            request: (email, ip) => this.handleRequest(email, ip),
+            verify: (email, code, ip) => this.handleVerify(email, code, ip),
+            session: (token) => verifySession(token),
+            status: async (token) => ({
+                authenticated: Boolean(await verifySession(token)),
+                email: (await verifySession(token)) ?? undefined,
+                enabled: true,
+            }),
+        };
+    }
+    async handleRequest(email, ip) {
+        const address = email.trim().toLowerCase();
+        const byIp = this.requestLimiter.hit(`ip:${ip}`);
+        const byEmail = this.requestLimiter.hit(`email:${address}`);
+        if (!byIp.allowed || !byEmail.allowed) {
+            return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };
+        }
+        if (looksLikeEmail(address) && matchesAllowlist(address, this.resolved.allow)) {
+            const code = await this.codes.issue(address);
+            try {
+                await this.config.sendCode?.(address, code, {
+                    subject: this.resolved.subject,
+                    brandName: this.resolved.brandName,
+                    message: this.resolved.message,
+                });
+            }
+            catch (error) {
+                logger.warn("failed to send OTP email", { error });
+            }
+        }
+        return { ok: true };
+    }
+    async handleVerify(email, code, ip) {
+        const address = email.trim().toLowerCase();
+        const byIp = this.verifyLimiter.hit(`ip:${ip}`);
+        const byEmail = this.verifyLimiter.hit(`email:${address}`);
+        if (!byIp.allowed || !byEmail.allowed) {
+            return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };
+        }
+        if ((await this.codes.verify(address, code.trim())) !== "ok")
+            return { ok: false };
+        this.requestLimiter.reset(`email:${address}`);
+        this.verifyLimiter.reset(`email:${address}`);
+        return { ok: true, token: await signSession(address, this.resolved.sessionTtlSeconds) };
+    }
+}
+/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */
+export const authGate = toPlugin(AuthGatePlugin);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,MAAM,EAAE,QAAQ,EAA8C,MAAM,oBAAoB,CAAC;AAClG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;AAwCzC,MAAM,QAAQ,GAAG;IACf,OAAO,EAAE,mBAAmB;IAC5B,SAAS,EAAE,UAAU;IACrB,OAAO,EAAE,gCAAgC;IACzC,iBAAiB,EAAE,KAAK;IACxB,cAAc,EAAE,GAAG;IACnB,WAAW,EAAE,CAAC;CACf,CAAC;AAEF,2EAA2E;AAC3E,SAAS,GAAG,CAAC,KAAyB,EAAE,GAAuB,EAAE,QAAgB;IAC/E,MAAM,GAAG,GAAG,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACrD,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC;AACrF,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,qBAAqB,CAAC,MAAsB;IAC1D,OAAO;QACL,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAC7F,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,QAAQ,CAAC,OAAO;QAC/E,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,QAAQ,CAAC,SAAS;QACxF,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,IAAI,QAAQ,CAAC,OAAO;QAC/E,iBAAiB,EAAE,GAAG,CACpB,MAAM,CAAC,iBAAiB,EACxB,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAC5B,QAAQ,CAAC,iBAAiB,CAC3B;QACD,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,QAAQ,CAAC,cAAc,CAAC;QAC9F,WAAW,EAAE,MAAM,CAAC,WAAW,IAAI,QAAQ,CAAC,WAAW;KACxD,CAAC;AACJ,CAAC;AAoBD,sFAAsF;AACtF,MAAM,OAAO,cAAe,SAAQ,MAAsB;IACxD,MAAM,CAAC,QAAQ,GAAG;QAChB,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,WAAW;QACxB,WAAW,EAAE,0DAA0D;QACvE,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;KACL,CAAC;IAE/B,QAAQ,CAA0B;IAClC,KAAK,CAAa;IAC1B,6EAA6E;IAC7E,0DAA0D;IACzC,cAAc,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;IACpD,aAAa,GAAG,IAAI,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;IAE5D,KAAK,CAAC,KAAK;QAClB,IAAI,CAAC,QAAQ,GAAG,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnD,IAAI,CAAC,KAAK,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACpF,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM;YACpC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,iBAAiB;SACnD,CAAC,CAAC;IACL,CAAC;IAEQ,OAAO;QACd,OAAO;YACL,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC,iBAAiB;YAClD,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,EAAE,CAAC;YACrD,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;YAC/D,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC;YACxC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;gBACxB,aAAa,EAAE,OAAO,CAAC,MAAM,aAAa,CAAC,KAAK,CAAC,CAAC;gBAClD,KAAK,EAAE,CAAC,MAAM,aAAa,CAAC,KAAK,CAAC,CAAC,IAAI,SAAS;gBAChD,OAAO,EAAE,IAAI;aACd,CAAC;SACH,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,aAAa,CACzB,KAAa,EACb,EAAU;QAEV,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QACjD,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,OAAO,EAAE,CAAC,CAAC;QAC5D,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACtC,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;QACzE,CAAC;QACD,IAAI,cAAc,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9E,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAC7C,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE;oBAC1C,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO;oBAC9B,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;oBAClC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO;iBAC/B,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YACrD,CAAC;QACH,CAAC;QACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;IACtB,CAAC;IAEO,KAAK,CAAC,YAAY,CACxB,KAAa,EACb,IAAY,EACZ,EAAU;QAEV,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAChD,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,OAAO,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACtC,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;QAC1E,CAAC;QACD,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,IAAI;YAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;QACnF,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,SAAS,OAAO,EAAE,CAAC,CAAC;QAC9C,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,SAAS,OAAO,EAAE,CAAC,CAAC;QAC7C,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC;IAC1F,CAAC;;AAGH,kFAAkF;AAClF,MAAM,CAAC,MAAM,QAAQ,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC","sourcesContent":["/**\n * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.\n *\n * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the\n * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin\n * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed\n * one-time-code store, and the session JWT. `createApp` (with no `server()`) is\n * used only to auto-init `CacheManager` + prime the sibling `email` transport;\n * this plugin is where the gate logic lives.\n *\n * Options come from CLI flags OR env, with sensible defaults - see\n * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't\n * resolve itself is HOW to email the code, so it takes a `sendCode` callback the\n * app wires to the email plugin.\n *\n * @module\n */\n\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { log, string } from \"@dbx-tools/shared-core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-email\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { CodeStore, signSession, verifySession } from \"./otp.ts\";\nimport { RateLimiter } from \"./rate-limit.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env EMAIL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /** Subject line for the code email. Env AUTH_SUBJECT. */\n  subject?: string;\n  /** Product/brand name used in the email + login copy. Env AUTH_BRAND_NAME. */\n  brandName?: string;\n  /** One-line message shown above the code in the email. Env AUTH_MESSAGE. */\n  message?: string;\n  /** Session lifetime (seconds). Env AUTH_SESSION_TTL. Default 43200 (12h). */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /** Deliver a code to an address. Wired by the app to the email plugin. */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n}\n\nconst DEFAULTS = {\n  subject: \"Your sign-in code\",\n  brandName: \"This app\",\n  message: \"Your one-time sign-in code is:\",\n  sessionTtlSeconds: 43200,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n};\n\n/** Positive finite number from a value / env string, else the fallback. */\nfunction num(value: number | undefined, env: string | undefined, fallback: number): number {\n  const raw = value ?? (env ? Number(env) : undefined);\n  return typeof raw === \"number\" && Number.isFinite(raw) && raw > 0 ? raw : fallback;\n}\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  return {\n    allow: [...string.parseList(config.allow), ...string.parseList(process.env.EMAIL_AUTH_ALLOW)],\n    subject: config.subject ?? process.env.AUTH_SUBJECT?.trim() ?? DEFAULTS.subject,\n    brandName: config.brandName ?? process.env.AUTH_BRAND_NAME?.trim() ?? DEFAULTS.brandName,\n    message: config.message ?? process.env.AUTH_MESSAGE?.trim() ?? DEFAULTS.message,\n    sessionTtlSeconds: num(\n      config.sessionTtlSeconds,\n      process.env.AUTH_SESSION_TTL,\n      DEFAULTS.sessionTtlSeconds,\n    ),\n    codeTtlSeconds: num(config.codeTtlSeconds, process.env.AUTH_CODE_TTL, DEFAULTS.codeTtlSeconds),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n  };\n}\n\n/** The handlers the proxy calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Handle a code request. Always resolves `{ ok: true }` (anti-enumeration). */\n  request(email: string, ip: string): Promise<{ ok: true; retryAfter?: number }>;\n  /** Handle a code verification. On success returns the session token to cookie. */\n  verify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }>;\n  /** Resolve the authenticated email for a session token, or undefined. */\n  session(token: string | undefined): Promise<string | undefined>;\n  /** Session TTL in seconds (for the cookie Max-Age). */\n  readonly sessionTtlSeconds: number;\n  /** The gate status payload (`enabled` is always true when this plugin runs). */\n  status(token: string | undefined): Promise<AuthStatus>;\n}\n\n/** AppKit plugin owning the email-OTP gate's logic (no HTTP routes; proxy-driven). */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Email one-time-password access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private codes!: CodeStore;\n  // Requesting a code is email-spam-prone; verifying is a brute-force surface.\n  // Per-email AND per-IP so neither axis alone is a bypass.\n  private readonly requestLimiter = new RateLimiter(5, 15 * 60 * 1000);\n  private readonly verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n    this.codes = new CodeStore(this.resolved.codeTtlSeconds, this.resolved.maxAttempts);\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n    });\n  }\n\n  override exports(): AuthGateApi {\n    return {\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      request: (email, ip) => this.handleRequest(email, ip),\n      verify: (email, code, ip) => this.handleVerify(email, code, ip),\n      session: (token) => verifySession(token),\n      status: async (token) => ({\n        authenticated: Boolean(await verifySession(token)),\n        email: (await verifySession(token)) ?? undefined,\n        enabled: true,\n      }),\n    };\n  }\n\n  private async handleRequest(\n    email: string,\n    ip: string,\n  ): Promise<{ ok: true; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.requestLimiter.hit(`ip:${ip}`);\n    const byEmail = this.requestLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if (looksLikeEmail(address) && matchesAllowlist(address, this.resolved.allow)) {\n      const code = await this.codes.issue(address);\n      try {\n        await this.config.sendCode?.(address, code, {\n          subject: this.resolved.subject,\n          brandName: this.resolved.brandName,\n          message: this.resolved.message,\n        });\n      } catch (error) {\n        logger.warn(\"failed to send OTP email\", { error });\n      }\n    }\n    return { ok: true };\n  }\n\n  private async handleVerify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.verifyLimiter.hit(`ip:${ip}`);\n    const byEmail = this.verifyLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if ((await this.codes.verify(address, code.trim())) !== \"ok\") return { ok: false };\n    this.requestLimiter.reset(`email:${address}`);\n    this.verifyLimiter.reset(`email:${address}`);\n    return { ok: true, token: await signSession(address, this.resolved.sessionTtlSeconds) };\n  }\n}\n\n/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */\nexport const authGate = toPlugin(AuthGatePlugin);\n"]}

package/lib/src/portr.d.ts

@@ -0,0 +1,39 @@
+/**
+ * portr install + config + launch for the tunnel CLI.
+ *
+ * On a Databricks App the container's `$HOME` is read-only on cold start, so the
+ * portr binary and its config are placed under a writable, cwd-rooted `.home`.
+ * The install is idempotent (the installer skips when the on-PATH binary is
+ * current). The config is rendered from `PUBLIC_DOMAIN` (`<subdomain>.<server>`)
+ * + `PORTR_TOKEN` and points portr at the PUBLIC port (the proxy listens there).
+ *
+ * @module
+ */
+import { spawn } from "node:child_process";
+/** Resolved portr wiring, or `undefined` when no tunnel is configured. */
+export interface PortrConfig {
+    subdomain: string;
+    server: string;
+    token: string;
+    port: number;
+}
+/**
+ * Resolve portr config from `PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an explicit
+ * `subdomain`. `PUBLIC_DOMAIN` is `<subdomain>.<server>` (e.g.
+ * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a
+ * usable domain is absent.
+ */
+export declare function resolvePortrConfig(opts: {
+    publicDomain?: string;
+    subdomain?: string;
+    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;
+/** Render `~/.portr/config.yaml` for the resolved tunnel. */
+export declare function writePortrConfig(config: PortrConfig, env: NodeJS.ProcessEnv): 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;

package/lib/src/portr.js

@@ -0,0 +1,90 @@
+/**
+ * portr install + config + launch for the tunnel CLI.
+ *
+ * On a Databricks App the container's `$HOME` is read-only on cold start, so the
+ * portr binary and its config are placed under a writable, cwd-rooted `.home`.
+ * The install is idempotent (the installer skips when the on-PATH binary is
+ * current). The config is rendered from `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 { delimiter, join } from "node:path";
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("tunnel:portr");
+/**
+ * Resolve portr config from `PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an explicit
+ * `subdomain`. `PUBLIC_DOMAIN` is `<subdomain>.<server>` (e.g.
+ * `demo.apps.dbx.tools`). Returns `undefined` (no tunnel) when the token or a
+ * usable domain is absent.
+ */
+export function resolvePortrConfig(opts) {
+    const token = opts.token ?? process.env.PORTR_TOKEN;
+    const domain = opts.publicDomain ?? process.env.PUBLIC_DOMAIN;
+    if (!token)
+        return undefined;
+    let subdomain = opts.subdomain;
+    let server;
+    if (domain) {
+        subdomain ??= domain.split(".")[0];
+        server = domain.slice(domain.indexOf(".") + 1);
+    }
+    server ??= process.env.PORTR_SERVER;
+    if (!subdomain || !server || server === domain)
+        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;
+}
+/** Install portr (idempotent) into the cwd-rooted home and return the child env. */
+export function installPortr() {
+    const home = portrHome();
+    const env = {
+        ...process.env,
+        HOME: home,
+        PORTR_AUTO_ADD_PATH: "no",
+        PATH: [join(home, ".portr", "bin"), 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, [
+        `server_url: ${config.server}`,
+        `ssh_url: ${config.server}:4444`,
+        `secret_key: ${config.token}`,
+        "disable_dashboard: true",
+        "disable_tui: true",
+        "tunnels:",
+        `  - name: ${config.subdomain}`,
+        `    subdomain: ${config.subdomain}`,
+        `    port: ${config.port}`,
+        "",
+    ].join("\n"));
+}
+/** Launch `portr start` as a child process (caller supervises + kills it). */
+export function startPortr(config, env) {
+    // 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" });
+}
+/** True when the installed portr binary path exists (post-install sanity). */
+export function portrInstalled(env) {
+    return existsSync(join(env.HOME, ".portr", "bin", "portr"));
+}
+//# 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 + launch for the tunnel CLI.\n *\n * On a Databricks App the container's `$HOME` is read-only on cold start, so the\n * portr binary and its config are placed under a writable, cwd-rooted `.home`.\n * The install is idempotent (the installer skips when the on-PATH binary is\n * current). The config is rendered from `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 { log } from \"@dbx-tools/shared-core\";\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 `PUBLIC_DOMAIN` + `PORTR_TOKEN`, or an explicit\n * `subdomain`. `PUBLIC_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  const token = opts.token ?? process.env.PORTR_TOKEN;\n  const domain = opts.publicDomain ?? process.env.PUBLIC_DOMAIN;\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 ??= process.env.PORTR_SERVER;\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"]}

package/lib/src/proxy.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The tunnel gate reverse-proxy.
+ *
+ * Binds the PUBLIC port (the container's `DATABRICKS_APP_PORT`) and forwards to
+ * the real app on a private loopback port. It is the single front door for both
+ * traffic paths into the container:
+ *
+ *   - **portr client** (same container, connects over LOOPBACK) - the public
+ *     tunnel. This is what the gate protects.
+ *   - **Databricks control plane / front door** (reaches the `0.0.0.0` port from
+ *     a NON-loopback container-network address) - passed through UNGATED, per the
+ *     rule "if it's not from the portr client, let it in".
+ *
+ * The distinguisher is the connection's source address: a loopback
+ * `req.socket.remoteAddress` is the portr client; anything else is the platform.
+ *
+ * For portr traffic the gate is a standard SPA gate: static assets + the login
+ * flow (`/api/email/auth/*`, answered IN-PROCESS by this proxy via the
+ * {@link AuthGateApi}) are open so the browser can load the client and render the
+ * `<AuthGate>`; every other `/api/*` needs a valid session cookie or gets 401.
+ * WebSocket upgrades are gated the same way and forwarded with `http-proxy-3`.
+ *
+ * @module
+ */
+import type { AuthGateApi } from "./plugin.ts";
+/** Options for {@link startProxy}. */
+export interface ProxyOptions {
+    /** Public port to listen on (the container's DATABRICKS_APP_PORT). */
+    publicPort: number;
+    /** Private port the real app listens on (loopback). */
+    appPort: number;
+    /**
+     * The in-process gate API, or `undefined` to run OPEN (insecure mode): every
+     * request - including portr traffic - is forwarded ungated. Used when the
+     * operator passed `--insecure` / `TUNNEL_INSECURE=true`.
+     */
+    gate?: AuthGateApi;
+}
+/** Start the gate proxy. Resolves once it is listening. */
+export declare function startProxy({ publicPort, appPort, gate }: ProxyOptions): Promise<void>;