@prosopo/provider 4.15.14 → 4.15.16

package/dist/cjs/tasks/spam/evaluateEmailSpamRules.cjs

@@ -1,92 +1,83 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("@prosopo/types");
-const GMAIL_DOMAINS = /* @__PURE__ */ new Set(["gmail.com", "googlemail.com"]);
-const DEFAULT_EMAIL_SPAM_PATTERNS = [
-  // More than 3 dots in the local part of any address (very common
-  // evasion against systems that don't normalise gmail addresses).
-  {
-    name: "many-dots-local-part",
-    pattern: /^[^@]*\.[^@]*\.[^@]*\.[^@]*\.[^@]*@/
-  },
-  // Random alphanumeric suffix tags on gmail (e.g. +vkd38uoukd5).
-  {
-    name: "gmail-random-plus-tag",
-    pattern: /^[^@+]+\+[a-z0-9]{6,}@(gmail|googlemail)\.com$/i
-  }
-];
-const splitEmail = (email) => {
-  const trimmed = email.trim().toLowerCase();
-  const at = trimmed.lastIndexOf("@");
-  if (at <= 0 || at === trimmed.length - 1) {
-    return null;
-  }
-  return { local: trimmed.slice(0, at), domain: trimmed.slice(at + 1) };
+let _prosopo_types = require("@prosopo/types");
+//#region src/tasks/spam/evaluateEmailSpamRules.ts
+var GMAIL_DOMAINS = /* @__PURE__ */ new Set(["gmail.com", "googlemail.com"]);
+var DEFAULT_EMAIL_SPAM_PATTERNS = [{
+	name: "many-dots-local-part",
+	pattern: /^[^@]*\.[^@]*\.[^@]*\.[^@]*\.[^@]*@/
+}, {
+	name: "gmail-random-plus-tag",
+	pattern: /^[^@+]+\+[a-z0-9]{6,}@(gmail|googlemail)\.com$/i
+}];
+var splitEmail = (email) => {
+	const trimmed = email.trim().toLowerCase();
+	const at = trimmed.lastIndexOf("@");
+	if (at <= 0 || at === trimmed.length - 1) return null;
+	return {
+		local: trimmed.slice(0, at),
+		domain: trimmed.slice(at + 1)
+	};
 };
-const normaliseGmailAddress = (email) => {
-  const parts = splitEmail(email);
-  if (!parts) return email.trim().toLowerCase();
-  if (!GMAIL_DOMAINS.has(parts.domain)) {
-    return `${parts.local}@${parts.domain}`;
-  }
-  const stripped = parts.local.replace(/\./g, "").split("+")[0] ?? "";
-  return `${stripped}@gmail.com`;
+/**
+* Removes dots and +tag suffixes from a gmail/googlemail local part.
+* Useful for treating x.y@gmail.com, xy@gmail.com, x.y+tag@gmail.com as the
+* same underlying account.
+*/
+var normaliseGmailAddress = (email) => {
+	const parts = splitEmail(email);
+	if (!parts) return email.trim().toLowerCase();
+	if (!GMAIL_DOMAINS.has(parts.domain)) return `${parts.local}@${parts.domain}`;
+	return `${parts.local.replace(/\./g, "").split("+")[0] ?? ""}@gmail.com`;
 };
-const countDots = (s) => {
-  let n = 0;
-  for (const c of s) if (c === ".") n += 1;
-  return n;
+var countDots = (s) => {
+	let n = 0;
+	for (const c of s) if (c === ".") n += 1;
+	return n;
 };
-const regexCache = /* @__PURE__ */ new Map();
-const getCompiledRegex = (raw) => {
-  const cached = regexCache.get(raw);
-  if (cached !== void 0) {
-    return cached;
-  }
-  let compiled;
-  try {
-    compiled = new RegExp(raw, "i");
-  } catch {
-    compiled = null;
-  }
-  regexCache.set(raw, compiled);
-  return compiled;
+var regexCache = /* @__PURE__ */ new Map();
+var getCompiledRegex = (raw) => {
+	const cached = regexCache.get(raw);
+	if (cached !== void 0) return cached;
+	let compiled;
+	try {
+		compiled = new RegExp(raw, "i");
+	} catch {
+		compiled = null;
+	}
+	regexCache.set(raw, compiled);
+	return compiled;
 };
-const evaluateEmailSpamRules = (email, rules) => {
-  if (!rules || !rules.enabled || !email) {
-    return { isSpam: false };
-  }
-  const parts = splitEmail(email);
-  if (!parts) {
-    return { isSpam: true, reason: types.ResultReason.EMAIL_INVALID };
-  }
-  if (typeof rules.maxLocalPartDots === "number" && countDots(parts.local) > rules.maxLocalPartDots) {
-    return { isSpam: true, reason: types.ResultReason.EMAIL_TOO_MANY_DOTS };
-  }
-  const target = rules.normaliseGmail ? normaliseGmailAddress(`${parts.local}@${parts.domain}`) : `${parts.local}@${parts.domain}`;
-  if (rules.useDefaultPatterns) {
-    for (const { name, pattern } of DEFAULT_EMAIL_SPAM_PATTERNS) {
-      if (pattern.test(`${parts.local}@${parts.domain}`)) {
-        return {
-          isSpam: true,
-          reason: types.ResultReason.EMAIL_MATCHED_DEFAULT_PATTERN,
-          pattern: name
-        };
-      }
-    }
-  }
-  for (const raw of rules.customRegexBlocklist ?? []) {
-    const regex = getCompiledRegex(raw);
-    if (regex?.test(target)) {
-      return {
-        isSpam: true,
-        reason: types.ResultReason.EMAIL_MATCHED_CUSTOM_PATTERN,
-        pattern: raw
-      };
-    }
-  }
-  return { isSpam: false };
+/**
+* Synchronously evaluates an email against a site's email spam rules.
+* Returns { isSpam: false } if the rules are disabled, no email is supplied,
+* or no rule matched.
+*/
+var evaluateEmailSpamRules = (email, rules) => {
+	if (!rules || !rules.enabled || !email) return { isSpam: false };
+	const parts = splitEmail(email);
+	if (!parts) return {
+		isSpam: true,
+		reason: _prosopo_types.ResultReason.EMAIL_INVALID
+	};
+	if (typeof rules.maxLocalPartDots === "number" && countDots(parts.local) > rules.maxLocalPartDots) return {
+		isSpam: true,
+		reason: _prosopo_types.ResultReason.EMAIL_TOO_MANY_DOTS
+	};
+	const target = rules.normaliseGmail ? normaliseGmailAddress(`${parts.local}@${parts.domain}`) : `${parts.local}@${parts.domain}`;
+	if (rules.useDefaultPatterns) {
+		for (const { name, pattern } of DEFAULT_EMAIL_SPAM_PATTERNS) if (pattern.test(`${parts.local}@${parts.domain}`)) return {
+			isSpam: true,
+			reason: _prosopo_types.ResultReason.EMAIL_MATCHED_DEFAULT_PATTERN,
+			pattern: name
+		};
+	}
+	for (const raw of rules.customRegexBlocklist ?? []) if (getCompiledRegex(raw)?.test(target)) return {
+		isSpam: true,
+		reason: _prosopo_types.ResultReason.EMAIL_MATCHED_CUSTOM_PATTERN,
+		pattern: raw
+	};
+	return { isSpam: false };
 };
+//#endregion
 exports.DEFAULT_EMAIL_SPAM_PATTERNS = DEFAULT_EMAIL_SPAM_PATTERNS;
 exports.evaluateEmailSpamRules = evaluateEmailSpamRules;
 exports.normaliseGmailAddress = normaliseGmailAddress;

package/dist/cjs/tasks/spam/updateSpamEmailDomains.cjs

@@ -1,58 +1,42 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const fs = require("node:fs");
-const types = require("@prosopo/types");
-const util = require("@prosopo/util");
-const node = require("@prosopo/util/node");
-const CACHE_FILE_PREFIX = "spam-email-domains";
-const CACHE_FILE_TYPE = ".txt";
-const updateSpamEmailDomains = async (db, logger, spamEmailDomainsUrls, cacheDir = "./spam-cache") => {
-  const taskID = await db.createScheduledTaskStatus(
-    types.ScheduledTaskNames.UpdateSpamEmailDomains,
-    types.ScheduledTaskStatus.Running
-  );
-  try {
-    const domainsSet = /* @__PURE__ */ new Set();
-    for (const [index, url] of spamEmailDomainsUrls.entries()) {
-      const filePath = await node.cacheFile(
-        cacheDir,
-        url,
-        logger,
-        `${CACHE_FILE_PREFIX}-${index.toString()}-`,
-        CACHE_FILE_TYPE
-      );
-      const text = fs.readFileSync(filePath, "utf-8");
-      const domains = text.trim().split("\n");
-      for (const domain of domains) {
-        const trimmedDomain = domain.trim().toLowerCase();
-        if (trimmedDomain && !trimmedDomain.startsWith("#") && !trimmedDomain.startsWith("//") && util.validateDomain(trimmedDomain)) {
-          domainsSet.add(trimmedDomain);
-        }
-      }
-    }
-    const ops = Array.from(domainsSet).map((domain) => ({
-      filter: { domain: domain.trim() },
-      update: { domain: domain.trim() }
-    }));
-    await db.bulkUpdateSpamEmailDomains(ops, true);
-    await db.updateScheduledTaskStatus(taskID, types.ScheduledTaskStatus.Completed, {
-      data: {
-        domainsProcessed: domainsSet.size
-      }
-    });
-    logger.info(() => ({
-      msg: "Successfully updated spam email domains.",
-      data: { domainsProcessed: domainsSet.size }
-    }));
-  } catch (error) {
-    logger.error(() => ({
-      msg: "Error updating spam email domains.",
-      error
-    }));
-    await db.updateScheduledTaskStatus(taskID, types.ScheduledTaskStatus.Failed, {
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+let _prosopo_types = require("@prosopo/types");
+let _prosopo_util = require("@prosopo/util");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+let _prosopo_util_node = require("@prosopo/util/node");
+//#region src/tasks/spam/updateSpamEmailDomains.ts
+var CACHE_FILE_PREFIX = "spam-email-domains";
+var CACHE_FILE_TYPE = ".txt";
+var updateSpamEmailDomains = async (db, logger, spamEmailDomainsUrls, cacheDir = "./spam-cache") => {
+	const taskID = await db.createScheduledTaskStatus(_prosopo_types.ScheduledTaskNames.UpdateSpamEmailDomains, _prosopo_types.ScheduledTaskStatus.Running);
+	try {
+		const domainsSet = /* @__PURE__ */ new Set();
+		for (const [index, url] of spamEmailDomainsUrls.entries()) {
+			const filePath = await (0, _prosopo_util_node.cacheFile)(cacheDir, url, logger, `${CACHE_FILE_PREFIX}-${index.toString()}-`, CACHE_FILE_TYPE);
+			const domains = node_fs.default.readFileSync(filePath, "utf-8").trim().split("\n");
+			for (const domain of domains) {
+				const trimmedDomain = domain.trim().toLowerCase();
+				if (trimmedDomain && !trimmedDomain.startsWith("#") && !trimmedDomain.startsWith("//") && (0, _prosopo_util.validateDomain)(trimmedDomain)) domainsSet.add(trimmedDomain);
+			}
+		}
+		const ops = Array.from(domainsSet).map((domain) => ({
+			filter: { domain: domain.trim() },
+			update: { domain: domain.trim() }
+		}));
+		await db.bulkUpdateSpamEmailDomains(ops, true);
+		await db.updateScheduledTaskStatus(taskID, _prosopo_types.ScheduledTaskStatus.Completed, { data: { domainsProcessed: domainsSet.size } });
+		logger.info(() => ({
+			msg: "Successfully updated spam email domains.",
+			data: { domainsProcessed: domainsSet.size }
+		}));
+	} catch (error) {
+		logger.error(() => ({
+			msg: "Error updating spam email domains.",
+			error
+		}));
+		await db.updateScheduledTaskStatus(taskID, _prosopo_types.ScheduledTaskStatus.Failed, { error: error instanceof Error ? error.message : String(error) });
+		throw error;
+	}
 };
+//#endregion
 exports.updateSpamEmailDomains = updateSpamEmailDomains;

package/dist/cjs/tasks/tasks.cjs

@@ -1,159 +1,108 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-const database = require("@prosopo/database");
-const logger = require("@prosopo/logger");
-const usageCounters = require("../util/usageCounters.cjs");
-const clientTasks = require("./client/clientTasks.cjs");
-const datasetTasks = require("./dataset/datasetTasks.cjs");
-const decisionMachineRunner = require("./decisionMachine/decisionMachineRunner.cjs");
-const frictionlessTasks = require("./frictionless/frictionlessTasks.cjs");
-const imgCaptchaTasks = require("./imgCaptcha/imgCaptchaTasks.cjs");
-const powTasks = require("./powCaptcha/powTasks.cjs");
-const puzzleTasks = require("./puzzleCaptcha/puzzleTasks.cjs");
-let globalWriteQueue = null;
-let flushStarted = false;
-class Tasks {
-  constructor(env, logger$1) {
-    this.env = env;
-    this.config = env.config;
-    this.db = env.getDb();
-    this.captchaConfig = env.config.captchas;
-    this.logger = logger$1 || logger.getLogger(logger.parseLogLevel(env.config.logLevel), "Tasks");
-    if (!env.pair) {
-      throw new common.ProsopoEnvError("DEVELOPER.MISSING_PROVIDER_PAIR", {
-        context: { failedFuncName: "Tasks.constructor" }
-      });
-    }
-    this.pair = env.pair;
-    if (this.config.mongoCaptchaUri && this.db instanceof database.ProviderDatabase && !this.db.hasCentralDbStreamer()) {
-      const streamer = new database.CentralDbStreamer(
-        this.config.mongoCaptchaUri,
-        this.logger
-      );
-      this.db.setCentralDbStreamer(streamer);
-      this.logger.info(() => ({
-        msg: "Central DB streamer initialized for real-time captcha data streaming"
-      }));
-    }
-    this.writeQueue = this.initWriteQueue();
-    this.decisionMachineRunner = new decisionMachineRunner.DecisionMachineRunner(this.db);
-    this.usageCounters = this.initUsageCounters();
-    this.powCaptchaManager = new powTasks.PowCaptchaManager(
-      this.db,
-      this.pair,
-      this.config,
-      this.logger,
-      this.writeQueue,
-      this.usageCounters
-    );
-    this.puzzleCaptchaManager = new puzzleTasks.PuzzleCaptchaManager(
-      this.db,
-      this.pair,
-      this.config,
-      this.logger,
-      this.usageCounters
-    );
-    this.datasetManager = new datasetTasks.DatasetManager(
-      this.config,
-      this.logger,
-      this.captchaConfig,
-      this.db
-    );
-    this.imgCaptchaManager = new imgCaptchaTasks.ImgCaptchaManager(
-      this.db,
-      this.pair,
-      this.config,
-      this.logger,
-      this.writeQueue,
-      this.usageCounters
-    );
-    this.clientTaskManager = new clientTasks.ClientTaskManager(
-      this.config,
-      this.logger,
-      this.db
-    );
-    this.frictionlessManager = new frictionlessTasks.FrictionlessManager(
-      this.db,
-      this.pair,
-      this.config,
-      this.logger,
-      this.writeQueue,
-      this.decisionMachineRunner,
-      this.usageCounters
-    );
-  }
-  initUsageCounters() {
-    if (!(this.db instanceof database.ProviderDatabase)) return null;
-    try {
-      return new usageCounters.UsageCounters(this.db.getRedisConnection(), this.logger);
-    } catch {
-      return null;
-    }
-  }
-  initWriteQueue() {
-    if (globalWriteQueue) {
-      return globalWriteQueue;
-    }
-    if (!(this.db instanceof database.ProviderDatabase)) {
-      return null;
-    }
-    try {
-      const redisConnection = this.db.getRedisConnection();
-      globalWriteQueue = new database.RedisWriteQueue(redisConnection, this.logger);
-      if (!flushStarted) {
-        flushStarted = true;
-        const db = this.db;
-        const logger2 = this.logger;
-        globalWriteQueue.startPeriodicFlush(async (queue) => {
-          await Tasks.flushWriteQueue(queue, db, logger2);
-        }, 1e4);
-      }
-      return globalWriteQueue;
-    } catch {
-      this.logger.debug(() => ({
-        msg: "Redis not available for write queue - falling back to direct writes"
-      }));
-      return null;
-    }
-  }
-  /**
-   * Flush queued session records from Redis to MongoDB in bulk.
-   * Called periodically by the write queue timer.
-   *
-   * Note: PoW challenge and pending image commitment records are written
-   * directly to MongoDB (not queued) because verification endpoints need
-   * to read them immediately after creation. Session records are safe to
-   * queue because they are not read in the immediate request path.
-   */
-  static async flushWriteQueue(queue, db, logger2) {
-    const sessionRecords = await queue.drainSessionRecords();
-    if (sessionRecords.length > 0) {
-      logger2.info(() => ({
-        msg: `Flushing ${sessionRecords.length} queued session records to MongoDB`
-      }));
-      for (const { record } of sessionRecords) {
-        try {
-          await db.storeSessionRecord(
-            record
-          );
-        } catch (error) {
-          logger2.error(() => ({
-            msg: "Failed to flush queued session record",
-            err: error
-          }));
-        }
-      }
-    }
-  }
-  setLogger(logger2) {
-    this.logger = logger2;
-    this.powCaptchaManager.logger = logger2;
-    this.puzzleCaptchaManager.logger = logger2;
-    this.datasetManager.logger = logger2;
-    this.imgCaptchaManager.logger = logger2;
-    this.clientTaskManager.logger = logger2;
-    this.frictionlessManager.logger = logger2;
-  }
-}
+const require_usageCounters = require("../util/usageCounters.cjs");
+const require_clientTasks = require("./client/clientTasks.cjs");
+const require_datasetTasks = require("./dataset/datasetTasks.cjs");
+const require_decisionMachineRunner = require("./decisionMachine/decisionMachineRunner.cjs");
+const require_frictionlessTasks = require("./frictionless/frictionlessTasks.cjs");
+const require_imgCaptchaTasks = require("./imgCaptcha/imgCaptchaTasks.cjs");
+const require_powTasks = require("./powCaptcha/powTasks.cjs");
+const require_puzzleTasks = require("./puzzleCaptcha/puzzleTasks.cjs");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_database = require("@prosopo/database");
+let _prosopo_logger = require("@prosopo/logger");
+//#region src/tasks/tasks.ts
+/**
+* Singleton write queue manager.
+* Ensures only one flush timer exists across all Tasks instances.
+*/
+var globalWriteQueue = null;
+var flushStarted = false;
+/**
+* @description Tasks that are shared by the API and CLI
+*/
+var Tasks = class Tasks {
+	constructor(env, logger) {
+		this.env = env;
+		this.config = env.config;
+		this.db = env.getDb();
+		this.captchaConfig = env.config.captchas;
+		this.logger = logger || (0, _prosopo_logger.getLogger)((0, _prosopo_logger.parseLogLevel)(env.config.logLevel), "Tasks");
+		if (!env.pair) throw new _prosopo_common.ProsopoEnvError("DEVELOPER.MISSING_PROVIDER_PAIR", { context: { failedFuncName: "Tasks.constructor" } });
+		this.pair = env.pair;
+		if (this.config.mongoCaptchaUri && this.db instanceof _prosopo_database.ProviderDatabase && !this.db.hasCentralDbStreamer()) {
+			const streamer = new _prosopo_database.CentralDbStreamer(this.config.mongoCaptchaUri, this.logger);
+			this.db.setCentralDbStreamer(streamer);
+			this.logger.info(() => ({ msg: "Central DB streamer initialized for real-time captcha data streaming" }));
+		}
+		this.writeQueue = this.initWriteQueue();
+		this.decisionMachineRunner = new require_decisionMachineRunner.DecisionMachineRunner(this.db);
+		this.usageCounters = this.initUsageCounters();
+		this.powCaptchaManager = new require_powTasks.PowCaptchaManager(this.db, this.pair, this.config, this.logger, this.writeQueue, this.usageCounters);
+		this.puzzleCaptchaManager = new require_puzzleTasks.PuzzleCaptchaManager(this.db, this.pair, this.config, this.logger, this.usageCounters);
+		this.datasetManager = new require_datasetTasks.DatasetManager(this.config, this.logger, this.captchaConfig, this.db);
+		this.imgCaptchaManager = new require_imgCaptchaTasks.ImgCaptchaManager(this.db, this.pair, this.config, this.logger, this.writeQueue, this.usageCounters);
+		this.clientTaskManager = new require_clientTasks.ClientTaskManager(this.config, this.logger, this.db);
+		this.frictionlessManager = new require_frictionlessTasks.FrictionlessManager(this.db, this.pair, this.config, this.logger, this.writeQueue, this.decisionMachineRunner, this.usageCounters);
+	}
+	initUsageCounters() {
+		if (!(this.db instanceof _prosopo_database.ProviderDatabase)) return null;
+		try {
+			return new require_usageCounters.UsageCounters(this.db.getRedisConnection(), this.logger);
+		} catch {
+			return null;
+		}
+	}
+	initWriteQueue() {
+		if (globalWriteQueue) return globalWriteQueue;
+		if (!(this.db instanceof _prosopo_database.ProviderDatabase)) return null;
+		try {
+			const redisConnection = this.db.getRedisConnection();
+			globalWriteQueue = new _prosopo_database.RedisWriteQueue(redisConnection, this.logger);
+			if (!flushStarted) {
+				flushStarted = true;
+				const db = this.db;
+				const logger = this.logger;
+				globalWriteQueue.startPeriodicFlush(async (queue) => {
+					await Tasks.flushWriteQueue(queue, db, logger);
+				}, 1e4);
+			}
+			return globalWriteQueue;
+		} catch {
+			this.logger.debug(() => ({ msg: "Redis not available for write queue - falling back to direct writes" }));
+			return null;
+		}
+	}
+	/**
+	* Flush queued session records from Redis to MongoDB in bulk.
+	* Called periodically by the write queue timer.
+	*
+	* Note: PoW challenge and pending image commitment records are written
+	* directly to MongoDB (not queued) because verification endpoints need
+	* to read them immediately after creation. Session records are safe to
+	* queue because they are not read in the immediate request path.
+	*/
+	static async flushWriteQueue(queue, db, logger) {
+		const sessionRecords = await queue.drainSessionRecords();
+		if (sessionRecords.length > 0) {
+			logger.info(() => ({ msg: `Flushing ${sessionRecords.length} queued session records to MongoDB` }));
+			for (const { record } of sessionRecords) try {
+				await db.storeSessionRecord(record);
+			} catch (error) {
+				logger.error(() => ({
+					msg: "Failed to flush queued session record",
+					err: error
+				}));
+			}
+		}
+	}
+	setLogger(logger) {
+		this.logger = logger;
+		this.powCaptchaManager.logger = logger;
+		this.puzzleCaptchaManager.logger = logger;
+		this.datasetManager.logger = logger;
+		this.imgCaptchaManager.logger = logger;
+		this.clientTaskManager.logger = logger;
+		this.frictionlessManager.logger = logger;
+	}
+};
+//#endregion
 exports.Tasks = Tasks;