@dbx-tools/tunnel 0.9.203 → 0.9.206

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
@@ -96,28 +97,30 @@ The package:
96
97
  - Better Auth rate limiting plus anti-enumeration: the compatibility code
97
98
  request always answers `{ ok: true }`, whether or not the address is allowed.
98
99
  - Inbound `x-` headers are stripped by default and re-allowed by pattern, so a
99
- public caller cannot spoof the headers the app trusts - above all
100
+ public caller cannot spoof the headers the app trusts, especially
100
101
  `x-forwarded-access-token`, which would otherwise let anyone drive the app's
101
102
  workspace calls with a pasted token. Add an app's own headers with
102
103
  `TUNNEL_FORWARD_HEADERS`.
103
104
  - Only Portr traffic is gated. The gate identifies tunnel requests by their
104
- `Host` header (`TUNNEL_PUBLIC_DOMAIN`), which portr's client preserves from the
105
- public visitor. Platform front-door traffic and any other local caller carry a
106
- different `Host` and pass through without a gate, so health checks and the workspace UI
107
- keep working. (There is no portr-injected identifying header and no source-IP
108
- 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.
109
111
  - SPA-aware gating: static assets and the login routes stay open so the browser
110
112
  can load the client and render the login form. Every other `/api/*` needs a
111
113
  valid session cookie or gets `401`. A WebSocket handshake is an ordinary `GET`
112
114
  and runs through the same gate.
113
- - Supervised teardown - `tunnelInterceptor` registers its tunnel supervisor with
115
+ - Supervised teardown: `tunnelInterceptor` registers its tunnel supervisor with
114
116
  AppKit's native `shutdown` lifecycle. Core exec terminates each tunnel process
115
117
  tree through the child handle's memoized `shutdown()` method.
116
- - Public liveness probes - while portr is running, the supervisor HEADs the
118
+ - Public liveness probes: while portr is running, the supervisor HEADs the
117
119
  public URL. An `x-portr-error: unregistered-subdomain` (or any other
118
- `x-portr-error`) kills the child so the forever-loop restarts it. Process-exit
119
- supervision alone is not enough: portr can stay alive after the edge drops the
120
- 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.
121
124
  - The gate fails fast when email is not configured for SMTP, because a gate that
122
125
  cannot send codes locks everyone out. `@dbx-tools/email` is an optional peer
123
126
  dependency, imported lazily. The app that mounts the gate provides it.
@@ -217,17 +220,17 @@ Resolution order:
217
220
  operator-held secret needs no shared cache, and it survives a cache flush.
218
221
  2. **A key persisted in AppKit's cache for 30 days.** With a persistent
219
222
  `CacheStorage` (Lakebase) the key outlives the process, so cookies stay valid
220
- 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
221
224
  it wraps reloads. On the default in-memory cache the key is per-process, the
222
225
  same as having no secret at all.
223
226
 
224
- Getting that persistence is not automatic, and the gate does the work at boot
225
- 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
226
229
  `PGHOST` / `PGDATABASE` / `PGUSER` the cache's pool also needs. Without them
227
230
  AppKit cannot build the pool, silently uses an in-memory cache, and every
228
- redeploy signs everyone out - so the startup log says which one you got
229
- (`lakebase resolved for the gate cache`, or `the gate cache stays in memory`).
230
- 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.
231
234
 
232
235
  3. **An ephemeral per-process key**, when there is no secret and no reachable
233
236
  cache. Sessions do not survive a restart, but the gate still serves: the key
@@ -239,22 +242,20 @@ booting together both miss the cache, so both generate. Adopting whatever is
239
242
  stored afterward makes them converge on one key instead of each trusting
240
243
  the one it minted. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race entirely.
241
244
 
242
- `TUNNEL_AUTH_SESSION_TTL` defaults to the same 30 days the key is stored for, on
243
- purpose - a key that expired before the cookies it signed would sign everyone out
244
- 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.
245
247
 
246
248
  ## <a id="email-code-subject"></a> Put the email code in the subject
247
249
 
248
- The subject line the gate sends is `123456 is your verification code` -
249
- `--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.
250
252
 
251
253
  Mobile autofill reads notification text instead of email body content. iOS scans
252
- incoming notification text for a code and offers to fill it - natively for
253
- Messages and Mail, and since iOS 26 for any app's notification, which is what
254
- finally made Gmail work. A notification carries the sender, the subject, and a
255
- short snippet. That is all. A code sitting in the body is invisible to it no
256
- matter how carefully the body is formatted, which is why a correctly shaped
257
- `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.
258
259
 
259
260
  So the code goes in both strings a notification actually shows:
260
261
 
@@ -285,32 +286,31 @@ TUNNEL_AUTH_SESSION_CUTOFF="now" ... # sign everyone out on this boot
285
286
 
286
287
  The value goes through `@dbx-tools/shared-core`'s `object.toDate`, so a date, an
287
288
  ISO instant, epoch seconds or millis from `date +%s`, and a relative duration
288
- (`-30d`, `12 hours ago`) all work - the relative spelling being the one an
289
- operator usually wants, since "sign out anything older than a month" needs no
290
- timestamp arithmetic. It works two ways at once, so it holds however the key was
291
- resolved: the cutoff is part of the key's cache key (moving it orphans the
292
- previous key), and it is also checked against each token's `iat` (which is what
293
- makes it bite when `TUNNEL_AUTH_JWT_SECRET` is set and there is no key to
294
- 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).
295
295
 
