@tradejs/cli 3.1.0 → 3.1.2

package/dist/scripts/runtimeConfig.js

@@ -0,0 +1,395 @@
+"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/runtimeConfig.ts
+var runtimeConfig_exports = {};
+__export(runtimeConfig_exports, {
+  buildBootstrapRuntimeDeployment: () => buildBootstrapRuntimeDeployment,
+  main: () => main,
+  runtimeConfig: () => runtimeConfig
+});
+module.exports = __toCommonJS(runtimeConfig_exports);
+var import_config = require("dotenv/config");
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"));
+var import_runtimeDeployments = require("@tradejs/infra/runtimeDeployments");
+var import_runtimeStrategyConfigs = require("@tradejs/infra/runtimeStrategyConfigs");
+var import_runtimeStrategyReleases = require("@tradejs/infra/runtimeStrategyReleases");
+var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
+var import_strategies = require("@tradejs/node/strategies");
+var argv = process.argv.slice(2);
+var action = argv[0] ?? "inspect";
+var option = (name) => {
+  const index = argv.indexOf(`--${name}`);
+  return index >= 0 ? argv[index + 1] : void 0;
+};
+var hasFlag = (name) => argv.includes(`--${name}`);
+var required = (name) => {
+  const value = String(option(name) ?? "").trim();
+  if (!value) throw new Error(`--${name} is required`);
+  return value;
+};
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var userName = String(option("user") ?? process.env.USER_NAME ?? "root");
+var OPERATIONAL_CONFIG_KEYS = [
+  "ACCOUNT_ID",
+  "AI_REPLAY_ANALYSES",
+  "DEPLOYMENT_ID",
+  "ENABLE",
+  "ENV",
+  "MAKE_ORDERS",
+  "RECORD_RUNTIME_TRADES",
+  "configId"
+];
+var toReleaseConfig = async (strategyName, sourceConfig) => {
+  const defaults = await (0, import_strategies.getStrategyDefaults)(strategyName, projectRoot) ?? {};
+  const config = { ...defaults, ...sourceConfig };
+  for (const key of OPERATIONAL_CONFIG_KEYS) delete config[key];
+  return config;
+};
+var writeMigrationBackup = async (payload) => {
+  const directory = import_node_path.default.join(projectRoot, "data", "runtime-config-backups");
+  await (0, import_promises.mkdir)(directory, { recursive: true });
+  const backupPath = import_node_path.default.join(
+    directory,
+    `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`
+  );
+  await (0, import_promises.writeFile)(backupPath, `${JSON.stringify(payload, null, 2)}
+`, {
+    flag: "wx"
+  });
+  return backupPath;
+};
+var publish = async ({
+  strategyName,
+  sourceConfig
+}) => {
+  const config = await toReleaseConfig(strategyName, sourceConfig);
+  const metadata = await (0, import_runtimeStrategies.getRuntimeStrategyPackageMetadata)({
+    strategyName,
+    projectRoot
+  });
+  return (0, import_runtimeStrategyReleases.publishRuntimeStrategyRelease)({
+    userName,
+    strategyName,
+    config,
+    ...metadata,
+    createdBy: `cli:${userName}`
+  });
+};
+var buildBootstrapRuntimeDeployment = ({
+  deploymentId,
+  label,
+  connectorName,
+  provider,
+  accountId,
+  strategyName,
+  releaseVersion,
+  config
+}) => ({
+  id: deploymentId,
+  label,
+  connectorName,
+  provider,
+  accountId,
+  universe: config.UNIVERSE,
+  interval: String(config.INTERVAL),
+  enabled: true,
+  strategies: [
+    {
+      strategyName,
+      releaseVersion,
+      controlState: "entries_paused"
+    }
+  ]
+});
+var bootstrap = async () => {
+  const strategyName = required("strategy");
+  const deploymentId = required("deployment");
+  const accountId = required("account");
+  const connectorName = option("connector") ?? "bybit";
+  const provider = option("provider") ?? connectorName;
+  const label = option("label") ?? deploymentId;
+  const configFile = import_node_path.default.resolve(projectRoot, required("file"));
+  const sourceConfig = JSON.parse(
+    await (0, import_promises.readFile)(configFile, "utf8")
+  );
+  const existingDeployment = await (0, import_runtimeDeployments.getRuntimeDeployment)(userName, deploymentId);
+  if (existingDeployment) {
+    throw new Error(
+      `Deployment already exists: ${deploymentId}; publish a release and switch its pointer instead`
+    );
+  }
+  const releaseConfig = await toReleaseConfig(strategyName, sourceConfig);
+  const previewDeployment = buildBootstrapRuntimeDeployment({
+    deploymentId,
+    label,
+    connectorName,
+    provider,
+    accountId,
+    strategyName,
+    releaseVersion: 1,
+    config: releaseConfig
+  });
+  if (!hasFlag("write")) {
+    console.log(
+      JSON.stringify(
+        {
+          dryRun: true,
+          releaseConfig,
+          deployment: {
+            ...previewDeployment,
+            strategies: previewDeployment.strategies.map((strategy) => ({
+              ...strategy,
+              releaseVersion: "<allocated on write>"
+            }))
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const backupPath = await writeMigrationBackup({
+    userName,
+    capturedAt: Date.now(),
+    reason: "bootstrap",
+    sourceConfig
+  });
+  const release = await publish({ strategyName, sourceConfig });
+  const deployment = await (0, import_runtimeDeployments.saveRuntimeDeployment)(
+    userName,
+    buildBootstrapRuntimeDeployment({
+      deploymentId,
+      label,
+      connectorName,
+      provider,
+      accountId,
+      strategyName,
+      releaseVersion: release.releaseVersion,
+      config: release.config
+    })
+  );
+  console.log(
+    JSON.stringify(
+      { bootstrapped: true, backupPath, release, deployment },
+      null,
+      2
+    )
+  );
+};
+var migrate = async () => {
+  const strategyName = required("strategy");
+  const configId = option("config") ?? "config";
+  const deploymentId = required("deployment");
+  const [sourceConfig, deployment] = await Promise.all([
+    (0, import_runtimeStrategyConfigs.getRuntimeStrategyConfig)(userName, strategyName, configId),
+    (0, import_runtimeDeployments.getRuntimeDeployment)(userName, deploymentId)
+  ]);
+  if (!sourceConfig) {
+    throw new Error(`Legacy config not found: ${strategyName}:${configId}`);
+  }
+  if (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
+  const reference = deployment.strategies.find(
+    (strategy) => strategy.strategyName === strategyName
+  );
+  if (!reference) {
+    throw new Error(`${strategyName} is not bound to ${deploymentId}`);
+  }
+  const preview = {
+    source: { configId, config: sourceConfig },
+    releaseConfig: await toReleaseConfig(strategyName, sourceConfig),
+    deployment: {
+      id: deployment.id,
+      accountId: deployment.accountId,
+      strategy: {
+        strategyName,
+        releaseVersion: "<allocated on write>",
+        controlState: "entries_paused"
+      }
+    }
+  };
+  if (!hasFlag("write")) {
+    console.log(JSON.stringify({ dryRun: true, ...preview }, null, 2));
+    return;
+  }
+  const backupPath = await writeMigrationBackup({
+    userName,
+    capturedAt: Date.now(),
+    deployment,
+    legacyConfig: sourceConfig
+  });
+  const release = await publish({ strategyName, sourceConfig });
+  const updatedDeployment = {
+    ...deployment,
+    strategies: deployment.strategies.map(
+      (strategy) => strategy.strategyName === strategyName ? {
+        strategyName,
+        releaseVersion: release.releaseVersion,
+        controlState: "entries_paused"
+      } : strategy
+    )
+  };
+  await (0, import_runtimeDeployments.saveRuntimeDeployment)(userName, updatedDeployment);
+  console.log(
+    JSON.stringify(
+      { migrated: true, backupPath, release, deployment: updatedDeployment },
+      null,
+      2
+    )
+  );
+};
+var publishDraft = async () => {
+  const strategyName = required("strategy");
+  const draft = await (0, import_runtimeStrategyReleases.getRuntimeStrategyDraft)(userName, strategyName);
+  if (!draft) throw new Error(`Draft not found: ${strategyName}`);
+  const release = await publish({ strategyName, sourceConfig: draft.config });
+  console.log(JSON.stringify({ release }, null, 2));
+};
+var updateControlState = async (nextState) => {
+  const strategyName = required("strategy");
+  const deploymentId = required("deployment");
+  const deployment = await (0, import_runtimeDeployments.getRuntimeDeployment)(userName, deploymentId);
+  if (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
+  const reference = deployment.strategies.find(
+    (strategy) => strategy.strategyName === strategyName
+  );
+  if (!reference?.releaseVersion) {
+    throw new Error(`${strategyName} is not a versioned deployment reference`);
+  }
+  const previousState = reference.controlState ?? "active";
+  const updated = await (0, import_runtimeDeployments.saveRuntimeDeployment)(userName, {
+    ...deployment,
+    strategies: deployment.strategies.map(
+      (strategy) => strategy.strategyName === strategyName ? { ...strategy, controlState: nextState } : strategy
+    )
+  });
+  const event = previousState === nextState ? null : await (0, import_runtimeStrategyReleases.recordRuntimeStrategyControlEvent)({
+    userName,
+    deploymentId,
+    strategyName,
+    releaseVersion: reference.releaseVersion,
+    previousState,
+    nextState,
+    createdBy: `cli:${userName}`
+  });
+  console.log(JSON.stringify({ deployment: updated, event }, null, 2));
+};
+var rollback = async () => {
+  const strategyName = required("strategy");
+  const deploymentId = required("deployment");
+  const releaseVersion = Number(required("release"));
+  if (!Number.isSafeInteger(releaseVersion) || releaseVersion <= 0) {
+    throw new Error("--release must be a positive integer");
+  }
+  const deployment = await (0, import_runtimeDeployments.getRuntimeDeployment)(userName, deploymentId);
+  if (!deployment) throw new Error(`Deployment not found: ${deploymentId}`);
+  const release = (await (0, import_runtimeStrategyReleases.listRuntimeStrategyReleases)(userName, strategyName)).find((candidate) => candidate.releaseVersion === releaseVersion);
+  if (!release)
+    throw new Error(`Release not found: ${strategyName} v${releaseVersion}`);
+  const backupPath = await writeMigrationBackup({
+    userName,
+    capturedAt: Date.now(),
+    deployment,
+    reason: "rollback"
+  });
+  const updated = await (0, import_runtimeDeployments.saveRuntimeDeployment)(userName, {
+    ...deployment,
+    strategies: deployment.strategies.map(
+      (strategy) => strategy.strategyName === strategyName ? {
+        strategyName,
+        releaseVersion,
+        controlState: "entries_paused"
+      } : strategy
+    )
+  });
+  console.log(JSON.stringify({ backupPath, deployment: updated }, null, 2));
+};
+var verify = async () => {
+  const deployments = await (0, import_runtimeDeployments.listRuntimeDeployments)(userName);
+  const selected = option("deployment") ? deployments.filter((deployment) => deployment.id === option("deployment")) : deployments;
+  const results = [];
+  for (const deployment of selected) {
+    try {
+      const strategies = await (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({
+        userName,
+        projectRoot,
+        deployment,
+        connectorName: deployment.connectorName
+      });
+      results.push({
+        deploymentId: deployment.id,
+        ok: true,
+        strategies: strategies.map((strategy) => ({
+          strategyName: strategy.strategyName,
+          releaseVersion: strategy.releaseVersion,
+          controlState: strategy.controlState,
+          interval: strategy.interval,
+          universe: strategy.universe,
+          accountId: strategy.accountId
+        }))
+      });
+    } catch (error) {
+      results.push({
+        deploymentId: deployment.id,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  console.log(JSON.stringify({ userName, results }, null, 2));
+  if (results.some((result) => !result.ok)) process.exitCode = 1;
+};
+var inspect = async () => {
+  const strategyName = option("strategy");
+  const deployments = await (0, import_runtimeDeployments.listRuntimeDeployments)(userName);
+  const releases = strategyName ? await (0, import_runtimeStrategyReleases.listRuntimeStrategyReleases)(userName, strategyName) : void 0;
+  console.log(JSON.stringify({ userName, deployments, releases }, null, 2));
+};
+var runtimeConfig = async () => {
+  if (action === "bootstrap") return bootstrap();
+  if (action === "migrate") return migrate();
+  if (action === "publish-draft") return publishDraft();
+  if (action === "verify") return verify();
+  if (action === "pause") return updateControlState("entries_paused");
+  if (action === "resume") return updateControlState("active");
+  if (action === "rollback") return rollback();
+  if (action === "inspect") return inspect();
+  throw new Error(
+    "Usage: tradejs runtime-config inspect|verify|bootstrap|migrate|publish-draft|pause|resume|rollback"
+  );
+};
+var main = runtimeConfig;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildBootstrapRuntimeDeployment,
+  main,
+  runtimeConfig
+});

package/dist/scripts/runtimeEvidence.js

@@ -573,7 +573,7 @@ var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
 
 // src/lib/runtimeLineage.ts
-var runtimeLineageKey = (lineage) => [
+var runtimeLineageKey = (lineage) => lineage.schemaVersion === 2 ? ["v2", lineage.releaseVersion].join(":") : [
   lineage.schemaVersion,
   lineage.compositionId ?? "unbound-composition",
   lineage.gitSha ?? "unknown",

package/dist/scripts/runtimeParity.js

@@ -4808,7 +4808,7 @@ var buildRuntimeModeStrategyConfig = ({
   ...strategyConfig,
   ENV: env,
   MAKE_ORDERS: makeOrders,
-  INTERVAL: interval2,
+  INTERVAL: strategyConfig.INTERVAL ?? interval2,
   ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
   ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
 });