@tradejs/cli 1.0.0

package/dist/scripts/selectStrategy.js

@@ -0,0 +1,99 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/selectStrategy.ts
+var selectStrategy_exports = {};
+__export(selectStrategy_exports, {
+  selectStrategy: () => selectStrategy
+});
+module.exports = __toCommonJS(selectStrategy_exports);
+var import_readline = __toESM(require("readline"));
+var import_chalk = __toESM(require("chalk"));
+var import_strategies = require("@tradejs/node/strategies");
+var defaultStrategy = "TrendLine";
+var getStrategyChoices = async () => {
+  try {
+    const loaded = await (0, import_strategies.getAvailableStrategyNames)();
+    if (loaded.length) {
+      return loaded;
+    }
+  } catch (error) {
+    console.warn(`Failed to load strategy list: ${String(error)}`);
+  }
+  return [
+    "Breakout",
+    "MaStrategy",
+    "AdaptiveMomentumRibbon",
+    "TrendLine",
+    "VolumeDivergence"
+  ];
+};
+var selectStrategy = async (promptLabel = "Select strategy") => {
+  const strategies = await getStrategyChoices();
+  const fallbackStrategy = strategies.includes(defaultStrategy) ? defaultStrategy : strategies[0];
+  if (!process.stdin.isTTY) {
+    return fallbackStrategy;
+  }
+  console.log(import_chalk.default.cyan("Available strategies:"));
+  strategies.forEach((name, index) => {
+    const isDefault = name === defaultStrategy;
+    const label = isDefault ? import_chalk.default.green(name) : name;
+    const suffix = isDefault ? import_chalk.default.gray(" (default)") : "";
+    console.log(`  ${import_chalk.default.yellow(String(index + 1))}) ${label}${suffix}`);
+  });
+  const rl = import_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const question = (text) => new Promise((resolve) => rl.question(text, resolve));
+  const answer = await question(
+    `${promptLabel} [${import_chalk.default.green(fallbackStrategy)}]: `
+  );
+  rl.close();
+  const trimmed = answer.trim();
+  if (!trimmed) {
+    return fallbackStrategy;
+  }
+  const asNumber = Number(trimmed);
+  if (Number.isFinite(asNumber) && asNumber >= 1 && asNumber <= strategies.length) {
+    return strategies[asNumber - 1];
+  }
+  const byName = strategies.find(
+    (name) => name.toLowerCase() === trimmed.toLowerCase()
+  );
+  if (byName) {
+    return byName;
+  }
+  console.warn(`Unknown strategy "${trimmed}", using ${fallbackStrategy}.`);
+  return fallbackStrategy;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  selectStrategy
+});

package/dist/scripts/signals.js

