@tradejs/cli 1.0.0

package/dist/scripts/bot.js

@@ -0,0 +1,153 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scripts/bot.ts
+var import_config = require("dotenv/config");
+
+// src/lib/runBot.ts
+var import_lodash = __toESM(require("lodash"));
+var import_connectors = require("@tradejs/node/connectors");
+var import_json = require("@tradejs/core/json");
+var import_strategies = require("@tradejs/node/strategies");
+var import_async = require("@tradejs/core/async");
+var import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
+var import_logger = require("@tradejs/infra/logger");
+var import_redis = require("@tradejs/infra/redis");
+var runBot = async () => {
+  const botResults = [];
+  const preloadStart = (0, import_time.getTimestamp)(import_constants.BOT_PRELOAD_DAYS);
+  const end = (0, import_time.getTimestamp)();
+  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.botsPrefix());
+  const botKeys = keys.filter((key) => key.endsWith(":bots"));
+  await (0, import_async.delay)(5e3);
+  import_logger.logger.log("info", "files count: %s", botKeys.length);
+  for await (const key of botKeys) {
+    const userName = key.split(":")[1];
+    import_logger.logger.log("info", "user: %s", userName);
+    const botConfig = await (0, import_redis.getData)(import_redis.redisKeys.bots(userName));
+    if (import_lodash.default.isEmpty(botConfig)) {
+      import_logger.logger.log("error", "botConfig is empty: %s", userName);
+      continue;
+    }
+    import_logger.logger.log("info", "bots count: %s", botConfig.length);
+    for await (const bot of botConfig) {
+      const { symbol, strategyName, strategyConfig, connectorName, disabled } = bot;
+      import_logger.logger.log("info", "bot %s", symbol);
+      if (disabled) {
+        import_logger.logger.log("error", "bot %s disabled", symbol);
+        continue;
+      }
+      try {
+        const strategyCreator = await (0, import_strategies.getStrategyCreator)(strategyName);
+        if (!strategyCreator) {
+          throw new Error(`Unknown strategy: ${strategyName}`);
+        }
+        const connectorCreator = await (0, import_connectors.getConnectorCreatorByName)(connectorName);
+        if (!connectorCreator) {
+          throw new Error(`Unknown connector: ${connectorName}`);
+        }
+        const connector = await connectorCreator({
+          userName
+        });
+        const binanceConnectorCreator = await (0, import_connectors.getConnectorCreatorByName)(
+          import_connectors.BUILTIN_CONNECTOR_NAMES.Binance
+        );
+        const coinbaseConnectorCreator = await (0, import_connectors.getConnectorCreatorByName)(
+          import_connectors.BUILTIN_CONNECTOR_NAMES.Coinbase
+        );
+        if (!binanceConnectorCreator || !coinbaseConnectorCreator) {
+          throw new Error("Binance/Coinbase connectors are required");
+        }
+        const [binanceConnector, coinbaseConnector] = await Promise.all([
+          binanceConnectorCreator({
+            userName
+          }),
+          coinbaseConnectorCreator({
+            userName
+          })
+        ]);
+        const interval = "15";
+        const data = await connector.kline({
+          symbol,
+          start: preloadStart,
+          end,
+          interval
+        });
+        const [btcData, btcBinanceData, btcCoinbaseData] = await Promise.all([
+          connector.kline({
+            symbol: "BTCUSDT",
+            start: preloadStart,
+            end,
+            interval
+          }),
+          binanceConnector.kline({
+            symbol: "BTCUSDT",
+            start: preloadStart,
+            end,
+            interval
+          }),
+          coinbaseConnector.kline({
+            symbol: "BTCUSDT",
+            start: preloadStart,
+            end,
+            interval
+          })
+        ]);
+        const candle = data.pop();
+        const btcCandle = btcData.pop();
+        const strategy = await strategyCreator({
+          userName,
+          config: strategyConfig,
+          symbol,
+          data,
+          btcData,
+          btcBinanceData,
+          btcCoinbaseData,
+          connector
+        });
+        import_logger.logger.log("info", "strategy created");
+        if (!candle || !btcCandle) {
+          throw new Error("Candle is empty");
+        }
+        const status = await strategy(candle, btcCandle);
+        botResults.push({
+          symbol,
+          status: JSON.stringify(status)
+        });
+      } catch (err) {
+        import_logger.logger.log("error", "bot %s error: %s", bot.symbol, (0, import_json.toJson)(err, false));
+      }
+    }
+  }
+  import_logger.logger.log("info", "botResults: %s", (0, import_json.toJson)(botResults, true));
+  return botResults;
+};
+
+// src/scripts/bot.ts
+var run = async () => {
+  await runBot();
+  process.exit();
+};
+run();

