@dbx-tools/tunnel 0.9.202 → 0.9.205

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -22,32 +22,33 @@ await appkit.createApp({
22
22
  });
23
23
  ```
24
24
 
25
- Supports the [SSE-enabled Portr fork](https://github.com/reggie-db/portr/releases/tag/v1.0.15-sse.2),
26
- based on [upstream Portr](https://github.com/amalshaji/portr), plus
27
- [FRP](https://github.com/fatedier/frp). Use this library
28
- when an app needs to be reachable from outside its network - a stakeholder demo,
29
- a webhook sender that has to reach a dev build, an OAuth redirect that cannot
30
- point at `localhost` - without publishing the app to anyone who learns the URL.
31
- It is shaped for Databricks Apps (it honors the `DATABRICKS_APP_PORT` contract
32
- and lets the platform's own front door through ungated) but the gate itself is
25
+ Supports the [SSE-enabled Portr
26
+ fork](https://github.com/reggie-db/portr/releases/tag/v1.0.15-sse.2), based on
27
+ [upstream Portr](https://github.com/amalshaji/portr), plus
28
+ [FRP](https://github.com/fatedier/frp). Use this library when an app needs to be
29
+ reachable from outside its network without publishing the app to anyone who
30
+ learns the URL. Examples include a stakeholder demo, a webhook sender that has
31
+ to reach a dev build, and an OAuth redirect that cannot point at `localhost`. It
32
+ is shaped for Databricks Apps (it honors the `DATABRICKS_APP_PORT` contract and
33
+ lets the platform's own front door through ungated) but the gate itself is
33
34
  platform-neutral.
34
35
 
35
- The tunnel plugs into `@dbx-tools/appkit`'s `createApp` through its INTERCEPTOR
36
+ The tunnel plugs into `@dbx-tools/appkit`'s `createApp` through its interceptor
36
37
  context: `createApp({ interceptor: tunnelInterceptor() })` applies the computed
37
38
  `DATABRICKS_HOST`, launches the selected client(s) pointed at the app's public
38
- port, and binds them so the app and tunnels live and die as one (signals pass
39
- through, either death tears the pair down). The app is the process. The tunnel
40
- rides along inside it. Access is granted per email address against an allowlist,
41
- authenticated by Better Auth email OTP or a passkey. The gate itself is the
42
- `authGate` AppKit plugin, which registers the login routes and a gating
43
- middleware on the app's Express server (no separate proxy process).
39
+ port, and binds them to the app process. Signals pass through, and when either
40
+ the app or a tunnel client exits, both stop. The tunnel runs inside the app
41
+ process. Access is granted per email address against an allowlist, authenticated
42
+ by Better Auth email OTP or a passkey. The gate itself is the `authGate` AppKit
43
+ plugin, which registers the login routes and a gating middleware on the app's
44
+ Express server (no separate proxy process).
44
45
 
45
46
  The package:
46
47
 
47
- - Consumed in-process through the `createApp` interceptor context - no wrapper CLI,
48
- no separate process: `createApp({ interceptor: tunnelInterceptor() })`. A no-op
49
- when the selected clients are not configured, so it is safe to register
50
- unconditionally.
48
+ - Consumed in-process through the `createApp` interceptor context, with no
49
+ wrapper CLI or separate process:
50
+ `createApp({ interceptor: tunnelInterceptor() })`. A no-op when the selected clients are not configured, so it is safe to
51
+ register unconditionally.
51
52
  - Uses the shared email-template brand for the code email's color, font, and
52
53
  logo. The displayed app name defaults to the dbx-tools brand and can be set
53
54
  with `brandName` or `TUNNEL_AUTH_BRAND_NAME`.
@@ -60,21 +61,21 @@ The package:
60
61
  - The code appears in the subject, preheader, and body:
61
62
  `123456 is your verification code`. Mobile autofill reads an incoming
62
63
  notification, and a notification contains the sender, the subject, and a short
63
- snippet - nothing else - so a code that lives only in the body is unreachable
64
+ snippet, so a code that lives only in the body is unreachable
64
65
  however cleanly the body is shaped. See
65
66
  [Why the code is in the subject](#email-code-subject).
66
67
  - The two MIME parts are built separately, on purpose. The HTML card uses the
67
68
  configured subject template as its neutral title and shows the code once as a
68
- large styled body heading. The `text/plain` part
69
- is authored directly, keeping the prompt and the code on one line
70
- (`Your verification code is: 123456`) because that is the shape client code
71
- detection reads most reliably. A generated text part cannot hold it - the text
72
- part is a rendering of the HTML, so the heading's CSS margin arrives as blank
73
- lines and autofill stops being offered while the HTML still renders correctly. See
74
- `codeEmailTextBody` in the `app` module.
69
+ large styled body heading. The `text/plain` part is authored directly, keeping
70
+ the prompt and the code on one line (`Your verification code is: 123456`)
71
+ because that is the shape client code detection reads most reliably. A
72
+ generated text part cannot hold it because the text part is a rendering of the
73
+ HTML, so the heading's CSS margin arrives as blank lines and autofill stops
74
+ being offered while the HTML still renders correctly. See `codeEmailTextBody`
75
+ in the `app` module.
75
76
  - The sign-in code is system mail: it sends from `no-reply@EMAIL_DOMAIN` (or
76
77
  `EMAIL_SYSTEM_FROM`), never a person's address, because a reply to a
77
- machine-generated code reaches nobody. `EMAIL_FROM` is not required - see
78
+ machine-generated code reaches nobody. `EMAIL_FROM` is not required. See
78
79
  [@dbx-tools/email](../../node/email#sender-addresses).
79
80
  - Better Auth owns users, hashed OTP verification records, sessions, rate
80
81
  limits, and passkey credentials. `@dbx-tools/tunnel` supplies only its
@@ -83,40 +84,43 @@ The package:
83
84
  the operating system's application-data directory. Both adapters run Better
84
85
  Auth's own migrations under a Postgres advisory lock or file lock.
85
86
  - Email OTP remains bootstrap and recovery. Returning users can authenticate
86
- with discoverable passkeys. The OTP form can create a passkey immediately
87
- after verification, and users can enroll, name, or remove more passkeys
88
- through [@dbx-tools/ui/auth](../../ui/appkit). Each passkey uses the exact
89
- public tunnel hostname as its WebAuthn relying-party ID. Its display name
90
- combines `TUNNEL_AUTH_PASSKEY_NAME_PREFIX` with the humanized first hostname
91
- label; the prefix defaults to `projectUtils.name()`.
87
+ with discoverable passkeys when `TUNNEL_AUTH_PASSKEYS` is enabled. Set it to
88
+ `false` or pass `--no-passkeys` to keep the gate email-only. The OTP form can
89
+ create a passkey immediately after verification, and users can enroll, name,
90
+ or remove more passkeys through [@dbx-tools/ui/auth](../../ui/appkit). Each
91
+ passkey uses the exact public tunnel hostname as its WebAuthn relying-party
92
+ ID. Its display name combines `TUNNEL_AUTH_PASSKEY_NAME_PREFIX` with the
93
+ humanized first hostname label; the prefix defaults to `projectUtils.name()`.
92
94
  - Allow-list patterns in three shapes, matched in order: a domain shortcut
93
95
  (`example.com`, `@example.com`), a shell-style glob (`*@example.com`), or a
94
96
  regex literal (`/^ops-.*@example\.com$/`). An empty list allows nobody.
95
97
  - Better Auth rate limiting plus anti-enumeration: the compatibility code
96
98
  request always answers `{ ok: true }`, whether or not the address is allowed.
97
99
  - Inbound `x-` headers are stripped by default and re-allowed by pattern, so a
98
- public caller cannot spoof the headers the app trusts - above all
100
+ public caller cannot spoof the headers the app trusts, especially
99
101
  `x-forwarded-access-token`, which would otherwise let anyone drive the app's
100
102
  workspace calls with a pasted token. Add an app's own headers with
101
103
  `TUNNEL_FORWARD_HEADERS`.
102
104
  - Only Portr traffic is gated. The gate identifies tunnel requests by their
103
- `Host` header (`TUNNEL_PUBLIC_DOMAIN`), which portr's client preserves from the
104
- public visitor. Platform front-door traffic and any other local caller carry a
105
- different `Host` and pass through without a gate, so health checks and the workspace UI
106
- keep working. (There is no portr-injected identifying header and no source-IP
107
- signal - the client dials the app over plain loopback - so `Host` is the signal.)
105
+ `Host` header (`TUNNEL_PUBLIC_DOMAIN`), which portr's client preserves from
106
+ the public visitor. Platform front-door traffic and any other local caller
107
+ carry a different `Host` and pass through without a gate, so health checks and
108
+ the workspace UI keep working. Portr injects no identifying header, and the
109
+ client dials the app over plain loopback, so the source IP is not a signal
110
+ either.
108
111
  - SPA-aware gating: static assets and the login routes stay open so the browser
109
112
  can load the client and render the login form. Every other `/api/*` needs a
110
113
  valid session cookie or gets `401`. A WebSocket handshake is an ordinary `GET`
111
114
  and runs through the same gate.
112
- - Supervised teardown - `tunnelInterceptor` registers its tunnel supervisor with
115
+ - Supervised teardown: `tunnelInterceptor` registers its tunnel supervisor with
113
116
  AppKit's native `shutdown` lifecycle. Core exec terminates each tunnel process
114
117
  tree through the child handle's memoized `shutdown()` method.
115
- - Public liveness probes - while portr is running, the supervisor HEADs the
118
+ - Public liveness probes: while portr is running, the supervisor HEADs the
116
119
  public URL. An `x-portr-error: unregistered-subdomain` (or any other
117
- `x-portr-error`) kills the child so the forever-loop restarts it. Process-exit
118
- supervision alone is not enough: portr can stay alive after the edge drops the
119
- registration, leaving the subdomain dark until a full app bounce.
120
+ `x-portr-error`) stops the child so the restart loop starts it again.
121
+ Process-exit supervision alone is not enough: portr can stay alive after the
122
+ edge drops the registration, leaving the subdomain unreachable until the app
123
+ restarts.
120
124
  - The gate fails fast when email is not configured for SMTP, because a gate that
121
125
  cannot send codes locks everyone out. `@dbx-tools/email` is an optional peer
122
126
  dependency, imported lazily. The app that mounts the gate provides it.
@@ -178,6 +182,7 @@ without touching code.
178
182
  | `TUNNEL_AUTH_ALLOW` | empty (allow nobody) |
179
183
  | `TUNNEL_AUTH_SUBJECT` | `Your verification code` |
180
184
  | `TUNNEL_AUTH_BRAND_NAME` | the brand context `name` |
185
+ | `TUNNEL_AUTH_PASSKEYS` | `true` |
181
186
  | `TUNNEL_AUTH_PASSKEY_NAME_PREFIX` | `projectUtils.name()` |
182
187
  | `TUNNEL_AUTH_MESSAGE` | `Your verification code is:` |
183
188
  | `TUNNEL_AUTH_SESSION_TTL` | `2592000` (30 days) |
@@ -215,17 +220,17 @@ Resolution order:
215
220
  operator-held secret needs no shared cache, and it survives a cache flush.
216
221
  2. **A key persisted in AppKit's cache for 30 days.** With a persistent
217
222
  `CacheStorage` (Lakebase) the key outlives the process, so cookies stay valid
218
- across restarts - which a tunnel does often, since it restarts whenever the app
223
+ across restarts. A tunnel restarts often because it restarts whenever the app
219
224
  it wraps reloads. On the default in-memory cache the key is per-process, the
220
225
  same as having no secret at all.
221
226
 
222
- Getting that persistence is not automatic, and the gate does the work at boot
223
- using `lakebaseResolver.applyLakebaseEnv()`: it turns `LAKEBASE_ENDPOINT` into the
227
+ The gate configures that persistence at boot using
228
+ `lakebaseResolver.applyLakebaseEnv()`: it turns `LAKEBASE_ENDPOINT` into the
224
229
  `PGHOST` / `PGDATABASE` / `PGUSER` the cache's pool also needs. Without them
225
230
  AppKit cannot build the pool, silently uses an in-memory cache, and every
226
- redeploy signs everyone out - so the startup log says which one you got
227
- (`lakebase resolved for the gate cache`, or `the gate cache stays in memory`).
228
- Bind a `postgres` resource to the app to get the persistent path.
231
+ redeploy signs everyone out. The startup log reports which cache is in use
232
+ (`lakebase resolved for the gate cache`, or
233
+ `the gate cache stays in memory`). Bind a `postgres` resource to the app to get the persistent path.
229
234
 
230
235
  3. **An ephemeral per-process key**, when there is no secret and no reachable
231
236
  cache. Sessions do not survive a restart, but the gate still serves: the key
@@ -237,22 +242,20 @@ booting together both miss the cache, so both generate. Adopting whatever is
237
242
  stored afterward makes them converge on one key instead of each trusting
238
243
  the one it minted. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race entirely.
239
244
 
240
- `TUNNEL_AUTH_SESSION_TTL` defaults to the same 30 days the key is stored for, on
241
- purpose - a key that expired before the cookies it signed would sign everyone out
242
- for no reason.
245
+ `TUNNEL_AUTH_SESSION_TTL` defaults to the same 30 days the key is stored for. A
246
+ key that expired before the cookies it signed would sign everyone out early.
243
247
 
244
248
  ## <a id="email-code-subject"></a> Put the email code in the subject
245
249
 
246
- The subject line the gate sends is `123456 is your verification code` -
247
- `--subject` is the template the code is spliced into, not the literal line.
250
+ The gate sends the subject line `123456 is your verification code`.
251
+ `--subject` sets the template that receives the code.
248
252
 
249
253
  Mobile autofill reads notification text instead of email body content. iOS scans
250
- incoming notification text for a code and offers to fill it - natively for
251
- Messages and Mail, and since iOS 26 for any app's notification, which is what
252
- finally made Gmail work. A notification carries the sender, the subject, and a
253
- short snippet. That is all. A code sitting in the body is invisible to it no
254
- matter how carefully the body is formatted, which is why a correctly shaped
255
- `text/plain` part alone produced no prompt in Gmail.
254
+ incoming notification text for a code and offers to fill it. iOS does this for
255
+ Messages and Mail, and since iOS 26 for any app's notification, including Gmail.
256
+ A notification carries only the sender, the subject, and a short snippet.
257
+ Autofill cannot read a code that appears only in the body, which is why a
258
+ correctly shaped `text/plain` part alone produced no prompt in Gmail.
256
259
 
257
260
  So the code goes in both strings a notification actually shows:
258
261
 
@@ -283,32 +286,31 @@ TUNNEL_AUTH_SESSION_CUTOFF="now" ... # sign everyone out on this boot
283
286
 
284
287
  The value goes through `@dbx-tools/shared-core`'s `object.toDate`, so a date, an
285
288
  ISO instant, epoch seconds or millis from `date +%s`, and a relative duration
286
- (`-30d`, `12 hours ago`) all work - the relative spelling being the one an
287
- operator usually wants, since "sign out anything older than a month" needs no
288
- timestamp arithmetic. It works two ways at once, so it holds however the key was
289
- resolved: the cutoff is part of the key's cache key (moving it orphans the
290
- previous key), and it is also checked against each token's `iat` (which is what
291
- makes it bite when `TUNNEL_AUTH_JWT_SECRET` is set and there is no key to
292
- rotate).
289
+ (`-30d`, `12 hours ago`) all work. A relative duration avoids timestamp
290
+ arithmetic for a request such as "sign out anything older than a month." The
291
+ cutoff applies in two places, so it works however the key was resolved: the
292
+ cutoff is part of the key's cache key (moving it orphans the previous key), and
293
+ it is also checked against each token's `iat` (which makes it take effect when
294
+ `TUNNEL_AUTH_JWT_SECRET` is set and there is no key to rotate).
293
295
 
294
296
  A future date is clamped to now, because an unclamped one would refuse the
295
- sessions it is about to mint as well as the old ones - an app nobody can sign in
296
- to, from a mistyped year. An unparseable value is ignored with a warning rather
297
- than failing startup: this is the switch that gets a fleet back in.
297
+ sessions it is about to mint as well as the old ones. A mistyped year would then
298
+ make the app impossible to sign in to. An unparseable value is ignored with a
299
+ warning instead of failing startup, so this setting cannot block recovery.
298
300
 
299
301
  ## Inbound header policy
300
302
 
301
- Tunnel traffic arrives from the public internet, so every header on it is
302
- attacker-controlled - and the headers an app trusts are exactly the ones a caller
303
+ Tunnel traffic arrives from the public internet, so a caller controls every
304
+ header on it. The headers an app trusts are exactly the ones a caller
303
305
  must not be able to write, because the app cannot tell a header the Databricks
304
306
  front door set from one a browser typed.
305
307
 
306
- Enumerating headers to remove is a losing game (a denylist is only correct until
307
- the platform adds a header), so the policy is inverted: **every `x-`-prefixed
308
- request header is stripped from tunnel traffic unless a pattern allows it.** A
309
- header nobody thought about is removed rather than trusted. Non-`x-` headers -
310
- `content-type`, `accept`, `authorization`, `cookie` - are the app's normal input
311
- and pass through untouched.
308
+ A denylist of headers to remove is correct only until the platform adds a
309
+ header, so the policy uses an allowlist. Every `x-`-prefixed request header is
310
+ stripped from tunnel traffic unless a pattern allows it, so an unlisted header
311
+ is removed. Headers without the `x-` prefix, such as `content-type`, `accept`,
312
+ `authorization`, and `cookie`, are the app's normal input and pass through
313
+ unchanged.
312
314
 
313
315
  The default allowlist covers the `x-` namespaces this repo's own client sends
314
316
  and its own server reads, so a dbx-tools app works behind the tunnel with no
@@ -321,10 +323,10 @@ configuration:
321
323
  | `x-requested-with` | the conventional AJAX marker |
322
324
 
323
325
  Add an app's own headers with `TUNNEL_FORWARD_HEADERS` (or `forwardHeaders` on
324
- `authGate`). Each entry is a literal name, a shell-style glob, or a `/regex/` -
325
- the same three shapes the email allowlist takes - and the configured list is
326
- combined with the defaults, so extending it never silently breaks the built-in
327
- surfaces:
326
+ `authGate`). Each entry is a literal name, a shell-style glob, or a `/regex/`,
327
+ which are the same three shapes the email allowlist accepts. The configured list
328
+ is combined with the defaults, so extending it never silently breaks the
329
+ built-in surfaces:
328
330
 
329
331
  ```sh
330
332
  TUNNEL_FORWARD_HEADERS="x-acme-*, /^x-trace-/, x-tenant" ...
@@ -342,15 +344,15 @@ came from, and on tunnel traffic only the gate may answer that:
342
344
  | `x-forwarded-for`, `x-real-ip` | Client IP. Spoofing forges the audit trail and gives a caller a fresh rate-limit bucket per request. |
343
345
  | `x-request-id` | Request correlation UUID. Forged or colliding ids make logs unreliable. |
344
346
 
345
- The identity headers are AppKit's OBO contract. The rest are the
346
- [X-Forwarded-* set that Databricks Apps documents passing to an
347
+ The identity headers are AppKit's OBO contract. The rest are the [X-Forwarded-*
348
+ set that Databricks Apps documents passing to an
347
349
  app](https://docs.databricks.com/aws/en/dev-tools/databricks-apps/http-headers),
348
350
  plus the conventional `x-forwarded-proto`/`-port`/`x-real-ip` a library may read
349
- anyway. Dropping the transport headers costs nothing: `xfwd` re-adds them from the
350
- real socket after the policy runs, so the app sees the honest values instead of the
351
- caller's claim. Rate limiting reads the client IP before stripping, and takes the
352
- **rightmost** `x-forwarded-for` entry - the only one portr appended rather than a
353
- client supplied.
351
+ anyway. Dropping the transport headers loses no information: `xfwd` re-adds them
352
+ from the real socket after the policy runs, so the app sees the honest values
353
+ instead of the caller's claim. Rate limiting reads the client IP before
354
+ stripping, and takes the rightmost `x-forwarded-for` entry, which is the only
355
+ one portr appended instead of a client.
354
356
 
355
357
  ## Use the gate
356
358
 
@@ -377,9 +379,9 @@ await appkit.createApp({
377
379
  Override `sendCode` only to deliver through something other than the shared
378
380
  transport. The default builds the OTP email (code in the subject + preheader for
379
381
  mobile autofill) and sends it as the system sender. `@dbx-tools/email` is an
380
- optional peer dependency - a tunnel without the gate needs no mail - so the app
381
- that mounts `authGate` must include it (or run `TUNNEL_INSECURE=true` to skip the
382
- gate). A missing transport fails fast at boot.
382
+ optional peer dependency because a tunnel without the gate needs no mail. The
383
+ app that mounts `authGate` must include it (or run `TUNNEL_INSECURE=true` to
384
+ skip the gate). A missing transport fails fast at boot.
383
385
 
384
386
  `GET /api/email/auth/status` is what a client asks before deciding to render a
385
387
  login screen, and it answers per request, not per deployment: on a non-tunnel
package/index.ts CHANGED
@@ -3,7 +3,7 @@
3
3
  // Hand edits are overwritten on the next watch; this file is read-only.
4
4
 
5
5
  export const PACKAGE_IDENTIFIER = "@dbx-tools/tunnel";
6
- export const PACKAGE_VERSION = "0.9.202";
6
+ export const PACKAGE_VERSION = "0.9.205";
7
7
  export * as allowlist from "./src/allowlist.ts";
8
8
  export * as codeEmail from "./src/code-email.ts";
9
9
  export * as frp from "./src/frp.ts";
@@ -20,8 +20,8 @@ export * as vite from "./src/vite.ts";
20
20
  export { matchesAllowlist, looksLikeEmail } from "./src/allowlist.ts";
21
21
  export { expiresIn, codeEmailHtmlBody, codeEmailTextBody, codeEmailSubject, codeEmailPreview } from "./src/code-email.ts";
22
22
  export type { CodeCopy } from "./src/code-email.ts";
23
- export { FrpOptionsSchema, resolveFrpConfig, frpAssetName, installFrp, writeFrpConfig, startFrp, superviseFrp } from "./src/frp.ts";
24
- export type { FrpInstallOptions, FrpConfig, FrpOptions } from "./src/frp.ts";
23
+ export { FrpOptionsSchema, FrpConfigSchema, resolveFrpConfig, frpAssetName, installFrp, writeFrpConfig, startFrp, superviseFrp } from "./src/frp.ts";
24
+ export type { FrpInstallOptions, FrpOptions, FrpConfig } from "./src/frp.ts";
25
25
  export { isTunnelHost, clientIp, webHeaders, webRequest, sendWebResponse, gateRequest, UNAUTHORIZED_BODY, normalizeReturnTo, requestReturnTo, loginPath, unauthorizedBody, loginReturnTo, wantsHostedLogin, wantsLoginPage, mountGate } from "./src/gate.ts";
26
26
  export type { GateOptions, GateAction } from "./src/gate.ts";
27
27
  export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS, toHeaderPolicy } from "./src/headers.ts";
@@ -33,8 +33,8 @@ export type { LoginPageOptions } from "./src/login-page.ts";
33
33
  export { startPathProxy } from "./src/path-proxy.ts";
34
34
  export { mountGateOnContext, AuthGateConfigSchema, resolveAuthGateConfig, AuthGatePlugin, authGate } from "./src/plugin.ts";
35
35
  export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateApi } from "./src/plugin.ts";
36
- export { normalizePortrOutput, PortrOptionsSchema, resolvePortrConfig, portrAssetName, installPortr, writePortrConfig, startPortr, probePortrPublicUrl, supervisePortr } from "./src/portr.ts";
37
- export type { PortrInstallOptions, PortrConfig, PortrOptions } from "./src/portr.ts";
36
+ export { normalizePortrOutput, PortrOptionsSchema, PortrConfigSchema, resolvePortrConfig, portrAssetName, installPortr, writePortrConfig, startPortr, probePortrPublicUrl, supervisePortr } from "./src/portr.ts";
37
+ export type { PortrInstallOptions, PortrOptions, PortrConfig } from "./src/portr.ts";
38
38
  export { TUNNEL_TRACE_TAG, TUNNEL_SUBDOMAIN_TRACE_TAG, requestTunnelTraceTags } from "./src/request-context.ts";
39
39
  export { ensureEmailAvailable, sendCode } from "./src/send-code.ts";
40
40
  export { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey, resetSigningKey } from "./src/signing-key.ts";
package/lib/index.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  export declare const PACKAGE_IDENTIFIER = "@dbx-tools/tunnel";
2
- export declare const PACKAGE_VERSION = "0.9.202";
2
+ export declare const PACKAGE_VERSION = "0.9.205";
3
3
  export * as allowlist from "./src/allowlist.ts";
4
4
  export * as codeEmail from "./src/code-email.ts";
5
5
  export * as frp from "./src/frp.ts";
@@ -16,8 +16,8 @@ export * as vite from "./src/vite.ts";
16
16
  export { matchesAllowlist, looksLikeEmail } from "./src/allowlist.ts";
17
17
  export { expiresIn, codeEmailHtmlBody, codeEmailTextBody, codeEmailSubject, codeEmailPreview } from "./src/code-email.ts";
18
18
  export type { CodeCopy } from "./src/code-email.ts";
19
- export { FrpOptionsSchema, resolveFrpConfig, frpAssetName, installFrp, writeFrpConfig, startFrp, superviseFrp } from "./src/frp.ts";
20
- export type { FrpInstallOptions, FrpConfig, FrpOptions } from "./src/frp.ts";
19
+ export { FrpOptionsSchema, FrpConfigSchema, resolveFrpConfig, frpAssetName, installFrp, writeFrpConfig, startFrp, superviseFrp } from "./src/frp.ts";
20
+ export type { FrpInstallOptions, FrpOptions, FrpConfig } from "./src/frp.ts";
21
21
  export { isTunnelHost, clientIp, webHeaders, webRequest, sendWebResponse, gateRequest, UNAUTHORIZED_BODY, normalizeReturnTo, requestReturnTo, loginPath, unauthorizedBody, loginReturnTo, wantsHostedLogin, wantsLoginPage, mountGate } from "./src/gate.ts";
22
22
  export type { GateOptions, GateAction } from "./src/gate.ts";
23
23
  export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS, toHeaderPolicy } from "./src/headers.ts";
@@ -29,8 +29,8 @@ export type { LoginPageOptions } from "./src/login-page.ts";
29
29
  export { startPathProxy } from "./src/path-proxy.ts";
30
30
  export { mountGateOnContext, AuthGateConfigSchema, resolveAuthGateConfig, AuthGatePlugin, authGate } from "./src/plugin.ts";
31
31
  export type { AuthGateConfig, SendCodeOptions, ResolvedAuthGateConfig, AuthGateApi } from "./src/plugin.ts";
32
- export { normalizePortrOutput, PortrOptionsSchema, resolvePortrConfig, portrAssetName, installPortr, writePortrConfig, startPortr, probePortrPublicUrl, supervisePortr } from "./src/portr.ts";
33
- export type { PortrInstallOptions, PortrConfig, PortrOptions } from "./src/portr.ts";
32
+ export { normalizePortrOutput, PortrOptionsSchema, PortrConfigSchema, resolvePortrConfig, portrAssetName, installPortr, writePortrConfig, startPortr, probePortrPublicUrl, supervisePortr } from "./src/portr.ts";
33
+ export type { PortrInstallOptions, PortrOptions, PortrConfig } from "./src/portr.ts";
34
34
  export { TUNNEL_TRACE_TAG, TUNNEL_SUBDOMAIN_TRACE_TAG, requestTunnelTraceTags } from "./src/request-context.ts";
35
35
  export { ensureEmailAvailable, sendCode } from "./src/send-code.ts";
36
36
  export { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey, resetSigningKey } from "./src/signing-key.ts";
package/lib/index.js CHANGED
@@ -2,7 +2,7 @@
2
2
  // Regenerated from the exporting modules in ./src.
3
3
  // Hand edits are overwritten on the next watch; this file is read-only.
4
4
  export const PACKAGE_IDENTIFIER = "@dbx-tools/tunnel";
5
- export const PACKAGE_VERSION = "0.9.202";
5
+ export const PACKAGE_VERSION = "0.9.205";
6
6
  export * as allowlist from "./src/allowlist.js";
7
7
  export * as codeEmail from "./src/code-email.js";
8
8
  export * as frp from "./src/frp.js";
@@ -18,17 +18,17 @@ export * as supervisor from "./src/supervisor.js";
18
18
  export * as vite from "./src/vite.js";
19
19
  export { matchesAllowlist, looksLikeEmail } from "./src/allowlist.js";
20
20
  export { expiresIn, codeEmailHtmlBody, codeEmailTextBody, codeEmailSubject, codeEmailPreview } from "./src/code-email.js";
21
- export { FrpOptionsSchema, resolveFrpConfig, frpAssetName, installFrp, writeFrpConfig, startFrp, superviseFrp } from "./src/frp.js";
21
+ export { FrpOptionsSchema, FrpConfigSchema, resolveFrpConfig, frpAssetName, installFrp, writeFrpConfig, startFrp, superviseFrp } from "./src/frp.js";
22
22
  export { isTunnelHost, clientIp, webHeaders, webRequest, sendWebResponse, gateRequest, UNAUTHORIZED_BODY, normalizeReturnTo, requestReturnTo, loginPath, unauthorizedBody, loginReturnTo, wantsHostedLogin, wantsLoginPage, mountGate } from "./src/gate.js";
23
23
  export { PROTECTED_HEADERS, DEFAULT_FORWARD_HEADERS, toHeaderPolicy } from "./src/headers.js";
24
24
  export { TunnelTransportSchema, TunnelInterceptorOptionsSchema, resolveTunnelTransport, tunnelInterceptor } from "./src/interceptor.js";
25
25
  export { loginPageHtml } from "./src/login-page.js";
26
26
  export { startPathProxy } from "./src/path-proxy.js";
27
27
  export { mountGateOnContext, AuthGateConfigSchema, resolveAuthGateConfig, AuthGatePlugin, authGate } from "./src/plugin.js";
28
- export { normalizePortrOutput, PortrOptionsSchema, resolvePortrConfig, portrAssetName, installPortr, writePortrConfig, startPortr, probePortrPublicUrl, supervisePortr } from "./src/portr.js";
28
+ export { normalizePortrOutput, PortrOptionsSchema, PortrConfigSchema, resolvePortrConfig, portrAssetName, installPortr, writePortrConfig, startPortr, probePortrPublicUrl, supervisePortr } from "./src/portr.js";
29
29
  export { TUNNEL_TRACE_TAG, TUNNEL_SUBDOMAIN_TRACE_TAG, requestTunnelTraceTags } from "./src/request-context.js";
30
30
  export { ensureEmailAvailable, sendCode } from "./src/send-code.js";
31
31
  export { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey, resetSigningKey } from "./src/signing-key.js";
32
32
  export { superviseProcessForever } from "./src/supervisor.js";
33
33
  export { tunnelAllowedHosts } from "./src/vite.js";
34
- //# sourceMappingURL=data:application/json;base64,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
34
+ //# sourceMappingURL=data:application/json;base64,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
package/lib/src/frp.d.ts CHANGED
@@ -16,19 +16,6 @@ export interface FrpInstallOptions {
16
16
  /** Home directory containing `.frpc`; defaults to the OS home directory. */
