@prosopo/cli 3.6.74 → 3.6.75

package/dist/cjs/prosopo.config.cjs

@@ -1,140 +1,116 @@
-"use strict";
-const logger = require("@prosopo/logger");
-const types = require("@prosopo/types");
-const RateLimiter = require("./RateLimiter.cjs");
-const process_env = require("./process.env.cjs");
-var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+const require_RateLimiter = require("./RateLimiter.cjs");
+const require_process_env = require("./process.env.cjs");
+let _prosopo_logger = require("@prosopo/logger");
+let _prosopo_types = require("@prosopo/types");
+//#region src/prosopo.config.ts
 function getMongoURI() {
-  const protocol = process.env.PROSOPO_DATABASE_PROTOCOL || "mongodb";
-  const mongoSrv = protocol === "mongodb+srv";
-  const password = process.env.PROSOPO_DATABASE_PASSWORD || "root";
-  const username = process.env.PROSOPO_DATABASE_USERNAME || "root";
-  const host = process.env.PROSOPO_DATABASE_HOST || "localhost";
-  const port = mongoSrv ? "" : `:${process.env.PROSOPO_DATABASE_PORT || 27017}`;
-  const retries = mongoSrv ? "?retryWrites=true&w=majority" : "";
-  const mongoURI = `${protocol}://${username}:${password}@${host}${port}/${retries}`;
-  return mongoURI;
+	const protocol = process.env.PROSOPO_DATABASE_PROTOCOL || "mongodb";
+	const mongoSrv = protocol === "mongodb+srv";
+	const password = process.env.PROSOPO_DATABASE_PASSWORD || "root";
+	return `${protocol}://${process.env.PROSOPO_DATABASE_USERNAME || "root"}:${password}@${process.env.PROSOPO_DATABASE_HOST || "localhost"}${mongoSrv ? "" : `:${process.env.PROSOPO_DATABASE_PORT || 27017}`}/${mongoSrv ? "?retryWrites=true&w=majority" : ""}`;
 }