package/dist/scripts/cleanDir.js

@@ -0,0 +1,40 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scripts/cleanDir.ts
+var import_args = __toESM(require("args"));
+var import_cli = require("@tradejs/node/cli");
+import_args.default.option("dir", "Directory clean up", "cache");
+var flags = import_args.default.parse(process.argv);
+var getDir = () => {
+  if (flags.dir) {
+    return `data/${flags.dir}`;
+  }
+  return "data/cache";
+};
+var run = async () => {
+  await (0, import_cli.cleanFiles)(getDir());
+  process.exit();
+};
+run();

package/dist/scripts/cleanRedis.js

@@ -0,0 +1,40 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scripts/cleanRedis.ts
+var import_args = __toESM(require("args"));
+var import_cli = require("@tradejs/node/cli");
+import_args.default.option("area", "Area clean up", "cache");
+var flags = import_args.default.parse(process.argv);
+var getArea = () => {
+  if (flags.area) {
+    return flags.area;
+  }
+  return "cache";
+};
+var run = async () => {
+  await (0, import_cli.cleanRedis)(getArea());
+  process.exit();
+};
+run();

package/dist/scripts/cleanTests.js

@@ -0,0 +1,81 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scripts/cleanTests.ts
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+var import_cli = require("@tradejs/node/cli");
+var import_redis = require("@tradejs/infra/redis");
+import_args.default.option(["U", "user"], "Clean tests for user", "");
+import_args.default.option(["C", "cache"], "Clean only cache keys", false);
+var flags = import_args.default.parse(process.argv);
+var extractUsers = (keys) => {
+  const users = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    const parts = key.split(":");
+    if (parts.length < 2) {
+      continue;
+    }
+    if (parts[0] !== "users" || parts[1] !== "index") {
+      continue;
+    }
+    const userName = (parts[2] ?? "").trim();
+    if (userName) {
+      users.add(userName);
+    }
+  }
+  return Array.from(users).sort();
+};
+var getUsersToClean = async () => {
+  const userName = String(flags.user || "").trim();
+  if (userName) {
+    return [userName];
+  }
+  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.users());
+  return extractUsers(keys);
+};
+var cleanUserTests = async (userName) => {
+  const testsPrefix = `users:${userName}:tests:`;
+  const testsCachePrefix = `users:${userName}:cache:tests:`;
+  if (flags.cache) {
+    console.log(import_chalk.default.yellow(`clean user cache: ${userName}`));
+    await (0, import_cli.cleanRedis)(testsCachePrefix);
+    return;
+  }
+  console.log(import_chalk.default.yellow(`clean user tests: ${userName}`));
+  await (0, import_cli.cleanRedis)(testsPrefix);
+  await (0, import_cli.cleanRedis)(testsCachePrefix);
+};
+var run = async () => {
+  const users = await getUsersToClean();
+  if (users.length === 0) {
+    console.log(import_chalk.default.yellow("No users found to clean tests."));
+    process.exit();
+  }
+  for await (const userName of users) {
+    await cleanUserTests(userName);
+  }
+  process.exit();
+};
+run();

package/dist/scripts/continuity.js

