@rstreamlabs/tunnels 3.8.3 → 3.10.1

package/dist/node-engine-http-6DJZZEME.mjs

@@ -0,0 +1,102 @@
+// src/node-engine-http.ts
+import { Agent } from "https";
+import { request } from "https";
+var responseHeaders = (response) => {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(response.headers)) {
+    if (Array.isArray(value))
+      for (const item of value) headers.append(name, item);
+    else if (value !== void 0) headers.set(name, value);
+  }
+  return headers;
+};
+var responseBody = (response) => {
+  const state = { ended: false };
+  return new ReadableStream({
+    start(controller) {
+      response.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk));
+        response.pause();
+      });
+      response.once("end", () => {
+        if (!state.ended) {
+          state.ended = true;
+          controller.close();
+        }
+      });
+      response.once("error", (error) => {
+        if (!state.ended) {
+          state.ended = true;
+          controller.error(error);
+        }
+      });
+      response.once("aborted", () => {
+        if (!state.ended) {
+          state.ended = true;
+          controller.error(new Error("Engine response was interrupted."));
+        }
+      });
+    },
+    pull() {
+      response.resume();
+    },
+    cancel() {
+      state.ended = true;
+      response.destroy();
+    }
+  });
+};
+var NodeEngineHTTP = class {
+  constructor(tls) {
+    this.tls = tls;
+  }
+  tls;
+  agent = new Agent({
+    keepAlive: true,
+    maxSockets: 16,
+    maxFreeSockets: 4,
+    maxTotalSockets: 16
+  });
+  fetch = async (input, init) => {
+    const incoming = new Request(input, init);
+    const url = new URL(incoming.url);
+    if (url.protocol !== "https:" || url.username || url.password)
+      throw new Error(
+        "Engine HTTP requests require HTTPS without URL credentials."
+      );
+    const body = incoming.body ? new Uint8Array(await incoming.arrayBuffer()) : void 0;
+    incoming.signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+      const outgoing = request(
+        url,
+        {
+          ...this.tls,
+          servername: url.hostname,
+          agent: this.agent,
+          method: incoming.method,
+          headers: Object.fromEntries(incoming.headers),
+          signal: incoming.signal
+        },
+        (response) => {
+          const status = response.statusCode ?? 502;
+          const empty = incoming.method === "HEAD" || [204, 205, 304].includes(status);
+          if (empty) response.resume();
+          resolve(
+            new Response(empty ? null : responseBody(response), {
+              status,
+              headers: responseHeaders(response)
+            })
+          );
+        }
+      );
+      outgoing.once("error", reject);
+      outgoing.end(body);
+    });
+  };
+  close() {
+    this.agent.destroy();
+  }
+};
+export {
+  NodeEngineHTTP
+};

package/dist/openapi.d.mts

@@ -24,11 +24,19 @@ declare const engineOpenApiDocument: {
             };
         };
     }[];
-    security: {
+    security: ({
         bearerAuth: never[];
-    }[];
+        mutualTLS?: undefined;
+    } | {
+        mutualTLS: never[];
+        bearerAuth?: undefined;
+    })[];
     components: {
         securitySchemes: {
+            mutualTLS: {
+                type: string;
+                description: string;
+            };
             bearerAuth: {
                 type: string;
                 scheme: string;
@@ -98,6 +106,74 @@ declare const engineOpenApiDocument: {
             };
         };
         schemas: {
+            EngineDiscovery: {
+                type: string;
+                required: string[];
+                properties: {
+                    version: {
+                        type: string;
+                        const: number;
+                    };
+                    projectEndpoint: {
+                        type: string;
+                    };
+                    mtlsApiUrl: {
+                        type: string;
+                        format: string;
+                        example: string;
+                    };
+                    capabilities: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        examples: string[][];
+                    };
+                };
+            };
+            CreateTURNCredentials: {
+                type: string;
+                additionalProperties: boolean;
+                properties: {
+                    ttlSeconds: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                        default: number;
+                    };
+                };
+            };
+            TURNCredentials: {
+                type: string;
+                required: string[];
+                properties: {
+                    username: {
+                        type: string;
+                        maxLength: number;
+                        description: string;
+                    };
+                    credential: {
+                        type: string;
+                        maxLength: number;
+                        description: string;
+                    };
+                    urls: {
+                        type: string;
+                        minItems: number;
+                        maxItems: number;
+                        items: {
+                            type: string;
+                            maxLength: number;
+                        };
+                    };
+                    ttl: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                        description: string;
+                    };
+                };
+            };
             Client: unknown;
             Event: unknown;
             ListClientsParams: unknown;
