@moly-mcp/lido 1.0.6 → 1.0.8

package/dist/chunk-GL6TLHSF.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+import {
+  L2_CHAINS,
+  getBalance,
+  getConversionRate,
+  getRuntime
+} from "./chunk-EKZFGIVK.js";
+
+// src/tools/bridge.ts
+import { formatEther, parseEther, parseAbi } from "viem";
+var LIFI_BASE = "https://li.quest/v1";
+var ERC20_ABI = parseAbi([
+  "function balanceOf(address) view returns (uint256)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)"
+]);
+var NATIVE_TOKEN = "0x0000000000000000000000000000000000000000";
+var L1_WSTETH = "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0";
+function tokenAddress(chain, token) {
+  if (token === "ETH") return NATIVE_TOKEN;
+  return L2_CHAINS[chain].wstETH;
+}
+function toTokenAddress(toToken) {
+  if (!toToken || toToken === "ETH") return NATIVE_TOKEN;
+  return L1_WSTETH;
+}
+function ensureMainnet() {
+  const rt = getRuntime();
+  if (rt.config.network !== "mainnet") {
+    throw new Error("Bridge tools only work on mainnet. LI.FI does not support testnets.");
+  }
+}
+async function getL2Balance(sourceChain, address) {
+  ensureMainnet();
+  const rt = getRuntime();
+  const addr = address ?? rt.getAddress();
+  const client = rt.getL2PublicClient(sourceChain);
+  const cfg = L2_CHAINS[sourceChain];
+  const [eth, wsteth] = await Promise.all([
+    client.getBalance({ address: addr }),
+    client.readContract({ address: cfg.wstETH, abi: ERC20_ABI, functionName: "balanceOf", args: [addr] })
+  ]);
+  return {
+    address: addr,
+    chain: cfg.name,
+    chainId: cfg.chainId,
+    balances: { ETH: formatEther(eth), wstETH: formatEther(wsteth) }
+  };
+}
+async function getBridgeQuote(sourceChain, token, amount, toToken) {
+  ensureMainnet();
+  const rt = getRuntime();
+  const addr = rt.getAddress();
+  const cfg = L2_CHAINS[sourceChain];
+  const fromToken = tokenAddress(sourceChain, token);
+  const toAddr = toTokenAddress(toToken);
+  const fromAmount = parseEther(amount).toString();
+  const url = `${LIFI_BASE}/quote?fromChain=${cfg.chainId}&toChain=1&fromToken=${fromToken}&toToken=${toAddr}&fromAmount=${fromAmount}&fromAddress=${addr}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`LI.FI quote failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  return {
+    sourceChain: cfg.name,
+    token,
+    amount,
+    toToken: toToken ?? "ETH",
+    toAmount: formatEther(BigInt(data.estimate?.toAmount ?? "0")),
+    estimatedDuration: `${Math.ceil((data.estimate?.executionDuration ?? 0) / 60)} min`,
+    gasCosts: data.estimate?.gasCosts ?? [],
+    feeCosts: data.estimate?.feeCosts ?? [],
+    tool: data.tool
+  };
+}
+async function bridgeToEthereum(sourceChain, token, amount, toToken, dryRun) {
+  ensureMainnet();
+  const rt = getRuntime();
+  const addr = rt.getAddress();
+  const cfg = L2_CHAINS[sourceChain];
+  const fromToken = tokenAddress(sourceChain, token);
+  const toAddr = toTokenAddress(toToken);
+  const fromAmount = parseEther(amount).toString();
+  const shouldDryRun = rt.config.mode === "simulation" ? dryRun !== false : !!dryRun;
+  const url = `${LIFI_BASE}/quote?fromChain=${cfg.chainId}&toChain=1&fromToken=${fromToken}&toToken=${toAddr}&fromAmount=${fromAmount}&fromAddress=${addr}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`LI.FI quote failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  const txReq = data.transactionRequest;
+  const quote = {
+    sourceChain: cfg.name,
+    token,
+    amount,
+    toToken: toToken ?? "ETH",
+    toAmount: formatEther(BigInt(data.estimate?.toAmount ?? "0")),
+    estimatedDuration: `${Math.ceil((data.estimate?.executionDuration ?? 0) / 60)} min`,
+    tool: data.tool
+  };
+  if (shouldDryRun) {
+    return { simulated: true, mode: rt.config.mode, ...quote };
+  }
+  const wallet = rt.getL2Wallet(sourceChain);
+  const client = rt.getL2PublicClient(sourceChain);
+  if (token === "wstETH" && txReq.to) {
+    const allowance = await client.readContract({
+      address: cfg.wstETH,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [addr, txReq.to]
+    });
+    if (allowance < BigInt(fromAmount)) {
+      const approveTx = await wallet.writeContract({
+        address: cfg.wstETH,
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [txReq.to, BigInt(fromAmount)]
+      });
+      await client.waitForTransactionReceipt({ hash: approveTx });
+    }
+  }
+  const hash = await wallet.sendTransaction({
+    to: txReq.to,
+    data: txReq.data,
+    value: txReq.value ? BigInt(txReq.value) : 0n,
+    gas: txReq.gasLimit ? BigInt(txReq.gasLimit) : void 0,
+    chain: void 0
+  });
+  return {
+    simulated: false,
+    mode: rt.config.mode,
+    ...quote,
+    txHash: hash,
+    note: "Bridge submitted. Use get_bridge_status to track progress (may take 1-20 min)."
+  };
+}
+async function getBridgeStatus(txHash, sourceChain) {
+  ensureMainnet();
+  const cfg = L2_CHAINS[sourceChain];
+  const url = `${LIFI_BASE}/status?txHash=${txHash}&fromChain=${cfg.chainId}&toChain=1`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`LI.FI status failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  return {
+    txHash,
+    sourceChain: cfg.name,
+    status: data.status,
+    substatus: data.substatus ?? null,
+    sending: data.sending ? { txHash: data.sending.txHash, amount: data.sending.amount } : null,
+    receiving: data.receiving ? { txHash: data.receiving.txHash, amount: data.receiving.amount } : null
+  };
+}
+
+// src/tools/position.ts
+async function getTotalPosition(address) {
+  const rt = getRuntime();
+  const addr = address ?? rt.getAddress();
+  const isMainnet = rt.config.network === "mainnet";
+  const l1 = await getBalance(addr);
+  const rate = await getConversionRate();
+  const wstethToEth = parseFloat(rate["1_wstETH_in_stETH"]);
+  const l1Eth = parseFloat(l1.balances.eth);
+  const l1Steth = parseFloat(l1.balances.stETH);
+  const l1Wsteth = parseFloat(l1.balances.wstETH);
+  const l1WstethInEth = l1Wsteth * wstethToEth;
+  const positions = {
+    ethereum: {
+      eth: l1.balances.eth,
+      stETH: l1.balances.stETH,
+      wstETH: l1.balances.wstETH,
+      ethEquivalent: (l1Eth + l1Steth + l1WstethInEth).toFixed(6)
+    }
+  };
+  let totalEthEquiv = l1Eth + l1Steth + l1WstethInEth;
+  if (isMainnet) {
+    for (const chain of ["base", "arbitrum"]) {
+      try {
+        const l2 = await getL2Balance(chain, addr);
+        const l2Eth = parseFloat(l2.balances.ETH);
+        const l2Wsteth = parseFloat(l2.balances.wstETH);
+        const l2WstethInEth = l2Wsteth * wstethToEth;
+        positions[chain] = {
+          eth: l2.balances.ETH,
+          wstETH: l2.balances.wstETH,
+          ethEquivalent: (l2Eth + l2WstethInEth).toFixed(6)
+        };
+        totalEthEquiv += l2Eth + l2WstethInEth;
+      } catch {
+        positions[chain] = { error: "failed to fetch" };
+      }
+    }
+  }
+  return {
+    address: addr,
+    network: rt.chainAddresses.name,
+    conversionRate: rate["1_wstETH_in_stETH"],
+    positions,
+    totalEthEquivalent: totalEthEquiv.toFixed(6),
+    note: isMainnet ? "Includes Ethereum + Base + Arbitrum" : "Testnet: Ethereum only"
+  };
+}
+
+export {
+  getL2Balance,
+  getBridgeQuote,
+  bridgeToEthereum,
+  getBridgeStatus,
+  getTotalPosition
+};

package/dist/{chunk-PIFEXJ56.js → chunk-P6VFMSPM.js}

@@ -11,10 +11,14 @@ function configExists() {
 }
 function loadConfig() {
   if (!existsSync(CONFIG_PATH)) {
-    throw new Error("No config found. Run: npx @moly/lido  (or: moly setup)");
+    throw new Error("No config found. Run: npx @moly-mcp/lido  (or: moly setup)");
   }
   try {
-    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    const cfg = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    if (!cfg.chainScope) cfg.chainScope = "ethereum";
+    if (!cfg.ows) cfg.ows = null;
+    if (!cfg.alertChannels) cfg.alertChannels = null;
+    return cfg;
   } catch {
     throw new Error(`Failed to parse config at ${CONFIG_PATH}. Run: moly reset`);
   }
@@ -29,6 +33,12 @@ function saveConfig(cfg) {
   } catch {
   }
 }
+function updateConfig(partial) {
+  const current = loadConfig();
+  const next = { ...current, ...partial };
+  saveConfig(next);
+  return next;
+}
 function deleteConfig() {
   if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
 }
@@ -39,8 +49,14 @@ function redactedConfig(cfg) {
   return {
     network: cfg.network,
     mode: cfg.mode,
+    chainScope: cfg.chainScope ?? "ethereum",
     rpc: cfg.rpc ?? "(default public RPC)",
     privateKey: cfg.privateKey ? "*** configured" : "(not set)",
+    ows: cfg.ows ? { walletName: cfg.ows.walletName, passphrase: "*** configured" } : "(not configured)",
+    alertChannels: cfg.alertChannels ? {
+      telegram: cfg.alertChannels.telegram ? { chatId: cfg.alertChannels.telegram.chatId, token: "*** configured" } : void 0,
+      webhook: cfg.alertChannels.webhook ? { url: cfg.alertChannels.webhook.url } : void 0
+    } : "(not configured)",
     ai: cfg.ai ? {
       provider: cfg.ai.provider,
       model: cfg.ai.model,
@@ -53,6 +69,7 @@ export {
   configExists,
   loadConfig,
   saveConfig,
+  updateConfig,
   deleteConfig,
   getConfigPath,
   redactedConfig

package/dist/chunk-PDX44BCA.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-RR74UAKD.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./chunk-PDX44BCA.js";
+
+// src/ledger/store.ts
+import Database from "better-sqlite3";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DB_PATH = join(homedir(), ".moly", "ledger.db");
+var MARKER = join(homedir(), ".moly", ".ledger_imported");
+var _db = null;
+function getDb() {
+  if (_db) return _db;
+  _db = new Database(DB_PATH);
+  _db.pragma("journal_mode = WAL");
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS ledger (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp TEXT NOT NULL,
+      tool TEXT NOT NULL,
+      args TEXT,
+      result TEXT,
+      wallet TEXT,
+      chain TEXT,
+      status TEXT DEFAULT 'ok',
+      tx_hash TEXT,
+      gas_used TEXT,
+      amount TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_ledger_ts ON ledger(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_ledger_tool ON ledger(tool);
+    CREATE INDEX IF NOT EXISTS idx_ledger_wallet ON ledger(wallet);
+    CREATE INDEX IF NOT EXISTS idx_ledger_tx ON ledger(tx_hash);
+  `);
+  return _db;
+}
+function initLedger() {
+  getDb();
+  importJsonlIfNeeded();
+}
+function logEntry(entry) {
+  const db = getDb();
+  db.prepare(`
+    INSERT INTO ledger (timestamp, tool, args, result, wallet, chain, status, tx_hash, gas_used, amount)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    (/* @__PURE__ */ new Date()).toISOString(),
+    entry.tool,
+    JSON.stringify(entry.args),
+    entry.result.slice(0, 4e3),
+    entry.wallet ?? null,
+    entry.chain ?? null,
+    entry.status ?? "ok",
+    entry.tx_hash ?? null,
+    entry.gas_used ?? null,
+    entry.amount ?? null
+  );
+}
+function queryLedger(opts = {}) {
+  const db = getDb();
+  const conditions = [];
+  const params = [];
+  if (opts.tool) {
+    conditions.push("tool = ?");
+    params.push(opts.tool);
+  }
+  if (opts.wallet) {
+    conditions.push("wallet = ?");
+    params.push(opts.wallet);
+  }
+  if (opts.chain) {
+    conditions.push("chain = ?");
+    params.push(opts.chain);
+  }
+  if (opts.since) {
+    conditions.push("timestamp >= ?");
+    params.push(opts.since);
+  }
+  if (opts.tx_hash) {
+    conditions.push("tx_hash = ?");
+    params.push(opts.tx_hash);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = opts.limit ?? 50;
+  return db.prepare(`SELECT * FROM ledger ${where} ORDER BY id DESC LIMIT ?`).all(...params, limit);
+}
+function ledgerStats(since) {
+  const db = getDb();
+  const where = since ? "WHERE timestamp >= ?" : "";
+  const params = since ? [since] : [];
+  const total = db.prepare(`SELECT COUNT(*) as count FROM ledger ${where}`).get(...params)?.count ?? 0;
+  const errors = db.prepare(`SELECT COUNT(*) as count FROM ledger ${where ? where + " AND" : "WHERE"} status = 'error'`).get(...params)?.count ?? 0;
+  const byTool = db.prepare(`SELECT tool, COUNT(*) as count FROM ledger ${where} GROUP BY tool ORDER BY count DESC`).all(...params);
+  const stakeWhere = since ? `WHERE tool = 'stake_eth' AND status = 'ok' AND timestamp >= ?` : `WHERE tool = 'stake_eth' AND status = 'ok'`;
+  const staked = db.prepare(`SELECT SUM(CAST(amount AS REAL)) as total FROM ledger ${stakeWhere}`).get(...params);
+  return {
+    total,
+    errors,
+    byTool,
+    totalStakedEth: (staked?.total ?? 0).toFixed(6)
+  };
+}
+function exportLedger(opts) {
+  const rows = queryLedger({ since: opts.since, limit: opts.limit ?? 1e4 });
+  if (opts.format === "csv") {
+    if (rows.length === 0) return "";
+    const headers = Object.keys(rows[0]);
+    const lines = [headers.join(",")];
+    for (const row of rows) {
+      lines.push(headers.map((h) => {
+        const v = String(row[h] ?? "");
+        return v.includes(",") || v.includes('"') ? `"${v.replace(/"/g, '""')}"` : v;
+      }).join(","));
+    }
+    return lines.join("\n");
+  }
+  return JSON.stringify(rows, null, 2);
+}
+function importJsonlIfNeeded() {
+  if (existsSync(MARKER)) return;
+  const tradesDir = join(process.cwd(), "trades");
+  if (!existsSync(tradesDir)) {
+    writeMarker();
+    return;
+  }
+  const files = readdirSync(tradesDir).filter((f) => f.endsWith(".jsonl"));
+  const db = getDb();
+  const insert = db.prepare(`
+    INSERT INTO ledger (timestamp, tool, args, result, status)
+    VALUES (?, ?, ?, ?, 'ok')
+  `);
+  const importAll = db.transaction(() => {
+    for (const file of files) {
+      const lines = readFileSync(join(tradesDir, file), "utf-8").split("\n").filter(Boolean);
+      for (const line of lines) {
+        try {
+          const rec = JSON.parse(line);
+          insert.run(rec.ts, rec.tool, JSON.stringify(rec.args), JSON.stringify(rec.result));
+        } catch {
+        }
+      }
+    }
+  });
+  importAll();
+  writeMarker();
+}
+function writeMarker() {
+  try {
+    const { writeFileSync: wf } = __require("fs");
+    wf(MARKER, (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
+  } catch {
+  }
+}
+
+export {
+  initLedger,
+  logEntry,
+  queryLedger,
+  ledgerStats,
+  exportLedger
+};

package/dist/daemon-GU45VVNU.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import {
+  getProposals,
+  getWithdrawalRequests,
+  getWithdrawalStatus
+} from "./chunk-EQYEWCQO.js";
+import {
+  loadAlerts,
+  loadChannelConfig,
+  saveAlerts
+} from "./chunk-6F64RPQQ.js";
+import {
+  getBalance,
+  getConversionRate,
+  getRewards,
+  getRuntime
+} from "./chunk-EKZFGIVK.js";
+import "./chunk-P6VFMSPM.js";
+import "./chunk-PDX44BCA.js";
+
+// src/alerts/notify.ts
+async function sendTelegram(token, chatId, message) {
+  try {
+    const res = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text: message, parse_mode: "Markdown" })
+    });
+    if (!res.ok) {
+      process.stderr.write(`Telegram send failed (${res.status}): ${await res.text()}
+`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    process.stderr.write(`Telegram error: ${err.message}
+`);
+    return false;
+  }
+}
+async function sendWebhook(url, payload) {
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      process.stderr.write(`Webhook send failed (${res.status})
+`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    process.stderr.write(`Webhook error: ${err.message}
+`);
+    return false;
+  }
+}
+function formatTelegramMessage(alert, data2) {
+  const lines = [
+    "*Moly Alert*",
+    "",
+    `Condition: \`${alert.condition}\``
+  ];
+  if (alert.threshold !== void 0) lines.push(`Threshold: ${alert.threshold}`);
+  if (data2.current !== void 0) lines.push(`Current: ${data2.current}`);
+  if (data2.detail) lines.push(`Detail: ${data2.detail}`);
+  lines.push(`Triggered: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  return lines.join("\n");
+}
+async function dispatch(channelConfig, channel, alert, data2) {
+  if (channel === "telegram") {
+    const tg = channelConfig.telegram;
+    if (!tg) {
+      process.stderr.write("Telegram not configured\n");
+      return false;
+    }
+    return sendTelegram(tg.token, tg.chatId, formatTelegramMessage(alert, data2));
+  }
+  if (channel === "webhook") {
+    const wh = channelConfig.webhook;
+    if (!wh) {
+      process.stderr.write("Webhook not configured\n");
+      return false;
+    }
+    return sendWebhook(wh.url, {
+      alert: { id: alert.id, condition: alert.condition, threshold: alert.threshold },
+      data: data2,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "moly-alerts"
+    });
+  }
+  return false;
+}
+
+// src/alerts/daemon.ts
+var COOLDOWN_MS = 5 * 60 * 1e3;
+async function evaluateAlert(alert, lastProposalCount) {
+  try {
+    switch (alert.condition) {
+      case "balance_below":
+      case "balance_above": {
+        const res = await getBalance();
+        const total = parseFloat(res.balances.eth) + parseFloat(res.balances.stETH) + parseFloat(res.balances.wstETH);
+        const hit = alert.condition === "balance_below" ? total < (alert.threshold ?? 0) : total > (alert.threshold ?? 0);
+        return { triggered: hit, data: { current: total.toFixed(6), balances: res.balances } };
+      }
+      case "reward_rate_below":
+      case "reward_rate_above": {
+        const res = await getRewards(void 0, 30);
+        const rate = parseFloat(res.totalRewards);
+        const hit = alert.condition === "reward_rate_below" ? rate < (alert.threshold ?? 0) : rate > (alert.threshold ?? 0);
+        return { triggered: hit, data: { current: rate.toFixed(6), detail: `${res.totalRewards} ETH over 30d` } };
+      }
+      case "conversion_rate_above":
+      case "conversion_rate_below": {
+        const res = await getConversionRate();
+        const rate = parseFloat(res["1_wstETH_in_stETH"]);
+        const hit = alert.condition === "conversion_rate_above" ? rate > (alert.threshold ?? 0) : rate < (alert.threshold ?? 0);
+        return { triggered: hit, data: { current: rate.toFixed(6) } };
+      }
+      case "withdrawal_ready": {
+        const reqs = await getWithdrawalRequests();
+        if (!reqs.requestIds?.length) return { triggered: false, data: { detail: "no pending withdrawals" } };
+        const status = await getWithdrawalStatus(reqs.requestIds);
+        const ready = (status.statuses ?? []).filter((s) => s.isFinalized);
+        return {
+          triggered: ready.length > 0,
+          data: { current: ready.length, detail: `${ready.length} of ${reqs.requestIds.length} finalized` }
+        };
+      }
+      case "proposal_new": {
+        const res = await getProposals(1);
+        const current = res.totalProposals ?? 0;
+        if (lastProposalCount === void 0) {
+          return { triggered: false, data: { detail: "tracking started" }, newProposalCount: current };
+        }
+        return {
+          triggered: current > lastProposalCount,
+          data: { current, detail: `${current - lastProposalCount} new proposal(s)` },
+          newProposalCount: current
+        };
+      }
+      case "reward_delta": {
+        const res = await getBalance();
+        const current = parseFloat(res.balances.stETH);
+        const prev = data.lastRewardBalance ? parseFloat(data.lastRewardBalance) : current;
+        const delta = current - prev;
+        data.lastRewardBalance = current.toString();
+        return {
+          triggered: delta > (alert.threshold ?? 0),
+          data: { delta: delta.toFixed(8), current: current.toFixed(6), previous: prev.toFixed(6) }
+        };
+      }
+      case "governance_expiring": {
+        const res = await getProposals(10);
+        const now = Date.now();
+        const soon = 24 * 60 * 60 * 1e3;
+        const votingWindow = 72 * 60 * 60 * 1e3;
+        const expiring = (res.proposals ?? []).filter(
+          (p) => p.open && p.startDate && new Date(p.startDate).getTime() + votingWindow - now < soon
+        );
+        return {
+          triggered: expiring.length > 0,
+          data: { count: expiring.length, ids: expiring.map((p) => p.id) }
+        };
+      }
+      default:
+        return null;
+    }
+  } catch (err) {
+    process.stderr.write(`Alert eval error [${alert.condition}]: ${err.message}
+`);
+    return null;
+  }
+}
+async function runDaemon(intervalMs = 3e4) {
+  getRuntime();
+  const channelConfig = loadChannelConfig();
+  process.stderr.write(`Alert daemon running, polling every ${intervalMs / 1e3}s
+`);
+  const initData = loadAlerts();
+  initData.daemonPid = process.pid;
+  initData.daemonStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveAlerts(initData);
+  while (true) {
+    const data2 = loadAlerts();
+    const active = data2.alerts.filter((a) => a.enabled);
+    for (const alert of active) {
+      if (alert.lastTriggered) {
+        const elapsed = Date.now() - new Date(alert.lastTriggered).getTime();
+        if (elapsed < COOLDOWN_MS) continue;
+      }
+      const result = await evaluateAlert(alert, data2.lastProposalCount);
+      if (!result) continue;
+      if (result.newProposalCount !== void 0) {
+        data2.lastProposalCount = result.newProposalCount;
+      }
+      if (result.triggered) {
+        process.stderr.write(`Alert triggered: ${alert.condition} (${alert.id.slice(0, 8)})
+`);
+        await dispatch(channelConfig, alert.channel, alert, result.data);
+        alert.lastTriggered = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    }
+    data2.lastCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+    saveAlerts(data2);
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+}
+export {
+  runDaemon
+};

package/dist/position-LKVHTEKX.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  getTotalPosition
+} from "./chunk-GL6TLHSF.js";
+import "./chunk-EKZFGIVK.js";
+import "./chunk-P6VFMSPM.js";
+import "./chunk-PDX44BCA.js";
+export {
+  getTotalPosition
+};