@@ -0,0 +1,183 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scripts/continuity.ts
+var import_args = __toESM(require("args"));
+var import_progress = __toESM(require("progress"));
+var import_chalk = __toESM(require("chalk"));
+var import_connectors = require("@tradejs/node/connectors");
+var import_cli = require("@tradejs/node/cli");
+var import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
+var import_logger = require("@tradejs/infra/logger");
+var import_timescale = require("@tradejs/infra/timescale");
+import_args.default.option(["t", "tickers"], "Selected tickers");
+import_args.default.option(["f", "timeframe"], "Timeframe", 15);
+import_args.default.option(
+  ["p", "provider"],
+  "Data provider: all|bybit|binance|coinbase or comma list",
+  "all"
+);
+import_args.default.option(["U", "user"], "Use user confg", "root");
+var flags = import_args.default.parse(process.argv);
+var interval = Number(flags.timeframe);
+var intervalKey = flags.timeframe.toString();
+var parseProviders = async (value) => {
+  const allProviders = await (0, import_connectors.getAvailableConnectorProviders)();
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw || raw === "all") {
+    return allProviders;
+  }
+  const selected = raw.split(",").map((item) => item.trim()).filter(Boolean);
+  const uniqueSelected = [...new Set(selected)];
+  const invalid = uniqueSelected.filter((item) => !allProviders.includes(item));
+  if (invalid.length) {
+    import_logger.logger.error(
+      "Unknown provider(s): %s. Supported: %s",
+      invalid.join(", "),
+      allProviders.join(", ")
+    );
+    process.exit(1);
+  }
+  return uniqueSelected;
+};
+var findGapInData = (data, expectedMs) => {
+  for (let i = 1; i < data.length; i++) {
+    const prev = data[i - 1];
+    const current = data[i];
+    const diff = current.timestamp - prev.timestamp;
+    if (diff !== expectedMs) {
+      return {
+        prevTs: prev.timestamp,
+        ts: current.timestamp,
+        diffSeconds: Math.floor(diff / 1e3)
+      };
+    }
+  }
+  return null;
+};
+var continuity = async () => {
+  if (!Number.isFinite(interval) || interval <= 0) {
+    import_logger.logger.error("Invalid timeframe: %s", flags.timeframe);
+    process.exit(1);
+  }
+  await (0, import_timescale.waitForDbReady)();
+  const reloadStart = (0, import_time.getTimestamp)(import_constants.PRELOAD_DAYS);
+  const reloadEnd = (0, import_time.getTimestamp)();
+  const providerIds = await parseProviders(flags.provider);
+  const providers = await Promise.all(
+    providerIds.map(async (providerId) => {
+      const connectorName = await (0, import_connectors.getConnectorNameByProvider)(providerId);
+      if (!connectorName) {
+        import_logger.logger.warn(
+          'Skip provider "%s": connector mapping is missing',
+          providerId
+        );
+        return null;
+      }
+      const creator = await (0, import_connectors.getConnectorCreatorByName)(connectorName);
+      if (!creator) {
+        import_logger.logger.warn(
+          'Skip provider "%s": connector "%s" is not registered',
+          providerId,
+          connectorName
+        );
+        return null;
+      }
+      return {
+        id: providerId,
+        name: connectorName,
+        create: creator
+      };
+    })
+  );
+  const activeProviders = providers.filter(Boolean);
+  if (!activeProviders.length) {
+    import_logger.logger.error("No connector providers available");
+    process.exit(1);
+  }
+  for await (const provider of activeProviders) {
+    const connector = await provider.create({
+      userName: flags.user
+    });
+    const tickers = await (0, import_cli.getTickers)(connector, flags.tickers);
+    const bar = new import_progress.default(
+      ":current/:total [:bar][:percent] broken::broken fixed::fixed :eta(s) :symbol",
+      {
+        total: tickers.length,
+        width: 30
+      }
+    );
+    let broken = 0;
+    let fixed = 0;
+    const expectedMs = interval * 60 * 1e3;
+    import_logger.logger.info(import_chalk.default.yellow(`continuity ${provider.name}: ${tickers.length}`));
+    for await (const symbol of tickers) {
+      const data = await connector.kline({
+        symbol,
+        interval: intervalKey,
+        start: reloadStart,
+        end: reloadEnd,
+        silent: true
+      });
+      let gap = findGapInData(data, expectedMs);
+      if (gap) {
+        broken++;
+        import_logger.logger.warn(
+          "[%s] gap %s %s: %s -> %s (%ss)",
+          provider.id,
+          symbol,
+          interval,
+          (0, import_time.formatUnix)(gap.prevTs),
+          (0, import_time.formatUnix)(gap.ts),
+          gap.diffSeconds
+        );
+        await (0, import_timescale.deleteCandles)(symbol, interval);
+        const reloaded = await connector.kline({
+          symbol,
+          interval: intervalKey,
+          start: reloadStart,
+          end: reloadEnd,
+          silent: true
+        });
+        gap = findGapInData(reloaded, expectedMs);
+        if (!gap) {
+          fixed++;
+        }
+      }
+      bar.tick(1, {
+        broken: import_chalk.default.yellow(broken),
+        fixed: import_chalk.default.cyan(fixed),
+        symbol: import_chalk.default.gray(symbol)
+      });
+    }
+    import_logger.logger.info(
+      import_chalk.default.yellow(
+        `[${provider.id}] broken: ${broken}/${tickers.length}, fixed: ${fixed}`
+      )
+    );
+  }
+  process.exit();
+};
+continuity();