17
17
  homeDir?: string;
18
18
  }
19
- /** Resolved frpc wiring, or `undefined` when no FRP tunnel is configured. */
20
- export interface FrpConfig {
21
- publicDomain: string;
22
- server: string;
23
- serverPort: number;
24
- protocol: string;
25
- token?: string;
26
- proxyName: string;
27
- path: string;
28
- stripPrefix: boolean;
29
- port: number;
30
- targetPort: number;
31
- }
32
19
  export declare const FrpOptionsSchema: z.ZodObject<{
33
20
  publicDomain: z.ZodOptional<z.ZodString>;
34
21
  server: z.ZodOptional<z.ZodString>;
@@ -42,6 +29,21 @@ export declare const FrpOptionsSchema: z.ZodObject<{
42
29
  targetPort: z.ZodOptional<z.ZodCoercedNumber<number>>;
43
30
  }, z.core.$strict>;
44
31
  export type FrpOptions = z.input<typeof FrpOptionsSchema>;
32
+ /** Resolved frpc wiring with every routing field populated; authentication remains optional. */
33
+ export declare const FrpConfigSchema: z.ZodObject<{
34
+ publicDomain: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
35
+ server: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
36
+ serverPort: z.ZodNonOptional<z.ZodOptional<z.ZodCoercedNumber<number>>>;
37
+ protocol: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
38
+ proxyName: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
39
+ path: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
40
+ stripPrefix: z.ZodNonOptional<z.ZodOptional<z.ZodBoolean>>;
41
+ port: z.ZodNonOptional<z.ZodCoercedNumber<number>>;
42
+ targetPort: z.ZodNonOptional<z.ZodOptional<z.ZodCoercedNumber<number>>>;
43
+ token: z.ZodOptional<z.ZodString>;
44
+ }, z.core.$strict>;
45
+ /** Resolved frpc wiring, or `undefined` when no FRP tunnel is configured. */
46
+ export type FrpConfig = z.output<typeof FrpConfigSchema>;
45
47
  /** Resolve frpc config from the public domain and FRP-specific environment. */
46
48
  export declare function resolveFrpConfig(opts: FrpOptions): FrpConfig | undefined;
47
49
  /** GitHub release asset name for the current or supplied OS/architecture. */
package/lib/src/frp.js CHANGED
@@ -35,6 +35,10 @@ export const FrpOptionsSchema = z
35
35
  })