296
296
  A future date is clamped to now, because an unclamped one would refuse the
297
- sessions it is about to mint as well as the old ones - an app nobody can sign in
298
- to, from a mistyped year. An unparseable value is ignored with a warning rather
299
- 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.
300
300
 
301
301
  ## Inbound header policy
302
302
 
303
- Tunnel traffic arrives from the public internet, so every header on it is
304
- 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
305
305
  must not be able to write, because the app cannot tell a header the Databricks
306
306
  front door set from one a browser typed.
307
307
 
308
- Enumerating headers to remove is a losing game (a denylist is only correct until
309
- the platform adds a header), so the policy is inverted: **every `x-`-prefixed
310
- request header is stripped from tunnel traffic unless a pattern allows it.** A
311
- header nobody thought about is removed rather than trusted. Non-`x-` headers -
312
- `content-type`, `accept`, `authorization`, `cookie` - are the app's normal input
313
- 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.
314
314
 
315
315
  The default allowlist covers the `x-` namespaces this repo's own client sends
316
316
  and its own server reads, so a dbx-tools app works behind the tunnel with no
@@ -323,10 +323,10 @@ configuration:
323
323
  | `x-requested-with` | the conventional AJAX marker |
324
324
 
325
325
  Add an app's own headers with `TUNNEL_FORWARD_HEADERS` (or `forwardHeaders` on
326
- `authGate`). Each entry is a literal name, a shell-style glob, or a `/regex/` -
327
- the same three shapes the email allowlist takes - and the configured list is
328
- combined with the defaults, so extending it never silently breaks the built-in
329
- 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:
330
330
 
