mcp-scraper 0.22.0 → 0.24.0

package/dist/{server-K6C7W7ED.js → server-I5U3OUZZ.js}

@@ -35,7 +35,7 @@ import {
   sanitizeAttempts,
   sanitizeHarvestResult,
   transcribeMediaUrl
-} from "./chunk-3SQTNNGK.js";
+} from "./chunk-SUPUHPJS.js";
 import {
   auditImages,
   buildLinkReport,
@@ -76,7 +76,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-XGIPATLV.js";
-import "./chunk-Q6GSQEE4.js";
+import "./chunk-CDLHUCMT.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -21463,6 +21463,130 @@ ${lines.length ? `${lines.join("\n")}
   };
 }
 
+// src/api/search-console-table-export.ts
+import { randomUUID as randomUUID8 } from "crypto";
+var SEARCH_CONSOLE_TABLE_EXPORT_MAX_ROWS = 5e4;
+var SEARCH_CONSOLE_TABLE_EXPORT_PAGE_SIZE = 2e3;
+var SEARCH_CONSOLE_TABLE_EXPORT_MAX_BYTES = 50 * 1024 * 1024;
+var SEARCH_CONSOLE_TABLE_COLUMNS = [
+  "id",
+  "provider_record_id",
+  "connection_id",
+  "site_url",
+  "permission_level",
+  "date",
+  "query",
+  "page",
+  "country",
+  "device",
+  "clicks",
+  "impressions",
+  "ctr",
+  "position",
+  "captured_at",
+  "content_hash",
+  "created_at",
+  "updated_at"
+];
+var SearchConsoleTableExportValidationError = class extends Error {
+};
+function validateSearchConsoleTableExportRequest(args) {
+  const tableName = typeof args.tableName === "string" ? args.tableName.trim() : "";
+  if (!/^gsc_performance_[a-f0-9]{12}$/.test(tableName)) {
+    throw new SearchConsoleTableExportValidationError("tableName must be a Search Console performance table returned by list_service_connections.");
+  }
+  const allowedColumns = new Set(SEARCH_CONSOLE_TABLE_COLUMNS);
+  const allowedOps = /* @__PURE__ */ new Set(["eq", "neq", "gt", "gte", "lt", "lte", "like", "in"]);
+  const rawFilters = args.filters === void 0 ? [] : args.filters;
+  if (!Array.isArray(rawFilters) || rawFilters.length > 20) {
+    throw new SearchConsoleTableExportValidationError("filters must be an array with at most 20 entries.");
+  }
+  const filters = rawFilters.map((value) => {
+    const filter = value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    if (!filter || typeof filter.column !== "string" || !allowedColumns.has(filter.column) || typeof filter.op !== "string" || !allowedOps.has(filter.op)) {
+      throw new SearchConsoleTableExportValidationError("Each filter must use a documented Search Console table column and supported operator.");
+    }
+    if (filter.op === "in" && !Array.isArray(filter.value)) {
+      throw new SearchConsoleTableExportValidationError("The in filter operator requires an array value.");
+    }
+    return {
+      column: filter.column,
+      op: filter.op,
+      value: filter.value
+    };
+  });
+  let sort;
+  if (args.sort !== void 0) {
+    const raw = args.sort && typeof args.sort === "object" && !Array.isArray(args.sort) ? args.sort : null;
+    if (!raw || typeof raw.column !== "string" || !allowedColumns.has(raw.column) || raw.direction !== void 0 && raw.direction !== "asc" && raw.direction !== "desc") {
+      throw new SearchConsoleTableExportValidationError("sort must use a documented Search Console table column and asc or desc direction.");
+    }
+    sort = {
+      column: raw.column,
+      ...raw.direction ? { direction: raw.direction } : {}
+    };
+  }
+  const maxRows = args.maxRows === void 0 ? 1e4 : Number(args.maxRows);
+  if (!Number.isInteger(maxRows) || maxRows < 1 || maxRows > SEARCH_CONSOLE_TABLE_EXPORT_MAX_ROWS) {
+    throw new SearchConsoleTableExportValidationError(`maxRows must be an integer from 1 to ${SEARCH_CONSOLE_TABLE_EXPORT_MAX_ROWS}.`);
+  }
+  return { tableName, filters, ...sort ? { sort } : {}, maxRows };
+}
+async function exportSearchConsoleTableData(args) {
+  const lines = [];
+  let bytes = 0;
+  let offset = 0;
+  let matchedRows = 0;
+  let stoppedForBytes = false;
+  while (offset < args.maxRows) {
+    const limit = Math.min(SEARCH_CONSOLE_TABLE_EXPORT_PAGE_SIZE, args.maxRows - offset);
+    const page = await args.queryPage({
+      tableName: args.tableName,
+      filters: args.filters,
+      ...args.sort ? { sort: args.sort } : {},
+      limit,
+      offset
+    });
+    if (!page.ok) throw new Error(page.error || "Search Console table query failed.");
+    const rows = Array.isArray(page.rows) ? page.rows : [];
+    matchedRows = Number.isSafeInteger(page.count) && Number(page.count) >= 0 ? Number(page.count) : rows.length;
+    for (const row of rows) {
+      const line = `${JSON.stringify(row)}
+`;
+      const lineBytes = Buffer.byteLength(line);
+      if (bytes + lineBytes > SEARCH_CONSOLE_TABLE_EXPORT_MAX_BYTES) {
+        stoppedForBytes = true;
+        break;
+      }
+      lines.push(line);
+      bytes += lineBytes;
+    }
+    offset += rows.length;
+    if (stoppedForBytes || rows.length < limit || offset >= matchedRows) break;
+  }
+  const exportId = randomUUID8();
+  const artifact = await args.writeArtifact({
+    ownerId: args.ownerId,
+    exportId,
+    filename: `search-console-filtered-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.jsonl`,
+    content: lines.join("")
+  });
+  const complete = lines.length >= matchedRows;
+  const warnings = [];
+  if (!complete && lines.length >= args.maxRows) warnings.push("max_rows_reached");
+  if (stoppedForBytes) warnings.push("artifact_size_limit_reached");
+  warnings.push("search_console_source_returns_top_rows_not_guaranteed_exhaustive");
+  return {
+    ok: true,
+    tableName: args.tableName,
+    rowsExported: lines.length,
+    matchedRows,
+    complete,
+    artifact,
+    warnings
+  };
+}
+
 // src/api/credit-operations.ts
 async function applyMonthlyFreeRefresh(user) {
   return user;
@@ -23781,6 +23905,31 @@ app.post("/schedule-connections/actions/export", auth2, requireIntegrationsTier,
     return scheduleConnectionError(c, err, "Unable to export this connected service.");
   }
 });
