@tradejs/cli 1.0.9 → 1.0.11

package/dist/scripts/researchAuto.js

@@ -30,15 +30,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/scripts/researchAuto.ts
 var researchAuto_exports = {};
 __export(researchAuto_exports, {
+  acquireResearchAutoLock: () => acquireResearchAutoLock,
+  buildNodeOptions: () => buildNodeOptions,
   buildTelegramReport: () => buildTelegramReport,
   createEmptySteps: () => createEmptySteps,
   escapeHtml: () => escapeHtml,
   formatMskDateTime: () => formatMskDateTime,
   getBacktestResultsPrefix: () => getBacktestResultsPrefix,
+  getResearchAutoLockPath: () => getResearchAutoLockPath,
+  isProcessAlive: () => isProcessAlive,
   listMergedFiles: () => listMergedFiles,
   listRuntimeStrategyNames: () => listRuntimeStrategyNames,
   main: () => main,
   parseJsonOutput: () => parseJsonOutput,
+  releaseResearchAutoLock: () => releaseResearchAutoLock,
+  resolveHeapMbFromEnv: () => resolveHeapMbFromEnv,
   resolveStrategyNameByConfigKey: () => resolveStrategyNameByConfigKey,
   resolveTarget: () => resolveTarget,
   runCliCommand: () => runCliCommand,
@@ -47,15 +53,83 @@ __export(researchAuto_exports, {
 });
 module.exports = __toCommonJS(researchAuto_exports);
 var import_args = __toESM(require("args"));
-var import_chalk = __toESM(require("chalk"));
+var import_chalk2 = __toESM(require("chalk"));
 var import_node_child_process = require("child_process");
 var import_promises = __toESM(require("fs/promises"));
+var import_node_os = __toESM(require("os"));
 var import_node_path = __toESM(require("path"));
+var import_constants = require("@tradejs/core/constants");
 var import_ai = require("@tradejs/infra/ai");
 var import_logger = require("@tradejs/infra/logger");
-var import_redis = require("@tradejs/infra/redis");
+var import_redis2 = require("@tradejs/infra/redis");
 var import_strategies = require("@tradejs/strategies");
 
+// src/lib/runtimeRedis.ts
+var import_redis = require("@tradejs/infra/redis");
+var import_time = require("@tradejs/core/time");
+var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
+var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
+var resolveStrategyConfigIdentityByKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) return null;
+  const [users, keyUserName, strategiesKey, strategyName, configId] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || !strategyName || !configId || RESERVED_STRATEGY_NAMES.has(strategyName) || RESERVED_CONFIG_IDS.has(configId) || !/^[a-zA-Z0-9_-]+$/.test(configId)) {
+    return null;
+  }
+  return { strategyName, configId };
+};
+var isRuntimeStrategyEnabled = (strategyConfig) => {
+  const enabled = strategyConfig.ENABLE;
+  return enabled !== false;
+};
+var resolveStrategyNameByConfigKey = (userName, key) => {
+  return resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null;
+};
+var getRuntimeStrategyConfigKeys = async (userName) => {
+  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
+  return keys.filter((key) => resolveStrategyConfigIdentityByKey(userName, key)).sort((left, right) => left.localeCompare(right));
+};
+var loadRuntimeStrategyConfigs = async (userName, {
+  onInvalidConfig
+} = {}) => {
+  const configKeys = await getRuntimeStrategyConfigKeys(userName);
+  const strategyConfigs = await Promise.all(
+    configKeys.map(async (key) => {
+      const strategyName = resolveStrategyNameByConfigKey(userName, key);
+      const identity = resolveStrategyConfigIdentityByKey(userName, key);
+      if (!strategyName || !identity) {
+        return null;
+      }
+      const strategyConfig = await (0, import_redis.getData)(
+        key,
+        null
+      );
+      if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
+        onInvalidConfig?.(key);
+        return null;
+      }
+      return {
+        key,
+        strategyName,
+        configId: identity.configId,
+        strategyConfig
+      };
+    })
+  );
+  return strategyConfigs.filter(Boolean);
+};
+
+// src/lib/runtimeStrategyBacktest.ts
+var import_chalk = __toESM(require("chalk"));
+var BACKTEST_CLI_RUNTIME_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "ENV",
+  "INTERVAL",
+  "MAKE_ORDERS",
+  "CLOSE_OPPOSITE_POSITIONS",
+  "BACKTEST_PRICE_MODE",
+  "BACKTEST_ENTRY_DELAY_BARS"
+]);
+
 // src/lib/telegramReports.ts
 var import_cli = require("@tradejs/node/cli");
 var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
