@tradejs/node 3.1.0 → 3.1.2

package/dist/runtimeStrategies.mjs

@@ -0,0 +1,264 @@
+import {
+  getStrategyCreator,
+  getStrategyPluginSource
+} from "./chunk-XN7BC7XK.mjs";
+import "./chunk-WS5DYEVZ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/runtimeStrategies.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { getData, redisKeys } from "@tradejs/infra/redis";
+import { getRuntimeStrategyRelease } from "@tradejs/infra/runtimeStrategyReleases";
+import { loadRuntimeStrategyConfigs } from "@tradejs/infra/runtimeStrategyConfigs";
+import { resolveTradingAccount } from "@tradejs/infra/tradingAccounts";
+var readPackageManifest = async (projectRoot) => {
+  const candidates = [
+    process.env.TRADEJS_RUNTIME_PACKAGE_MANIFEST,
+    path.join(projectRoot, "runtime-package-manifest.json"),
+    "/app/runtime-package-manifest.json"
+  ].filter((candidate) => Boolean(candidate));
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(
+        await readFile(candidate, "utf8")
+      );
+    } catch {
+    }
+  }
+  return { packages: {} };
+};
+var resolveInstalledPackageVersion = async (projectRoot, packageName, manifest) => {
+  if (!packageName || packageName === "runtime") return null;
+  const manifestVersion = manifest.packages?.[packageName];
+  if (manifestVersion) return manifestVersion;
+  try {
+    const packageJsonPath = path.join(
+      projectRoot,
+      "node_modules",
+      ...packageName.split("/"),
+      "package.json"
+    );
+    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+    return packageJson.version ?? null;
+  } catch {
+    return null;
+  }
+};
+var validateReleaseRuntimeCompatibility = async ({
+  release,
+  projectRoot,
+  packageManifest
+}) => {
+  const installedStrategyVersion = await resolveInstalledPackageVersion(
+    projectRoot,
+    release.strategyPackage,
+    packageManifest
+  );
+  if (release.strategyPackageVersion && installedStrategyVersion && release.strategyPackageVersion !== installedStrategyVersion) {
+    throw new Error(
+      `${release.strategyName} v${release.releaseVersion} requires ${release.strategyPackage}@${release.strategyPackageVersion}, image has ${installedStrategyVersion}`
+    );
+  }
+  const installedRuntimeVersion = packageManifest.packages?.["@tradejs/node"];
+  if (release.runtimePackageVersion && installedRuntimeVersion && release.runtimePackageVersion !== installedRuntimeVersion) {
+    throw new Error(
+      `${release.strategyName} v${release.releaseVersion} requires @tradejs/node@${release.runtimePackageVersion}, image has ${installedRuntimeVersion}`
+    );
+  }
+};
+var resolveAccountId = async ({
+  userName,
+  deployment,
+  connectorName,
+  universe,
+  legacyAccountId
+}) => {
+  const requestedAccountId = deployment?.accountId ?? legacyAccountId;
+  const account = await resolveTradingAccount({
+    userName,
+    accountId: requestedAccountId,
+    provider: deployment?.provider ?? connectorName,
+    universe
+  });
+  return account?.id ?? requestedAccountId;
+};
+var loadVersionedRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deployment,
+  connectorName
+}) => {
+  const packageManifest = await readPackageManifest(projectRoot);
+  return Promise.all(
+    deployment.strategies.map(async (reference) => {
+      if (!Number.isSafeInteger(reference.releaseVersion) || !reference.releaseVersion) {
+        throw new Error(
+          `Deployment ${deployment.id} strategy ${reference.strategyName} has no releaseVersion`
+        );
+      }
+      if (reference.config && Object.keys(reference.config).length) {
+        throw new Error(
+          `Deployment ${deployment.id} must not embed config for ${reference.strategyName}`
+        );
+      }
+      const release = await getRuntimeStrategyRelease(
+        userName,
+        reference.strategyName,
+        reference.releaseVersion
+      );
+      if (!release) {
+        throw new Error(
+          `Runtime release not found: ${reference.strategyName} v${reference.releaseVersion}`
+        );
+      }
+      await validateReleaseRuntimeCompatibility({
+        release,
+        projectRoot,
+        packageManifest
+      });
+      const strategyCreator = await getStrategyCreator(
+        reference.strategyName,
+        projectRoot
+      );
+      if (!strategyCreator) {
+        throw new Error(`Unknown strategy: ${reference.strategyName}`);
+      }
+      const interval = String(release.config.INTERVAL);
+      const universe = release.config.UNIVERSE;
+      const accountId = await resolveAccountId({
+        userName,
+        deployment,
+        connectorName,
+        universe
+      });
+      return {
+        strategyName: reference.strategyName,
+        releaseVersion: release.releaseVersion,
+        controlState: reference.controlState ?? "active",
+        interval,
+        universe,
+        accountId,
+        strategyPackage: release.strategyPackage,
+        strategyPackageVersion: release.strategyPackageVersion,
+        runtimePackageVersion: release.runtimePackageVersion,
+        strategyCreator,
+        sourceStrategyConfig: release.config,
+        strategyConfig: release.config,
+        // Symbol result configs are mutable legacy overlays and are not read by v2.
+        strategyResults: {}
+      };
+    })
+  );
+};
+var loadLegacyRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deployment,
+  connectorName
+}) => {
+  const deploymentStrategies = new Map(
+    (deployment?.strategies ?? []).map((strategy) => [
+      strategy.strategyName,
+      strategy
+    ])
+  );
+  const candidates = await Promise.all(
+    (await loadRuntimeStrategyConfigs(userName)).map(async (record) => {
+      const binding = deploymentStrategies.get(record.strategyName);
+      if (binding?.enabled === false || record.strategyConfig.ENABLE === false) {
+        return null;
+      }
+      const universe = record.strategyConfig.UNIVERSE === "tradfi" ? "tradfi" : "crypto";
+      const interval = String(
+        record.strategyConfig.INTERVAL ?? "15"
+      );
+      const accountId = await resolveAccountId({
+        userName,
+        deployment,
+        connectorName,
+        universe,
+        legacyAccountId: typeof record.strategyConfig.ACCOUNT_ID === "string" ? record.strategyConfig.ACCOUNT_ID : void 0
+      });
+      const [strategyCreator, strategyResults] = await Promise.all([
+        getStrategyCreator(record.strategyName, projectRoot),
+        getData(redisKeys.strategyResults(userName, record.strategyName), {})
+      ]);
+      if (!strategyCreator) return null;
+      return {
+        strategyName: record.strategyName,
+        configId: record.configId,
+        controlState: "active",
+        interval,
+        universe,
+        accountId,
+        strategyCreator,
+        sourceStrategyConfig: record.strategyConfig,
+        strategyConfig: record.strategyConfig,
+        strategyResults: strategyResults ?? {}
+      };
+    })
+  );
+  return candidates.filter(Boolean);
+};
+var loadResolvedRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deployment,
+  connectorName = "bybit",
+  universe,
+  accountId,
+  interval
+}) => {
+  const hasVersionedReferences = Boolean(
+    deployment?.strategies.some((strategy) => strategy.releaseVersion != null)
+  );
+  if (hasVersionedReferences && deployment?.strategies.some((strategy) => strategy.releaseVersion == null)) {
+    throw new Error(
+      `Deployment ${deployment.id} mixes legacy configs and versioned releases`
+    );
+  }
+  const strategies = hasVersionedReferences ? await loadVersionedRuntimeStrategies({
+    userName,
+    projectRoot,
+    deployment,
+    connectorName
+  }) : await loadLegacyRuntimeStrategies({
+    userName,
+    projectRoot,
+    deployment,
+    connectorName
+  });
+  const filtered = strategies.filter(
+    (candidate) => (!universe || candidate.universe === universe) && (!interval || String(candidate.interval) === String(interval)) && (!accountId || candidate.accountId === accountId)
+  );
+  const identities = /* @__PURE__ */ new Set();
+  for (const candidate of filtered) {
+    const identity = `${candidate.strategyName}:${candidate.accountId ?? "default"}`;
+    if (identities.has(identity)) {
+      throw new Error(`Runtime strategy conflict: ${identity}`);
+    }
+    identities.add(identity);
+  }
+  return filtered;
+};
+var getRuntimeStrategyPackageMetadata = async ({
+  strategyName,
+  projectRoot
+}) => {
+  const packageManifest = await readPackageManifest(projectRoot);
+  const strategyPackage = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
+  return {
+    strategyPackage,
+    strategyPackageVersion: await resolveInstalledPackageVersion(
+      projectRoot,
+      strategyPackage,
+      packageManifest
+    ),
+    runtimePackageVersion: packageManifest.packages?.["@tradejs/node"] ?? null
+  };
+};
+export {
+  getRuntimeStrategyPackageMetadata,
+  loadResolvedRuntimeStrategies
+};

