@base44-preview/cli 0.1.32-pr.662.e04bb64 → 0.1.32-pr.664.478a865

package/dist/cli/index.js

@@ -253161,10 +253161,6 @@ var STATIC_EGRESS_ENABLED_ENV = "BASE44_STATIC_EGRESS_ENABLED";
 var STATIC_EGRESS_DIAGNOSTIC_LIMIT = 5;
 var staticEgressFetchInstalled = false;
 var staticEgressDiagnosticCount = 0;
-var dedicatedEgressResponses = /* @__PURE__ */ new WeakSet();
-function isDedicatedEgressResponse(response) {
-  return dedicatedEgressResponses.has(response);
-}
 function inputKind(input) {
   if (typeof input === "string") return "string";
   return input instanceof URL ? "url" : "request";
@@ -253266,10 +253262,7 @@ function createRequestScopedStaticEgressFetch(originalFetch, readEnvironment) {
       return originalFetch(input, init);
     }
     logStaticEgressDecision("dedicated", input, binding, enableSecret);
-    return binding.fetch(input, init).then((response) => {
-      dedicatedEgressResponses.add(response);
-      return response;
-    });
+    return binding.fetch(input, init);
   };
 }
 function installStaticEgressFetch() {
@@ -253281,128 +253274,6 @@ function installStaticEgressFetch() {
   staticEgressFetchInstalled = true;
 }
 
-// src/edge-errors.ts
-var EDGE_ERRORS_HEADER = "X-B44-Edge-Errors";
-var MAX_EDGE_ERRORS = 5;
-var MAX_INSPECTED_BODY_BYTES = 8192;
-var BODY_READ_TIMEOUT_MS = 500;
-var PLAIN_TEXT_EDGE_ERROR = /^error code: (\\d{3,4})\\s*$/;
-var UNBRANDED_5XX_PAGE = /<center>cloudflare<\\/center>/i;
-var SAFE_VALUE = /^[\\x20-\\x7e]{1,253}$/;
-function safe(value) {
-  return typeof value === "string" && SAFE_VALUE.test(value) ? value : void 0;
-}
-function parseEdgeErrorBody(body, status) {
-  const plain = PLAIN_TEXT_EDGE_ERROR.exec(body);
-  if (plain) return { code: Number(plain[1]) };
-  if (status >= 500 && UNBRANDED_5XX_PAGE.test(body)) return { code: status };
-  try {
-    const json = JSON.parse(body);
-    if (json === null || typeof json !== "object") return null;
-    const fields = json;
-    if (fields.cloudflare_error !== true || !Number.isInteger(fields.error_code)) return null;
-    return {
-      code: fields.error_code,
-      name: safe(fields.error_name),
-      category: safe(fields.error_category),
-      zone: safe(fields.zone)
-    };
-  } catch {
-    return null;
-  }
-}
-async function readBodyPrefix(response) {
-  if (Number(response.headers.get("content-length")) > MAX_INSPECTED_BODY_BYTES) return null;
-  const reader = response.clone().body?.getReader();
-  if (!reader) return "";
-  const timer = setTimeout(() => reader.cancel().catch(() => {
-  }), BODY_READ_TIMEOUT_MS);
-  const decoder = new TextDecoder();
-  let text = "";
-  let size = 0;
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      size += value.byteLength;
-      if (size > MAX_INSPECTED_BODY_BYTES) return null;
-      text += decoder.decode(value, { stream: true });
-    }
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-    reader.cancel().catch(() => {
-    });
-  }
-  return text + decoder.decode();
-}
-async function readEdgeError(response) {
-  if (response.status < 400 || !response.headers.get("cf-ray")) return null;
-  if (response.headers.get("cf-mitigated") === "challenge") {
-    return { code: response.status, name: "challenge" };
-  }
-  const body = await readBodyPrefix(response);
-  return body === null ? null : parseEdgeErrorBody(body, response.status);
-}
-function targetOrigin(input) {
-  try {
-    const raw = input instanceof URL ? input.href : typeof input === "string" ? input : input.url;
-    return new URL(raw).origin;
-  } catch {
-    return null;
-  }
-}
-async function recordEdgeError(input, response, startedAt) {
-  const store = currentWorkerRuntimeContext();
-  if (!store) return;
-  const body = await readEdgeError(response);
-  const target = targetOrigin(input);
-  if (!body || !target) return;
-  const record = store.edgeErrors ??= { errors: [], dropped: 0 };
-  if (record.errors.length >= MAX_EDGE_ERRORS) {
-    record.dropped += 1;
-    return;
-  }
-  record.errors.push({
-    ...body,
-    target,
-    status: response.status,
-    ray: safe(response.headers.get("cf-ray")) ?? "",
-    egress: isDedicatedEgressResponse(response) ? "dedicated" : "shared",
-    elapsed_ms: Date.now() - startedAt
-  });
-}
-function createEdgeErrorFetch(innerFetch) {
-  return async (input, init) => {
-    const startedAt = Date.now();
-    const response = await innerFetch(input, init);
-    try {
-      await recordEdgeError(input, response, startedAt);
-    } catch {
-    }
-    return response;
-  };
-}
-var edgeErrorFetchInstalled = false;
-function installEdgeErrorFetch() {
-  if (edgeErrorFetchInstalled) return;
-  globalThis.fetch = createEdgeErrorFetch(globalThis.fetch.bind(globalThis));
-  edgeErrorFetchInstalled = true;
-}
-function attachEdgeErrors(response) {
-  const record = currentWorkerRuntimeContext()?.edgeErrors;
-  if (!record || !(response instanceof Response)) return response;
-  if (response.status === 101 || response.webSocket) return response;
-  try {
-    const wrapped = new Response(response.body, response);
-    wrapped.headers.set(EDGE_ERRORS_HEADER, JSON.stringify(record));
-    return wrapped;
-  } catch {
-    return response;
-  }
-}
-
 // src/static-egress-tcp-core.mjs
 function normalizeHost(host) {
   return host.toLowerCase().replace(/^\\[(.*)\\]$/, "$1").replace(/\\.$/, "");
@@ -253531,6 +253402,8 @@ var deno2 = Object.freeze({
 });
 globalThis.Deno = deno2;
 globalThis.Buffer = Buffer2;
+AsyncLocalStorage.prototype.enterWith = () => {
+};
 function getRegisteredHandler() {
   return registeredHandler;
 }
@@ -253556,9 +253429,7 @@ function resolveHandler(functionName) {
   return handler;
 }
 export {
-  attachEdgeErrors,
   getRegisteredHandler,
-  installEdgeErrorFetch,
   installStaticEgressFetch,
   registerLazy,
   resolveHandler
@@ -256603,22 +256474,20 @@ registerLazy(${JSON.stringify(functionName)}, () => import(${JSON.stringify(user
 function buildAppEntrySource(functionModules, telemetry, runtimeSecrets = false) {
   const moduleImports = functionModules.map((file) => `import "./${file}";`).join(`
 `);
-  const handlerExpr = `_b44AttachInvocationLogs(_b44AttachEdgeErrors(${telemetry ? "_b44AttachTelemetry(await handler(request, info))" : "await handler(request, info)"}))`;
+  const handlerExpr = `_b44AttachInvocationLogs(${telemetry ? "_b44AttachTelemetry(await handler(request, info))" : "await handler(request, info)"})`;
   const guard = activationGuard(runtimeSecrets);
   const returnExpr = guard(handlerExpr);
   return `// Auto-generated by the base44 bundler. Do not edit.
 
 import { currentWorkerRuntimeContext as _b44Context, runWithWorkerEnvironment as _b44Run } from ${JSON.stringify(RUNTIME_CONTEXT_SPECIFIER)};
-import { attachEdgeErrors as _b44AttachEdgeErrors, installEdgeErrorFetch, installStaticEgressFetch, resolveHandler } from "./${SHIM_FILENAME}";${activationImport(runtimeSecrets)}
+import { installStaticEgressFetch, resolveHandler } from "./${SHIM_FILENAME}";${activationImport(runtimeSecrets)}
 ${moduleImports}
 
 ${consolePatch(runtimeSecrets)}
 ${INVOCATION_LOGS_PATCH}
-// Static egress reads workerEnv from the active request store. Install it and
-// the edge-error recorder before telemetry so telemetry remains the outermost
-// fetch wrapper.
+// Static egress reads workerEnv from the active request store. Install it
+// before telemetry so telemetry remains the outermost fetch wrapper.
 installStaticEgressFetch();
-installEdgeErrorFetch();
 ${telemetry ? TELEMETRY_PATCH : ""}
 
 export default {
@@ -261124,6 +260993,97 @@ function runtimeVirtualPlugin() {
   };
 }
 
+// ../functions-compiler/src/esbuild/ws-native-virtual.ts
+var NAMESPACE4 = "base44-ws-native";
+var WS_SPECIFIER = /^(npm:)?ws(@[^/]+)?$/;
+var ADAPTER = `"use strict";
+const toBuffer = (value) => (globalThis.Buffer ? globalThis.Buffer.from(value) : value);
+class WebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  #socket;
+  #listeners = new Map();
+  constructor(address, protocols) {
+    this.#socket = new globalThis.WebSocket(String(address), typeof protocols === "string" || Array.isArray(protocols) ? protocols : undefined);
+    try { this.#socket.binaryType = "arraybuffer"; } catch {}
+    this.#socket.addEventListener("open", () => this.emit("open"));
+    this.#socket.addEventListener("message", (event) => {
+      const isBinary = typeof event.data !== "string";
+      this.emit("message", toBuffer(isBinary ? new Uint8Array(event.data) : event.data), isBinary);
+    });
+    this.#socket.addEventListener("error", (event) => this.emit("error", event.error ?? new Error(event.message || "WebSocket error")));
+    this.#socket.addEventListener("close", (event) => this.emit("close", event.code, toBuffer(event.reason ?? "")));
+  }
+  get readyState() { return this.#socket.readyState; }
+  get url() { return this.#socket.url; }
+  get protocol() { return this.#socket.protocol; }
+  on(name, listener) { return this.#add(name, listener, false); }
+  addListener(name, listener) { return this.#add(name, listener, false); }
+  once(name, listener) { return this.#add(name, listener, true); }
+  off(name, listener) { return this.removeListener(name, listener); }
+  removeListener(name, listener) {
+    const listeners = this.#listeners.get(name);
+    if (listeners) this.#listeners.set(name, listeners.filter((entry) => entry.listener !== listener));
+    return this;
+  }
+  removeAllListeners(name) {
+    if (name === undefined) this.#listeners.clear();
+    else this.#listeners.delete(name);
+    return this;
+  }
+  emit(name, ...args) {
+    const listeners = this.#listeners.get(name) ?? [];
+    this.#listeners.set(name, listeners.filter((entry) => !entry.once));
+    for (const entry of listeners) entry.listener.apply(this, args);
+    return listeners.length > 0;
+  }
+  send(data, options, callback) {
+    const done = typeof options === "function" ? options : callback;
+    try {
+      this.#socket.send(data);
+      done?.();
+    } catch (error) {
+      if (!done) throw error;
+      done(error);
+    }
+  }
+  close(code, reason) { this.#socket.close(code, reason); }
+  terminate() { this.#socket.close(); }
+  #add(name, listener, once) {
+    const listeners = this.#listeners.get(name) ?? [];
+    listeners.push({ listener, once });
+    this.#listeners.set(name, listeners);
+    return this;
+  }
+}
+class WebSocketServer {
+  constructor() {
+    throw new Error("ws WebSocketServer is not available in Base44 functions: a function can open WebSocket connections but cannot listen for them.");
+  }
+}
+module.exports = WebSocket;
+module.exports.WebSocket = WebSocket;
+module.exports.WebSocketServer = WebSocketServer;
+module.exports.default = WebSocket;
+`;
+function wsNativeVirtualPlugin() {
+  return {
+    name: "base44-ws-native",
+    setup(build) {
+      build.onResolve({ filter: WS_SPECIFIER }, () => ({
+        path: "ws",
+        namespace: NAMESPACE4
+      }));
+      build.onLoad({ filter: /.*/, namespace: NAMESPACE4 }, () => ({
+        contents: ADAPTER,
+        loader: "js"
+      }));
+    }
+  };
+}
+
 // ../functions-compiler/src/deno-bundle.ts
 async function bundleToModule(prepared, nodeModulesDir = "none") {
   const dir = await mkdtemp(path21.join(tmpdir2(), "b44-bundle-"));
@@ -261147,6 +261107,7 @@ async function bundleToModule(prepared, nodeModulesDir = "none") {
         sourcemap: false,
         logLevel: "silent",
         plugins: [
+          wsNativeVirtualPlugin(),
           nodeBuiltinRequirePlugin(),
           userFilesPlugin(prepared.files, prepared.entry),
           privateDataSourcesVirtualPlugin(),
@@ -271535,4 +271496,4 @@ export {
   runCLI
 };
 
-//# debugId=45318CD4F94D8EF364756E2164756E21
+//# debugId=F78FCF622784F43164756E2164756E21