scrapebadger 0.24.1 → 0.25.0

package/dist/index.mjs

@@ -3,7 +3,7 @@ import { EventEmitter } from 'events';
 import WebSocket from 'ws';
 
 // src/internal/version.ts
-var SDK_VERSION = "0.24.1";
+var SDK_VERSION = "0.24.2";
 
 // src/internal/exceptions.ts
 var ScrapeBadgerError = class _ScrapeBadgerError extends Error {
@@ -118,7 +118,8 @@ var WebSocketStreamError = class _WebSocketStreamError extends ScrapeBadgerError
 };
 
 // src/internal/client.ts
-var BaseClient = class {
+var RETRYABLE_STATUS_CODES = [500, 502, 503, 504];
+var BaseClient = class _BaseClient {
   config;
   constructor(config) {
     this.config = config;
@@ -130,6 +131,39 @@ var BaseClient = class {
     const { data } = await this.requestRaw(path, options);
     return data;
   }
+  /**
+   * POST and return the undecoded response body.
+   *
+   * For endpoints that answer with something other than JSON — currently
+   * `/v1/web/scrape` with `raw_content: true`, which returns the scraped body
+   * itself. The normal path funnels a non-JSON response into
+   * `{ detail: await response.text() }`, which both loses the result and, for
+   * a binary payload, corrupts it: `text()` decodes bytes as UTF-8.
+   *
+   * Returns the raw bytes plus the response headers.
+   */
+  async postBinary(path, options = {}) {
+    const url = new URL(path, this.config.baseUrl);
+    const { body, headers = {} } = options;
+    const response = await this.fetchWithTimeout(url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey,
+        "User-Agent": `scrapebadger-node/${SDK_VERSION}`,
+        ...headers
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      await this.handleResponse(response);
+    }
+    return {
+      bytes: new Uint8Array(await response.arrayBuffer()),
+      headers: response.headers,
+      status: response.status
+    };
+  }
   /**
    * Make an HTTP request and return both data and rate limit headers.
    */
@@ -178,7 +212,7 @@ var BaseClient = class {
         return { data, rateLimit };
       } catch (error) {
         lastError = error;
-        if (error instanceof ScrapeBadgerError && !(error instanceof RateLimitError)) {
+        if (!_BaseClient.isRetryable(error)) {
           throw error;
         }
         if (attempt === this.config.maxRetries) {
@@ -305,6 +339,22 @@ var BaseClient = class {
         throw new ScrapeBadgerError(message);
     }
   }
+  /**
+   * Whether a failed request is worth another attempt.
+   *
+   * Retryable: transient server failures (500/502/503/504), request timeouts,
+   * rate limits, and raw network faults thrown by `fetch` itself. Everything
+   * else — auth, validation, not-found, conflict — is final.
+   */
+  static isRetryable(error) {
+    if (error instanceof ServerError) {
+      return RETRYABLE_STATUS_CODES.includes(error.statusCode);
+    }
+    if (error instanceof RateLimitError || error instanceof TimeoutError) {
+      return true;
+    }
+    return !(error instanceof ScrapeBadgerError);
+  }
   /**
    * Sleep for a given duration.
    */
@@ -2458,11 +2508,54 @@ var WebClient = class {
     if (options.aiPrompt !== void 0) body.ai_prompt = options.aiPrompt;
     if (options.rawContent !== void 0) body.raw_content = options.rawContent;
     if (options.skipBotDetection !== void 0) body.skip_bot_detection = options.skipBotDetection;
+    if (options.rawContent) {
+      return this.scrapeRaw(body);
+    }
     return this.client.request("/v1/web/scrape", {
       method: "POST",
       body
     });
   }
+  /**
+   * Run a `rawContent` scrape, whose response is not JSON.
+   *
+   * The normal path funnels a non-JSON response into `{ detail: text }`, so a
+   * raw scrape returned a result with no content — and for a binary target,
+   * `response.text()` decoded the bytes as UTF-8 and destroyed them. Read the
+   * body as bytes and rebuild the metadata from the `X-Scrape-*` headers the
+   * server sends in this mode.
+   */
+  async scrapeRaw(body) {
+    const { bytes, headers, status } = await this.client.postBinary("/v1/web/scrape", {
+      body
+    });
+    const int = (name) => {
+      const parsed = Number.parseInt(headers.get(name) ?? "", 10);
+      return Number.isNaN(parsed) ? 0 : parsed;
+    };
+    const mediaType = ((headers.get("content-type") ?? "").split(";")[0] ?? "").trim().toLowerCase();
+    const isText = mediaType.startsWith("text/") || ["application/json", "application/xml", "image/svg+xml"].includes(mediaType);
+    return {
+      success: headers.get("x-scrape-success") !== "0",
+      url: headers.get("x-scrape-url") ?? (typeof body.url === "string" ? body.url : ""),
+      status_code: int("x-scrape-status-code") || status,
+      content: isText ? new TextDecoder().decode(bytes) : null,
+      content_bytes: bytes,
+      content_base64: null,
+      is_binary: !isText,
+      content_type: mediaType || null,
+      format: headers.get("x-scrape-format") ?? "html",
+      engine_used: headers.get("x-scrape-engine") ?? "",
+      credits_used: int("x-credits-used"),
+      duration_ms: int("x-scrape-duration-ms"),
+      retries_used: int("x-scrape-retries"),
+      content_length: int("x-scrape-content-length") || bytes.length,
+      screenshot_url: null,
+      video_url: null,
+      headers: {},
+      blocking_detected: false
+    };
+  }
   /**
    * Extract structured data from a web page using AI.
    *