@@ -100,8 +174,16 @@ ${line}` : line;
 };
 var sendTelegramReport = async (message, options = {}) => {
   const chunks = splitTelegramReport(message);
+  const sendAttachments = async () => {
+    for (const attachment of options.attachments || []) {
+      await (0, import_cli.sendDocumentToTG)(attachment, {
+        userName: options.userName
+      });
+    }
+  };
   if (chunks.length === 1) {
     await (0, import_cli.sendTextToTG)(chunks[0], options);
+    await sendAttachments();
     return chunks.length;
   }
   for (const [index, chunk] of chunks.entries()) {
@@ -113,6 +195,7 @@ ${chunk}`, {
       markup: index === chunks.length - 1 ? options.markup : void 0
     });
   }
+  await sendAttachments();
   return chunks.length;
 };
 
@@ -128,16 +211,150 @@ import_args.default.option(["o", "connector"], "Backtest connector", "bybit");
 import_args.default.option(["f", "timeframe"], "Backtest timeframe", "15");
 import_args.default.option(["d", "days"], "Backtest days window", 45);
 import_args.default.option(["n", "recent"], "AI train recent rows window", 1e3);
-import_args.default.option("skip", "AI train skip rows from end", 0);
-import_args.default.option("minQuality", "Minimum AI quality required to approve entry", 4);
-import_args.default.option("outDir", "AI export output directory", "data/ai/export");
-import_args.default.option("skipAgent", "Skip direct research agent invocation", false);
-import_args.default.option("json", "Print structured JSON summary", false);
+import_args.default.option(["k", "skip"], "AI train skip rows from end", 0);
+import_args.default.option(
+  ["M", "minQuality"],
+  "Minimum AI quality required to approve entry",
+  4
+);
+import_args.default.option(["O", "outDir"], "AI export output directory", "data/ai/export");
+import_args.default.option(["A", "skipAgent"], "Skip direct research agent invocation", false);
+import_args.default.option(["j", "json"], "Print structured JSON summary", false);
 var flags = import_args.default.parse(process.argv);
 var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
 var dotenvPath = String(
   process.env.DOTENV_CONFIG_PATH || import_node_path.default.join(projectRoot, ".env")
 ).trim() || import_node_path.default.join(projectRoot, ".env");