@@ -0,0 +1,300 @@
+"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/signals.ts
+var import_config = require("dotenv/config");
+var import_args = __toESM(require("args"));
+var import_progress = __toESM(require("progress"));
+var import_connectors = require("@tradejs/connectors");
+var import_chalk = __toESM(require("chalk"));
+var import_connectors2 = require("@tradejs/node/connectors");
+var import_cli = require("@tradejs/node/cli");
+var import_async = require("@tradejs/core/async");
+var import_constants = require("@tradejs/core/constants");
+var import_strategies = require("@tradejs/node/strategies");
+var import_time = require("@tradejs/core/time");
+var import_logger = require("@tradejs/infra/logger");
+var import_redis = require("@tradejs/infra/redis");
+import_args.default.option(["t", "tickers"], "Selected tickers");
+import_args.default.option(["e", "exclude"], "Exclude tickers from tests");
+import_args.default.option(["l", "tickersLimit"], "Tickers limit");
+import_args.default.option(["f", "timeframe"], "Timeframe", 15);
+import_args.default.option(["m", "makeOrders"], "Make orders");
+import_args.default.option(["N", "notify"], "Send message in Telegram", false);
+import_args.default.option(["S", "skipScreenshots"], "Skip screenshot generation", false);
+import_args.default.option(["u", "updateOnly"], "Only update tickers history", false);
+import_args.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
+import_args.default.option(["L", "showTickersList"], "Just show only ticker list", false);
+import_args.default.option(["c", "chunk"], "Split by chunks, ex. 1/3");
+import_args.default.option(["U", "user"], "Use user confg", "root");
+import_args.default.option(
+  "connector",
+  "Connector provider or name for signals (e.g. bybit, binance, coinbase, custom)",
+  "bybit"
+);
+var PRELOAD_START = (0, import_time.getTimestamp)(import_constants.SIGNALS_PRELOAD_DAYS);
+var flags = import_args.default.parse(process.argv);
+var minTouches = parseInt(flags.points);
+var offset = parseInt(flags.offset);
+var interval = flags.timeframe.toString();
+var resolveStrategyNameByConfigKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) {
+    return null;
+  }
+  const [users, keyUserName, strategiesKey, strategyName, configKey] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || configKey !== "config" || !strategyName) {
+    return null;
+  }
+  return strategyName;
+};
+var loadRuntimeStrategies = async (userName) => {
+  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
+  const configKeys = keys.filter((key) => key.endsWith(":config")).sort((a, b) => a.localeCompare(b));
+  const strategyConfigs = await Promise.all(
+    configKeys.map(async (key) => {
+      const strategyName = resolveStrategyNameByConfigKey(userName, key);
+      if (!strategyName) {
+        return null;
+      }
+      const strategyCreator = await (0, import_strategies.getStrategyCreator)(strategyName);
+      if (!strategyCreator) {
+        import_logger.logger.warn("Skip unknown strategy config key: %s", key);
+        return null;
+      }
+      const strategyConfig = await (0, import_redis.getData)(key, {});
+      return {
+        strategyName,
+        strategyCreator,
+        strategyConfig
+      };
+    })
+  );
+  return strategyConfigs.filter(Boolean);
+};
+var resolveSignalsConnectorName = async (value) => {
+  const connectorName = await (0, import_connectors2.resolveConnectorName)(value);
+  if (connectorName) {
+    return connectorName;
+  }
+  import_logger.logger.warn(
+    'Unknown connector "%s". Fallback to %s.',
+    String(value || "").trim() || String(value),
+    import_connectors2.DEFAULT_CONNECTOR_NAME
+  );
+  return import_connectors2.DEFAULT_CONNECTOR_NAME;
+};
+var findSignals = async (symbol, connector, btcBinanceData, btcCoinbaseData, runtimeStrategies) => {
+  const prevSignals = await (0, import_redis.getKeys)(import_redis.redisKeys.signalsBySymbol(symbol));
+  if (prevSignals.length) {
+    import_logger.logger.info("Exit by signal exists %s", symbol);
+    return null;
+  }
+  const currentTimestamp = (0, import_time.getTimestamp)();
+  const [cachedData, btcCachedData] = await Promise.all([
+    connector.kline({
+      symbol,
+      start: PRELOAD_START,
+      end: currentTimestamp,
+      cacheOnly: true,
+      interval
+    }),
+    connector.kline({
+      symbol: "BTCUSDT",
+      start: PRELOAD_START,
+      end: currentTimestamp,
+      cacheOnly: true,
+      interval
+    })
+  ]);
+  const lastCandle = cachedData.pop();
+  const btcLastCandle = btcCachedData.pop();
+  if (!lastCandle || !btcLastCandle) {
+    return;
+  }
+  for (const runtimeStrategy of runtimeStrategies) {
+    const { strategyName, strategyCreator, strategyConfig } = runtimeStrategy;
+    const strategy = await strategyCreator({
+      userName: flags.user,
+      connector,
+      symbol,
+      data: [...cachedData],
+      btcData: [...btcCachedData],
+      btcBinanceData: [...btcBinanceData],
+      btcCoinbaseData: [...btcCoinbaseData],
+      config: {
+        ...strategyConfig,
+        ENV: "CRON",
+        INTERVAL: interval,
+        MAKE_ORDERS: flags.makeOrders
+      }
+    });
+    const signal = await strategy(lastCandle, btcLastCandle);
+    if (!signal || typeof signal === "string") {
+      continue;
+    }
+    await (0, import_redis.setData)(import_redis.redisKeys.signal(symbol, signal.signalId), signal, {
+      expire: import_constants.TTL_1D
+    });
+    await (0, import_redis.setData)(import_redis.redisKeys.storeSignal(symbol, signal.signalId), signal, {
+      expire: import_constants.TTL_3M
+    });
+    import_logger.logger.info("Signal found %s by strategy %s", symbol, strategyName);
+    return signal;
+  }
+};
+var signals = async () => {
+  const signals2 = new Array();
+  const connectorName = await resolveSignalsConnectorName(flags.connector);
+  const connectorFactory = await (0, import_connectors2.getConnectorCreatorByName)(connectorName);
+  if (!connectorFactory) {
+    throw new Error(`Connector "${connectorName}" is not registered`);
+  }
+  const marketConnector = await connectorFactory({
+    userName: flags.user
+  });
+  let btcBinanceConnector = marketConnector;
+  let btcCoinbaseConnector = marketConnector;
+  if (connectorName.toLowerCase() === import_connectors2.DEFAULT_CONNECTOR_NAME.toLowerCase()) {
+    const binanceFactory = await (0, import_connectors2.getConnectorCreatorByName)(
+      import_connectors.ConnectorNames.Binance
+    );
+    if (binanceFactory) {
+      btcBinanceConnector = await binanceFactory({
+        userName: flags.user
+      });
+    } else {
+      import_logger.logger.warn(
+        "Binance connector is unavailable. Reusing %s.",
+        connectorName
+      );
+    }
+    const coinbaseFactory = await (0, import_connectors2.getConnectorCreatorByName)(
+      import_connectors.ConnectorNames.Coinbase
+    );
+    if (coinbaseFactory) {
+      btcCoinbaseConnector = await coinbaseFactory({
+        userName: flags.user
+      });
+    } else {
+      import_logger.logger.warn(
+        "Coinbase connector is unavailable. Reusing %s.",
+        connectorName
+      );
+    }
+  }
+  const tickers = await (0, import_cli.getTickers)(
+    marketConnector,
+    flags.tickers,
+    flags.exclude,
+    flags.tickersLimit,
+    flags.chunk
+  );
+  if (flags.showTickersList) {
+    console.log(import_chalk.default.gray(JSON.stringify(tickers.sort(), null, 2)));
+    return;
+  }
+  if (!flags.cacheOnly) {
+    await (0, import_cli.update)(marketConnector, interval, tickers);
+    if (btcBinanceConnector !== marketConnector) {
+      await (0, import_cli.update)(btcBinanceConnector, interval, ["BTCUSDT"]);
+    }
+    if (btcCoinbaseConnector !== marketConnector) {
+      await (0, import_cli.update)(btcCoinbaseConnector, interval, ["BTCUSDT"]);
+    }
+  }
+  const currentTimestamp = (0, import_time.getTimestamp)();
+  const [btcBinanceData, btcCoinbaseData] = await Promise.all([
+    btcBinanceConnector.kline({
+      symbol: "BTCUSDT",
+      start: PRELOAD_START,
+      end: currentTimestamp,
+      cacheOnly: true,
+      interval
+    }),
+    btcCoinbaseConnector.kline({
+      symbol: "BTCUSDT",
+      start: PRELOAD_START,
+      end: currentTimestamp,
+      cacheOnly: true,
+      interval
+    })
+  ]);
+  if (flags.updateOnly) {
+    return;
+  }
+  const runtimeStrategies = await loadRuntimeStrategies(flags.user);
+  if (!runtimeStrategies.length) {
+    import_logger.logger.warn(
+      "No strategy configs found by users:%s:strategies:*:config",
+      flags.user
+    );
+    return;
+  }
+  import_logger.logger.info(
+    import_chalk.default.yellow(
+      `loaded strategies: ${runtimeStrategies.map((s) => s.strategyName).join(", ")}`
+    )
+  );
+  const bar = new import_progress.default(
+    ":current/:total [:bar][:percent] :found :eta(s) :symbol",
+    {
+      total: tickers.length,
+      width: 30
+    }
+  );
+  import_logger.logger.info(import_chalk.default.yellow(`tickers: ${tickers.length}`));
+  await (0, import_async.runWithConcurrency)(tickers, 5, async (symbol) => {
+    const signal = await findSignals(
+      symbol,
+      marketConnector,
+      btcBinanceData,
+      btcCoinbaseData,
+      runtimeStrategies
+    );
+    if (signal) {
+      signals2.push(signal);
+    }
+    bar.tick(1, {
+      found: import_chalk.default.cyan(signals2.length),
+      symbol: import_chalk.default.gray(symbol)
+    });
+  });
+  if (!flags.skipScreenshots) {
+    await (0, import_cli.makeScreenshots)(signals2, "15");
+    await (0, import_cli.makeScreenshots)(signals2, "60");
+  }
+  if (flags.notify) {
+    await (0, import_cli.sendToTG)(signals2, "15");
+  }
+  import_logger.logger.info(
+    JSON.stringify(
+      signals2.map((s) => s.symbol),
+      null,
+      2
+    )
+  );
+  process.exit();
+};
+signals();

