@tradejs/cli 3.1.2 → 3.1.4

package/dist/scripts/backtest.js

@@ -5013,8 +5013,7 @@ var persistTestSummariesIndex = async () => {
 };
 var validateBacktestRuntimeDeployment = ({
   deployment,
-  deploymentId,
-  requestedInterval
+  deploymentId
 }) => {
   if (deploymentId && !deployment) {
     throw new Error(`Runtime deployment not found: ${deploymentId}`);
@@ -5022,18 +5021,12 @@ var validateBacktestRuntimeDeployment = ({
   if (deployment && !deployment.enabled) {
     throw new Error(`Runtime deployment is disabled: ${deployment.id}`);
   }
-  if (deployment && String(deployment.interval) !== String(requestedInterval)) {
-    throw new Error(
-      `Deployment ${deployment.id} requires timeframe ${deployment.interval}; received ${requestedInterval}`
-    );
-  }
   return deployment;
 };
 var prepareRunEnvironment2 = async () => {
   const deployment = validateBacktestRuntimeDeployment({
     deployment: flags.deployment ? await (0, import_runtimeDeployments.getRuntimeDeployment)(userName, String(flags.deployment)) : null,
-    deploymentId: typeof flags.deployment === "string" ? flags.deployment : void 0,
-    requestedInterval: interval
+    deploymentId: typeof flags.deployment === "string" ? flags.deployment : void 0
   });
   const preparedRun = await prepareRunEnvironment({
     connector: deployment?.connectorName ?? flags.connector,
@@ -5048,7 +5041,7 @@ var prepareRunEnvironment2 = async () => {
     cacheOnly: flags.cacheOnly,
     interval,
     projectRoot,
-    universe: deployment?.universe ?? marketUniverse,
+    universe: marketUniverse,
     accountId: deployment?.accountId ?? flags.account,
     deploymentId: deployment?.id,
     assetClasses: deployment?.assetClasses,
@@ -5708,15 +5701,7 @@ var backtest = async () => {
       preparedRun.connectorName,
       interval
     ).map((test) => {
-      const deploymentStrategy = preparedRun.deployment?.strategies.find(
-        ({ strategyName }) => strategyName === config.strategyName
-      );
-      if (deploymentStrategy?.enabled === false) {
-        throw new Error(
-          `Strategy ${config.strategyName} is disabled in deployment ${preparedRun.deployment?.id}`
-        );
-      }
-      const policyProfileId = (typeof flags.policyProfile === "string" && flags.policyProfile.trim() ? flags.policyProfile.trim() : deploymentStrategy?.policyProfileId) || void 0;
+      const policyProfileId = (typeof flags.policyProfile === "string" && flags.policyProfile.trim() ? flags.policyProfile.trim() : void 0) || void 0;
       return {
         ...test,
         instrument: preparedRun.instrumentsBySymbol.get(
@@ -5728,7 +5713,6 @@ var backtest = async () => {
         policyProfileId,
         strategyConfig: {
           ...test.strategyConfig,
-          ...deploymentStrategy?.config,
           ...policyProfileId ? { POLICY_PROFILE_ID: policyProfileId } : {}
         }
       };

package/dist/scripts/runtimeConfig.js

@@ -30,20 +30,32 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/scripts/runtimeConfig.ts
 var runtimeConfig_exports = {};
 __export(runtimeConfig_exports, {
-  buildBootstrapRuntimeDeployment: () => buildBootstrapRuntimeDeployment,
+  RUNTIME_CONFIG_ACTIONS: () => RUNTIME_CONFIG_ACTIONS,
+  buildProvisionedRuntimeDeployment: () => buildProvisionedRuntimeDeployment,
+  isEquivalentRuntimeStrategyRelease: () => isEquivalentRuntimeStrategyRelease,
   main: () => main,
+  pointRuntimeDeploymentAtRelease: () => pointRuntimeDeploymentAtRelease,
   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_node_util = require("util");
 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 RUNTIME_CONFIG_ACTIONS = [
+  "inspect",
+  "verify",
+  "provision",
+  "rollout",
+  "pause",
+  "resume",
+  "rollback"
+];
 var action = argv[0] ?? "inspect";
 var option = (name) => {
   const index = argv.indexOf(`--${name}`);
@@ -64,28 +76,26 @@ var OPERATIONAL_CONFIG_KEYS = [
   "ENABLE",
   "ENV",
   "MAKE_ORDERS",
-  "RECORD_RUNTIME_TRADES",
-  "configId"
+  "RECORD_RUNTIME_TRADES"
 ];
+var requireRuntimePackageIdentity = (strategyName, metadata) => {
+  if (!metadata.strategyPackage || !metadata.strategyPackageVersion || !metadata.runtimePackageVersion) {
+    throw new Error(
+      `Runtime package manifest is incomplete for ${strategyName}`
+    );
+  }
+  return {
+    strategyPackage: metadata.strategyPackage,
+    strategyPackageVersion: metadata.strategyPackageVersion,
+    runtimePackageVersion: metadata.runtimePackageVersion
+  };
+};
 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
@@ -95,31 +105,29 @@ var publish = async ({
     strategyName,
     projectRoot
   });
+  const packageIdentity = requireRuntimePackageIdentity(strategyName, metadata);
   return (0, import_runtimeStrategyReleases.publishRuntimeStrategyRelease)({
     userName,
     strategyName,
     config,
-    ...metadata,
+    ...packageIdentity,
     createdBy: `cli:${userName}`
   });
 };
-var buildBootstrapRuntimeDeployment = ({
+var buildProvisionedRuntimeDeployment = ({
   deploymentId,
   label,
   connectorName,
   provider,
   accountId,
   strategyName,
-  releaseVersion,
-  config
+  releaseVersion
 }) => ({
   id: deploymentId,
   label,
   connectorName,
   provider,
   accountId,
-  universe: config.UNIVERSE,
-  interval: String(config.INTERVAL),
   enabled: true,
   strategies: [
     {
@@ -129,7 +137,30 @@ var buildBootstrapRuntimeDeployment = ({
     }
   ]
 });
-var bootstrap = async () => {
+var isEquivalentRuntimeStrategyRelease = ({
+  release,
+  config,
+  strategyPackage,
+  strategyPackageVersion,
+  runtimePackageVersion
+}) => Boolean(
+  release && (0, import_node_util.isDeepStrictEqual)(release.config, config) && release.strategyPackage === strategyPackage && release.strategyPackageVersion === strategyPackageVersion && release.runtimePackageVersion === runtimePackageVersion
+);
+var pointRuntimeDeploymentAtRelease = ({
+  deployment,
+  strategyName,
+  releaseVersion
+}) => ({
+  ...deployment,
+  strategies: deployment.strategies.map(
+    (strategy) => strategy.strategyName === strategyName ? {
+      strategyName,
+      releaseVersion,
+      controlState: "entries_paused"
+    } : strategy
+  )
+});
+var provision = async () => {
   const strategyName = required("strategy");
   const deploymentId = required("deployment");
   const accountId = required("account");
@@ -147,15 +178,14 @@ var bootstrap = async () => {
     );
   }
   const releaseConfig = await toReleaseConfig(strategyName, sourceConfig);
-  const previewDeployment = buildBootstrapRuntimeDeployment({
+  const previewDeployment = buildProvisionedRuntimeDeployment({
     deploymentId,
     label,
     connectorName,
     provider,
     accountId,
     strategyName,
-    releaseVersion: 1,
-    config: releaseConfig
+    releaseVersion: 1
   });
   if (!hasFlag("write")) {
     console.log(
@@ -177,102 +207,103 @@ var bootstrap = async () => {
     );
     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({
+    buildProvisionedRuntimeDeployment({
       deploymentId,
       label,
       connectorName,
       provider,
       accountId,
       strategyName,
-      releaseVersion: release.releaseVersion,
-      config: release.config
+      releaseVersion: release.releaseVersion
     })
   );
   console.log(
-    JSON.stringify(
-      { bootstrapped: true, backupPath, release, deployment },
-      null,
-      2
-    )
+    JSON.stringify({ provisioned: true, release, deployment }, null, 2)
   );
 };
-var migrate = async () => {
+var rollout = 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)
+  const configFile = import_node_path.default.resolve(projectRoot, required("file"));
+  const [deployment, sourceConfig] = await Promise.all([
+    (0, import_runtimeDeployments.getRuntimeDeployment)(userName, deploymentId),
+    (0, import_promises.readFile)(configFile, "utf8").then(
+      (value) => JSON.parse(value)
+    )
   ]);
-  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) {
+  if (!reference)
     throw new Error(`${strategyName} is not bound to ${deploymentId}`);
-  }
+  const [config, metadata, currentRelease] = await Promise.all([
+    toReleaseConfig(strategyName, sourceConfig),
+    (0, import_runtimeStrategies.getRuntimeStrategyPackageMetadata)({ strategyName, projectRoot }),
+    (0, import_runtimeStrategyReleases.getRuntimeStrategyRelease)(userName, strategyName, reference.releaseVersion)
+  ]);
+  const packageIdentity = requireRuntimePackageIdentity(strategyName, metadata);
+  const unchanged = isEquivalentRuntimeStrategyRelease({
+    release: currentRelease,
+    config,
+    ...packageIdentity
+  });
   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"
-      }
-    }
+    deploymentId,
+    strategyName,
+    currentReleaseVersion: reference.releaseVersion,
+    nextControlState: "entries_paused",
+    unchanged,
+    config,
+    ...packageIdentity
   };
   if (!hasFlag("write")) {
     console.log(JSON.stringify({ dryRun: true, ...preview }, null, 2));
     return;
   }
-  const backupPath = await writeMigrationBackup({
+  if (unchanged) {
+    console.log(
+      JSON.stringify(
+        {
+          rolledOut: false,
+          reason: "release_config_and_packages_unchanged",
+          release: currentRelease,
+          deployment
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  const release = await (0, import_runtimeStrategyReleases.publishRuntimeStrategyRelease)({
     userName,
-    capturedAt: Date.now(),
+    strategyName,
+    config,
+    ...packageIdentity,
+    createdBy: `cli:${userName}`
+  });
+  const updatedDeployment = pointRuntimeDeploymentAtRelease({
     deployment,
-    legacyConfig: sourceConfig
+    strategyName,
+    releaseVersion: release.releaseVersion
   });
-  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 },
+      {
+        rolledOut: true,
+        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");
@@ -281,10 +312,9 @@ var updateControlState = async (nextState) => {
   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";
+  if (!reference)
+    throw new Error(`${strategyName} is not bound to ${deploymentId}`);
+  const previousState = reference.controlState;
   const updated = await (0, import_runtimeDeployments.saveRuntimeDeployment)(userName, {
     ...deployment,
     strategies: deployment.strategies.map(
@@ -314,12 +344,6 @@ var rollback = async () => {
   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(
@@ -330,7 +354,7 @@ var rollback = async () => {
       } : strategy
     )
   });
-  console.log(JSON.stringify({ backupPath, deployment: updated }, null, 2));
+  console.log(JSON.stringify({ deployment: updated }, null, 2));
 };
 var verify = async () => {
   const deployments = await (0, import_runtimeDeployments.listRuntimeDeployments)(userName);
@@ -341,8 +365,7 @@ var verify = async () => {
       const strategies = await (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({
         userName,
         projectRoot,
-        deployment,
-        connectorName: deployment.connectorName
+        deployment
       });
       results.push({
         deploymentId: deployment.id,
@@ -374,22 +397,24 @@ var inspect = async () => {
   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 === "provision") return provision();
+  if (action === "rollout") return rollout();
   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"
+    `Usage: tradejs runtime-config ${RUNTIME_CONFIG_ACTIONS.join("|")}`
   );
 };
 var main = runtimeConfig;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  buildBootstrapRuntimeDeployment,
+  RUNTIME_CONFIG_ACTIONS,
+  buildProvisionedRuntimeDeployment,
+  isEquivalentRuntimeStrategyRelease,
   main,
+  pointRuntimeDeploymentAtRelease,
   runtimeConfig
 });