36
36
  .strict()
37
37
  .describe("FRP tunnel resolution options.");
38
+ /** Resolved frpc wiring with every routing field populated; authentication remains optional. */
39
+ export const FrpConfigSchema = FrpOptionsSchema.required()
40
+ .extend({ token: FrpOptionsSchema.shape.token })
41
+ .describe("Resolved FRP tunnel configuration.");
38
42
  function bareHost(value) {
39
43
  if (!value)
40
44
  return undefined;
@@ -163,4 +167,4 @@ export function superviseFrp(resolved, childEnv, configPath) {
163
167
  start: () => startFrp(resolved, childEnv, configPath),
164
168
  });
165
169
  }
166
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frp.js","sourceRoot":"","sources":["../../src/frp.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install and run an frp client (`frpc`) for a public HTTP tunnel.\n *\n * The defaults match the deployment shape used by inspire-mediamix: a single\n * TLS-terminating host is both the WSS control endpoint and the HTTP custom\n * domain. Callers may point `server` somewhere else when frps is exposed on a\n * separate control host.\n *\n * @module\n */\n\nimport { spawn } from \"node:child_process\";\nimport { mkdir, writeFile } from \"node:fs/promises\";\nimport os from \"node:os\";\nimport { delimiter, join } from \"node:path\";\n\nimport { exec, ensure, parseVersion, string, port, boolean } from \"@dbx-tools/core\";\nimport type { ChildProcessResult, ChildProcessTerminationOptions } from \"@dbx-tools/core\";\nimport { log, tcpPortOrZeroSchema } from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { superviseProcessForever, type ProcessSupervisor } from \"./supervisor.ts\";\n\nconst logger = log.logger(\"tunnel:frp\");\nconst FRP_VERSION = \"0.68.1\";\nconst FRP_RELEASE_URL = `https://github.com/fatedier/frp/releases/download/v${FRP_VERSION}`;\n\n/** Options for installing the frpc executable. */\nexport interface FrpInstallOptions {\n  /** Home directory containing `.frpc`; defaults to the OS home directory. */\n  homeDir?: string;\n}\n\n/** Resolved frpc wiring, or `undefined` when no FRP tunnel is configured. */\nexport interface FrpConfig {\n  publicDomain: string;\n  server: string;\n  serverPort: number;\n  protocol: string;\n  token?: string;\n  proxyName: string;\n  path: string;\n  stripPrefix: boolean;\n  port: number;\n  targetPort: number;\n}\n\nexport const FrpOptionsSchema = z\n  .object({\n    publicDomain: z.string().trim().min(1).optional().describe(\"FRP public HTTP host.\"),\n    server: z.string().trim().min(1).optional().describe(\"FRP control host.\"),\n    serverPort: tcpPortOrZeroSchema.optional().describe(\"FRP control port.\"),\n    protocol: z.string().trim().min(1).optional().describe(\"FRP transport protocol.\"),\n    token: z.string().trim().min(1).optional().describe(\"FRP authentication token.\"),\n    proxyName: z.string().trim().min(1).optional().describe(\"FRP proxy registration name.\"),\n    path: z.string().trim().min(1).optional().describe(\"FRP public path.\"),\n    stripPrefix: z.boolean().optional().describe(\"Strip the FRP path before forwarding.\"),\n    port: tcpPortOrZeroSchema.describe(\"Public listener port.\"),\n    targetPort: tcpPortOrZeroSchema.optional().describe(\"Private target port.\"),\n  })\n  .strict()\n  .describe(\"FRP tunnel resolution options.\");\n\nexport type FrpOptions = z.input<typeof FrpOptionsSchema>;\n\nfunction bareHost(value: string | undefined): string | undefined {\n  if (!value) return undefined;\n  const normalized = value\n    .replace(/^https?:\\/\\//, \"\")\n    .split(\"/\")[0]\n    ?.trim();\n  return normalized || undefined;\n}\n\nfunction normalizePath(value: string | undefined): string {\n  const trimmed = value?.trim();\n  if (!trimmed || trimmed === \"/\") return \"/\";\n  return `/${trimmed.replace(/^\\/+|\\/+$/g, \"\")}`;\n}\n\n/** Resolve frpc config from the public domain and FRP-specific environment. */\nexport function resolveFrpConfig(opts: FrpOptions): FrpConfig | undefined {\n  const options = FrpOptionsSchema.parse(opts);\n  const publicDomain = bareHost(\n    string(\n      options.publicDomain,\n      [\"TUNNEL_FRP_PUBLIC_DOMAIN\", \"TUNNEL_PUBLIC_DOMAIN\"],\n      TUNNEL_CONFIG,\n    ),\n  );\n  if (!publicDomain) return undefined;\n  const server = bareHost(string(options.server, \"FRP_SERVER\")) ?? publicDomain;\n  const serverPort = port(options.serverPort, \"FRP_SERVER_PORT\", 443);\n  const protocol = string(options.protocol, \"FRP_PROTOCOL\") ?? \"wss\";\n  const token = string(options.token, [\"FRP_TOKEN\", \"TUNNEL_TOKEN\"]);\n  const proxyName =\n    string(options.proxyName, \"FRP_PROXY_NAME\") ?? publicDomain.split(\".\")[0] ?? \"app\";\n  const appName = string(undefined, \"DATABRICKS_APP_NAME\") ?? proxyName;\n  const path = normalizePath(string(options.path, \"FRP_PATH\") ?? appName);\n  const stripPrefix = boolean(options.stripPrefix, \"FRP_STRIP_PREFIX\") ?? path !== \"/\";\n  return {\n    publicDomain,\n    server,\n    serverPort,\n    protocol,\n    ...(token ? { token } : {}),\n    proxyName,\n    path,\n    stripPrefix,\n    port: options.port,\n    targetPort: options.targetPort ?? options.port,\n  };\n}\n\n/** GitHub release asset name for the current or supplied OS/architecture. */\nexport function frpAssetName(\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\" ? \"amd64\" : undefined;\n  if (!osName || !archName) {\n    throw new Error(`frp has no supported release asset for ${platform}/${arch}`);\n  }\n  return `frp_${version}_${osName}_${archName}.tar.gz`;\n}\n\nfunction frpDownloadUrl(): string {\n  const assetName = frpAssetName(FRP_VERSION);\n  logger.info(\"installing frpc\", { version: FRP_VERSION, asset: assetName });\n  return `${FRP_RELEASE_URL}/${assetName}`;\n}\n\nasync function selectFrpc(source: string): Promise<string> {\n  const path = join(source, frpArchiveDirectory(), \"frpc\");\n  if (process.platform === \"darwin\") {\n    await new Promise<void>((resolve, reject) => {\n      const signer = spawn(\"codesign\", [\"--force\", \"--sign\", \"-\", path], { stdio: \"ignore\" });\n      signer.once(\"error\", reject);\n      signer.once(\"exit\", (code) =>\n        code === 0 ? resolve() : reject(new Error(`codesign exited with code ${code}`)),\n      );\n    });\n  }\n  return path;\n}\n\n/** Install frpc when absent and return the environment used by its process. */\nexport async function installFrp(options: FrpInstallOptions = {}): Promise<NodeJS.ProcessEnv> {\n  const homeDir = options.homeDir ?? os.homedir();\n  const context = await ensure(\"frpc\", frpDownloadUrl, {\n    autoUnpackage: true,\n    homeDir,\n    minVersion: FRP_VERSION,\n    selector: ({ source }) => selectFrpc(source),\n    versionParser: ({ stdout, stderr }) => {\n      const version = parseVersion({ stdout, stderr });\n      return version === FRP_VERSION ? version : undefined;\n    },\n  });\n  return {\n    ...process.env,\n    HOME: homeDir,\n    PATH: [context.binDir, process.env.PATH ?? \"\"].join(delimiter),\n  };\n}\n\nfunction frpArchiveDirectory(\n  platform: NodeJS.Platform = process.platform,\n  arch: string = process.arch,\n): string {\n  return frpAssetName(FRP_VERSION, platform, arch).replace(/\\.tar\\.gz$/, \"\");\n}\n\nfunction tomlString(value: string): string {\n  return JSON.stringify(value);\n}\n\n/** Render `~/.frpc/frpc.toml` for the resolved tunnel. */\nexport async function writeFrpConfig(\n  resolved: FrpConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<string> {\n  const directory = join(childEnv.HOME ?? os.homedir(), \".frpc\");\n  const path = join(directory, \"frpc.toml\");\n  await mkdir(directory, { recursive: true });\n  const lines = [\n    `serverAddr = ${tomlString(resolved.server)}`,\n    `serverPort = ${resolved.serverPort}`,\n    `transport.protocol = ${tomlString(resolved.protocol)}`,\n    \"loginFailExit = false\",\n  ];\n  if (resolved.token) lines.push(`auth.token = ${tomlString(resolved.token)}`);\n  lines.push(\n    \"\",\n    \"[[proxies]]\",\n    `name = ${tomlString(resolved.proxyName)}`,\n    'type = \"http\"',\n    `localPort = ${resolved.targetPort}`,\n    `customDomains = [${tomlString(resolved.publicDomain)}]`,\n    ...(resolved.path === \"/\" ? [] : [`locations = [${tomlString(resolved.path)}]`]),\n    \"\",\n  );\n  await writeFile(path, lines.join(\"\\n\"));\n  return path;\n}\n\n/** Launch frpc as a child process (caller supervises and terminates it). */\nexport function startFrp(\n  resolved: FrpConfig,\n  childEnv: NodeJS.ProcessEnv,\n  configPath: string,\n  options: ChildProcessTerminationOptions = {},\n): ChildProcessResult {\n  logger.info(\n    `frpc tunneling https://${resolved.publicDomain}${resolved.path === \"/\" ? \"\" : resolved.path} -> :${resolved.port}`,\n  );\n  return exec.spawn(\"frpc\", [\"-c\", configPath], {\n    ...options,\n    env: childEnv,\n    stdin: \"inherit\",\n    stdout: \"inherit\",\n    stderr: \"inherit\",\n  });\n}\n\n/** Supervise the FRP client for a resolved tunnel configuration. */\nexport function superviseFrp(\n  resolved: FrpConfig,\n  childEnv: NodeJS.ProcessEnv,\n  configPath: string,\n): ProcessSupervisor {\n  return superviseProcessForever({\n    name: \"frpc\",\n    logger,\n    start: () => startFrp(resolved, childEnv, configPath),\n  });\n}\n"]}
170
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frp.js","sourceRoot":"","sources":["../../src/frp.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install and run an frp client (`frpc`) for a public HTTP tunnel.\n *\n * The defaults match the deployment shape used by inspire-mediamix: a single\n * TLS-terminating host is both the WSS control endpoint and the HTTP custom\n * domain. Callers may point `server` somewhere else when frps is exposed on a\n * separate control host.\n *\n * @module\n */\n\nimport { spawn } from \"node:child_process\";\nimport { mkdir, writeFile } from \"node:fs/promises\";\nimport os from \"node:os\";\nimport { delimiter, join } from \"node:path\";\n\nimport { exec, ensure, parseVersion, string, port, boolean } from \"@dbx-tools/core\";\nimport type { ChildProcessResult, ChildProcessTerminationOptions } from \"@dbx-tools/core\";\nimport { log, tcpPortOrZeroSchema } from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { superviseProcessForever, type ProcessSupervisor } from \"./supervisor.ts\";\n\nconst logger = log.logger(\"tunnel:frp\");\nconst FRP_VERSION = \"0.68.1\";\nconst FRP_RELEASE_URL = `https://github.com/fatedier/frp/releases/download/v${FRP_VERSION}`;\n\n/** Options for installing the frpc executable. */\nexport interface FrpInstallOptions {\n  /** Home directory containing `.frpc`; defaults to the OS home directory. */\n  homeDir?: string;\n}\n\nexport const FrpOptionsSchema = z\n  .object({\n    publicDomain: z.string().trim().min(1).optional().describe(\"FRP public HTTP host.\"),\n    server: z.string().trim().min(1).optional().describe(\"FRP control host.\"),\n    serverPort: tcpPortOrZeroSchema.optional().describe(\"FRP control port.\"),\n    protocol: z.string().trim().min(1).optional().describe(\"FRP transport protocol.\"),\n    token: z.string().trim().min(1).optional().describe(\"FRP authentication token.\"),\n    proxyName: z.string().trim().min(1).optional().describe(\"FRP proxy registration name.\"),\n    path: z.string().trim().min(1).optional().describe(\"FRP public path.\"),\n    stripPrefix: z.boolean().optional().describe(\"Strip the FRP path before forwarding.\"),\n    port: tcpPortOrZeroSchema.describe(\"Public listener port.\"),\n    targetPort: tcpPortOrZeroSchema.optional().describe(\"Private target port.\"),\n  })\n  .strict()\n  .describe(\"FRP tunnel resolution options.\");\n\nexport type FrpOptions = z.input<typeof FrpOptionsSchema>;\n\n/** Resolved frpc wiring with every routing field populated; authentication remains optional. */\nexport const FrpConfigSchema = FrpOptionsSchema.required()\n  .extend({ token: FrpOptionsSchema.shape.token })\n  .describe(\"Resolved FRP tunnel configuration.\");\n\n/** Resolved frpc wiring, or `undefined` when no FRP tunnel is configured. */\nexport type FrpConfig = z.output<typeof FrpConfigSchema>;\n\nfunction bareHost(value: string | undefined): string | undefined {\n  if (!value) return undefined;\n  const normalized = value\n    .replace(/^https?:\\/\\//, \"\")\n    .split(\"/\")[0]\n    ?.trim();\n  return normalized || undefined;\n}\n\nfunction normalizePath(value: string | undefined): string {\n  const trimmed = value?.trim();\n  if (!trimmed || trimmed === \"/\") return \"/\";\n  return `/${trimmed.replace(/^\\/+|\\/+$/g, \"\")}`;\n}\n\n/** Resolve frpc config from the public domain and FRP-specific environment. */\nexport function resolveFrpConfig(opts: FrpOptions): FrpConfig | undefined {\n  const options = FrpOptionsSchema.parse(opts);\n  const publicDomain = bareHost(\n    string(\n      options.publicDomain,\n      [\"TUNNEL_FRP_PUBLIC_DOMAIN\", \"TUNNEL_PUBLIC_DOMAIN\"],\n      TUNNEL_CONFIG,\n    ),\n  );\n  if (!publicDomain) return undefined;\n  const server = bareHost(string(options.server, \"FRP_SERVER\")) ?? publicDomain;\n  const serverPort = port(options.serverPort, \"FRP_SERVER_PORT\", 443);\n  const protocol = string(options.protocol, \"FRP_PROTOCOL\") ?? \"wss\";\n  const token = string(options.token, [\"FRP_TOKEN\", \"TUNNEL_TOKEN\"]);\n  const proxyName =\n    string(options.proxyName, \"FRP_PROXY_NAME\") ?? publicDomain.split(\".\")[0] ?? \"app\";\n  const appName = string(undefined, \"DATABRICKS_APP_NAME\") ?? proxyName;\n  const path = normalizePath(string(options.path, \"FRP_PATH\") ?? appName);\n  const stripPrefix = boolean(options.stripPrefix, \"FRP_STRIP_PREFIX\") ?? path !== \"/\";\n  return {\n    publicDomain,\n    server,\n    serverPort,\n    protocol,\n    ...(token ? { token } : {}),\n    proxyName,\n    path,\n    stripPrefix,\n    port: options.port,\n    targetPort: options.targetPort ?? options.port,\n  };\n}\n\n/** GitHub release asset name for the current or supplied OS/architecture. */\nexport function frpAssetName(\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\" ? \"amd64\" : undefined;\n  if (!osName || !archName) {\n    throw new Error(`frp has no supported release asset for ${platform}/${arch}`);\n  }\n  return `frp_${version}_${osName}_${archName}.tar.gz`;\n}\n\nfunction frpDownloadUrl(): string {\n  const assetName = frpAssetName(FRP_VERSION);\n  logger.info(\"installing frpc\", { version: FRP_VERSION, asset: assetName });\n  return `${FRP_RELEASE_URL}/${assetName}`;\n}\n\nasync function selectFrpc(source: string): Promise<string> {\n  const path = join(source, frpArchiveDirectory(), \"frpc\");\n  if (process.platform === \"darwin\") {\n    await new Promise<void>((resolve, reject) => {\n      const signer = spawn(\"codesign\", [\"--force\", \"--sign\", \"-\", path], { stdio: \"ignore\" });\n      signer.once(\"error\", reject);\n      signer.once(\"exit\", (code) =>\n        code === 0 ? resolve() : reject(new Error(`codesign exited with code ${code}`)),\n      );\n    });\n  }\n  return path;\n}\n\n/** Install frpc when absent and return the environment used by its process. */\nexport async function installFrp(options: FrpInstallOptions = {}): Promise<NodeJS.ProcessEnv> {\n  const homeDir = options.homeDir ?? os.homedir();\n  const context = await ensure(\"frpc\", frpDownloadUrl, {\n    autoUnpackage: true,\n    homeDir,\n    minVersion: FRP_VERSION,\n    selector: ({ source }) => selectFrpc(source),\n    versionParser: ({ stdout, stderr }) => {\n      const version = parseVersion({ stdout, stderr });\n      return version === FRP_VERSION ? version : undefined;\n    },\n  });\n  return {\n    ...process.env,\n    HOME: homeDir,\n    PATH: [context.binDir, process.env.PATH ?? \"\"].join(delimiter),\n  };\n}\n\nfunction frpArchiveDirectory(\n  platform: NodeJS.Platform = process.platform,\n  arch: string = process.arch,\n): string {\n  return frpAssetName(FRP_VERSION, platform, arch).replace(/\\.tar\\.gz$/, \"\");\n}\n\nfunction tomlString(value: string): string {\n  return JSON.stringify(value);\n}\n\n/** Render `~/.frpc/frpc.toml` for the resolved tunnel. */\nexport async function writeFrpConfig(\n  resolved: FrpConfig,\n  childEnv: NodeJS.ProcessEnv,\n): Promise<string> {\n  const directory = join(childEnv.HOME ?? os.homedir(), \".frpc\");\n  const path = join(directory, \"frpc.toml\");\n  await mkdir(directory, { recursive: true });\n  const lines = [\n    `serverAddr = ${tomlString(resolved.server)}`,\n    `serverPort = ${resolved.serverPort}`,\n    `transport.protocol = ${tomlString(resolved.protocol)}`,\n    \"loginFailExit = false\",\n  ];\n  if (resolved.token) lines.push(`auth.token = ${tomlString(resolved.token)}`);\n  lines.push(\n    \"\",\n    \"[[proxies]]\",\n    `name = ${tomlString(resolved.proxyName)}`,\n    'type = \"http\"',\n    `localPort = ${resolved.targetPort}`,\n    `customDomains = [${tomlString(resolved.publicDomain)}]`,\n    ...(resolved.path === \"/\" ? [] : [`locations = [${tomlString(resolved.path)}]`]),\n    \"\",\n  );\n  await writeFile(path, lines.join(\"\\n\"));\n  return path;\n}\n\n/** Launch frpc as a child process (caller supervises and terminates it). */\nexport function startFrp(\n  resolved: FrpConfig,\n  childEnv: NodeJS.ProcessEnv,\n  configPath: string,\n  options: ChildProcessTerminationOptions = {},\n): ChildProcessResult {\n  logger.info(\n    `frpc tunneling https://${resolved.publicDomain}${resolved.path === \"/\" ? \"\" : resolved.path} -> :${resolved.port}`,\n  );\n  return exec.spawn(\"frpc\", [\"-c\", configPath], {\n    ...options,\n    env: childEnv,\n    stdin: \"inherit\",\n    stdout: \"inherit\",\n    stderr: \"inherit\",\n  });\n}\n\n/** Supervise the FRP client for a resolved tunnel configuration. */\nexport function superviseFrp(\n  resolved: FrpConfig,\n  childEnv: NodeJS.ProcessEnv,\n  configPath: string,\n): ProcessSupervisor {\n  return superviseProcessForever({\n    name: \"frpc\",\n    logger,\n    start: () => startFrp(resolved, childEnv, configPath),\n  });\n}\n"]}