package/dist/scripts/test-ml.js

@@ -0,0 +1,133 @@
+"use strict";
+
+// src/scripts/test-ml.ts
+var import_config = require("dotenv/config");
+var import_constants = require("@tradejs/core/constants");
+var import_ml = require("@tradejs/infra/ml");
+var import_strategies = require("@tradejs/strategies");
+var now = Date.now();
+var INTERVAL_MIN = 15;
+var CANDLES = import_constants.ML_BASE_CANDLES_WINDOW;
+var makeSeries = (len, base, step = 0.1) => Array.from({ length: len }, (_, i) => base + i * step);
+var makeCandles = (startPrice, startTs) => {
+  const candles = [];
+  let price = startPrice;
+  for (let i = 0; i < CANDLES; i += 1) {
+    const ts = startTs + i * INTERVAL_MIN * 6e4;
+    const delta = (i % 2 === 0 ? 1 : -1) * (0.2 + i * 0.01);
+    const open = price;
+    const close = price + delta;
+    const high = Math.max(open, close) + 0.15;
+    const low = Math.min(open, close) - 0.15;
+    const volume = 1e3 + i * 10;
+    candles.push({
+      open,
+      high,
+      low,
+      close,
+      volume,
+      turnover: volume * close,
+      timestamp: ts,
+      dt: new Date(ts).toISOString()
+    });
+    price = close;
+  }
+  return candles;
+};
+var buildTrendline = (entryTs, price) => ({
+  id: "mock-trendline",
+  mode: "lows",
+  distance: 0.75,
+  touches: [
+    { timestamp: entryTs - 6 * INTERVAL_MIN * 6e4, value: price * 0.985 },
+    { timestamp: entryTs - 3 * INTERVAL_MIN * 6e4, value: price * 0.99 }
+  ],
+  points: [
+    { timestamp: entryTs - 12 * INTERVAL_MIN * 6e4, value: price * 0.98 },
+    { timestamp: entryTs - 2 * INTERVAL_MIN * 6e4, value: price * 0.995 }
+  ]
+});
+var main = async () => {
+  const startTs = now - CANDLES * INTERVAL_MIN * 6e4;
+  const candles = makeCandles(120, startTs);
+  const btcCandles = makeCandles(42e3, startTs);
+  const lastCandle = candles[candles.length - 1];
+  const currentPrice = lastCandle.close;
+  const signal = {
+    signalId: "mock-signal",
+    symbol: "ETHUSDT",
+    interval: String(INTERVAL_MIN),
+    strategy: "TRENDLINE",
+    direction: "LONG",
+    timestamp: lastCandle.timestamp,
+    figures: {
+      trendLine: buildTrendline(lastCandle.timestamp, currentPrice)
+    },
+    prices: {
+      currentPrice,
+      takeProfitPrice: currentPrice * 1.03,
+      stopLossPrice: currentPrice * 0.99,
+      riskRatio: 2.2
+    },
+    indicators: {
+      correlation: 0.18,
+      touches: 6,
+      distance: 0.7,
+      candles15m: candles.slice(-import_constants.ML_BASE_CANDLES_WINDOW),
+      btcCandles15m: btcCandles.slice(-import_constants.ML_BASE_CANDLES_WINDOW),
+      atr: makeSeries(10, 1.2, 0.02),
+      atrPct: makeSeries(10, 1.05, 5e-3),
+      maFast: makeSeries(10, currentPrice * 0.995, 0.01),
+      maMedium: makeSeries(10, currentPrice * 1, 5e-3),
+      maSlow: makeSeries(10, currentPrice * 1.01, 2e-3),
+      bbUpper: makeSeries(10, currentPrice * 1.02, 0.01),
+      bbMiddle: makeSeries(10, currentPrice, 5e-3),
+      bbLower: makeSeries(10, currentPrice * 0.98, 0.01),
+      obv: makeSeries(10, 2e3, 50),
+      smaObv: makeSeries(10, 1950, 45),
+      macd: makeSeries(10, 0.2, 0.01),
+      macdSignal: makeSeries(10, 0.18, 0.01),
+      macdHistogram: makeSeries(10, 0.02, 5e-3),
+      price24hPcnt: makeSeries(10, 1.2, 0.05),
+      price1hPcnt: makeSeries(10, 0.2, 0.02),
+      highPrice1h: makeSeries(10, currentPrice * 1.01, 0.01),
+      lowPrice1h: makeSeries(10, currentPrice * 0.99, 0.01),
+      volume1h: makeSeries(10, 1200, 30),
+      highPrice24h: makeSeries(10, currentPrice * 1.03, 0.02),
+      lowPrice24h: makeSeries(10, currentPrice * 0.97, 0.02),
+      volume24h: makeSeries(10, 8e3, 200)
+    }
+  };
+  const { TRENDLINE, HIGHS, LOWS, ML_THRESHOLD } = import_strategies.trendLineDefaultConfig;
+  const fullRow = (0, import_ml.buildMlTrainingRow)(
+    {
+      signal,
+      context: {
+        strategyName: "TrendLine",
+        strategyConfig: {
+          TRENDLINE_CONFIG: TRENDLINE,
+          HIGHS,
+          LOWS
+        },
+        symbol: signal.symbol
+      }
+    },
+    null
+  );
+  const row = (0, import_ml.trimMlTrainingRowWindows)(fullRow, 5);
+  const features = (0, import_ml.buildMlFeatures)(row);
+  const mlResult = await (0, import_ml.fetchMlThreshold)({
+    strategy: "TrendLine",
+    features,
+    threshold: ML_THRESHOLD
+  });
+  if (!mlResult) {
+    console.log("ML result is null (check ml-infer or ML_GRPC_ADDRESS).");
+    return;
+  }
+  console.log("ML result:", mlResult);
+};
+main().catch((err) => {
+  console.error("test-ml failed:", err);
+  process.exit(1);
+});

