firecrawl 4.21.0 → 4.22.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   require_package
-} from "./chunk-R625SBJY.js";
+} from "./chunk-XWPH5FOQ.js";
 
 // src/v2/utils/httpClient.ts
 import axios from "axios";
@@ -113,6 +113,15 @@ var HttpClient = class {
   delete(endpoint, headers) {
     return this.request({ method: "delete", url: endpoint, headers });
   }
+  patch(endpoint, body, options) {
+    return this.request({
+      method: "patch",
+      url: endpoint,
+      data: body,
+      headers: options?.headers,
+      timeout: options?.timeoutMs
+    });
+  }
   prepareHeaders(idempotencyKey) {
     const headers = {};
     if (idempotencyKey) headers["x-idempotency-key"] = idempotencyKey;
@@ -635,12 +644,13 @@ async function fetchAllPages(http, nextUrl, initial, pagination) {
       break;
     }
     if (!payload?.success) break;
-    for (const d of payload.data || []) {
+    const pageData = Array.isArray(payload.data) ? payload.data : payload.data?.pages || [];
+    for (const d of pageData) {
       if (maxResults != null && docs.length >= maxResults) break;
       docs.push(d);
     }
     if (maxResults != null && docs.length >= maxResults) break;
-    current = payload.next ?? null;
+    current = payload.next ?? (Array.isArray(payload.data) ? null : payload.data?.next) ?? null;
     pageCount += 1;
   }
   return docs;
@@ -1223,6 +1233,126 @@ async function getTokenUsageHistorical(http, byApiKey) {
   }
 }
 
+// src/v2/methods/monitor.ts
+function queryString(params) {
+  if (!params) return "";
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) query.set(key, String(value));
+  }
+  const str = query.toString();
+  return str ? `?${str}` : "";
+}
+function dataOrThrow(res, action) {
+  if (res.status !== 200 || !res.data?.success || res.data.data == null) {
+    throwForBadResponse(res, action);
+  }
+  return res.data.data;
+}
+async function createMonitor(http, request) {
+  try {
+    const res = await http.post("/v2/monitor", request);
+    return dataOrThrow(res, "create monitor");
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "create monitor");
+    throw err;
+  }
+}
+async function listMonitors(http, options) {
+  try {
+    const res = await http.get(
+      `/v2/monitor${queryString(options)}`
+    );
+    return dataOrThrow(res, "list monitors");
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "list monitors");
+    throw err;
+  }
+}
+async function getMonitor(http, monitorId) {
+  try {
+    const res = await http.get(`/v2/monitor/${monitorId}`);
+    return dataOrThrow(res, "get monitor");
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "get monitor");
+    throw err;
+  }
+}
+async function updateMonitor(http, monitorId, request) {
+  try {
+    const res = await http.patch(
+      `/v2/monitor/${monitorId}`,
+      request
+    );
+    return dataOrThrow(res, "update monitor");
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "update monitor");
+    throw err;
+  }
+}
+async function deleteMonitor(http, monitorId) {
+  try {
+    const res = await http.delete(`/v2/monitor/${monitorId}`);
+    if (res.status !== 200 || !res.data?.success) {
+      throwForBadResponse(res, "delete monitor");
+    }
+    return true;
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "delete monitor");
+    throw err;
+  }
+}
+async function runMonitor(http, monitorId) {
+  try {
+    const res = await http.post(
+      `/v2/monitor/${monitorId}/run`,
+      {}
+    );
+    return dataOrThrow(res, "run monitor");
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "run monitor");
+    throw err;
+  }
+}
+async function listMonitorChecks(http, monitorId, options) {
+  try {
+    const res = await http.get(
+      `/v2/monitor/${monitorId}/checks${queryString(options)}`
+    );
+    return dataOrThrow(res, "list monitor checks");
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "list monitor checks");
+    throw err;
+  }
+}
+async function getMonitorCheck(http, monitorId, checkId, options) {
+  try {
+    const { autoPaginate: _autoPaginate, maxPages: _maxPages, maxResults: _maxResults, maxWaitTime: _maxWaitTime, ...query } = options ?? {};
+    const res = await http.get(
+      `/v2/monitor/${monitorId}/checks/${checkId}${queryString(query)}`
+    );
+    const detail = dataOrThrow(res, "get monitor check");
+    const next = res.data?.next ?? detail.next ?? null;
+    const auto = options?.autoPaginate ?? true;
+    if (!auto || !next) {
+      return { ...detail, next };
+    }
+    return {
+      ...detail,
+      pages: await fetchAllPages(
+        http,
+        next,
+        detail.pages || [],
+        options
+      ),
+      next: null
+    };
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "get monitor check");
+    throw err;
+  }
+}
+
 // src/v2/watcher.ts
 import { EventEmitter } from "events";
 var hasGlobalWebSocket = () => {
@@ -1604,6 +1734,55 @@ var FirecrawlClient = class {
   async crawlParamsPreview(url, prompt) {
     return crawlParamsPreview(this.http, url, prompt);
   }
+  // Monitor
+  /**
+   * Create a scheduled monitor.
+   */
+  async createMonitor(request) {
+    return createMonitor(this.http, request);
+  }
+  /**
+   * List monitors for the authenticated team.
+   */
+  async listMonitors(options) {
+    return listMonitors(this.http, options);
+  }
+  /**
+   * Get a monitor by id.
+   */
+  async getMonitor(monitorId) {
+    return getMonitor(this.http, monitorId);
+  }
+  /**
+   * Update a monitor.
+   */
+  async updateMonitor(monitorId, request) {
+    return updateMonitor(this.http, monitorId, request);
+  }
+  /**
+   * Delete a monitor.
+   */
+  async deleteMonitor(monitorId) {
+    return deleteMonitor(this.http, monitorId);
+  }
+  /**
+   * Trigger a manual monitor check.
+   */
+  async runMonitor(monitorId) {
+    return runMonitor(this.http, monitorId);
+  }
+  /**
+   * List checks for a monitor.
+   */
+  async listMonitorChecks(monitorId, options) {
+    return listMonitorChecks(this.http, monitorId, options);
+  }
+  /**
+   * Get a monitor check with paginated page results and inline diffs.
+   */
+  async getMonitorCheck(monitorId, checkId, options) {
+    return getMonitorCheck(this.http, monitorId, checkId, options);
+  }
   // Batch
   /**
    * Start a batch scrape job for multiple URLs (async).
@@ -1809,7 +1988,7 @@ var FirecrawlApp = class {
       if (typeof process !== "undefined" && process.env && process.env.npm_package_version) {
         return process.env.npm_package_version;
       }
-      const packageJson = await import("./package-MRLSD24T.js");
+      const packageJson = await import("./package-VALCXP74.js");
       return packageJson.default.version;
     } catch (error) {
       const isTest = typeof process !== "undefined" && (process.env.JEST_WORKER_ID != null || false);

package/dist/{package-MRLSD24T.js → package-VALCXP74.js}

@@ -1,4 +1,4 @@
 import {
   require_package
-} from "./chunk-R625SBJY.js";
+} from "./chunk-XWPH5FOQ.js";
 export default require_package();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firecrawl",
-  "version": "4.21.0",
+  "version": "4.22.0",
   "description": "JavaScript SDK for Firecrawl API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,7 @@
   "author": "Mendable.ai",
   "license": "MIT",
   "dependencies": {
-    "axios": "1.15.0",
+    "axios": "1.15.2",
     "typescript-event-target": "^1.1.1",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.0"

package/src/__tests__/unit/v2/pagination.test.ts

@@ -1,6 +1,7 @@
 import { describe, test, expect, jest } from "@jest/globals";
 import { getCrawlStatus } from "../../../v2/methods/crawl";
 import { getBatchScrapeStatus } from "../../../v2/methods/batch";
+import { getMonitorCheck } from "../../../v2/methods/monitor";
 
 describe("JS SDK v2 pagination", () => {
   function makeHttp(getImpl: (url: string) => any) {
@@ -64,6 +65,26 @@ describe("JS SDK v2 pagination", () => {
     expect(res.next).toBe("https://api/nextBatch");
   });
 
+  test("monitor check: default autoPaginate aggregates pages and nulls next", async () => {
+    const first = { status: 200, data: { success: true, next: "https://api/m1", data: { id: "check1", monitorId: "mon1", status: "completed", trigger: "manual", billingStatus: "confirmed", summary: {}, createdAt: "now", updatedAt: "now", pages: [{ url: "a", status: "changed" }], next: "https://api/m1" } } };
+    const second = { status: 200, data: { success: true, next: null, data: { pages: [{ url: "b", status: "same" }], next: null } } };
+    const http = makeHttp((url) => {
+      if (url.includes("/v2/monitor/")) return first;
+      return second;
+    });
+    const res = await getMonitorCheck(http, "mon1", "check1");
+    expect(res.pages.length).toBe(2);
+    expect(res.next).toBeNull();
+  });
+
+  test("monitor check: autoPaginate=false returns next", async () => {
+    const first = { status: 200, data: { success: true, next: "https://api/m1", data: { id: "check1", monitorId: "mon1", status: "completed", trigger: "manual", billingStatus: "confirmed", summary: {}, createdAt: "now", updatedAt: "now", pages: [{ url: "a", status: "changed" }], next: "https://api/m1" } } };
+    const http = makeHttp(() => first);
+    const res = await getMonitorCheck(http, "mon1", "check1", { autoPaginate: false });
+    expect(res.pages.length).toBe(1);
+    expect(res.next).toBe("https://api/m1");
+  });
+
   test("crawl: maxWaitTime stops pagination after first page", async () => {
     const first = { status: 200, data: { success: true, status: "completed", completed: 1, total: 5, next: "https://api/n1", data: [{ markdown: "a" }] } };
     const p1 = { status: 200, data: { success: true, next: "https://api/n2", data: [{ markdown: "b" }] } };

package/src/v2/client.ts

@@ -32,6 +32,16 @@ import {
   listBrowsers,
 } from "./methods/browser";
 import { getConcurrency, getCreditUsage, getQueueStatus, getTokenUsage, getCreditUsageHistorical, getTokenUsageHistorical } from "./methods/usage";
+import {
+  createMonitor as createMonitorMethod,
+  deleteMonitor as deleteMonitorMethod,
+  getMonitor as getMonitorMethod,
+  getMonitorCheck as getMonitorCheckMethod,
+  listMonitorChecks as listMonitorChecksMethod,
+  listMonitors as listMonitorsMethod,
+  runMonitor as runMonitorMethod,
+  updateMonitor as updateMonitorMethod,
+} from "./methods/monitor";
 import type {
   Document,
   ParseFile,
@@ -60,6 +70,14 @@ import type {
   ScrapeExecuteRequest,
   ScrapeExecuteResponse,
   ScrapeBrowserDeleteResponse,
+  CreateMonitorRequest,
+  ListMonitorChecksOptions,
+  ListMonitorsOptions,
+  Monitor,
+  MonitorCheck,
+  MonitorCheckDetail,
+  GetMonitorCheckOptions,
+  UpdateMonitorRequest,
 } from "./types";
 import { Watcher } from "./watcher";
 import type { WatcherOptions } from "./watcher";
@@ -276,6 +294,73 @@ export class FirecrawlClient {
     return crawlParamsPreview(this.http, url, prompt);
   }
 
+  // Monitor
+  /**
+   * Create a scheduled monitor.
+   */
+  async createMonitor(request: CreateMonitorRequest): Promise<Monitor> {
+    return createMonitorMethod(this.http, request);
+  }
+
+  /**
+   * List monitors for the authenticated team.
+   */
+  async listMonitors(options?: ListMonitorsOptions): Promise<Monitor[]> {
+    return listMonitorsMethod(this.http, options);
+  }
+
+  /**
+   * Get a monitor by id.
+   */
+  async getMonitor(monitorId: string): Promise<Monitor> {
+    return getMonitorMethod(this.http, monitorId);
+  }
+
+  /**
+   * Update a monitor.
+   */
+  async updateMonitor(
+    monitorId: string,
+    request: UpdateMonitorRequest,
+  ): Promise<Monitor> {
+    return updateMonitorMethod(this.http, monitorId, request);
+  }
+
+  /**
+   * Delete a monitor.
+   */
+  async deleteMonitor(monitorId: string): Promise<boolean> {
+    return deleteMonitorMethod(this.http, monitorId);
+  }
+
+  /**
+   * Trigger a manual monitor check.
+   */
+  async runMonitor(monitorId: string): Promise<MonitorCheck> {
+    return runMonitorMethod(this.http, monitorId);
+  }
+
+  /**
+   * List checks for a monitor.
+   */
+  async listMonitorChecks(
+    monitorId: string,
+    options?: ListMonitorChecksOptions,
+  ): Promise<MonitorCheck[]> {
+    return listMonitorChecksMethod(this.http, monitorId, options);
+  }
+
+  /**
+   * Get a monitor check with paginated page results and inline diffs.
+   */
+  async getMonitorCheck(
+    monitorId: string,
+    checkId: string,
+    options?: GetMonitorCheckOptions,
+  ): Promise<MonitorCheckDetail> {
+    return getMonitorCheckMethod(this.http, monitorId, checkId, options);
+  }
+
   // Batch
   /**
    * Start a batch scrape job for multiple URLs (async).

package/src/v2/methods/monitor.ts

@@ -0,0 +1,181 @@
+import {
+  type CreateMonitorRequest,
+  type ListMonitorsOptions,
+  type ListMonitorChecksOptions,
+  type Monitor,
+  type MonitorCheck,
+  type MonitorCheckDetail,
+  type MonitorCheckPage,
+  type GetMonitorCheckOptions,
+  type UpdateMonitorRequest,
+} from "../types";
+import { HttpClient } from "../utils/httpClient";
+import {
+  throwForBadResponse,
+  normalizeAxiosError,
+} from "../utils/errorHandler";
+import { fetchAllPages } from "../utils/pagination";
+
+type ApiResponse<T> = {
+  success: boolean;
+  data?: T;
+  id?: string;
+  error?: string;
+};
+
+function queryString(params?: Record<string, unknown>): string {
+  if (!params) return "";
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null) query.set(key, String(value));
+  }
+  const str = query.toString();
+  return str ? `?${str}` : "";
+}
+
+function dataOrThrow<T>(res: { status: number; data?: ApiResponse<T> }, action: string): T {
+  if (res.status !== 200 || !res.data?.success || res.data.data == null) {
+    throwForBadResponse(res as any, action);
+  }
+  return res.data.data;
+}
+
+export async function createMonitor(
+  http: HttpClient,
+  request: CreateMonitorRequest,
+): Promise<Monitor> {
+  try {
+    const res = await http.post<ApiResponse<Monitor>>("/v2/monitor", request as any);
+    return dataOrThrow(res, "create monitor");
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "create monitor");
+    throw err;
+  }
+}
+
+export async function listMonitors(
+  http: HttpClient,
+  options?: ListMonitorsOptions,
+): Promise<Monitor[]> {
+  try {
+    const res = await http.get<ApiResponse<Monitor[]>>(
+      `/v2/monitor${queryString(options as Record<string, unknown>)}`,
+    );
+    return dataOrThrow(res, "list monitors");
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "list monitors");
+    throw err;
+  }
+}
+
+export async function getMonitor(
+  http: HttpClient,
+  monitorId: string,
+): Promise<Monitor> {
+  try {
+    const res = await http.get<ApiResponse<Monitor>>(`/v2/monitor/${monitorId}`);
+    return dataOrThrow(res, "get monitor");
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "get monitor");
+    throw err;
+  }
+}
+
+export async function updateMonitor(
+  http: HttpClient,
+  monitorId: string,
+  request: UpdateMonitorRequest,
+): Promise<Monitor> {
+  try {
+    const res = await http.patch<ApiResponse<Monitor>>(
+      `/v2/monitor/${monitorId}`,
+      request as any,
+    );
+    return dataOrThrow(res, "update monitor");
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "update monitor");
+    throw err;
+  }
+}
+
+export async function deleteMonitor(
+  http: HttpClient,
+  monitorId: string,
+): Promise<boolean> {
+  try {
+    const res = await http.delete<ApiResponse<unknown>>(`/v2/monitor/${monitorId}`);
+    if (res.status !== 200 || !res.data?.success) {
+      throwForBadResponse(res, "delete monitor");
+    }
+    return true;
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "delete monitor");
+    throw err;
+  }
+}
+
+export async function runMonitor(
+  http: HttpClient,
+  monitorId: string,
+): Promise<MonitorCheck> {
+  try {
+    const res = await http.post<ApiResponse<MonitorCheck>>(
+      `/v2/monitor/${monitorId}/run`,
+      {},
+    );
+    return dataOrThrow(res, "run monitor");
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "run monitor");
+    throw err;
+  }
+}
+
+export async function listMonitorChecks(
+  http: HttpClient,
+  monitorId: string,
+  options?: ListMonitorChecksOptions,
+): Promise<MonitorCheck[]> {
+  try {
+    const res = await http.get<ApiResponse<MonitorCheck[]>>(
+      `/v2/monitor/${monitorId}/checks${queryString(options as Record<string, unknown>)}`,
+    );
+    return dataOrThrow(res, "list monitor checks");
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "list monitor checks");
+    throw err;
+  }
+}
+
+export async function getMonitorCheck(
+  http: HttpClient,
+  monitorId: string,
+  checkId: string,
+  options?: GetMonitorCheckOptions,
+): Promise<MonitorCheckDetail> {
+  try {
+    const { autoPaginate: _autoPaginate, maxPages: _maxPages, maxResults: _maxResults, maxWaitTime: _maxWaitTime, ...query } = options ?? {};
+    const res = await http.get<ApiResponse<MonitorCheckDetail>>(
+      `/v2/monitor/${monitorId}/checks/${checkId}${queryString(query as Record<string, unknown>)}`,
+    );
+    const detail = dataOrThrow(res, "get monitor check");
+    const next = res.data?.next ?? detail.next ?? null;
+    const auto = options?.autoPaginate ?? true;
+    if (!auto || !next) {
+      return { ...detail, next };
+    }
+
+    return {
+      ...detail,
+      pages: await fetchAllPages<MonitorCheckPage>(
+        http,
+        next,
+        detail.pages || [],
+        options,
+      ),
+      next: null,
+    };
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "get monitor check");
+    throw err;
+  }
+}