@floegence/flowersec-core 0.26.0 → 2.0.0

package/dist/proxy/scope.d.ts

@@ -0,0 +1,6 @@
+import type { ProxyRuntimeScope } from "./types.js";
+export declare const PROXY_RUNTIME_SCOPE: Readonly<{
+    name: "proxy.runtime";
+    version: 2;
+}>;
+export declare function assertProxyRuntimeScope(payload: unknown): ProxyRuntimeScope;

package/dist/proxy/scope.js

@@ -0,0 +1,131 @@
+export const PROXY_RUNTIME_SCOPE = Object.freeze({ name: "proxy.runtime", version: 2 });
+const MAX_PAYLOAD_BYTES = 8 * 1024;
+const MAX_FIELDS = 48;
+const MAX_DEPTH = 6;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function reject(message) {
+    throw new TypeError(`invalid proxy.runtime@2: ${message}`);
+}
+function exactFields(value, allowed, label) {
+    const set = new Set(allowed);
+    for (const key of Object.keys(value))
+        if (!set.has(key))
+            reject(`${label}.${key}`);
+}
+function containerDepth(value) {
+    if (Array.isArray(value))
+        return 1 + value.reduce((best, item) => Math.max(best, containerDepth(item)), 0);
+    if (!isRecord(value))
+        return 0;
+    return 1 + Object.values(value).reduce((best, item) => Math.max(best, containerDepth(item)), 0);
+}
+function fieldCount(value) {
+    if (Array.isArray(value))
+        return value.reduce((total, item) => total + fieldCount(item), 0);
+    if (!isRecord(value))
+        return 0;
+    return Object.values(value).reduce((total, item) => total + 1 + fieldCount(item), 0);
+}
+function nonEmpty(name, value) {
+    if (typeof value !== "string" || value.trim() === "" || value !== value.trim())
+        reject(name);
+    return value;
+}
+function positiveInt(name, value) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+        reject(name);
+    return value;
+}
+function optionalLimits(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value))
+        reject("limits");
+    exactFields(value, ["timeoutMs", "maxJsonFrameBytes", "maxChunkBytes", "maxBodyBytes", "maxWsFrameBytes"], "limits");
+    const result = {};
+    for (const key of ["timeoutMs", "maxJsonFrameBytes", "maxChunkBytes", "maxBodyBytes", "maxWsFrameBytes"]) {
+        if (value[key] !== undefined)
+            result[key] = positiveInt(`limits.${key}`, value[key]);
+    }
+    return Object.freeze(result);
+}
+function optionalAppBasePath(value) {
+    if (value === undefined)
+        return undefined;
+    const path = nonEmpty("appBasePath", value);
+    if (!path.startsWith("/") || path.startsWith("//") || /[\u0000-\u0020]/u.test(path))
+        reject("appBasePath");
+    return path;
+}
+function allowedOrigins(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 16)
+        reject("controllerBridge.allowedOrigins");
+    const result = [];
+    for (const entry of value) {
+        const origin = nonEmpty("controllerBridge.allowedOrigins", entry);
+        let parsed;
+        try {
+            parsed = new URL(origin);
+        }
+        catch {
+            reject("controllerBridge.allowedOrigins");
+        }
+        if ((parsed.protocol !== "https:" && parsed.protocol !== "http:") || parsed.origin !== origin || parsed.username !== "" || parsed.password !== "") {
+            reject("controllerBridge.allowedOrigins");
+        }
+        if (!result.includes(origin))
+            result.push(origin);
+    }
+    if (result.length === 0)
+        reject("controllerBridge.allowedOrigins");
+    return Object.freeze(result);
+}
+export function assertProxyRuntimeScope(payload) {
+    if (!isRecord(payload))
+        reject("payload");
+    let encoded;
+    try {
+        encoded = JSON.stringify(payload);
+    }
+    catch {
+        reject("payload");
+    }
+    if (new TextEncoder().encode(encoded).length > MAX_PAYLOAD_BYTES || containerDepth(payload) > MAX_DEPTH || fieldCount(payload) > MAX_FIELDS) {
+        reject("payload bounds");
+    }
+    exactFields(payload, ["version", "mode", "appBasePath", "serviceWorker", "controllerBridge", "limits"], "scope");
+    if (payload.version !== undefined && payload.version !== 2)
+        reject("version");
+    const appBasePath = optionalAppBasePath(payload.appBasePath);
+    const limits = optionalLimits(payload.limits);
+    if (payload.mode === "service_worker") {
+        if (!isRecord(payload.serviceWorker) || payload.controllerBridge !== undefined)
+            reject("serviceWorker");
+        exactFields(payload.serviceWorker, ["scriptUrl", "scope"], "serviceWorker");
+        const result = {
+            mode: "service_worker",
+            ...(appBasePath === undefined ? {} : { appBasePath }),
+            serviceWorker: Object.freeze({
+                scriptUrl: nonEmpty("serviceWorker.scriptUrl", payload.serviceWorker.scriptUrl),
+                scope: nonEmpty("serviceWorker.scope", payload.serviceWorker.scope),
+            }),
+            ...(limits === undefined ? {} : { limits }),
+        };
+        return Object.freeze(result);
+    }
+    if (payload.mode === "controller_bridge") {
+        if (!isRecord(payload.controllerBridge) || payload.serviceWorker !== undefined)
+            reject("controllerBridge");
+        exactFields(payload.controllerBridge, ["allowedOrigins"], "controllerBridge");
+        const result = {
+            mode: "controller_bridge",
+            ...(appBasePath === undefined ? {} : { appBasePath }),
+            controllerBridge: Object.freeze({ allowedOrigins: allowedOrigins(payload.controllerBridge.allowedOrigins) }),
+            ...(limits === undefined ? {} : { limits }),
+        };
+        return Object.freeze(result);
+    }
+    reject("mode");
+}

package/dist/proxy/serviceWorker.d.ts

@@ -2,22 +2,11 @@ export type ProxyServiceWorkerPassthroughOptions = Readonly<{
     paths?: readonly string[];
     prefixes?: readonly string[];
 }>;
-export type ProxyServiceWorkerInjectHTMLInlineModule = Readonly<{
-    mode?: "inline_module";
-    proxyModuleUrl: string;
+export type ProxyServiceWorkerInjectHTMLOptions = Readonly<{
+    mode?: "inline_module" | "external_script" | "external_module";
+    proxyModuleUrl?: string;
+    scriptUrl?: string;
     runtimeGlobal?: string;
-}>;
-export type ProxyServiceWorkerInjectHTMLExternalScript = Readonly<{
-    mode: "external_script";
-    scriptUrl: string;
-    runtimeGlobal?: string;
-}>;
-export type ProxyServiceWorkerInjectHTMLExternalModule = Readonly<{
-    mode: "external_module";
-    scriptUrl: string;
-    runtimeGlobal?: string;
-}>;
-export type ProxyServiceWorkerInjectHTMLOptions = (ProxyServiceWorkerInjectHTMLInlineModule | ProxyServiceWorkerInjectHTMLExternalScript | ProxyServiceWorkerInjectHTMLExternalModule) & Readonly<{
     excludePathPrefixes?: readonly string[];
     stripValidatorHeaders?: boolean;
     setNoStore?: boolean;
@@ -39,4 +28,4 @@ export type ProxyServiceWorkerScriptOptions = Readonly<{
         keepScriptPathSuffixes?: readonly string[];
     }>;
 }>;
-export declare function createProxyServiceWorkerScript(opts?: ProxyServiceWorkerScriptOptions): string;
+export declare function createProxyServiceWorkerScript(options?: ProxyServiceWorkerScriptOptions): string;