-const getLRules = () => {
-  if (!process.env.L_RULES) {
-    return {};
-  }
-  try {
-    return JSON.parse(process.env.L_RULES);
-  } catch (e) {
-    return {};
-  }
+var getLRules = () => {
+	if (!process.env.L_RULES) return {};
+	try {
+		return JSON.parse(process.env.L_RULES);
+	} catch (e) {
+		return {};
+	}
 };
-const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
-const getDnsServers = () => {
-  if (!process.env.PROSOPO_DNS_SERVERS) {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(process.env.PROSOPO_DNS_SERVERS);
-    if (isStringArray(parsed)) {
-      return parsed;
-    }
-    return void 0;
-  } catch (e) {
-    return void 0;
-  }
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+var getDnsServers = () => {
+	if (!process.env.PROSOPO_DNS_SERVERS) return;
+	try {
+		const parsed = JSON.parse(process.env.PROSOPO_DNS_SERVERS);
+		if (isStringArray(parsed)) return parsed;
+		return;
+	} catch (e) {
+		return;
+	}
 };
-const getSpamEmailDomainsUrls = () => {
-  if (!process.env.SPAM_EMAIL_DOMAINS_URLS) {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(process.env.SPAM_EMAIL_DOMAINS_URLS);
-    if (isStringArray(parsed)) {
-      return parsed;
-    }
-    return void 0;
-  } catch (e) {
-    return void 0;
-  }
+var getSpamEmailDomainsUrls = () => {
+	if (!process.env.SPAM_EMAIL_DOMAINS_URLS) return;
+	try {
+		const parsed = JSON.parse(process.env.SPAM_EMAIL_DOMAINS_URLS);
+		if (isStringArray(parsed)) return parsed;
+		return;
+	} catch (e) {
+		return;
+	}
 };
-const getHost = () => {
-  const importMeta = { url: typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("prosopo.config.cjs", document.baseURI).href };
-  return process.env.CADDY_DOMAIN || importMeta.env?.VITE_CADDY_DOMAIN;
+var getHost = () => {
+	return process.env.CADDY_DOMAIN || {}.env?.VITE_CADDY_DOMAIN;
 };
 function getConfig(captchaSolutionsConfig, captchaServeConfig, who = "PROVIDER", admin = "ADMIN") {
-  return types.ProsopoConfigSchema.parse({
-    logLevel: logger.parseLogLevel(process.env.PROSOPO_LOG_LEVEL, "info"),
-    host: getHost(),
-    defaultEnvironment: process.env.PROSOPO_DEFAULT_ENVIRONMENT ? types.EnvironmentTypesSchema.parse(process.env.PROSOPO_DEFAULT_ENVIRONMENT) : types.EnvironmentTypesSchema.enum.development,
-    account: {
-      address: process_env.getAddress(who),
-      password: process_env.getPassword(who),
-      secret: process_env.getSecret(who)
-    },
-    database: {
-      development: {
-        type: types.DatabaseTypes.enum.provider,
-        endpoint: getMongoURI(),
-        dbname: process.env.PROSOPO_DATABASE_NAME,
-        authSource: process.env.PROSOPO_DATABASE_AUTH_SOURCE
-      },
-      staging: {
-        type: types.DatabaseTypes.enum.provider,
-        endpoint: getMongoURI(),
-        dbname: process.env.PROSOPO_DATABASE_NAME,
-        authSource: process.env.PROSOPO_DATABASE_AUTH_SOURCE
-      },
-      production: {
-        type: types.DatabaseTypes.enum.provider,
-        endpoint: getMongoURI(),
-        dbname: process.env.PROSOPO_DATABASE_NAME,
-        authSource: process.env.PROSOPO_DATABASE_AUTH_SOURCE
-      }
-    },
-    server: {
-      baseURL: process.env.PROSOPO_API_BASE_URL || "http://localhost",
-      port: process.env.PROSOPO_API_PORT ? Number.parseInt(process.env.PROSOPO_API_PORT) : 9229
-    },
-    captchaSolutions: captchaSolutionsConfig,
-    captchas: captchaServeConfig,
-    penalties: types.FrictionlessPenalties.parse({
-      PENALTY_OLD_TIMESTAMP: process.env.PENALTY_OLD_TIMESTAMP,
-      PENALTY_ACCESS_RULE: process.env.PENALTY_ACCESS_RULE,
-      PENALTY_UNVERIFIED_HOST: process.env.PENALTY_UNVERIFIED_HOST
-    }),
-    mongoEventsUri: process.env.PROSOPO_MONGO_EVENTS_URI || "",
-    mongoCaptchaUri: process.env.PROSOPO_MONGO_CAPTCHA_URI || "",
-    mongoClientUri: process.env.PROSOPO_MONGO_CLIENT_URI || "",
-    redisConnection: {
-      url: process.env.REDIS_CONNECTION_URL || "",
-      password: process.env.REDIS_CONNECTION_PASSWORD || ""
-    },
-    rateLimits: RateLimiter.getRateLimitConfig(),
-    proxyCount: process.env.PROSOPO_PROXY_COUNT ? Number.parseInt(process.env.PROSOPO_PROXY_COUNT) : 0,
-    scheduledTasks: {
-      captchaScheduler: {
-        schedule: process.env.CAPTCHA_STORAGE_SCHEDULE
-      },
-      clientListScheduler: {
-        schedule: process.env.CLIENT_LIST_SCHEDULE
-      },
-      clientEntropyScheduler: {
-        schedule: process.env.CLIENT_ENTROPY_SCHEDULE
-      },
-      spamEmailDomainsScheduler: {
-        schedule: process.env.SPAM_EMAIL_DOMAINS_SCHEDULE
-      }
-    },
-    lRules: getLRules(),
-    spamEmailDomainsUrls: getSpamEmailDomainsUrls(),
-    authAccount: {
-      address: process_env.getAddress(admin),
-      password: process_env.getPassword(admin),
-      secret: process_env.getSecret(admin)
-    },
-    ipApi: {
-      apiKey: process.env.PROSOPO_IPAPI_KEY,
-      baseUrl: process.env.PROSOPO_IPAPI_URL
-    },
-    maxmindDbPath: process.env.MAXMIND_DB_PATH,
-    dnsServers: getDnsServers()
-  });
+	return _prosopo_types.ProsopoConfigSchema.parse({
+		logLevel: (0, _prosopo_logger.parseLogLevel)(process.env.PROSOPO_LOG_LEVEL, "info"),
+		host: getHost(),
+		defaultEnvironment: process.env.PROSOPO_DEFAULT_ENVIRONMENT ? _prosopo_types.EnvironmentTypesSchema.parse(process.env.PROSOPO_DEFAULT_ENVIRONMENT) : _prosopo_types.EnvironmentTypesSchema.enum.development,
+		account: {
+			address: require_process_env.getAddress(who),
+			password: require_process_env.getPassword(who),
+			secret: require_process_env.getSecret(who)
+		},
+		database: {
+			development: {
+				type: _prosopo_types.DatabaseTypes.enum.provider,
+				endpoint: getMongoURI(),
+				dbname: process.env.PROSOPO_DATABASE_NAME,
+				authSource: process.env.PROSOPO_DATABASE_AUTH_SOURCE
+			},
+			staging: {
+				type: _prosopo_types.DatabaseTypes.enum.provider,
+				endpoint: getMongoURI(),
+				dbname: process.env.PROSOPO_DATABASE_NAME,
+				authSource: process.env.PROSOPO_DATABASE_AUTH_SOURCE
+			},
+			production: {
+				type: _prosopo_types.DatabaseTypes.enum.provider,
+				endpoint: getMongoURI(),
+				dbname: process.env.PROSOPO_DATABASE_NAME,
+				authSource: process.env.PROSOPO_DATABASE_AUTH_SOURCE
+			}
+		},
+		server: {
+			baseURL: process.env.PROSOPO_API_BASE_URL || "http://localhost",
+			port: process.env.PROSOPO_API_PORT ? Number.parseInt(process.env.PROSOPO_API_PORT) : 9229
+		},
+		captchaSolutions: captchaSolutionsConfig,
+		captchas: captchaServeConfig,
+		penalties: _prosopo_types.FrictionlessPenalties.parse({
+			PENALTY_OLD_TIMESTAMP: process.env.PENALTY_OLD_TIMESTAMP,
+			PENALTY_ACCESS_RULE: process.env.PENALTY_ACCESS_RULE,
+			PENALTY_UNVERIFIED_HOST: process.env.PENALTY_UNVERIFIED_HOST
+		}),
+		mongoEventsUri: process.env.PROSOPO_MONGO_EVENTS_URI || "",
+		mongoCaptchaUri: process.env.PROSOPO_MONGO_CAPTCHA_URI || "",
+		mongoClientUri: process.env.PROSOPO_MONGO_CLIENT_URI || "",
+		redisConnection: {
+			url: process.env.REDIS_CONNECTION_URL || "",
+			password: process.env.REDIS_CONNECTION_PASSWORD || ""
+		},
+		rateLimits: require_RateLimiter.getRateLimitConfig(),
+		proxyCount: process.env.PROSOPO_PROXY_COUNT ? Number.parseInt(process.env.PROSOPO_PROXY_COUNT) : 0,
+		scheduledTasks: {
+			captchaScheduler: { schedule: process.env.CAPTCHA_STORAGE_SCHEDULE },
+			clientListScheduler: { schedule: process.env.CLIENT_LIST_SCHEDULE },
+			clientEntropyScheduler: { schedule: process.env.CLIENT_ENTROPY_SCHEDULE },
+			spamEmailDomainsScheduler: { schedule: process.env.SPAM_EMAIL_DOMAINS_SCHEDULE }
+		},
+		lRules: getLRules(),
+		spamEmailDomainsUrls: getSpamEmailDomainsUrls(),
+		authAccount: {
+			address: require_process_env.getAddress(admin),
+			password: require_process_env.getPassword(admin),
+			secret: require_process_env.getSecret(admin)
+		},
+		ipApi: {
+			apiKey: process.env.PROSOPO_IPAPI_KEY,
+			baseUrl: process.env.PROSOPO_IPAPI_URL
+		},
+		maxmindDbPath: process.env.MAXMIND_DB_PATH,
+		dnsServers: getDnsServers()
+	});
 }
-module.exports = getConfig;
+//#endregion
+exports.default = getConfig;

package/dist/cjs/reloader.cjs

@@ -1,63 +1,54 @@
-"use strict";
-const fs = require("node:fs");
-const dotenv = require("@prosopo/dotenv");
-const env = require("@prosopo/env");
-const logger = require("@prosopo/logger");
-const start = require("./start.cjs");
-const log = logger.getLogger(logger.LogLevel.enum.info, "cli");
-class ReloadingAPI {
-  constructor(envPath, config, pair, authAccount, processedArgs) {
-    this._envPath = envPath;
-    this._config = config;
-    this._pair = pair;
-    this._authAccount = authAccount;
-    this._processedArgs = processedArgs;
-    this._restarting = false;
-  }
-  get env() {
-    if (!this._env) {
-      throw new Error("Environment not initialized. Call start() first.");
-    }
-    return this._env;
-  }
-  async start(reloadEnv = false) {
-    log.info(() => ({ msg: "Starting API" }));
-    dotenv.loadEnv();
-    if (!this._env || reloadEnv) {
-      this._env = new env.ProviderEnvironment(
-        this._config,
-        this._pair,
-        this._authAccount
-      );
-    }
-    await this.env.isReady();
-    this.api = await start.start(this.env, !!this._processedArgs.adminApi);
-    if (process.env.NODE_ENV === "development") {
-      this._envWatcher = await this._watchEnv();
-    }
-  }
-  async stop() {
-    log.info(() => ({ msg: "Stopping API" }));
-    return new Promise((resolve) => {
-      if (this.api) {
-        this.api.close(resolve);
-      }
-    });
-  }
-  async _watchEnv() {
-    return fs.watch(this._envPath, async () => {
-      log.info(() => ({
-        data: { restarting: this._restarting },
-        msg: "env file change detected. Restarting"
-      }));
-      if (!this._restarting) {
-        this._restarting = true;
-        await this.stop();
-        dotenv.loadEnv();
-        await this.start(true);
-        this._restarting = false;
-      }
-    });
-  }
-}
-module.exports = ReloadingAPI;
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_start = require("./start.cjs");
+let _prosopo_logger = require("@prosopo/logger");
+let _prosopo_env = require("@prosopo/env");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+let _prosopo_dotenv = require("@prosopo/dotenv");
+//#region src/reloader.ts
+var log = (0, _prosopo_logger.getLogger)(_prosopo_logger.LogLevel.enum.info, "cli");
+var ReloadingAPI = class {
+	constructor(envPath, config, pair, authAccount, processedArgs) {
+		this._envPath = envPath;
+		this._config = config;
+		this._pair = pair;
+		this._authAccount = authAccount;
+		this._processedArgs = processedArgs;
+		this._restarting = false;
+	}
+	get env() {
+		if (!this._env) throw new Error("Environment not initialized. Call start() first.");
+		return this._env;
+	}
+	async start(reloadEnv = false) {
+		log.info(() => ({ msg: "Starting API" }));
+		(0, _prosopo_dotenv.loadEnv)();
+		if (!this._env || reloadEnv) this._env = new _prosopo_env.ProviderEnvironment(this._config, this._pair, this._authAccount);
+		await this.env.isReady();
+		this.api = await require_start.start(this.env, !!this._processedArgs.adminApi);
+		if (process.env.NODE_ENV === "development") this._envWatcher = await this._watchEnv();
+	}
+	async stop() {
+		log.info(() => ({ msg: "Stopping API" }));
+		return new Promise((resolve) => {
+			if (this.api) this.api.close(resolve);
+		});
+	}
+	async _watchEnv() {
+		return node_fs.default.watch(this._envPath, async () => {
+			log.info(() => ({
+				data: { restarting: this._restarting },
+				msg: "env file change detected. Restarting"
+			}));
+			if (!this._restarting) {
+				this._restarting = true;
+				await this.stop();
+				(0, _prosopo_dotenv.loadEnv)();
+				await this.start(true);
+				this._restarting = false;
+			}
+		});
+	}
+};
+//#endregion
+exports.default = ReloadingAPI;

package/dist/cjs/start.cjs

@@ -1,83 +1,61 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const dotenv = require("@prosopo/dotenv");
-const env = require("@prosopo/env");
-const keyring = require("@prosopo/keyring");
-const provider = require("@prosopo/provider");
-const process_env = require("./process.env.cjs");
-const prosopo_config = require("./prosopo.config.cjs");
-async function start(env$1, admin, port) {
-  if (!env$1) {
-    dotenv.loadEnv();
-    process_env.getDB();
-    const secret = process_env.getSecret();
-    const config = prosopo_config(void 0, {
-      solved: { count: 2 },
-      unsolved: { count: 0 }
-    });
-    const pair = keyring.getPair(secret);
-    let authAccount;
-    if (config.authAccount) {
-      authAccount = keyring.getPair(void 0, config.authAccount.address);
-    }
-    env$1 = new env.ProviderEnvironment(config, pair, authAccount);
-  } else {
-    env$1.logger.debug(() => ({
-      msg: "Env already defined",
-      data: {
-        config: env$1?.config
-      }
-    }));
-  }
-  await env$1.isReady();
-  env$1.cleanup();
-  const maintenanceMode = process.env.MAINTENANCE_MODE?.toLowerCase() === "true";
-  if (env$1.pair && !maintenanceMode) {
-    const cronScheduleStorage = env$1.config.scheduledTasks?.captchaScheduler?.schedule;
-    if (cronScheduleStorage) {
-      provider.storeCaptchasExternally(env$1.pair, cronScheduleStorage, env$1.config).catch(
-        (err) => {
-          console.error("Failed to start scheduler:", err);
-        }
-      );
-    }
-    const cronScheduleClient = env$1.config.scheduledTasks?.clientListScheduler?.schedule;
-    if (cronScheduleClient) {
-      provider.getClientList(env$1.pair, cronScheduleClient, env$1.config).catch((err) => {
-        env$1.logger.error(() => ({
-          msg: "Failed to start client list scheduler",
-          err,
-          context: { failedFuncName: provider.getClientList.name }
-        }));
-      });
-    }
-    const cronClientEntropySetter = env$1.config.scheduledTasks?.clientEntropyScheduler?.schedule;
-    if (cronClientEntropySetter) {
-      provider.setClientEntropy(env$1.pair, cronClientEntropySetter, env$1.config).catch(
-        (err) => {
-          env$1.logger.error(() => ({
-            msg: "Failed to start client entropy scheduler",
-            err,
-            context: { failedFuncName: provider.setClientEntropy.name }
-          }));
-        }
-      );
-    }
-    const cronSpamEmailDomains = env$1.config.scheduledTasks?.spamEmailDomainsScheduler?.schedule;
-    if (cronSpamEmailDomains) {
-      provider.updateSpamEmailDomainsScheduler(
-        env$1.pair,
-        cronSpamEmailDomains,
-        env$1.config
-      ).catch((err) => {
-        env$1.logger.error(() => ({
-          msg: "Failed to start spam email domains scheduler",
-          err,
-          context: { failedFuncName: provider.updateSpamEmailDomainsScheduler.name }
-        }));
-      });
-    }
-  }
-  return provider.startProviderApi(env$1, admin, port);
+const require_process_env = require("./process.env.cjs");
+const require_prosopo_config = require("./prosopo.config.cjs");
+let _prosopo_env = require("@prosopo/env");
+let _prosopo_provider = require("@prosopo/provider");
+let _prosopo_dotenv = require("@prosopo/dotenv");
+let _prosopo_keyring = require("@prosopo/keyring");
+//#region src/start.ts
+async function start(env, admin, port) {
+	if (!env) {
+		(0, _prosopo_dotenv.loadEnv)();
+		require_process_env.getDB();
+		const secret = require_process_env.getSecret();
+		const config = require_prosopo_config.default(void 0, {
+			solved: { count: 2 },
+			unsolved: { count: 0 }
+		});
+		const pair = (0, _prosopo_keyring.getPair)(secret);
+		let authAccount;
+		if (config.authAccount) authAccount = (0, _prosopo_keyring.getPair)(void 0, config.authAccount.address);
+		env = new _prosopo_env.ProviderEnvironment(config, pair, authAccount);
+	} else env.logger.debug(() => ({
+		msg: "Env already defined",
+		data: { config: env?.config }
+	}));
+	await env.isReady();
+	env.cleanup();
+	const maintenanceMode = process.env.MAINTENANCE_MODE?.toLowerCase() === "true";
+	if (env.pair && !maintenanceMode) {
+		const cronScheduleStorage = env.config.scheduledTasks?.captchaScheduler?.schedule;
+		if (cronScheduleStorage) (0, _prosopo_provider.storeCaptchasExternally)(env.pair, cronScheduleStorage, env.config).catch((err) => {
+			console.error("Failed to start scheduler:", err);
+		});
+		const cronScheduleClient = env.config.scheduledTasks?.clientListScheduler?.schedule;
+		if (cronScheduleClient) (0, _prosopo_provider.getClientList)(env.pair, cronScheduleClient, env.config).catch((err) => {
+			env.logger.error(() => ({
+				msg: "Failed to start client list scheduler",
+				err,
+				context: { failedFuncName: _prosopo_provider.getClientList.name }
+			}));
+		});
+		const cronClientEntropySetter = env.config.scheduledTasks?.clientEntropyScheduler?.schedule;
+		if (cronClientEntropySetter) (0, _prosopo_provider.setClientEntropy)(env.pair, cronClientEntropySetter, env.config).catch((err) => {
+			env.logger.error(() => ({
+				msg: "Failed to start client entropy scheduler",
+				err,
+				context: { failedFuncName: _prosopo_provider.setClientEntropy.name }
+			}));
+		});
+		const cronSpamEmailDomains = env.config.scheduledTasks?.spamEmailDomainsScheduler?.schedule;
+		if (cronSpamEmailDomains) (0, _prosopo_provider.updateSpamEmailDomainsScheduler)(env.pair, cronSpamEmailDomains, env.config).catch((err) => {
+			env.logger.error(() => ({
+				msg: "Failed to start spam email domains scheduler",
+				err,
+				context: { failedFuncName: _prosopo_provider.updateSpamEmailDomainsScheduler.name }
+			}));
+		});
+	}
+	return (0, _prosopo_provider.startProviderApi)(env, admin, port);
 }
+//#endregion
 exports.start = start;

package/dist/cli.js

@@ -1,43 +1,33 @@
+import { processArgs } from "./argv.js";
+import getConfig from "./prosopo.config.js";
+import ReloadingAPI from "./reloader.js";
+import { LogLevel, getLogger } from "@prosopo/logger";
+import { isMain } from "@prosopo/util";
 import process from "node:process";
 import { loadEnv } from "@prosopo/dotenv";
 import { getPair } from "@prosopo/keyring";
 import { loadI18next } from "@prosopo/locale";
-import { getLogger, LogLevel } from "@prosopo/logger";
-import { isMain } from "@prosopo/util";
-import { processArgs } from "./argv.js";
-import getConfig from "./prosopo.config.js";
-import ReloadingAPI from "./reloader.js";
-const log = getLogger(LogLevel.enum.info, "cli");
+//#region src/cli.ts
+var log = getLogger(LogLevel.enum.info, "cli");
 async function main() {
-  const envPath = loadEnv();
-  const config = getConfig();
-  const pair = getPair(config.account.secret, config.account.address);
-  const authAccount = getPair(
-    config.authAccount.secret,
-    config.authAccount.address
-  );
-  log.info(() => ({ data: { pairAddress: pair.address } }));
-  const processedArgs = await processArgs(
-    process.argv,
-    pair,
-    authAccount,
-    config
-  );
-  log.info(() => ({ data: { cliArgs: processedArgs } }));
-  if (processedArgs.api) {
-    await new ReloadingAPI(envPath, config, pair, authAccount, processedArgs).start().then(() => {
-      log.info(() => ({ msg: "Reloading API started..." }));
-    });
-  } else {
-    process.exit(0);
-  }
-}
-if (isMain(import.meta.url, "provider")) {
-  loadI18next(true).then(() => {
-    main().then(() => {
-      log.info(() => ({ msg: "Running main process..." }));
-    }).catch((error) => {
-      log.error(() => ({ err: error }));
-    });
-  });
+	const envPath = loadEnv();
+	const config = getConfig();
+	const pair = getPair(config.account.secret, config.account.address);
+	const authAccount = getPair(config.authAccount.secret, config.authAccount.address);
+	log.info(() => ({ data: { pairAddress: pair.address } }));
+	const processedArgs = await processArgs(process.argv, pair, authAccount, config);
+	log.info(() => ({ data: { cliArgs: processedArgs } }));
+	if (processedArgs.api) await new ReloadingAPI(envPath, config, pair, authAccount, processedArgs).start().then(() => {
+		log.info(() => ({ msg: "Reloading API started..." }));
+	});
+	else process.exit(0);
 }
+if (isMain(import.meta.url, "provider")) loadI18next(true).then(() => {
+	main().then(() => {
+		log.info(() => ({ msg: "Running main process..." }));
+	}).catch((error) => {
+		log.error(() => ({ err: error }));
+	});
+});
+//#endregion
+export {};

package/dist/commands/ensureExternalIndexes.js

@@ -1,29 +1,27 @@
+import { LogLevel, getLogger } from "@prosopo/logger";
 import { ProviderEnvironment } from "@prosopo/env";
-import { getLogger, LogLevel } from "@prosopo/logger";
 import { Tasks } from "@prosopo/provider";
-const commandEnsureExternalIndexes = (pair, config, cmdArgs) => {
-  const logger = cmdArgs?.logger || getLogger(LogLevel.enum.info, "cli.ensure_external_indexes");
-  return {
-    command: "ensure_external_indexes",
-    describe: "Ensure indexes for external database",
-    handler: async () => {
-      try {
-        const env = new ProviderEnvironment(config, pair);
-        await env.isReady();
-        const tasks = new Tasks(env);
-        if (!env.config.mongoCaptchaUri) {
-          throw new Error("mongoCaptchaUri not set in config");
-        }
-        await tasks.clientTaskManager.getCaptchaDB(env.config.mongoCaptchaUri).ensureIndexes().catch((err) => {
-          env.logger.error(() => ({ err }));
-        });
-      } catch (err) {
-        logger.error(() => ({ err }));
-      }
-    },
-    middlewares: []
-  };
-};
-export {
-  commandEnsureExternalIndexes as default
+//#region src/commands/ensureExternalIndexes.ts
+var ensureExternalIndexes_default = (pair, config, cmdArgs) => {
+	const logger = cmdArgs?.logger || getLogger(LogLevel.enum.info, "cli.ensure_external_indexes");
+	return {
+		command: "ensure_external_indexes",
+		describe: "Ensure indexes for external database",
+		handler: async () => {
+			try {
+				const env = new ProviderEnvironment(config, pair);
+				await env.isReady();
+				const tasks = new Tasks(env);
+				if (!env.config.mongoCaptchaUri) throw new Error("mongoCaptchaUri not set in config");
+				await tasks.clientTaskManager.getCaptchaDB(env.config.mongoCaptchaUri).ensureIndexes().catch((err) => {
+					env.logger.error(() => ({ err }));
+				});
+			} catch (err) {
+				logger.error(() => ({ err }));
+			}
+		},
+		middlewares: []
+	};
 };
+//#endregion
+export { ensureExternalIndexes_default as default };