@absolutejs/absolute 0.19.0-beta.1023 → 0.19.0-beta.1025

package/dist/src/dev/tunnel/protocol.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Reverse-tunnel wire protocol (pure Bun, no third-party deps).
+ *
+ * A dev machine behind NAT cannot accept inbound connections, so the dev
+ * `client` dials OUT to a public `relay` over a single control WebSocket. The
+ * relay receives public HTTP requests and forwards each one down that socket;
+ * the client replays it against the local app and sends the response back.
+ *
+ * Stage 1 covers HTTP request/response (webhooks). WebSocket passthrough for
+ * telephony media streams is layered on later with additional message types.
+ */
+/** Control-channel path the client connects to on the relay. */
+export declare const TUNNEL_CONTROL_PATH = "/__abs_tunnel/control";
+/** Header the relay strips/sets; lets the app know its public origin. */
+export declare const TUNNEL_FORWARDED_HOST_HEADER = "x-absolute-tunnel-host";
+/** A forwarded HTTP request (relay → client). Body is base64 (binary-safe). */
+export type TunnelRequestMessage = {
+    type: 'request';
+    id: string;
+    method: string;
+    /** Path + query, e.g. `/v1/sms/intake?x=1`. */
+    url: string;
+    headers: Record<string, string>;
+    bodyBase64?: string;
+};
+/** The client's response to a forwarded request (client → relay). */
+export type TunnelResponseMessage = {
+    type: 'response';
+    id: string;
+    status: number;
+    headers: Record<string, string>;
+    bodyBase64?: string;
+};
+/** Client could not produce a response (local app down, fetch threw). */
+export type TunnelErrorMessage = {
+    type: 'error';
+    id: string;
+    message: string;
+};
+/** Sent by the relay right after a successful auth handshake. */
+export type TunnelReadyMessage = {
+    type: 'ready';
+    /** Public base URL the relay is reachable at, e.g. `https://x.app`. */
+    publicUrl: string;
+};
+/** A public WS connection opened; client should dial the local app (relay → client). */
+export type TunnelWsOpenMessage = {
+    type: 'ws_open';
+    id: string;
+    /** Path + query of the upgraded request. */
+    url: string;
+    headers: Record<string, string>;
+};
+/** Result of the client opening the local WS (client → relay). */
+export type TunnelWsOpenAckMessage = {
+    type: 'ws_open_ack';
+    id: string;
+    ok: boolean;
+    error?: string;
+};
+/** One WS frame, either direction. Binary frames are base64. */
+export type TunnelWsDataMessage = {
+    type: 'ws_data';
+    id: string;
+    dataBase64: string;
+    binary: boolean;
+};
+/** A WS closed, either direction. */
+export type TunnelWsCloseMessage = {
+    type: 'ws_close';
+    id: string;
+    code?: number;
+    reason?: string;
+};
+/** App-level keepalive (either direction). */
+export type TunnelPingMessage = {
+    type: 'ping';
+};
+export type TunnelPongMessage = {
+    type: 'pong';
+};
+export type TunnelClientMessage = TunnelResponseMessage | TunnelErrorMessage | TunnelWsOpenAckMessage | TunnelWsDataMessage | TunnelWsCloseMessage | TunnelPongMessage | TunnelPingMessage;
+export type TunnelServerMessage = TunnelRequestMessage | TunnelReadyMessage | TunnelWsOpenMessage | TunnelWsDataMessage | TunnelWsCloseMessage | TunnelPingMessage | TunnelPongMessage;
+export declare const decodeTunnelMessage: (raw: string) => TunnelRequestMessage | TunnelResponseMessage | TunnelErrorMessage | TunnelReadyMessage | TunnelWsOpenMessage | TunnelWsOpenAckMessage | TunnelWsDataMessage | TunnelWsCloseMessage | TunnelPingMessage | TunnelPongMessage | null;
+export declare const encodeTunnelMessage: (message: TunnelClientMessage | TunnelServerMessage) => string;

package/dist/src/dev/tunnel/relay.d.ts

@@ -0,0 +1,28 @@
+type RelayOptions = {
+    /** Port the relay listens on (App Platform injects PORT). */
+    port?: number;
+    /** Shared secret the dev client must present (?token=). */
+    token: string;
+    /** Public base URL the relay is reachable at. Falls back to the request
+     *  origin when omitted (App Platform: set APP_URL or pass explicitly). */
+    publicUrl?: string;
+    /** How long to wait for the dev client to answer a forwarded request. */
+    requestTimeoutMs?: number;
+};
+type ControlSocketData = {
+    control: true;
+};
+type PublicSocketData = {
+    control: false;
+    id: string;
+    url: string;
+    headers: Record<string, string>;
+};
+type SocketData = ControlSocketData | PublicSocketData;
+/**
+ * Start the public reverse-tunnel relay. Holds one dev-client control socket
+ * and forwards every other inbound HTTP request — and public WebSocket — down
+ * it. Single-tenant: the shared `token` gates the control channel.
+ */
+export declare const startTunnelRelay: (options: RelayOptions) => Bun.Server<SocketData>;
+export {};

package/dist/src/utils/loadConfig.d.ts

@@ -35,6 +35,10 @@ export declare const loadConfig: (configPath?: string) => Promise<{
         host?: string;
         https?: boolean;
         watchDirs?: string[];
+        tunnel?: {
+            relay?: string;
+            token?: string;
+        };
         devtools?: {
             projectRoot?: string;
             uuid?: string;