331
331
  ```sh
332
332
  TUNNEL_FORWARD_HEADERS="x-acme-*, /^x-trace-/, x-tenant" ...
@@ -344,15 +344,15 @@ came from, and on tunnel traffic only the gate may answer that:
344
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. |
345
345
  | `x-request-id` | Request correlation UUID. Forged or colliding ids make logs unreliable. |
346
346
 
347
- The identity headers are AppKit's OBO contract. The rest are the
348
- [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
349
349
  app](https://docs.databricks.com/aws/en/dev-tools/databricks-apps/http-headers),
350
350
  plus the conventional `x-forwarded-proto`/`-port`/`x-real-ip` a library may read
351
- anyway. Dropping the transport headers costs nothing: `xfwd` re-adds them from the
352
- real socket after the policy runs, so the app sees the honest values instead of the
353
- caller's claim. Rate limiting reads the client IP before stripping, and takes the
354
- **rightmost** `x-forwarded-for` entry - the only one portr appended rather than a
355
- 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.
356
356
 
357
357
  ## Use the gate
358
358
 
@@ -379,9 +379,9 @@ await appkit.createApp({
379
379
  Override `sendCode` only to deliver through something other than the shared
380
380
  transport. The default builds the OTP email (code in the subject + preheader for
381
381
  mobile autofill) and sends it as the system sender. `@dbx-tools/email` is an
382
- optional peer dependency - a tunnel without the gate needs no mail - so the app
383
- that mounts `authGate` must include it (or run `TUNNEL_INSECURE=true` to skip the
384
- 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.
385
385
 
386
386
  `GET /api/email/auth/status` is what a client asks before deciding to render a
387
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.203";
6
+ export const PACKAGE_VERSION = "0.9.206";
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.203";
2
+ export declare const PACKAGE_VERSION = "0.9.206";
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.203";
5
+ export const PACKAGE_VERSION = "0.9.206";
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":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEpF,OAAO,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,uBAAuB,EAA0B,MAAM,iBAAiB,CAAC;AAElF,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;AACxC,MAAM,WAAW,GAAG,QAAQ,CAAC;AAC7B,MAAM,eAAe,GAAG,sDAAsD,WAAW,EAAE,CAAC;AAsB5F,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC;KAC9B,MAAM,CAAC;IACN,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,uBAAuB,CAAC;IACnF,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC;IACzE,UAAU,EAAE,mBAAmB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC;IACxE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,yBAAyB,CAAC;IACjF,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,2BAA2B,CAAC;IAChF,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,8BAA8B,CAAC;IACvF,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,kBAAkB,CAAC;IACtE,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,uCAAuC,CAAC;IACrF,IAAI,EAAE,mBAAmB,CAAC,QAAQ,CAAC,uBAAuB,CAAC;IAC3D,UAAU,EAAE,mBAAmB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;CAC5E,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,gCAAgC,CAAC,CAAC;AAI9C,SAAS,QAAQ,CAAC,KAAyB;IACzC,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,MAAM,UAAU,GAAG,KAAK;SACrB,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC;SAC3B,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACd,EAAE,IAAI,EAAE,CAAC;IACX,OAAO,UAAU,IAAI,SAAS,CAAC;AACjC,CAAC;AAED,SAAS,aAAa,CAAC,KAAyB;IAC9C,MAAM,OAAO,GAAG,KAAK,EAAE,IAAI,EAAE,CAAC;IAC9B,IAAI,CAAC,OAAO,IAAI,OAAO,KAAK,GAAG;QAAE,OAAO,GAAG,CAAC;IAC5C,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,EAAE,CAAC;AACjD,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,gBAAgB,CAAC,IAAgB;IAC/C,MAAM,OAAO,GAAG,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC7C,MAAM,YAAY,GAAG,QAAQ,CAC3B,MAAM,CACJ,OAAO,CAAC,YAAY,EACpB,CAAC,0BAA0B,EAAE,sBAAsB,CAAC,EACpD,aAAa,CACd,CACF,CAAC;IACF,IAAI,CAAC,YAAY;QAAE,OAAO,SAAS,CAAC;IACpC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,IAAI,YAAY,CAAC;IAC9E,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,iBAAiB,EAAE,GAAG,CAAC,CAAC;IACpE,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,cAAc,CAAC,IAAI,KAAK,CAAC;IACnE,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC;IACnE,MAAM,SAAS,GACb,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,gBAAgB,CAAC,IAAI,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC;IACrF,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,EAAE,qBAAqB,CAAC,IAAI,SAAS,CAAC;IACtE,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,OAAO,CAAC,CAAC;IACxE,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,kBAAkB,CAAC,IAAI,IAAI,KAAK,GAAG,CAAC;IACrF,OAAO;QACL,YAAY;QACZ,MAAM;QACN,UAAU;QACV,QAAQ;QACR,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3B,SAAS;QACT,IAAI;QACJ,WAAW;QACX,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,IAAI;KAC/C,CAAC;AACJ,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,YAAY,CAC1B,OAAe,EACf,WAA4B,OAAO,CAAC,QAAQ,EAC5C,OAAe,OAAO,CAAC,IAAI;IAE3B,MAAM,MAAM,GAAG,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7F,MAAM,QAAQ,GAAG,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IACnF,IAAI,CAAC,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,0CAA0C,QAAQ,IAAI,IAAI,EAAE,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,OAAO,OAAO,IAAI,MAAM,IAAI,QAAQ,SAAS,CAAC;AACvD,CAAC;AAED,SAAS,cAAc;IACrB,MAAM,SAAS,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC;IAC5C,MAAM,CAAC,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;IAC3E,OAAO,GAAG,eAAe,IAAI,SAAS,EAAE,CAAC;AAC3C,CAAC;AAED,KAAK,UAAU,UAAU,CAAC,MAAc;IACtC,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,EAAE,mBAAmB,EAAE,EAAE,MAAM,CAAC,CAAC;IACzD,IAAI,OAAO,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAClC,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC1C,MAAM,MAAM,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;YACxF,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC7B,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAC3B,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,6BAA6B,IAAI,EAAE,CAAC,CAAC,CAChF,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,+EAA+E;AAC/E,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,UAA6B,EAAE;IAC9D,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC;IAChD,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE;QACnD,aAAa,EAAE,IAAI;QACnB,OAAO;QACP,UAAU,EAAE,WAAW;QACvB,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC;QAC5C,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE;YACpC,MAAM,OAAO,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;YACjD,OAAO,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;QACvD,CAAC;KACF,CAAC,CAAC;IACH,OAAO;QACL,GAAG,OAAO,CAAC,GAAG;QACd,IAAI,EAAE,OAAO;QACb,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;KAC/D,CAAC;AACJ,CAAC;AAED,SAAS,mBAAmB,CAC1B,WAA4B,OAAO,CAAC,QAAQ,EAC5C,OAAe,OAAO,CAAC,IAAI;IAE3B,OAAO,YAAY,CAAC,WAAW,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;AAC7E,CAAC;AAED,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED,0DAA0D;AAC1D,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,QAAmB,EACnB,QAA2B;IAE3B,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,OAAO,CAAC,CAAC;IAC/D,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IAC1C,MAAM,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG;QACZ,gBAAgB,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;QAC7C,gBAAgB,QAAQ,CAAC,UAAU,EAAE;QACrC,wBAAwB,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;QACvD,uBAAuB;KACxB,CAAC;IACF,IAAI,QAAQ,CAAC,KAAK;QAAE,KAAK,CAAC,IAAI,CAAC,gBAAgB,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC7E,KAAK,CAAC,IAAI,CACR,EAAE,EACF,aAAa,EACb,UAAU,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,EAC1C,eAAe,EACf,eAAe,QAAQ,CAAC,UAAU,EAAE,EACpC,oBAAoB,UAAU,CAAC,QAAQ,CAAC,YAAY,CAAC,GAAG,EACxD,GAAG,CAAC,QAAQ,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,gBAAgB,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAChF,EAAE,CACH,CAAC;IACF,MAAM,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACxC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,QAAQ,CACtB,QAAmB,EACnB,QAA2B,EAC3B,UAAkB,EAClB,UAA0C,EAAE;IAE5C,MAAM,CAAC,IAAI,CACT,0BAA0B,QAAQ,CAAC,YAAY,GAAG,QAAQ,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,QAAQ,QAAQ,CAAC,IAAI,EAAE,CACpH,CAAC;IACF,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE;QAC5C,GAAG,OAAO;QACV,GAAG,EAAE,QAAQ;QACb,KAAK,EAAE,SAAS;QAChB,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,SAAS;KAClB,CAAC,CAAC;AACL,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,YAAY,CAC1B,QAAmB,EACnB,QAA2B,EAC3B,UAAkB;IAElB,OAAO,uBAAuB,CAAC;QAC7B,IAAI,EAAE,MAAM;QACZ,MAAM;QACN,KAAK,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC;KACtD,CAAC,CAAC;AACL,CAAC","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"]}