package/dist/scripts/test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+// src/scripts/test.ts
+var import_config = require("dotenv/config");
+var import_connectors = require("@tradejs/connectors");
+var getPositions = async (connector) => {
+  const res = await connector.getPositions();
+  console.log("res", res);
+};
+var main = async () => {
+  const byBitConnector = await import_connectors.connectors.ByBit({
+    userName: "root"
+  });
+  await getPositions(byBitConnector);
+};
+main();

package/dist/scripts/user-add.js

@@ -0,0 +1,64 @@
+"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/user-add.ts
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+var import_bcryptjs = __toESM(require("bcryptjs"));
+var import_crypto = __toESM(require("crypto"));
+var import_redis = require("@tradejs/infra/redis");
+import_args.default.example("yarn user-add -u myname -p 123456", "Create or update user");
+import_args.default.option(["u", "user"], "Username", "");
+import_args.default.option(["p", "password"], "Password (plain text)", "");
+import_args.default.option(["t", "token"], "Persistent token (optional)", "");
+var flags = import_args.default.parse(process.argv);
+var run = async () => {
+  const userName = String(flags.user || "").trim();
+  const password = String(flags.password || "");
+  const requestedToken = String(flags.token || "").trim();
+  if (!userName || !password) {
+    console.error(import_chalk.default.red("Missing -U <user> or -P <password>"));
+    process.exit(1);
+  }
+  const passwordHash = await import_bcryptjs.default.hash(password, 10);
+  const existing = await (0, import_redis.getData)(import_redis.redisKeys.user(userName), null);
+  const existingToken = typeof existing === "object" && existing ? existing.token : void 0;
+  const token = requestedToken || existingToken || (userName === "root" ? import_crypto.default.randomBytes(24).toString("hex") : void 0);
+  const next = {
+    ...existing ?? {},
+    passwordHash,
+    userName,
+    ...token ? { token } : {},
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await (0, import_redis.setData)(import_redis.redisKeys.user(userName), next, {
+    expire: 0
+  });
+  console.log(import_chalk.default.green(`User ${userName} updated`));
+  if (token) {
+    console.log(import_chalk.default.gray(`token: ${token}`));
+  }
+  process.exit(0);
+};
+run();

package/dist/workers/testerWorker.js

@@ -0,0 +1,54 @@
+"use strict";
+
+// src/workers/testerWorker.ts
+var import_backtest = require("@tradejs/node/backtest");
+var import_logger = require("@tradejs/infra/logger");
+var import_ml = require("@tradejs/infra/ml");
+var import_redis = require("@tradejs/infra/redis");
+var isProcessing = false;
+process.on(
+  "message",
+  async ({ chunkId, userName }) => {
+    if (isProcessing) {
+      return;
+    }
+    isProcessing = true;
+    try {
+      const testSuite = await (0, import_redis.getData)(
+        import_redis.redisKeys.cacheChunk(userName, chunkId)
+      );
+      for await (const test of testSuite) {
+        try {
+          const testResult = await (0, import_backtest.testing)(test);
+          if (!testResult) {
+            throw new Error("No result");
+          }
+          const { stat, orderLogId } = testResult;
+          process.send?.({
+            stat,
+            orderLogId,
+            test
+          });
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const errorStack = error instanceof Error ? error.stack : void 0;
+          import_logger.logger.error("tester worker error: %s", errorMessage);
+          process.send?.({
+            error: true,
+            id: test.name,
+            msg: {
+              message: errorMessage,
+              stack: errorStack
+            }
+          });
+        }
+      }
+    } finally {
+      await (0, import_ml.closeAllMlDatasetWriters)();
+      (0, import_backtest.resetTestingKlineCache)();
+    }
+    process.send?.({ done: true });
+    process.disconnect?.();
+    process.exit(0);
+  }
+);