+app.post("/schedule-connections/actions/export-search-console-table", auth2, requireIntegrationsTier, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  try {
+    const request = validateSearchConsoleTableExportRequest(body);
+    const { key, error } = await getOrCreateUserMemoryKey(user);
+    if (!key) return c.json({ ok: false, error: error ?? "Memory table access is unavailable." }, 503);
+    const result = await exportSearchConsoleTableData({
+      ownerId: sha256Hex(user.api_key).slice(0, 24),
+      ...request,
+      queryPage: (input) => memoryCall("queryTableTool", input, key),
+      writeArtifact: createConnectedDataArtifact
+    });
+    return c.json(result);
+  } catch (err) {
+    if (err instanceof SearchConsoleTableExportValidationError) {
+      return c.json({ ok: false, error: err.message }, 400);
+    }
+    if (err instanceof Error && err.message === "connected_data_private_blob_not_configured") {
+      return c.json({ ok: false, error: "Private connected-data artifact storage is not configured." }, 503);
+    }
+    console.error("[search-console-table-export]", err instanceof Error ? err.name : "unknown_error");
+    return c.json({ ok: false, error: "Unable to export the persisted Search Console table." }, 502);
+  }
+});
 app.post("/schedule-connections/actions/export-download", auth2, requireIntegrationsTier, async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -25042,4 +25191,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-K6C7W7ED.js.map
+//# sourceMappingURL=server-I5U3OUZZ.js.map