package/dist/strategies.d.mts

@@ -1,6 +1,6 @@
 export * from '@tradejs/core/strategies';
 export { AiChatMessage, DEFAULT_AI_MODEL, InvokeAiChatOptions, MAX_AI_SERIES_POINTS, askAI, buildAiHumanPrompt, buildAiPayload, buildAiPrompts, buildAiSystemPrompt, buildCompactAiIndicatorsSnapshot, getDeterministicAiGateContext, getOpenRouterModelKwargs, invokeAiChat, resetAiRuntimeCache, runAiPrompt, runAiPromptLocal, trimSeriesDeep } from './ai.mjs';
-export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyDefaults, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies } from './registry.mjs';
+export { e as ensureIndicatorPluginsLoaded, a as ensureStrategyPluginsLoaded, g as getAvailableStrategyNames, b as getRegisteredManifests, c as getRegisteredStrategies, d as getStrategyCreator, f as getStrategyDefaults, h as getStrategyManifest, i as getStrategyPluginSource, j as isKnownStrategy, r as registerStrategyEntries, k as resetStrategyRegistryCache, s as strategies } from './registry-DHTLjQcr.mjs';
 import { StrategyConfig, CreateStrategyCore, StrategyManifest, StrategyCreator, RuntimeStrategyConfigSnapshot, Signal, Direction, StrategyRuntimeMlOptions, StrategyRuntimeAiOptions, Connector, Tp, MarketFeatureInterval, StrategyEntrySignalContext } from '@tradejs/types';
 import { TradejsConfigOnBarHook, TradejsConfigBeforeSignalsHook } from '@tradejs/core/config';
 