@@ -122,6 +198,164 @@ declare const engineOpenApiDocument: {
         "read-managed-webtty-recordings": string[];
     };
     paths: {
+        "/.well-known/rstream/engine": {
+            get: {
+                tags: string[];
+                summary: string;
+                operationId: string;
+                description: string;
+                security: never[];
+                responses: {
+                    "200": {
+                        description: string;
+                        headers: {
+                            "Cache-Control": {
+                                schema: {
+                                    type: string;
+                                };
+                                example: string;
+                            };
+                        };
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                    "404": {
+                        description: string;
+                    };
+                };
+            };
+        };
+        "/api/turn-server/credentials": {
+            post: {
+                tags: string[];
+                summary: string;
+                operationId: string;
+                description: string;
+                security: ({
+                    bearerAuth: never[];
+                    mutualTLS?: undefined;
+                } | {
+                    mutualTLS: never[];
+                    bearerAuth?: undefined;
+                })[];
+                requestBody: {
+                    required: boolean;
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+                responses: {
+                    "200": {
+                        description: string;
+                        headers: {
+                            "Cache-Control": {
+                                schema: {
+                                    type: string;
+                                };
+                                example: string;
+                            };
+                        };
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                    "400": {
+                        description: string;
+                        headers: {
+                            "Cache-Control": {
+                                schema: {
+                                    type: string;
+                                };
+                                example: string;
+                            };
+                        };
+                    };
+                    "401": {
+                        description: string;
+                        headers: {
+                            "Cache-Control": {
+                                schema: {
+                                    type: string;
+                                };
+                                example: string;
+                            };
+                        };
+                    };
+                    "403": {
+                        description: string;
+                        headers: {
+                            "Cache-Control": {
+                                schema: {
+                                    type: string;
+                                };
+                                example: string;
+                            };
+                        };
+                    };
+                    "404": {
+                        description: string;
+                        headers: {
+                            "Cache-Control": {
+                                schema: {
+                                    type: string;
+                                };
+                                example: string;
+                            };
+                        };
+                    };
+                    "409": {
+                        description: string;
+                        headers: {
+                            "Cache-Control": {
+                                schema: {
+                                    type: string;
+                                };
+                                example: string;
+                            };
+                        };
+                    };
+                    "429": {
+                        description: string;
+                        headers: {
+                            "Cache-Control": {
+                                schema: {
+                                    type: string;
+                                };
+                                example: string;
+                            };
+                        };
+                    };
+                    "503": {
+                        description: string;
+                        headers: {
+                            "Cache-Control": {
+                                schema: {
+                                    type: string;
+                                };
+                                example: string;
+                            };
+                        };
+                    };
+                };
+                "x-rstream-required-rules": {
+                    resource: string;
+                    action: string;
+                }[];
+            };
+        };
         "/api/openapi.json": {
             get: {
                 tags: string[];
@@ -150,9 +384,13 @@ declare const engineOpenApiDocument: {
                 parameters: {
                     $ref: string;
                 }[];
-                security: {
+                security: ({
                     bearerAuth: never[];
-                }[];
+                    mutualTLS?: undefined;
+                } | {
+                    mutualTLS: never[];
+                    bearerAuth?: undefined;
+                })[];
                 responses: {
                     "200": {
                         description: string;
@@ -188,9 +426,13 @@ declare const engineOpenApiDocument: {
                 parameters: {
                     $ref: string;
                 }[];
-                security: {
+                security: ({
                     bearerAuth: never[];
-                }[];
+                    mutualTLS?: undefined;
+                } | {
+                    mutualTLS: never[];
+                    bearerAuth?: undefined;
+                })[];
                 responses: {
                     "200": {
                         description: string;
@@ -227,9 +469,13 @@ declare const engineOpenApiDocument: {
                 parameters: {
                     $ref: string;
                 }[];
-                security: {
+                security: ({
                     bearerAuth: never[];
-                }[];
+                    mutualTLS?: undefined;
+                } | {
+                    mutualTLS: never[];
+                    bearerAuth?: undefined;
+                })[];
                 responses: {
                     "200": {
                         description: string;
@@ -263,9 +509,13 @@ declare const engineOpenApiDocument: {
                 parameters: {
                     $ref: string;
                 }[];
-                security: {
+                security: ({
                     bearerAuth: never[];
-                }[];
+                    mutualTLS?: undefined;
+                } | {
+                    mutualTLS: never[];
+                    bearerAuth?: undefined;
+                })[];
                 responses: {
                     "101": {
                         description: string;