@byteplus-iga-pages/agent 0.0.0-stage → 1.0.4

package/dist/cjs/808.js

@@ -0,0 +1,322 @@
+"use strict";
+exports.ids = [
+    "808"
+];
+exports.modules = {
+    "../data-plane/dist/esm/index.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Ju: ()=>createAuthenticatedSupabaseClient,
+            FM: ()=>fetchRuntimeDataPlaneCredentials,
+            uQ: ()=>getControlPlaneHeaders,
+            R5: ()=>fetchDataPlaneCredentials,
+            ZQ: ()=>DataPlaneCredentialProvider,
+            I7: ()=>ALLOWED_STORE_HOST_SUFFIX,
+            KK: ()=>STORE_TOKEN_ENDPOINT,
+            $Y: ()=>CONTROL_PLANE_BASE_URL,
+            uk: ()=>validateDataPlaneRootUrl,
+            d: ()=>DataPlaneError
+        });
+        const CONTROL_PLANE_BASE_URL = "https://dsa-pages-api-bd.byteintlapi.com";
+        const ALLOWED_STORE_HOST_SUFFIX = ".supabase.aidap-global.ap-southeast-1.bytepluses.com";
+        const CONTROL_PLANE_HEADERS = {};
+        function getControlPlaneHeaders() {
+            return CONTROL_PLANE_HEADERS;
+        }
+        async function postStoreToken(options) {
+            const fetch = options.fetch ?? globalThis.fetch;
+            return fetch(options.endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    ...getControlPlaneHeaders()
+                },
+                body: options.body
+            });
+        }
+        class DataPlaneError extends Error {
+            constructor(code, message, options){
+                super(message);
+                this.name = "DataPlaneError";
+                this.code = code;
+                this.operation = options.operation;
+                this.retryable = options.retryable ?? false;
+                this.requestId = options.requestId;
+                this.status = options.status;
+                this.failureKind = options.failureKind;
+            }
+        }
+        const STORE_TOKEN_ENDPOINT = `${CONTROL_PLANE_BASE_URL}/pages/v1/api/store-token`;
+        const SAFE_REQUEST_ID = /^[A-Za-z0-9._:/-]{1,256}$/;
+        function safeRequestId(value) {
+            const normalized = value.trim();
+            return SAFE_REQUEST_ID.test(normalized) ? normalized : void 0;
+        }
+        function requestIdFrom(envelope) {
+            return "string" == typeof envelope?.log_id ? safeRequestId(envelope.log_id) : void 0;
+        }
+        function credentialErrorForStatus(status, requestId, authenticationFailed = false) {
+            if (401 === status) return new DataPlaneError("unauthenticated", "Data plane authorization failed", {
+                operation: "data-plane.authenticate",
+                requestId,
+                status
+            });
+            if (403 === status) return new DataPlaneError("permission_denied", "Data plane access was denied", {
+                operation: "data-plane.authenticate",
+                requestId,
+                status
+            });
+            if (429 === status) return new DataPlaneError("rate_limited", "Data plane authentication is rate limited", {
+                operation: "data-plane.authenticate",
+                requestId,
+                status,
+                retryable: true
+            });
+            return new DataPlaneError(status >= 500 ? "unavailable" : "internal", status >= 500 ? "Data plane authentication is temporarily unavailable" : "Data plane authentication failed", {
+                operation: "data-plane.authenticate",
+                requestId,
+                status,
+                retryable: status >= 500,
+                ...authenticationFailed ? {
+                    failureKind: "authentication_failed"
+                } : 408 === status || 504 === status ? {
+                    failureKind: "timeout"
+                } : {}
+            });
+        }
+        function validateDataPlaneRootUrl(value, isAllowedHostname) {
+            let url;
+            try {
+                url = new URL(value);
+            } catch  {
+                throw invalidCredentials();
+            }
+            if ("https:" !== url.protocol || "" !== url.username || "" !== url.password || "" !== url.pathname && "/" !== url.pathname || "" !== url.search || "" !== url.hash || !isAllowedHostname(url.hostname)) throw invalidCredentials();
+            return url.origin;
+        }
+        function invalidCredentials(requestId, status) {
+            return new DataPlaneError("internal", "Data plane returned invalid credentials", {
+                operation: "data-plane.authenticate",
+                requestId,
+                status
+            });
+        }
+        async function fetchDataPlaneCredentials(options) {
+            if (!options.token) throw new DataPlaneError("unavailable", "Data plane credentials are unavailable", {
+                operation: "data-plane.authenticate"
+            });
+            const timestamp = (options.now ?? Date.now)();
+            let endpoint;
+            try {
+                endpoint = new URL(options.endpoint);
+            } catch  {
+                throw new DataPlaneError("internal", "Data plane authentication is misconfigured", {
+                    operation: "data-plane.authenticate"
+                });
+            }
+            if ("https:" !== endpoint.protocol || "" !== endpoint.username || "" !== endpoint.password || !options.isAllowedTokenEndpoint(endpoint)) throw new DataPlaneError("internal", "Data plane authentication is misconfigured", {
+                operation: "data-plane.authenticate"
+            });
+            endpoint.searchParams.set("timestamp", String(timestamp));
+            endpoint.searchParams.set("token", options.token);
+            let response;
+            try {
+                response = await postStoreToken({
+                    endpoint,
+                    body: JSON.stringify({}),
+                    fetch: options.fetch
+                });
+            } catch (error) {
+                throw new DataPlaneError("unavailable", "Data plane authentication is temporarily unavailable", {
+                    operation: "data-plane.authenticate",
+                    retryable: true,
+                    ...error?.name === "TimeoutError" ? {
+                        failureKind: "timeout"
+                    } : {}
+                });
+            }
+            let envelope;
+            try {
+                envelope = await response.json();
+            } catch  {
+                if (!response.ok) throw credentialErrorForStatus(response.status);
+                throw new DataPlaneError("internal", "Data plane returned an invalid response", {
+                    operation: "data-plane.authenticate",
+                    status: response.status
+                });
+            }
+            const requestId = requestIdFrom(envelope);
+            if (!response.ok) throw credentialErrorForStatus(response.status, requestId, 400 === response.status && envelope?.error === "鉴权不通过");
+            if ("number" == typeof envelope?.code && 0 !== envelope.code) throw new DataPlaneError("internal", "Data plane returned invalid credentials", {
+                operation: "data-plane.authenticate",
+                requestId,
+                status: response.status,
+                failureKind: "authentication_failed"
+            });
+            const data = envelope?.data;
+            if (envelope?.code !== 0 || "string" != typeof data?.Url || "string" != typeof data.AnonKey || "" === data.AnonKey || "string" != typeof data.Jwt || "" === data.Jwt) throw invalidCredentials(requestId, response.status);
+            let url;
+            try {
+                url = validateDataPlaneRootUrl(data.Url, options.isAllowedHostname);
+            } catch  {
+                throw invalidCredentials(void 0, response.status);
+            }
+            return {
+                url,
+                anonKey: data.AnonKey,
+                jwt: data.Jwt
+            };
+        }
+        function fetchRuntimeDataPlaneCredentials(options) {
+            return fetchDataPlaneCredentials({
+                ...options,
+                endpoint: STORE_TOKEN_ENDPOINT,
+                isAllowedTokenEndpoint: (url)=>{
+                    const allowed = new URL(STORE_TOKEN_ENDPOINT);
+                    return url.origin === allowed.origin && url.pathname === allowed.pathname;
+                },
+                isAllowedHostname: (hostname)=>hostname.endsWith(ALLOWED_STORE_HOST_SUFFIX)
+            });
+        }
+        function credential_provider_invalidCredentials() {
+            return new DataPlaneError("internal", "Data plane returned invalid credentials", {
+                operation: "data-plane.authenticate"
+            });
+        }
+        function readJwtClaims(jwt) {
+            const segments = jwt.split(".");
+            if (3 !== segments.length) throw credential_provider_invalidCredentials();
+            let claims;
+            try {
+                const normalized = segments[1].replace(/-/g, "+").replace(/_/g, "/");
+                const padding = "=".repeat((4 - normalized.length % 4) % 4);
+                claims = JSON.parse(Buffer.from(normalized + padding, "base64").toString());
+            } catch  {
+                throw credential_provider_invalidCredentials();
+            }
+            if (null === claims || "object" != typeof claims || Array.isArray(claims)) throw credential_provider_invalidCredentials();
+            return claims;
+        }
+        function readJwtProjectId(jwt) {
+            const { sub } = readJwtClaims(jwt);
+            if ("string" != typeof sub || !sub.trim() || sub !== sub.trim()) throw credential_provider_invalidCredentials();
+            return sub;
+        }
+        function readJwtTiming(jwt) {
+            const { iat, exp } = readJwtClaims(jwt);
+            if ("number" != typeof iat || !Number.isFinite(iat) || "number" != typeof exp || !Number.isFinite(exp) || exp <= iat) throw credential_provider_invalidCredentials();
+            return {
+                issuedAtMs: 1000 * iat,
+                expiresAtMs: 1000 * exp
+            };
+        }
+        function waitWithSignal(promise, signal) {
+            if (!signal) return promise;
+            if (signal.aborted) return Promise.reject(new DataPlaneError("aborted", "Data plane request was cancelled", {
+                operation: "data-plane.authenticate"
+            }));
+            return new Promise((resolve, reject)=>{
+                const abort = ()=>reject(new DataPlaneError("aborted", "Data plane request was cancelled", {
+                        operation: "data-plane.authenticate"
+                    }));
+                signal.addEventListener("abort", abort, {
+                    once: true
+                });
+                promise.then(resolve, reject).finally(()=>signal.removeEventListener("abort", abort));
+            });
+        }
+        class DataPlaneCredentialProvider {
+            async getValidCredentials(signal) {
+                if (signal?.aborted) throw new DataPlaneError("aborted", "Data plane request was cancelled", {
+                    operation: "data-plane.authenticate"
+                });
+                const current = this.current;
+                if (current && this.now() < current.timing.expiresAtMs) return this.toPublic(current);
+                return this.toPublic(await waitWithSignal(this.refresh(), signal));
+            }
+            async getProjectId(signal) {
+                const credentials = await this.getValidCredentials(signal);
+                return readJwtProjectId(credentials.jwt);
+            }
+            invalidate(jwt) {
+                if (void 0 === jwt || this.current?.jwt === jwt) this.current = void 0;
+            }
+            refresh() {
+                if (this.refreshPromise) return this.refreshPromise;
+                this.refreshPromise = this.fetchCredentials().then((credentials)=>{
+                    const timing = readJwtTiming(credentials.jwt);
+                    if (timing.expiresAtMs <= this.now()) throw credential_provider_invalidCredentials();
+                    const projectId = readJwtProjectId(credentials.jwt);
+                    if (void 0 !== this.projectId && this.projectId !== projectId) throw credential_provider_invalidCredentials();
+                    const next = {
+                        ...credentials,
+                        timing
+                    };
+                    this.projectId = projectId;
+                    this.current = next;
+                    return next;
+                }).catch((error)=>{
+                    if (error instanceof DataPlaneError) throw error;
+                    throw new DataPlaneError("unavailable", "Data plane authentication is temporarily unavailable", {
+                        operation: "data-plane.authenticate",
+                        retryable: true
+                    });
+                }).finally(()=>{
+                    this.refreshPromise = void 0;
+                });
+                return this.refreshPromise;
+            }
+            toPublic(credentials) {
+                return {
+                    url: credentials.url,
+                    anonKey: credentials.anonKey,
+                    jwt: credentials.jwt
+                };
+            }
+            constructor(options){
+                this.fetchCredentials = options.fetchCredentials;
+                this.now = options.now ?? Date.now;
+            }
+        }
+        var dist = __webpack_require__("../../node_modules/.pnpm/@supabase+supabase-js@2.106.2/node_modules/@supabase/supabase-js/dist/index.mjs");
+        function mergeSignals(first, second) {
+            if (!first) return second;
+            if (!second || first === second) return first;
+            return AbortSignal.any([
+                first,
+                second
+            ]);
+        }
+        function createAuthenticatedSupabaseClient(options) {
+            const fetch = options.fetch ?? globalThis.fetch;
+            const scopedFetch = (input, init = {})=>{
+                const headers = new Headers(init.headers);
+                if (void 0 !== options.requestId) headers.set("x-dsa-trace-id", options.requestId);
+                return fetch(input, {
+                    ...init,
+                    headers,
+                    signal: mergeSignals(init.signal, options.signal)
+                });
+            };
+            const realtimeError = options.realtimeError;
+            class DisabledRealtimeTransport {
+                constructor(){
+                    throw realtimeError();
+                }
+            }
+            return (options.createClient ?? dist.U)(options.credentials.url, options.credentials.anonKey, {
+                accessToken: async ()=>options.credentials.jwt,
+                auth: {
+                    autoRefreshToken: false,
+                    persistSession: false,
+                    detectSessionInUrl: false
+                },
+                realtime: {
+                    transport: DisabledRealtimeTransport
+                },
+                global: {
+                    fetch: scopedFetch
+                }
+            });
+        }
+    }
+};