package/dist/strategies.d.ts

@@ -1,6 +1,6 @@
 export * from '@tradejs/core/strategies';
 export { AiChatMessage, DEFAULT_AI_MODEL, InvokeAiChatOptions, MAX_AI_SERIES_POINTS, askAI, buildAiHumanPrompt, buildAiPayload, buildAiPrompts, buildAiSystemPrompt, buildCompactAiIndicatorsSnapshot, getDeterministicAiGateContext, getOpenRouterModelKwargs, invokeAiChat, resetAiRuntimeCache, runAiPrompt, runAiPromptLocal, trimSeriesDeep } from './ai.js';
-export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyDefaults, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies } from './registry.js';
+export { e as ensureIndicatorPluginsLoaded, a as ensureStrategyPluginsLoaded, g as getAvailableStrategyNames, b as getRegisteredManifests, c as getRegisteredStrategies, d as getStrategyCreator, f as getStrategyDefaults, h as getStrategyManifest, i as getStrategyPluginSource, j as isKnownStrategy, r as registerStrategyEntries, k as resetStrategyRegistryCache, s as strategies } from './registry-DHTLjQcr.js';
 import { StrategyConfig, CreateStrategyCore, StrategyManifest, StrategyCreator, RuntimeStrategyConfigSnapshot, Signal, Direction, StrategyRuntimeMlOptions, StrategyRuntimeAiOptions, Connector, Tp, MarketFeatureInterval, StrategyEntrySignalContext } from '@tradejs/types';
 import { TradejsConfigOnBarHook, TradejsConfigBeforeSignalsHook } from '@tradejs/core/config';
 

