hive-intelligence 1.1.3 → 1.1.4

package/build/monitor-worker.js

@@ -0,0 +1,1140 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  executeToolByName
+} from "./chunk-CEWCB5YS.js";
+import {
+  closeRedisClient,
+  getSupabaseAdmin,
+  isSupabaseConfigured,
+  secureLogger
+} from "./chunk-JTUKQWIO.js";
+import "./chunk-VBOKVQ74.js";
+import "./chunk-ZCU7XQKF.js";
+import "./chunk-3WYWXTNN.js";
+
+// src/monitor-worker.ts
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/services/monitor-runner.ts
+import { createHash } from "crypto";
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_LOCK_TIMEOUT_SECONDS = 300;
+var DEFAULT_WORKER_ID = `hive-monitor-worker-${process.pid}`;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function booleanValue(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes"].includes(normalized)) return true;
+    if (["false", "0", "no"].includes(normalized)) return false;
+  }
+  return void 0;
+}
+function recordArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, 5).map((item) => {
+    if (isRecord(item)) return item;
+    if (typeof item === "string" && item.trim()) return { id: item.trim() };
+    return null;
+  }).filter((item) => Boolean(item));
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => typeof item === "string" ? item.trim() : void 0).filter((item) => Boolean(item)).slice(0, 5);
+}
+function normalizeAlchemyNetwork(target) {
+  const raw = stringValue(target.network) ?? stringValue(target.chain) ?? "ethereum";
+  const normalized = raw.toLowerCase();
+  const aliases = {
+    eth: "eth-mainnet",
+    ethereum: "eth-mainnet",
+    mainnet: "eth-mainnet",
+    base: "base-mainnet",
+    polygon: "polygon-mainnet",
+    matic: "polygon-mainnet",
+    arbitrum: "arb-mainnet",
+    arb: "arb-mainnet",
+    optimism: "opt-mainnet",
+    opt: "opt-mainnet",
+    zksync: "zksync-mainnet",
+    scroll: "scroll-mainnet",
+    linea: "linea-mainnet",
+    worldchain: "worldchain-mainnet"
+  };
+  return aliases[normalized] ?? raw;
+}
+function normalizeNetworkId(target) {
+  const explicit = numberValue(target.networkId) ?? numberValue(target.network_id) ?? numberValue(target.chainId) ?? numberValue(target.chain_id);
+  if (explicit) return explicit;
+  const raw = stringValue(target.network) ?? stringValue(target.chain) ?? "ethereum";
+  const aliases = {
+    eth: 1,
+    ethereum: 1,
+    mainnet: 1,
+    base: 8453,
+    polygon: 137,
+    matic: 137,
+    arbitrum: 42161,
+    arb: 42161,
+    optimism: 10,
+    opt: 10,
+    bsc: 56,
+    binance: 56,
+    avalanche: 43114,
+    avax: 43114,
+    linea: 59144,
+    scroll: 534352,
+    zksync: 324
+  };
+  return aliases[raw.toLowerCase()] ?? 1;
+}
+function isSolanaWalletTarget(target) {
+  const raw = stringValue(target.network) ?? stringValue(target.chain);
+  return ["sol", "solana", "svm", "solana-mainnet"].includes(
+    raw?.toLowerCase() ?? ""
+  );
+}
+function getMonitorTargetAddress(target) {
+  return stringValue(target.address) ?? stringValue(target.wallet) ?? stringValue(target.wallet_address) ?? stringValue(target.token_address) ?? stringValue(target.contract);
+}
+function buildWalletWorkflowPlan(monitor) {
+  const address = getMonitorTargetAddress(monitor.target);
+  if (!address) {
+    throw new Error("Wallet monitor target must include address.");
+  }
+  if (isSolanaWalletTarget(monitor.target)) {
+    return [
+      {
+        toolName: "helius_get_wallet_balances",
+        snapshotKey: "wallet_balances",
+        args: {
+          wallet: address,
+          limit: 100,
+          showNative: true,
+          showNfts: false
+        }
+      },
+      {
+        toolName: "helius_get_wallet_transfers",
+        snapshotKey: "wallet_transfers",
+        args: {
+          wallet: address,
+          limit: 25
+        }
+      },
+      {
+        toolName: "helius_get_wallet_history",
+        snapshotKey: "wallet_history",
+        args: {
+          wallet: address,
+          limit: 25
+        }
+      }
+    ];
+  }
+  const network = normalizeAlchemyNetwork(monitor.target);
+  const transferCategories = ["external", "erc20"];
+  const fromBlock = stringValue(monitor.target.from_block) ?? "0x0";
+  return [
+    {
+      toolName: "alchemy_get_token_balances_by_wallet",
+      snapshotKey: "token_balances",
+      args: {
+        address,
+        network,
+        includeNativeTokens: true,
+        includeErc20Tokens: true
+      }
+    },
+    {
+      toolName: "alchemy_get_native_balance",
+      snapshotKey: "native_balance",
+      args: { address, network }
+    },
+    {
+      toolName: "alchemy_get_asset_transfers",
+      snapshotKey: "outgoing_transfers",
+      args: {
+        network,
+        fromAddress: address,
+        fromBlock,
+        toBlock: "latest",
+        category: transferCategories,
+        maxCount: "0x5"
+      }
+    },
+    {
+      toolName: "alchemy_get_asset_transfers",
+      snapshotKey: "incoming_transfers",
+      args: {
+        network,
+        toAddress: address,
+        fromBlock,
+        toBlock: "latest",
+        category: transferCategories,
+        maxCount: "0x5"
+      }
+    }
+  ];
+}
+function buildTokenWorkflowPlan(monitor) {
+  const address = getMonitorTargetAddress(monitor.target);
+  if (!address) {
+    throw new Error("Token monitor target must include address.");
+  }
+  const network = normalizeAlchemyNetwork(monitor.target);
+  const networkId = normalizeNetworkId(monitor.target);
+  return [
+    {
+      toolName: "alchemy_get_token_metadata",
+      snapshotKey: "metadata",
+      args: { network, address }
+    },
+    {
+      toolName: "alchemy_get_token_prices_by_address",
+      snapshotKey: "alchemy_price",
+      args: { network, address }
+    },
+    {
+      toolName: "get_token_security",
+      snapshotKey: "security",
+      args: {
+        chainId: String(networkId),
+        contract_addresses: address
+      }
+    },
+    {
+      toolName: "get_token_price",
+      snapshotKey: "dex_price",
+      args: { inputs: [{ networkId, address }] }
+    },
+    {
+      toolName: "get_token_holders",
+      snapshotKey: "holders",
+      args: { networkId, address }
+    }
+  ];
+}
+function buildProtocolWorkflowPlan(monitor) {
+  const protocol = stringValue(monitor.target.protocol) ?? stringValue(monitor.target.slug) ?? stringValue(monitor.target.name);
+  if (!protocol) {
+    throw new Error("Protocol monitor target must include protocol.");
+  }
+  return [
+    {
+      toolName: "get_protocol_tvl",
+      snapshotKey: "tvl",
+      args: { protocol }
+    },
+    {
+      toolName: "get_protocol_fees",
+      snapshotKey: "fees",
+      args: { protocol }
+    },
+    {
+      toolName: "get_protocol_fee_summary",
+      snapshotKey: "fee_summary",
+      args: { protocol }
+    },
+    {
+      toolName: "get_global_defi",
+      snapshotKey: "global_defi",
+      args: {}
+    }
+  ];
+}
+function buildMarketWorkflowPlan(monitor) {
+  const ids = stringValue(monitor.target.ids) ?? stringValue(monitor.target.id) ?? stringValue(monitor.target.coin_id) ?? stringValue(monitor.target.symbol) ?? stringValue(monitor.target.name);
+  if (!ids) {
+    throw new Error("Market monitor target must include ids, id, coin_id, symbol, or name.");
+  }
+  const vsCurrencies = stringValue(monitor.target.vs_currencies) ?? stringValue(monitor.target.vs_currency) ?? "usd";
+  const calls = [
+    {
+      toolName: "get_price",
+      snapshotKey: "price",
+      args: {
+        ids,
+        vs_currencies: vsCurrencies,
+        include_market_cap: true,
+        include_24hr_vol: true,
+        include_24hr_change: true,
+        include_last_updated_at: true
+      }
+    }
+  ];
+  if (booleanValue(monitor.target.include_trending_pools) === true) {
+    calls.push({
+      toolName: "get_trending_pools",
+      snapshotKey: "trending_pools",
+      args: {
+        duration: stringValue(monitor.target.trending_duration) ?? "24h",
+        include: "base_token,quote_token,dex,network",
+        page: numberValue(monitor.target.trending_page) ?? 1
+      }
+    });
+  }
+  return calls;
+}
+function buildPredictionMarketWorkflowPlan(monitor) {
+  const marketId = stringValue(monitor.target.marketId) ?? stringValue(monitor.target.market_id) ?? stringValue(monitor.target.id);
+  if (marketId) {
+    return [
+      {
+        toolName: "codex_prediction_market_price",
+        snapshotKey: "market_price",
+        args: { marketId }
+      },
+      {
+        toolName: "codex_prediction_market_stats",
+        snapshotKey: "market_stats",
+        args: {
+          marketId,
+          bucketCount: numberValue(monitor.target.bucket_count) ?? 6,
+          durations: ["hour1", "day1"]
+        }
+      }
+    ];
+  }
+  const phrase = stringValue(monitor.target.phrase) ?? stringValue(monitor.target.query) ?? stringValue(monitor.target.title);
+  if (!phrase) {
+    throw new Error("Prediction-market monitor target must include marketId or phrase.");
+  }
+  return [
+    {
+      toolName: "codex_filter_prediction_markets",
+      snapshotKey: "market_search",
+      args: {
+        phrase,
+        limit: numberValue(monitor.target.limit) ?? 10,
+        offset: numberValue(monitor.target.offset) ?? 0
+      }
+    }
+  ];
+}
+function buildWatchlistDigestWorkflowPlan(monitor) {
+  const calls = [];
+  recordArray(monitor.target.wallets).slice(0, 2).forEach((wallet, index) => {
+    const target = { ...wallet };
+    if (!getMonitorTargetAddress(target) && typeof wallet.id === "string") {
+      target.address = wallet.id;
+    }
+    buildWalletWorkflowPlan({ target }).slice(0, 2).forEach((call) => {
+      calls.push({
+        ...call,
+        snapshotKey: `wallet_${index}_${call.snapshotKey}`
+      });
+    });
+  });
+  recordArray(monitor.target.tokens).slice(0, 2).forEach((token, index) => {
+    const target = { ...token };
+    if (!getMonitorTargetAddress(target) && typeof token.id === "string") {
+      target.address = token.id;
+    }
+    buildTokenWorkflowPlan({ target }).slice(0, 3).forEach((call) => {
+      calls.push({
+        ...call,
+        snapshotKey: `token_${index}_${call.snapshotKey}`
+      });
+    });
+  });
+  recordArray(monitor.target.protocols).slice(0, 2).forEach((protocol, index) => {
+    const target = { ...protocol };
+    if (!stringValue(target.protocol) && typeof protocol.id === "string") {
+      target.protocol = protocol.id;
+    }
+    buildProtocolWorkflowPlan({ target }).slice(0, 2).forEach((call) => {
+      calls.push({
+        ...call,
+        snapshotKey: `protocol_${index}_${call.snapshotKey}`
+      });
+    });
+  });
+  recordArray(monitor.target.markets).slice(0, 2).forEach((market, index) => {
+    const target = { ...market };
+    if (!stringValue(target.ids) && typeof market.id === "string") {
+      target.ids = market.id;
+    }
+    buildMarketWorkflowPlan({ target }).slice(0, 1).forEach((call) => {
+      calls.push({
+        ...call,
+        snapshotKey: `market_${index}_${call.snapshotKey}`
+      });
+    });
+  });
+  recordArray(monitor.target.prediction_markets).slice(0, 2).forEach((predictionMarket, index) => {
+    const target = { ...predictionMarket };
+    if (!stringValue(target.marketId) && typeof predictionMarket.id === "string") {
+      target.marketId = predictionMarket.id;
+    }
+    buildPredictionMarketWorkflowPlan({ target }).slice(0, 1).forEach((call) => {
+      calls.push({
+        ...call,
+        snapshotKey: `prediction_market_${index}_${call.snapshotKey}`
+      });
+    });
+  });
+  if (calls.length === 0) {
+    throw new Error(
+      "Watchlist digest target must include at least one wallet, token, protocol, market, or prediction_market."
+    );
+  }
+  return calls.slice(0, 20);
+}
+function buildTokenDiscoveryRiskWorkflowPlan(monitor) {
+  const calls = [];
+  const networks = stringArray(monitor.target.networks);
+  const include = "base_token,quote_token,dex,network";
+  if (networks.length === 0) {
+    calls.push({
+      toolName: "get_new_pools",
+      snapshotKey: "new_pools",
+      args: { include, page: numberValue(monitor.target.page) ?? 1 }
+    });
+  } else {
+    networks.slice(0, 3).forEach((network, index) => {
+      calls.push({
+        toolName: "get_new_pools_by_network",
+        snapshotKey: `new_pools_${index}`,
+        args: { network, include: "base_token,quote_token,dex", page: 1 }
+      });
+    });
+  }
+  calls.push({
+    toolName: "get_new_coins",
+    snapshotKey: "new_coins",
+    args: {}
+  });
+  stringArray(monitor.target.contracts ?? monitor.target.addresses).slice(0, 3).forEach((address, index) => {
+    const chainId = String(normalizeNetworkId(monitor.target));
+    calls.push({
+      toolName: "get_token_security",
+      snapshotKey: `token_security_${index}`,
+      args: { chainId, contract_addresses: address }
+    });
+  });
+  return calls;
+}
+function buildRiskWatchWorkflowPlan(monitor) {
+  const chainId = String(normalizeNetworkId(monitor.target));
+  const calls = [];
+  stringArray(monitor.target.addresses).slice(0, 5).forEach((address, index) => {
+    calls.push({
+      toolName: "check_malicious_address",
+      snapshotKey: `address_risk_${index}`,
+      args: { chainId, address }
+    });
+    calls.push({
+      toolName: "get_wallet_approvals",
+      snapshotKey: `wallet_approvals_${index}`,
+      args: { chainId, address }
+    });
+  });
+  stringArray(monitor.target.contracts).slice(0, 5).forEach((address, index) => {
+    calls.push({
+      toolName: "get_token_security",
+      snapshotKey: `contract_security_${index}`,
+      args: { chainId, contract_addresses: address }
+    });
+    calls.push({
+      toolName: "detect_rugpull",
+      snapshotKey: `rugpull_${index}`,
+      args: { chain_id: chainId, contract_address: address }
+    });
+  });
+  if (calls.length === 0) {
+    throw new Error("Risk-watch target must include addresses or contracts.");
+  }
+  return calls.slice(0, 20);
+}
+function buildMonitorWorkflowDefinition(monitor) {
+  switch (monitor.kind) {
+    case "wallet":
+      return {
+        type: "wallet",
+        label: "Wallet",
+        target: {
+          ...monitor.target,
+          address: getMonitorTargetAddress(monitor.target),
+          network: isSolanaWalletTarget(monitor.target) ? "solana" : normalizeAlchemyNetwork(monitor.target)
+        },
+        calls: buildWalletWorkflowPlan(monitor)
+      };
+    case "token":
+      return {
+        type: "token",
+        label: "Token",
+        target: {
+          ...monitor.target,
+          address: getMonitorTargetAddress(monitor.target),
+          network: normalizeAlchemyNetwork(monitor.target),
+          networkId: normalizeNetworkId(monitor.target)
+        },
+        calls: buildTokenWorkflowPlan(monitor)
+      };
+    case "protocol": {
+      const protocol = stringValue(monitor.target.protocol) ?? stringValue(monitor.target.slug) ?? stringValue(monitor.target.name);
+      return {
+        type: "protocol",
+        label: "Protocol",
+        target: { ...monitor.target, protocol },
+        calls: buildProtocolWorkflowPlan(monitor)
+      };
+    }
+    case "market": {
+      const ids = stringValue(monitor.target.ids) ?? stringValue(monitor.target.id) ?? stringValue(monitor.target.coin_id) ?? stringValue(monitor.target.symbol) ?? stringValue(monitor.target.name);
+      return {
+        type: "market",
+        label: "Market",
+        target: {
+          ...monitor.target,
+          ids,
+          vs_currencies: stringValue(monitor.target.vs_currencies) ?? stringValue(monitor.target.vs_currency) ?? "usd"
+        },
+        calls: buildMarketWorkflowPlan(monitor)
+      };
+    }
+    case "prediction_market":
+      return {
+        type: "prediction_market",
+        label: "Prediction market",
+        target: monitor.target,
+        calls: buildPredictionMarketWorkflowPlan(monitor)
+      };
+    case "watchlist_digest":
+      return {
+        type: "watchlist_digest",
+        label: "Watchlist digest",
+        target: monitor.target,
+        calls: buildWatchlistDigestWorkflowPlan(monitor)
+      };
+    case "token_discovery_risk":
+      return {
+        type: "token_discovery_risk",
+        label: "Token discovery risk",
+        target: monitor.target,
+        calls: buildTokenDiscoveryRiskWorkflowPlan(monitor)
+      };
+    case "risk_watch":
+      return {
+        type: "risk_watch",
+        label: "Risk watch",
+        target: monitor.target,
+        calls: buildRiskWatchWorkflowPlan(monitor)
+      };
+  }
+}
+function sortedJson(value) {
+  if (Array.isArray(value)) return `[${value.map(sortedJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${sortedJson(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function stripVolatileFields(value) {
+  if (Array.isArray(value)) return value.map(stripVolatileFields);
+  if (!isRecord(value)) return value;
+  const omitted = /* @__PURE__ */ new Set([
+    "_hive",
+    "duration_ms",
+    "fetched_at",
+    "captured_at",
+    "created_at",
+    "updated_at",
+    "cache_status",
+    "request_id"
+  ]);
+  return Object.fromEntries(
+    Object.entries(value).filter(([key]) => !omitted.has(key)).map(([key, item]) => [key, stripVolatileFields(item)])
+  );
+}
+function compactForStorage(value, depth = 0) {
+  if (depth > 8) return "[max-depth]";
+  if (typeof value === "string") {
+    return value.length > 5e3 ? `${value.slice(0, 5e3)}...[truncated]` : value;
+  }
+  if (Array.isArray(value)) {
+    const items = value.slice(0, 50).map((item) => compactForStorage(item, depth + 1));
+    if (value.length > items.length) {
+      items.push({ _truncated_items: value.length - items.length });
+    }
+    return items;
+  }
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        compactForStorage(item, depth + 1)
+      ])
+    );
+  }
+  return value;
+}
+function fingerprintSnapshot(snapshot) {
+  return createHash("sha256").update(sortedJson(stripVolatileFields(snapshot))).digest("hex");
+}
+function computeNextRunAt(cadence, from = /* @__PURE__ */ new Date()) {
+  const normalized = (cadence ?? "manual").trim().toLowerCase();
+  if (!normalized || normalized === "manual" || normalized === "once") {
+    return null;
+  }
+  const intervalMatch = normalized.match(/^(\d+)\s*(m|min|minute|minutes|h|hr|hour|hours|d|day|days|w|week|weeks)$/);
+  const next = new Date(from);
+  if (intervalMatch) {
+    const amount = Number.parseInt(intervalMatch[1], 10);
+    const unit = intervalMatch[2];
+    if (unit.startsWith("m")) next.setMinutes(next.getMinutes() + amount);
+    else if (unit.startsWith("h")) next.setHours(next.getHours() + amount);
+    else if (unit.startsWith("d")) next.setDate(next.getDate() + amount);
+    else next.setDate(next.getDate() + amount * 7);
+    return next.toISOString();
+  }
+  if (normalized === "hourly") next.setHours(next.getHours() + 1);
+  else if (normalized === "daily") next.setDate(next.getDate() + 1);
+  else if (normalized === "weekly") next.setDate(next.getDate() + 7);
+  else return null;
+  return next.toISOString();
+}
+function hasAlertRule(monitor) {
+  return monitor.rules.some(
+    (rule) => isRecord(rule) && (rule.alert === true || rule.notify === true || [
+      "any_change",
+      "wallet_change",
+      "large_transfer",
+      "token_change",
+      "protocol_change",
+      "market_change",
+      "prediction_market_change"
+    ].includes(String(rule.type ?? "")))
+  );
+}
+var RULE_SEVERITY_ORDER = {
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
+function ruleType(rule) {
+  if (!isRecord(rule)) return void 0;
+  return stringValue(rule.type) ?? stringValue(rule.metric);
+}
+function ruleThreshold(rule) {
+  if (!isRecord(rule)) return void 0;
+  return numberValue(rule.threshold) ?? numberValue(rule.threshold_pct) ?? numberValue(rule.min_value) ?? numberValue(rule.value);
+}
+function collectNumbersByKey(value, keyPatterns) {
+  const found = [];
+  const visit = (item, key = "") => {
+    if (found.length >= 100) return;
+    if (typeof item === "number" && Number.isFinite(item)) {
+      if (keyPatterns.some((pattern) => pattern.test(key))) found.push(item);
+      return;
+    }
+    if (typeof item === "string" && item.trim()) {
+      const parsed = Number(item.replace(/[$,%]/g, ""));
+      if (Number.isFinite(parsed) && keyPatterns.some((pattern) => pattern.test(key))) {
+        found.push(parsed);
+      }
+      return;
+    }
+    if (Array.isArray(item)) {
+      item.forEach((child) => visit(child, key));
+      return;
+    }
+    if (isRecord(item)) {
+      Object.entries(item).forEach(([childKey, child]) => visit(child, childKey));
+    }
+  };
+  visit(value);
+  return found;
+}
+function maxAbsPercentChange(previous, current) {
+  const count = Math.min(previous.length, current.length);
+  let maxChange = null;
+  for (let index = 0; index < count; index++) {
+    const before = previous[index];
+    const after = current[index];
+    if (!Number.isFinite(before) || !Number.isFinite(after) || before === 0) continue;
+    const change = Math.abs((after - before) / before * 100);
+    maxChange = maxChange === null ? change : Math.max(maxChange, change);
+  }
+  return maxChange;
+}
+function thresholdSeverity(value, threshold) {
+  if (value >= threshold * 5) return "critical";
+  if (value >= threshold * 3) return "high";
+  if (value >= threshold * 1.5) return "medium";
+  return "low";
+}
+function detectRiskSeverity(snapshot) {
+  const text = sortedJson(snapshot).toLowerCase();
+  if (/\bcritical\b|is_malicious[^a-z0-9]*true|honeypot[^a-z0-9]*true|rugpull[^a-z0-9]*true/.test(text)) {
+    return "critical";
+  }
+  if (/\bhigh\b|blacklist[^a-z0-9]*true|phishing[^a-z0-9]*true/.test(text)) {
+    return "high";
+  }
+  if (/\bmedium\b|warning|suspicious/.test(text)) return "medium";
+  if (/\blow\b/.test(text)) return "low";
+  return null;
+}
+function severityAtLeast(actual, minimum) {
+  return RULE_SEVERITY_ORDER[actual] >= RULE_SEVERITY_ORDER[minimum];
+}
+function evaluateMonitorRules(args) {
+  const evaluations = [];
+  for (const rule of args.monitor.rules) {
+    const type = ruleType(rule);
+    if (!type) continue;
+    if (type === "risk_severity_at_least") {
+      const minimum = isRecord(rule) && stringValue(rule.severity) || isRecord(rule) && stringValue(rule.minimum) || "high";
+      if (!["low", "medium", "high", "critical"].includes(minimum)) continue;
+      const actual = detectRiskSeverity(args.currentSnapshot);
+      if (actual && severityAtLeast(actual, minimum)) {
+        evaluations.push({
+          kind: "rule_risk_severity_at_least",
+          severity: actual,
+          title: `${args.monitor.name} matched risk severity rule`,
+          evidence: { rule, actual_severity: actual, minimum_severity: minimum }
+        });
+      }
+      continue;
+    }
+    const threshold = ruleThreshold(rule);
+    if (threshold === void 0 || threshold <= 0) continue;
+    const patternsByType = {
+      price_change_pct: [/price/i, /usd/i],
+      tvl_change_pct: [/tvl/i, /liquidity/i, /totalLiquidityUSD/i],
+      fee_change_pct: [/fee/i, /fees/i, /total24h/i, /total7d/i],
+      liquidity_change_pct: [/liquidity/i, /reserve.*usd/i, /totalLiquidityUSD/i],
+      transfer_value_usd: [/value.*usd/i, /amount.*usd/i, /usd/i]
+    };
+    const patterns = patternsByType[type];
+    if (!patterns) continue;
+    const currentNumbers = collectNumbersByKey(args.currentSnapshot, patterns);
+    if (type === "transfer_value_usd") {
+      const maxValue = Math.max(...currentNumbers, 0);
+      if (maxValue >= threshold) {
+        evaluations.push({
+          kind: "rule_transfer_value_usd",
+          severity: thresholdSeverity(maxValue, threshold),
+          title: `${args.monitor.name} matched transfer value rule`,
+          evidence: { rule, max_value_usd: maxValue, threshold }
+        });
+      }
+      continue;
+    }
+    if (!args.previousSnapshot) continue;
+    const previousNumbers = collectNumbersByKey(args.previousSnapshot, patterns);
+    const maxChange = maxAbsPercentChange(previousNumbers, currentNumbers);
+    if (maxChange !== null && maxChange >= threshold) {
+      evaluations.push({
+        kind: `rule_${type}`,
+        severity: thresholdSeverity(maxChange, threshold),
+        title: `${args.monitor.name} matched ${type} rule`,
+        evidence: { rule, max_change_pct: maxChange, threshold }
+      });
+    }
+  }
+  return evaluations;
+}
+async function executeMonitorWorkflow(monitor, executeTool, now) {
+  const definition = buildMonitorWorkflowDefinition(monitor);
+  const results = {};
+  const toolCalls = [];
+  const failedCalls = [];
+  for (const call of definition.calls) {
+    const result = await executeTool(call.toolName, call.args);
+    const record = {
+      tool: call.toolName,
+      args: call.args,
+      ok: result.ok,
+      duration_ms: result.durationMs,
+      runtime_status: result.meta.runtime_status,
+      ...result.error && { error: result.error.message }
+    };
+    toolCalls.push(record);
+    if (!result.ok) failedCalls.push(record);
+    results[call.snapshotKey] = result.ok ? compactForStorage(result.data) : { error: result.error?.message ?? "Tool call failed" };
+  }
+  const snapshot = {
+    type: definition.type,
+    monitor_id: monitor.id,
+    captured_at: now.toISOString(),
+    target: definition.target,
+    results
+  };
+  return {
+    type: definition.type,
+    label: definition.label,
+    snapshot,
+    fingerprint: fingerprintSnapshot(snapshot),
+    toolCalls,
+    failedCalls
+  };
+}
+var SupabaseMonitorRunnerStore = class {
+  supabase() {
+    if (!isSupabaseConfigured()) {
+      throw new Error(
+        "Supabase is not configured. Set SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY."
+      );
+    }
+    return getSupabaseAdmin();
+  }
+  async claimDueMonitors(args) {
+    const { data, error } = await this.supabase().rpc("claim_due_monitors", {
+      batch_limit: args.batchSize,
+      worker_id: args.workerId,
+      lock_timeout_seconds: args.lockTimeoutSeconds
+    });
+    if (error) {
+      secureLogger.error("claim_due_monitors failed", error, {
+        workerId: args.workerId
+      });
+      return {
+        ok: false,
+        code: "STATE_BACKEND_UNAVAILABLE",
+        message: `Failed to claim due monitors: ${error.message}`
+      };
+    }
+    return { ok: true, data: data ?? [] };
+  }
+  async createRun(args) {
+    const { data, error } = await this.supabase().from("monitor_runs").insert({
+      monitor_id: args.monitor.id,
+      user_id: args.monitor.user_id,
+      subject_id: args.monitor.subject_id,
+      status: "running",
+      source: args.source,
+      metadata: { worker_id: args.workerId }
+    }).select("*").single();
+    if (error) throw new Error(`Failed to create monitor run: ${error.message}`);
+    return data;
+  }
+  async getLatestSnapshot(monitorId) {
+    const { data, error } = await this.supabase().from("monitor_snapshots").select("*").eq("monitor_id", monitorId).order("created_at", { ascending: false }).limit(1).maybeSingle();
+    if (error) throw new Error(`Failed to fetch latest snapshot: ${error.message}`);
+    return data ?? null;
+  }
+  async writeSnapshot(args) {
+    const { error } = await this.supabase().from("monitor_snapshots").insert({
+      monitor_id: args.monitor.id,
+      user_id: args.monitor.user_id,
+      subject_id: args.monitor.subject_id,
+      run_id: args.runId,
+      snapshot: args.snapshot,
+      fingerprint: args.fingerprint
+    });
+    if (error && error.code !== "23505") {
+      throw new Error(`Failed to write snapshot: ${error.message}`);
+    }
+  }
+  async writeObservation(args) {
+    const { error } = await this.supabase().from("observations").insert({
+      monitor_id: args.monitor.id,
+      user_id: args.monitor.user_id,
+      subject_id: args.monitor.subject_id,
+      run_id: args.runId,
+      kind: args.kind,
+      severity: args.severity,
+      title: args.title,
+      evidence: args.evidence
+    });
+    if (error) throw new Error(`Failed to write observation: ${error.message}`);
+  }
+  async writeAlert(args) {
+    const { error } = await this.supabase().from("alerts").insert({
+      monitor_id: args.monitor.id,
+      user_id: args.monitor.user_id,
+      subject_id: args.monitor.subject_id,
+      severity: args.severity,
+      title: args.title,
+      body: args.body,
+      payload: args.payload
+    });
+    if (error) throw new Error(`Failed to write alert: ${error.message}`);
+  }
+  async finishRun(args) {
+    const { error } = await this.supabase().from("monitor_runs").update({
+      status: args.status,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      tool_calls: args.toolCalls,
+      summary: args.summary,
+      error_code: args.errorCode ?? null,
+      error_message: args.errorMessage ?? null,
+      metadata: args.metadata ?? {}
+    }).eq("id", args.runId);
+    if (error) throw new Error(`Failed to finish monitor run: ${error.message}`);
+  }
+  async releaseMonitor(args) {
+    const { error } = await this.supabase().from("monitors").update({
+      last_run_at: args.lastRunAt,
+      next_run_at: args.nextRunAt,
+      locked_at: null,
+      locked_by: null,
+      ...args.status && { status: args.status }
+    }).eq("id", args.monitor.id).eq("user_id", args.monitor.user_id).eq("subject_id", args.monitor.subject_id);
+    if (error) throw new Error(`Failed to release monitor: ${error.message}`);
+  }
+};
+async function processMonitor(monitor, options) {
+  const run = await options.store.createRun({
+    monitor,
+    workerId: options.workerId,
+    source: options.source
+  });
+  const completedAt = options.now.toISOString();
+  const nextRunAt = computeNextRunAt(monitor.cadence, options.now);
+  try {
+    const previous = await options.store.getLatestSnapshot(monitor.id);
+    const workflow = await executeMonitorWorkflow(
+      monitor,
+      options.executeTool,
+      options.now
+    );
+    await options.store.writeSnapshot({
+      monitor,
+      runId: run.id,
+      snapshot: workflow.snapshot,
+      fingerprint: workflow.fingerprint
+    });
+    const ruleEvaluations = evaluateMonitorRules({
+      monitor,
+      previousSnapshot: previous?.snapshot ?? null,
+      currentSnapshot: workflow.snapshot
+    });
+    let observations = 0;
+    let alerts = 0;
+    const observationPrefix = workflow.type;
+    let summary = `${workflow.label} monitor completed with no material change.`;
+    if (!previous) {
+      summary = `${workflow.label} monitor baseline snapshot recorded.`;
+      await options.store.writeObservation({
+        monitor,
+        runId: run.id,
+        kind: `${observationPrefix}_baseline`,
+        severity: "info",
+        title: `Baseline recorded for ${monitor.name}`,
+        evidence: { fingerprint: workflow.fingerprint }
+      });
+      observations++;
+    } else if (previous.fingerprint !== workflow.fingerprint) {
+      summary = `${workflow.label} monitor detected a snapshot change.`;
+      const evidence = {
+        previous_fingerprint: previous.fingerprint,
+        current_fingerprint: workflow.fingerprint,
+        failed_calls: workflow.failedCalls.map((call) => call.tool)
+      };
+      await options.store.writeObservation({
+        monitor,
+        runId: run.id,
+        kind: `${observationPrefix}_change`,
+        severity: workflow.failedCalls.length > 0 ? "medium" : "low",
+        title: `${workflow.label} monitor changed: ${monitor.name}`,
+        evidence
+      });
+      observations++;
+      if (hasAlertRule(monitor)) {
+        await options.store.writeAlert({
+          monitor,
+          severity: workflow.failedCalls.length > 0 ? "medium" : "low",
+          title: `${workflow.label} monitor changed: ${monitor.name}`,
+          body: `Hive detected a changed ${workflow.type} snapshot for this monitor.`,
+          payload: evidence
+        });
+        alerts++;
+      }
+    }
+    for (const evaluation of ruleEvaluations) {
+      await options.store.writeObservation({
+        monitor,
+        runId: run.id,
+        kind: evaluation.kind,
+        severity: evaluation.severity,
+        title: evaluation.title,
+        evidence: evaluation.evidence
+      });
+      observations++;
+      await options.store.writeAlert({
+        monitor,
+        severity: evaluation.severity,
+        title: evaluation.title,
+        body: "Hive matched a deterministic monitor rule threshold.",
+        payload: evaluation.evidence
+      });
+      alerts++;
+    }
+    if (workflow.failedCalls.length > 0) {
+      await options.store.writeObservation({
+        monitor,
+        runId: run.id,
+        kind: `${observationPrefix}_monitor_degraded`,
+        severity: "medium",
+        title: `${workflow.label} monitor had ${workflow.failedCalls.length} failed tool call(s)`,
+        evidence: {
+          failed_calls: workflow.failedCalls.map((call) => ({
+            tool: call.tool,
+            error: call.error
+          }))
+        }
+      });
+      observations++;
+    }
+    await options.store.finishRun({
+      runId: run.id,
+      status: "completed",
+      summary,
+      toolCalls: workflow.toolCalls,
+      metadata: {
+        fingerprint: workflow.fingerprint,
+        failed_call_count: workflow.failedCalls.length,
+        rule_evaluation_count: ruleEvaluations.length
+      }
+    });
+    await options.store.releaseMonitor({
+      monitor,
+      lastRunAt: completedAt,
+      nextRunAt
+    });
+    return {
+      monitorId: monitor.id,
+      kind: monitor.kind,
+      status: "completed",
+      runId: run.id,
+      summary,
+      nextRunAt,
+      observations,
+      alerts
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await options.store.finishRun({
+      runId: run.id,
+      status: "failed",
+      summary: "Monitor run failed.",
+      toolCalls: [],
+      errorCode: "MONITOR_RUN_FAILED",
+      errorMessage: message
+    });
+    await options.store.releaseMonitor({
+      monitor,
+      lastRunAt: completedAt,
+      nextRunAt
+    });
+    return {
+      monitorId: monitor.id,
+      kind: monitor.kind,
+      status: "failed",
+      runId: run.id,
+      summary: message,
+      nextRunAt,
+      observations: 0,
+      alerts: 0
+    };
+  }
+}
+async function runDueMonitors(options = {}) {
+  const store = options.store ?? new SupabaseMonitorRunnerStore();
+  const workerId = options.workerId ?? DEFAULT_WORKER_ID;
+  const batchSize = Math.max(1, Math.min(options.batchSize ?? DEFAULT_BATCH_SIZE, 100));
+  const lockTimeoutSeconds = options.lockTimeoutSeconds ?? DEFAULT_LOCK_TIMEOUT_SECONDS;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const executeTool = options.executeTool ?? executeToolByName;
+  const source = options.source ?? "scheduled";
+  const claimed = await store.claimDueMonitors({
+    batchSize,
+    workerId,
+    lockTimeoutSeconds
+  });
+  if (!claimed.ok) {
+    return {
+      ok: false,
+      claimed: 0,
+      completed: 0,
+      failed: 0,
+      skipped: 0,
+      results: [],
+      error: claimed.message
+    };
+  }
+  const results = [];
+  for (const monitor of claimed.data) {
+    results.push(
+      await processMonitor(monitor, {
+        store,
+        workerId,
+        now,
+        source,
+        executeTool
+      })
+    );
+  }
+  return {
+    ok: results.every((result) => result.status !== "failed"),
+    claimed: claimed.data.length,
+    completed: results.filter((result) => result.status === "completed").length,
+    failed: results.filter((result) => result.status === "failed").length,
+    skipped: results.filter((result) => result.status === "skipped").length,
+    results
+  };
+}
+
+// src/monitor-worker.ts
+function intEnv(name, fallback) {
+  const parsed = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+async function runMonitorWorkerFromEnv() {
+  try {
+    const result = await runDueMonitors({
+      batchSize: intEnv("HIVE_MONITOR_WORKER_BATCH_SIZE", 10),
+      workerId: process.env.HIVE_MONITOR_WORKER_ID,
+      lockTimeoutSeconds: intEnv("HIVE_MONITOR_LOCK_TIMEOUT_SECONDS", 300)
+    });
+    console.log(
+      JSON.stringify(
+        {
+          service: "hive-monitor-worker",
+          worker_id: process.env.HIVE_MONITOR_WORKER_ID ?? null,
+          ...result
+        },
+        null,
+        2
+      )
+    );
+    if (!result.ok) process.exitCode = 1;
+  } finally {
+    await closeRedisClient();
+  }
+}
+var invokedPath = process.argv[1] ? resolve(process.argv[1]) : "";
+if (invokedPath === fileURLToPath(import.meta.url)) {
+  runMonitorWorkerFromEnv().catch((error) => {
+    console.error(
+      JSON.stringify({
+        service: "hive-monitor-worker",
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      })
+    );
+    process.exitCode = 1;
+  });
+}
+export {
+  runMonitorWorkerFromEnv
+};