+var getResearchAutoLockPath = (userName) => import_node_path.default.join(
+  projectRoot,
+  "data",
+  "cache",
+  "research-auto",
+  `${(0, import_ai.toFileToken)(userName)}.lock.json`
+);
+var readResearchAutoLock = async (lockPath) => {
+  try {
+    const raw = await import_promises.default.readFile(lockPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var isProcessAlive = (pid) => {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? String(error.code || "") : "";
+    return code === "EPERM";
+  }
+};
+var acquireResearchAutoLock = async ({
+  runId,
+  userName,
+  strategy,
+  startedAt
+}) => {
+  const lockPath = getResearchAutoLockPath(userName);
+  const nextLock = {
+    runId,
+    userName,
+    strategy,
+    pid: process.pid,
+    ppid: process.ppid,
+    hostname: import_node_os.default.hostname(),
+    startedAt,
+    argv: [...process.argv]
+  };
+  await import_promises.default.mkdir(import_node_path.default.dirname(lockPath), { recursive: true });
+  const writeLock = async () => {
+    await import_promises.default.writeFile(lockPath, JSON.stringify(nextLock, null, 2), {
+      flag: "wx"
+    });
+  };
+  try {
+    await writeLock();
+    return lockPath;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? String(error.code || "") : "";
+    if (code !== "EEXIST") {
+      throw error;
+    }
+  }
+  const existingLock = await readResearchAutoLock(lockPath);
+  if (existingLock?.pid && isProcessAlive(existingLock.pid)) {
+    throw new Error(
+      `research:auto is already running for user ${userName} (runId=${existingLock.runId}, strategy=${existingLock.strategy}, pid=${existingLock.pid}, ppid=${existingLock.ppid}, startedAt=${existingLock.startedAt}, host=${existingLock.hostname})`
+    );
+  }
+  await import_promises.default.unlink(lockPath).catch(() => void 0);
+  await writeLock();
+  return lockPath;
+};
+var releaseResearchAutoLock = async (lockPath) => {
+  if (!lockPath) {
+    return;
+  }
+  const existingLock = await readResearchAutoLock(lockPath);
+  if (existingLock && existingLock.pid !== process.pid) {
+    return;
+  }
+  await import_promises.default.unlink(lockPath).catch(() => void 0);
+};
+var resolvePositiveInteger = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  if (Number.isInteger(parsed) && parsed > 0) {
+    return parsed;
+  }
+  return fallback;
+};
+var resolveHeapMbFromEnv = (envNames, fallback) => {
+  for (const envName of envNames) {
+    const resolved = resolvePositiveInteger(process.env[envName], void 0);
+    if (resolved != null) {
+      return resolved;
+    }
+  }
+  return fallback;
+};
+var buildNodeOptions = ({
+  heapMb,
+  baseNodeOptions = String(process.env.NODE_OPTIONS || "").trim()
+}) => [
+  heapMb ? `--max-old-space-size=${Math.max(256, heapMb)}` : "",
+  ...baseNodeOptions.split(/\s+/).map((value) => value.trim()).filter((value) => value && !value.startsWith("--max-old-space-size="))
+].filter(Boolean).join(" ");
+var RESEARCH_AUTO_PARENT_HEAP_MB = resolveHeapMbFromEnv(
+  ["RESEARCH_AUTO_PARENT_HEAP_MB"],
+  1024
+);
+var RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB = resolveHeapMbFromEnv(
+  [
+    "RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB",
+    "BACKTEST_PARENT_HEAP_MB",
+    "CLI_PARENT_HEAP_MB"
+  ],
+  1536
+);
+var RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB = resolveHeapMbFromEnv(
+  [
+    "RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB",
+    "AI_TRAIN_PARENT_HEAP_MB",
+    "CLI_PARENT_HEAP_MB"
+  ],
+  2048
+);
+var RESEARCH_AUTO_AGENT_PARENT_HEAP_MB = resolveHeapMbFromEnv(
+  [
+    "RESEARCH_AUTO_AGENT_PARENT_HEAP_MB",
+    "AGENT_RUN_PARENT_HEAP_MB",
+    "CLI_PARENT_HEAP_MB"
+  ],
+  2048
+);
 var trimTextTail = (value, limit = 4e3) => value.length <= limit ? value : value.slice(-limit);
 var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 var createEmptySteps = () => ({
@@ -178,11 +395,11 @@ var createEmptySteps = () => ({
   }
 });
 var saveRun = async (run) => {
-  await (0, import_redis.setData)(import_redis.redisKeys.researchRun(run.userName, run.runId), run, {
-    expire: 0
+  await (0, import_redis2.setData)(import_redis2.redisKeys.researchRun(run.userName, run.runId), run, {
+    expire: import_constants.TTL_1M
   });
-  await (0, import_redis.setData)(import_redis.redisKeys.researchLatestRun(run.userName, run.strategy), run, {
-    expire: 0
+  await (0, import_redis2.setData)(import_redis2.redisKeys.researchLatestRun(run.userName, run.strategy), run, {
+    expire: import_constants.TTL_1M
   });
 };
 var listMergedFiles = async (outDir, strategyName) => {
@@ -195,24 +412,13 @@ var listMergedFiles = async (outDir, strategyName) => {
   }
 };
 var getBacktestResultsPrefix = (userName, config) => `users:${userName}:backtests:results:${config}:`;
-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 listRuntimeStrategyNames = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
-  return keys.filter((key) => key.endsWith(":config")).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value)).sort((left, right) => left.localeCompare(right));
+  const strategyConfigs = await loadRuntimeStrategyConfigs(userName);
+  return strategyConfigs.filter(({ strategyConfig }) => isRuntimeStrategyEnabled(strategyConfig)).map(({ strategyName }) => strategyName).sort((left, right) => left.localeCompare(right));
 };
 var toStrategyConfigGrid = (strategyConfig) => {
   return Object.fromEntries(
-    Object.entries(strategyConfig).map(([key, value]) => [key, [value]])
+    Object.entries(strategyConfig).filter(([key]) => !BACKTEST_CLI_RUNTIME_CONFIG_KEYS.has(key)).map(([key, value]) => [key, [value]])
   );
 };
 var formatMskDateTime = (value) => {
@@ -321,11 +527,10 @@ var runCliCommand = async (params) => {
     ...process.env,
     PROJECT_CWD: projectRoot,
     DOTENV_CONFIG_PATH: dotenvPath,
-    ...params.node8g ? {
-      NODE_OPTIONS: [
-        "--max-old-space-size=8192",
-        String(process.env.NODE_OPTIONS || "").trim()
-      ].filter(Boolean).join(" ")
+    ...params.nodeHeapMb ? {
+      NODE_OPTIONS: buildNodeOptions({
+        heapMb: params.nodeHeapMb
+      })
     } : {}
   };
   return new Promise((resolve, reject) => {
@@ -351,14 +556,14 @@ var runCliCommand = async (params) => {
     const emitLines = (source, text) => {
       const prefix = params.liveLogPrefix ? `[research:auto:${params.liveLogPrefix}:${source}] ` : `[research:auto:${source}] `;
       for (const line of text.split(/\r?\n/).map((value) => value.trimEnd()).filter(Boolean)) {
-        import_logger.logger.info(import_chalk.default.gray(`${prefix}${line}`));
+        import_logger.logger.info(import_chalk2.default.gray(`${prefix}${line}`));
       }
     };
     if (params.heartbeatMs && params.heartbeatMs > 0) {
       heartbeatTimer = setInterval(() => {
         const elapsedMs = Date.now() - startedAt;
         import_logger.logger.info(
-          import_chalk.default.gray(
+          import_chalk2.default.gray(
             `[research:auto:${params.liveLogPrefix || params.command}] still running after ${Math.round(elapsedMs / 1e3)}s`
           )
         );
@@ -419,8 +624,8 @@ var resolveTarget = async () => {
   const candidates = [];
   for (const strategy of availableStrategies) {
     const config = `${strategy}:research`;
-    const latestRun = await (0, import_redis.getData)(
-      import_redis.redisKeys.researchLatestRun(userName, strategy),
+    const latestRun = await (0, import_redis2.getData)(
+      import_redis2.redisKeys.researchLatestRun(userName, strategy),
       null
     );
     const lastFinishedAt = latestRun?.finishedAt ? Date.parse(latestRun.finishedAt) : 0;
@@ -457,7 +662,7 @@ var parseJsonOutput = (stdout, label) => {
   return JSON.parse(trimmed);
 };
 var logResearch = (message) => {
-  import_logger.logger.info(import_chalk.default.cyan(`[research:auto] ${message}`));
+  import_logger.logger.info(import_chalk2.default.cyan(`[research:auto] ${message}`));
 };
 var executeNonBlockingStep = async (run, stepName, command, commandArgs, options = {}) => {
   logResearch(
@@ -474,7 +679,7 @@ var executeNonBlockingStep = async (run, stepName, command, commandArgs, options
   const result = await runCliCommand({
     command,
     args: commandArgs,
-    node8g: options.node8g,
+    nodeHeapMb: options.nodeHeapMb,
     liveLogPrefix: options.liveLog ? stepName : void 0,
     heartbeatMs: options.liveLog ? options.heartbeatMs || 6e4 : void 0,
     captureMode: options.captureMode
@@ -534,6 +739,7 @@ var main = async () => {
     steps: createEmptySteps(),
     artifacts: {}
   };
+  let lockPath = null;
   const executeStep = async (stepName, command, commandArgs, options = {}) => {
     logResearch(
       `starting step ${stepName}: ${command} ${commandArgs.join(" ")}`.trim()
@@ -549,7 +755,7 @@ var main = async () => {
     const result = await runCliCommand({
       command,
       args: commandArgs,
-      node8g: options.node8g,
+      nodeHeapMb: options.nodeHeapMb,
       liveLogPrefix: options.liveLog ? stepName : void 0,
       heartbeatMs: options.liveLog ? options.heartbeatMs || 6e4 : void 0,
       captureMode: options.captureMode
@@ -597,13 +803,13 @@ var main = async () => {
       startedAt
     };
     await saveRun(run);
-    const strategyConfigKey = import_redis.redisKeys.strategyConfig(
+    const strategyConfigKey = import_redis2.redisKeys.strategyConfig(
       userName,
       target.strategy
     );
-    const backtestConfigKey = import_redis.redisKeys.backtestConfig(userName, target.config);
+    const backtestConfigKey = import_redis2.redisKeys.backtestConfig(userName, target.config);
     const defaults = (0, import_strategies.getBuiltInStrategyDefaultConfig)(target.strategy) || {};
-    const userStrategyConfig = await (0, import_redis.getData)(
+    const userStrategyConfig = await (0, import_redis2.getData)(
       strategyConfigKey,
       {}
     );
@@ -617,7 +823,7 @@ var main = async () => {
       );
     }
     const backtestConfig = toStrategyConfigGrid(strategyConfig);
-    await (0, import_redis.setData)(backtestConfigKey, backtestConfig, { expire: 0 });
+    await (0, import_redis2.setData)(backtestConfigKey, backtestConfig, { expire: 0 });
     logResearch(
       `stored backtest config at ${backtestConfigKey} with ${Object.keys(strategyConfig).length} top-level fields`
     );
@@ -639,13 +845,25 @@ var main = async () => {
     const message = buildTelegramReport(run);
     await sendTelegramReport(message, { userName });
   };
-  await saveRun(run);
   try {
+    lockPath = await acquireResearchAutoLock({
+      runId,
+      userName,
+      strategy: target.strategy,
+      startedAt: run.startedAt
+    });
+    logResearch(
+      `run ${runId} acquired lock ${lockPath} (pid=${process.pid}, ppid=${process.ppid}, host=${import_node_os.default.hostname()})`
+    );
+    await saveRun(run);
     logResearch(
       `run ${runId} selected target strategy=${target.strategy}, config=${target.config}, selectedBy=${target.selectedBy}`
     );
+    logResearch(
+      `resource knobs: researchAutoHeapMb=${RESEARCH_AUTO_PARENT_HEAP_MB}, backtestParentHeapMb=${RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB}, aiTrainParentHeapMb=${RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB}, agentParentHeapMb=${RESEARCH_AUTO_AGENT_PARENT_HEAP_MB}, backtestWorkerHeapMb=${process.env.BACKTEST_WORKER_HEAP_MB || "auto"}, backtestMaxParallel=${process.env.BACKTEST_MAX_PARALLEL || "auto"}, klineConcurrency=${process.env.KLINE_CONCURRENCY_LIMIT || "default"}`
+    );
     const backtestKeysBefore = new Set(
-      await (0, import_redis.getKeys)(getBacktestResultsPrefix(userName, target.config))
+      await (0, import_redis2.getKeys)(getBacktestResultsPrefix(userName, target.config))
     );
     const aiFilesBefore = new Set(
       await listMergedFiles(outDir, target.strategy)
@@ -675,7 +893,11 @@ var main = async () => {
         String(days),
         "--ai"
       ],
-      { node8g: true, liveLog: true, heartbeatMs: 3e4 }
+      {
+        nodeHeapMb: RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB,
+        liveLog: true,
+        heartbeatMs: 3e4
+      }
     );
     await executeStep("aiExport", "ai-export", [
       "--strategy",
@@ -698,16 +920,19 @@ var main = async () => {
         "--localOnly",
         "--json"
       ],
-      { node8g: true, captureMode: "full" }
+      {
+        nodeHeapMb: RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB,
+        captureMode: "full"
+      }
     );
-    const backtestKeysAfter = await (0, import_redis.getKeys)(
+    const backtestKeysAfter = await (0, import_redis2.getKeys)(
       getBacktestResultsPrefix(userName, target.config)
     );
     const newBacktestKeys = backtestKeysAfter.filter((key) => !backtestKeysBefore.has(key)).sort();
     const backtestResultKey = newBacktestKeys[newBacktestKeys.length - 1] || backtestKeysAfter.sort().at(-1);
     if (backtestResultKey) {
       logResearch(`detected backtest result key ${backtestResultKey}`);
-      const backtestResult = await (0, import_redis.getData)(backtestResultKey, null);
+      const backtestResult = await (0, import_redis2.getData)(backtestResultKey, null);
       run.artifacts.backtestResultKey = backtestResultKey;
       run.artifacts.backtestResult = backtestResult ? {
         finishedAt: backtestResult.finishedAt,
@@ -755,7 +980,7 @@ var main = async () => {
           "--json"
         ],
         {
-          node8g: true,
+          nodeHeapMb: RESEARCH_AUTO_AGENT_PARENT_HEAP_MB,
           liveLog: true,
           heartbeatMs: 3e4,
           captureMode: "full"
@@ -783,19 +1008,19 @@ var main = async () => {
       console.log(JSON.stringify(run));
       process.exit(0);
     }
-    console.log(import_chalk.default.green("Research auto finished"));
+    console.log(import_chalk2.default.green("Research auto finished"));
     console.log(
-      import_chalk.default.gray(
+      import_chalk2.default.gray(
         `strategy=${run.strategy}, config=${run.config}, runId=${run.runId}`
       )
     );
     if (run.artifacts.backtestResultKey) {
       console.log(
-        import_chalk.default.gray(`backtestResultKey=${run.artifacts.backtestResultKey}`)
+        import_chalk2.default.gray(`backtestResultKey=${run.artifacts.backtestResultKey}`)
       );
     }
     if (run.artifacts.aiExportFile) {
-      console.log(import_chalk.default.gray(`aiExportFile=${run.artifacts.aiExportFile}`));
+      console.log(import_chalk2.default.gray(`aiExportFile=${run.artifacts.aiExportFile}`));
     }
     process.exit(0);
   } catch (error) {
@@ -817,28 +1042,30 @@ Telegram report failed: ${suffix}`;
     if (jsonOutput) {
       console.log(JSON.stringify(run));
     } else {
-      console.error(import_chalk.default.red(run.error));
+      console.error(import_chalk2.default.red(run.error));
     }
     process.exit(1);
+  } finally {
+    await releaseResearchAutoLock(lockPath);
   }
 };
-if (require.main === module) {
-  main().catch((error) => {
-    console.error(import_chalk.default.red(error?.message || String(error)));
-    process.exit(1);
-  });
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  acquireResearchAutoLock,
+  buildNodeOptions,
   buildTelegramReport,
   createEmptySteps,
   escapeHtml,
   formatMskDateTime,
   getBacktestResultsPrefix,
+  getResearchAutoLockPath,
+  isProcessAlive,
   listMergedFiles,
   listRuntimeStrategyNames,
   main,
   parseJsonOutput,
+  releaseResearchAutoLock,
+  resolveHeapMbFromEnv,
   resolveStrategyNameByConfigKey,
   resolveTarget,
   runCliCommand,

package/dist/scripts/results.js

@@ -1629,6 +1629,7 @@ var require_list_it = __commonJS({
 // src/scripts/results.ts
 var results_exports = {};
 __export(results_exports, {
+  main: () => main,
   results: () => results
 });
 module.exports = __toCommonJS(results_exports);
@@ -1924,10 +1925,9 @@ var results = async () => {
   }
   process.exit();
 };
-if (process.env.NODE_ENV !== "test") {
-  void results();
-}
+var main = results;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  main,
   results
 });