package/dist/strategies.js

@@ -72,6 +72,7 @@ __export(strategies_exports, {
   getStrategyCreator: () => getStrategyCreator,
   getStrategyDefaults: () => getStrategyDefaults,
   getStrategyManifest: () => getStrategyManifest,
+  getStrategyPluginSource: () => getStrategyPluginSource,
   invokeAiChat: () => invokeAiChat,
   isKnownStrategy: () => isKnownStrategy,
   isTrackedHyperliquidPerp: () => isTrackedHyperliquidPerp,
@@ -965,6 +966,7 @@ var createStrategyRegistryState = () => ({
   strategyCreators: /* @__PURE__ */ new Map(),
   strategyManifestsMap: /* @__PURE__ */ new Map(),
   strategyEntriesMap: /* @__PURE__ */ new Map(),
+  strategySourcesMap: /* @__PURE__ */ new Map(),
   pluginsLoadPromise: null
 });
 var registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
@@ -1035,6 +1037,7 @@ var registerEntries = (entries, source, state) => {
     }
     state.strategyManifestsMap.set(strategyName, entry.manifest);
     state.strategyEntriesMap.set(strategyName, entry);
+    state.strategySourcesMap.set(strategyName, source);
     materializeStrategyCreator(strategyName, state);
   }
 };
@@ -1157,6 +1160,11 @@ var getStrategyDefaults = async (name, cwd = getTradejsProjectCwd()) => {
   const { state } = getStrategyRegistryState(cwd);
   return state.strategyEntriesMap.get(name)?.defaults;
 };
+var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategySourcesMap.get(name);
+};
 var getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
   await ensureStrategyPluginsLoaded(cwd);
   const { state } = getStrategyRegistryState(cwd);
@@ -4538,6 +4546,7 @@ var executeEntryOrder = async ({
       deploymentId: signal.deploymentId,
       policyProfileId: signal.policyProfileId,
       runtimeConfigId: signal.runtimeConfigId,
+      runtimeReleaseVersion: signal.runtimeReleaseVersion,
       runtimeLineage: signal.runtimeLineage,
       ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {}
     });