package/dist/scripts/derivativesIngest.js

@@ -0,0 +1,107 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/scripts/derivativesIngest.ts
+var import_config = require("dotenv/config");
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+var import_indicators = require("@tradejs/core/indicators");
+var import_timescale = require("@tradejs/infra/timescale");
+var import_connectors = require("@tradejs/connectors");
+import_args.default.example(
+  "yarn ts-node ./src/scripts/derivativesIngest --provider coinalyze --symbols BTCUSDT,ETHUSDT --intervals 15m,1h --days 120",
+  "Ingest market features (derivatives/spread) into Timescale by provider"
+);
+import_args.default.option(["s", "symbols"], "Comma-separated symbols", "BTCUSDT,ETHUSDT");
+import_args.default.option(["t", "intervals"], "Comma-separated intervals: 15m,1h", "15m,1h");
+import_args.default.option(["d", "days"], "Lookback in days", 120);
+import_args.default.option(
+  ["p", "provider"],
+  "Provider name: coinalyze | binance_coinbase_spread",
+  "coinalyze"
+);
+import_args.default.option(["b", "batchDays"], "Request chunk size in days", 7);
+var flags = import_args.default.parse(process.argv);
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var run = async () => {
+  const providerName = String(flags.provider || "coinalyze").trim().toLowerCase();
+  const provider = import_connectors.marketDataProviders[providerName];
+  if (!provider) {
+    throw new Error(`Unsupported provider: ${providerName}`);
+  }
+  const symbols = (0, import_indicators.normalizeCoinalyzeSymbols)(flags.symbols);
+  const intervals = (0, import_indicators.normalizeDerivativesIntervals)(
+    flags.intervals
+  );
+  const days = asInt(flags.days, 120);
+  const batchDays = asInt(flags.batchDays, 7);
+  if (!symbols.length) throw new Error("No symbols provided");
+  if (!intervals.length) throw new Error("No intervals provided");
+  await (0, import_timescale.waitForDbReady)();
+  const now = Date.now();
+  const fromMs = now - days * 24 * 60 * 60 * 1e3;
+  let totalDerivativesRows = 0;
+  let totalSpreadRows = 0;
+  for (const symbol of symbols) {
+    for (const interval of intervals) {
+      let cursor = fromMs;
+      while (cursor < now) {
+        const toMs = Math.min(now, cursor + batchDays * 24 * 60 * 60 * 1e3);
+        process.stdout.write(
+          `\r${import_chalk.default.cyan(providerName)} ${import_chalk.default.yellow(symbol)} ${interval} ${new Date(cursor).toISOString()} .. ${new Date(toMs).toISOString()}   `
+        );
+        const window = await provider.fetchWindow({
+          symbol,
+          interval,
+          fromMs: cursor,
+          toMs
+        });
+        const derivativesRows = window.derivativesRows ?? [];
+        if (derivativesRows.length) {
+          await (0, import_timescale.upsertDerivatives)(derivativesRows);
+          totalDerivativesRows += derivativesRows.length;
+        }
+        const spreadRows = window.spreadRows ?? [];
+        if (spreadRows.length) {
+          await (0, import_timescale.upsertSpreadRows)(spreadRows);
+          totalSpreadRows += spreadRows.length;
+        }
+        cursor = toMs + 1;
+      }
+      process.stdout.write("\n");
+    }
+  }
+  console.log(
+    import_chalk.default.green(
+      `Done. provider=${providerName} derivatives_rows=${totalDerivativesRows} spread_rows=${totalSpreadRows}`
+    )
+  );
+};
+run().catch((error) => {
+  console.error(import_chalk.default.red(`derivativesIngest failed: ${error}`));
+  process.exit(1);
+});