@tradejs/cli 3.1.8-beta.206 → 3.1.8-beta.210

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/cli",
-  "version": "3.1.8-beta.206",
+  "version": "3.1.8-beta.210",
   "description": "Official CLI for the TradeJS TypeScript framework: infra setup, backtests, signals, bots, and ML workflows.",
   "keywords": [
     "tradejs",
@@ -32,13 +32,13 @@
     "tradejs": "dist/cli.js"
   },
   "dependencies": {
-    "@tradejs/connectors": "^3.1.8-beta.206",
-    "@tradejs/core": "^3.1.8-beta.206",
-    "@tradejs/indicators": "^3.1.8-beta.206",
-    "@tradejs/infra": "^3.1.8-beta.206",
-    "@tradejs/node": "^3.1.8-beta.206",
+    "@tradejs/connectors": "^3.1.8-beta.210",
+    "@tradejs/core": "^3.1.8-beta.210",
+    "@tradejs/indicators": "^3.1.8-beta.210",
+    "@tradejs/infra": "^3.1.8-beta.210",
+    "@tradejs/node": "^3.1.8-beta.210",
     "@tradejs/strategy-kit": "^3.0.0",
-    "@tradejs/types": "^3.1.8-beta.206",
+    "@tradejs/types": "^3.1.8-beta.210",
     "args": "^5.0.3",
     "bcryptjs": "^2.4.3",
     "chalk": "4.1.2",
@@ -83,7 +83,7 @@
     "runtime-evidence": "yarn run run:dist runtime-evidence",
     "runtime-evidence-sync": "yarn run run:dist runtime-evidence-sync",
     "runtime-scorecard": "yarn run run:dist runtime-scorecard",
-    "runtime-config": "yarn run run:dist runtime-config",
+    "runtime-control": "yarn run run:dist runtime-control",
     "strategy-release": "yarn run run:dist strategy-release",
     "continuity": "yarn run run:dist continuity",
     "derivatives:ingest": "yarn run run:dist derivatives:ingest",

package/dist/scripts/runtimeConfig.js

@@ -1,427 +0,0 @@
-"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, {
-  RUNTIME_CONFIG_ACTIONS: () => RUNTIME_CONFIG_ACTIONS,
-  buildProvisionedRuntimeDeployment: () => buildProvisionedRuntimeDeployment,
-  isEquivalentRuntimeStrategyRelease: () => isEquivalentRuntimeStrategyRelease,
-  main: () => main,
-  pointRuntimeDeploymentAtRelease: () => pointRuntimeDeploymentAtRelease,
-  resolveProvisionConnectorName: () => resolveProvisionConnectorName,
-  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_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}`);
-  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"
-];
-var resolveProvisionConnectorName = (value) => {
-  const connectorName = String(value ?? "").trim();
-  if (!connectorName) throw new Error("--connector is required");
-  return connectorName;
-};
-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 publish = async ({
-  strategyName,
-  sourceConfig
-}) => {
-  const config = await toReleaseConfig(strategyName, sourceConfig);
-  const metadata = await (0, import_runtimeStrategies.getRuntimeStrategyPackageMetadata)({
-    strategyName,
-    projectRoot
-  });
-  const packageIdentity = requireRuntimePackageIdentity(strategyName, metadata);
-  return (0, import_runtimeStrategyReleases.publishRuntimeStrategyRelease)({
-    userName,
-    strategyName,
-    config,
-    ...packageIdentity,
-    createdBy: `cli:${userName}`
-  });
-};
-var buildProvisionedRuntimeDeployment = ({
-  deploymentId,
-  label,
-  connectorName,
-  provider,
-  accountId,
-  strategyName,
-  releaseVersion
-}) => ({
-  id: deploymentId,
-  label,
-  connectorName,
-  provider,
-  accountId,
-  enabled: true,
-  strategies: [
-    {
-      strategyName,
-      releaseVersion,
-      controlState: "entries_paused"
-    }
-  ]
-});
-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");
-  const connectorName = resolveProvisionConnectorName(option("connector"));
-  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 = buildProvisionedRuntimeDeployment({
-    deploymentId,
-    label,
-    connectorName,
-    provider,
-    accountId,
-    strategyName,
-    releaseVersion: 1
-  });
-  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 release = await publish({ strategyName, sourceConfig });
-  const deployment = await (0, import_runtimeDeployments.saveRuntimeDeployment)(
-    userName,
-    buildProvisionedRuntimeDeployment({
-      deploymentId,
-      label,
-      connectorName,
-      provider,
-      accountId,
-      strategyName,
-      releaseVersion: release.releaseVersion
-    })
-  );
-  console.log(
-    JSON.stringify({ provisioned: true, release, deployment }, null, 2)
-  );
-};
-var rollout = async () => {
-  const strategyName = required("strategy");
-  const deploymentId = required("deployment");
-  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 (!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 [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 = {
-    deploymentId,
-    strategyName,
-    currentReleaseVersion: reference.releaseVersion,
-    nextControlState: "entries_paused",
-    unchanged,
-    config,
-    ...packageIdentity
-  };
-  if (!hasFlag("write")) {
-    console.log(JSON.stringify({ dryRun: true, ...preview }, null, 2));
-    return;
-  }
-  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,
-    strategyName,
-    config,
-    ...packageIdentity,
-    createdBy: `cli:${userName}`
-  });
-  const updatedDeployment = pointRuntimeDeploymentAtRelease({
-    deployment,
-    strategyName,
-    releaseVersion: release.releaseVersion
-  });
-  await (0, import_runtimeDeployments.saveRuntimeDeployment)(userName, updatedDeployment);
-  console.log(
-    JSON.stringify(
-      {
-        rolledOut: true,
-        release,
-        deployment: updatedDeployment
-      },
-      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)
-    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(
-      (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 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({ 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
-      });
-      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 === "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 ${RUNTIME_CONFIG_ACTIONS.join("|")}`
-  );
-};
-var main = runtimeConfig;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RUNTIME_CONFIG_ACTIONS,
-  buildProvisionedRuntimeDeployment,
-  isEquivalentRuntimeStrategyRelease,
-  main,
-  pointRuntimeDeploymentAtRelease,
-  resolveProvisionConnectorName,
-  runtimeConfig
-});