@@ -5462,6 +5471,9 @@ var createStrategyRuntime = ({
     deploymentId: requestedDeploymentId,
     policyProfileId,
     runtimeConfigId,
+    runtimeReleaseVersion,
+    entriesPaused = false,
+    runtimeLineage,
     runtimeConfigSnapshot,
     data,
     btcData,
@@ -6120,6 +6132,7 @@ var createStrategyRuntime = ({
       });
       const signal = decision.signal;
       if (signal) {
+        if (runtimeLineage) signal.runtimeLineage = runtimeLineage;
         if (universe) signal.universe = universe;
         if (assetClass) signal.assetClass = assetClass;
         if (accountId) signal.accountId = accountId;
@@ -6130,6 +6143,9 @@ var createStrategyRuntime = ({
             signal.signalId = `${signal.signalId}:${runtimeConfigId}`;
           }
         }
+        if (runtimeReleaseVersion) {
+          signal.runtimeReleaseVersion = runtimeReleaseVersion;
+        }
         if (decisionHookCtx.policyProfileId) {
           signal.policyProfileId = decisionHookCtx.policyProfileId;
         }
@@ -6236,6 +6252,15 @@ var createStrategyRuntime = ({
         quality,
         minAiQuality
       });
+      if (entriesPaused) {
+        const skipReason = "RUNTIME_ENTRIES_PAUSED";
+        if (signal) {
+          signal.orderStatus = "skipped";
+          signal.orderSkipReason = skipReason;
+          signal.runtimeReleaseVersion = runtimeReleaseVersion;
+        }
+        return signal ?? skipReason;
+      }
       if (!shouldMakeOrder) {
         if (signal) {
           signal.orderStatus = "skipped";
@@ -6752,6 +6777,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   getStrategyCreator,
   getStrategyDefaults,
   getStrategyManifest,
+  getStrategyPluginSource,
   invokeAiChat,
   isKnownStrategy,
   isTrackedHyperliquidPerp,

package/dist/strategies.mjs

@@ -29,7 +29,7 @@ import {
   resolveHyperliquidPerpFromSignalSymbol,
   resolveStrategyConfig,
   validateEntryProtectionAtArrival
-} from "./chunk-MKLTJQLY.mjs";
+} from "./chunk-W26Y6IRP.mjs";
 import {
   DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS,
@@ -39,26 +39,29 @@ import {
   buildAiPrompts,
   buildAiSystemPrompt,
   buildCompactAiIndicatorsSnapshot,
+  getDeterministicAiGateContext,
+  getOpenRouterModelKwargs,
+  invokeAiChat,
+  resetAiRuntimeCache,
+  runAiPrompt,
+  runAiPromptLocal,
+  trimSeriesDeep
+} from "./chunk-SEQJ6V6B.mjs";
+import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
   getAvailableStrategyNames,
-  getDeterministicAiGateContext,
-  getOpenRouterModelKwargs,
   getRegisteredManifests,
   getRegisteredStrategies,
   getStrategyCreator,
   getStrategyDefaults,
   getStrategyManifest,
-  invokeAiChat,
+  getStrategyPluginSource,
   isKnownStrategy,
   registerStrategyEntries,
-  resetAiRuntimeCache,
   resetStrategyRegistryCache,
-  runAiPrompt,
-  runAiPromptLocal,
-  strategies,
-  trimSeriesDeep
-} from "./chunk-KOQSLFT2.mjs";
+  strategies
+} from "./chunk-XN7BC7XK.mjs";
 import "./chunk-WS5DYEVZ.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {
@@ -103,6 +106,7 @@ export {
   getStrategyCreator,
   getStrategyDefaults,
   getStrategyManifest,
+  getStrategyPluginSource,
   invokeAiChat,
   isKnownStrategy,
   isTrackedHyperliquidPerp,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/node",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "Node-only runtime for the TradeJS TypeScript framework: strategies, backtests, Pine strategy loading, and plugin registries.",
   "keywords": [
     "tradejs",
@@ -9,7 +9,10 @@
     "node",
     "runtime",
     "strategy",
-    "pine-script"
+    "pine-script",
+    "ai",
+    "claude",
+    "codex"
   ],
   "repository": {
     "type": "git",
@@ -68,6 +71,11 @@
       "import": "./dist/runtimeDashboard.mjs",
       "require": "./dist/runtimeDashboard.js"
     },
+    "./runtimeStrategies": {
+      "types": "./dist/runtimeStrategies.d.ts",
+      "import": "./dist/runtimeStrategies.mjs",
+      "require": "./dist/runtimeStrategies.js"
+    },
     "./strategies": {
       "types": "./dist/strategies.d.ts",
       "import": "./dist/strategies.mjs",
@@ -77,9 +85,9 @@
   "dependencies": {
     "@langchain/core": "^1.2.3",
     "@langchain/openai": "^1.5.5",
-    "@tradejs/core": "^3.1.0",
-    "@tradejs/infra": "^3.1.0",
-    "@tradejs/types": "^3.1.0",
+    "@tradejs/core": "^3.1.2",
+    "@tradejs/infra": "^3.1.2",
+    "@tradejs/types": "^3.1.2",
     "chalk": "4.1.2",
     "ioredis": "5.11.1",
     "lodash": "^4.18.1",