hood-alerts 0.1.0

package/dist/chunk-32GS6XVE.js

@@ -0,0 +1,732 @@
+import {
+  createTelegramClient,
+  escapeHtml,
+  resolveFetch,
+  truncate
+} from "./chunk-NBMINJ5E.js";
+import {
+  linkMessage,
+  verifyWalletLink
+} from "./chunk-W2GUAWUR.js";
+import {
+  defaultRules,
+  formatValidationError,
+  parseSubscription,
+  ruleComplexity,
+  safeParseRule
+} from "./chunk-VC5MKEY2.js";
+
+// src/bot/commands.ts
+import { randomUUID } from "crypto";
+import { getAddress } from "viem";
+var reply = (text) => ({ html: escapeHtml(text), text });
+var html = (htmlText, plain) => ({ html: htmlText, text: plain });
+var COMMANDS = [
+  { name: "start", description: "Set up alerts in this chat", usage: "/start" },
+  { name: "help", description: "Show every command", usage: "/help" },
+  {
+    name: "subscribe",
+    description: "Send alerts here, with a starter rule set",
+    usage: "/subscribe [target]",
+    options: [
+      {
+        name: "target",
+        description: "Discord webhook URL or channel id. Defaults to this channel.",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "unsubscribe",
+    description: "Stop alerts for a subscription",
+    usage: "/unsubscribe [subscription id]",
+    options: [{ name: "id", description: "Subscription id from /status", required: false }]
+  },
+  { name: "rules", description: "List your rules", usage: "/rules" },
+  {
+    name: "rule",
+    description: "Add, remove, enable or disable a rule",
+    usage: "/rule add <json> | /rule rm <id> | /rule on <id> | /rule off <id>",
+    options: [{ name: "input", description: "add <json> | rm <id> | on <id> | off <id>", required: true }]
+  },
+  {
+    name: "threshold",
+    description: "Set a rule minimum USD value",
+    usage: "/threshold <rule id> <usd>",
+    options: [
+      { name: "rule", description: "Rule id", required: true },
+      { name: "usd", description: "Minimum USD value", required: true }
+    ]
+  },
+  {
+    name: "watch",
+    description: "Add a token to a rule watchlist",
+    usage: "/watch <token address> [rule id]",
+    options: [
+      { name: "token", description: "Token contract address", required: true },
+      { name: "rule", description: "Rule id (defaults to the first rule)", required: false }
+    ]
+  },
+  {
+    name: "unwatch",
+    description: "Remove a token from a rule watchlist",
+    usage: "/unwatch <token address> [rule id]",
+    options: [
+      { name: "token", description: "Token contract address", required: true },
+      { name: "rule", description: "Rule id (defaults to the first rule)", required: false }
+    ]
+  },
+  { name: "tier", description: "Show your tier and its limits", usage: "/tier" },
+  { name: "status", description: "Show your subscriptions and delivery state", usage: "/status" },
+  {
+    name: "link",
+    description: "Link a paying wallet (signature verified)",
+    usage: "/link [address] [signature]",
+    options: [
+      { name: "address", description: "Wallet address that pays", required: false },
+      { name: "signature", description: "Signature of the link message", required: false }
+    ]
+  },
+  { name: "upgrade", description: "How to go premium", usage: "/upgrade" }
+];
+function ruleSummary(rule) {
+  const parts = [
+    `${rule.enabled ? "on " : "off"} ${rule.id}`,
+    rule.name ? `"${rule.name}"` : null,
+    `kinds=${rule.kinds.join("/")}`,
+    `pads=${rule.launchpads.join("/")}`,
+    rule.minUsd !== void 0 ? `minUsd=${rule.minUsd}` : null,
+    rule.maxUsd !== void 0 ? `maxUsd=${rule.maxUsd}` : null,
+    rule.minLiquidityUsd !== void 0 ? `minLiq=${rule.minLiquidityUsd}` : null,
+    rule.maxLiquidityUsd !== void 0 ? `maxLiq=${rule.maxLiquidityUsd}` : null,
+    rule.side !== "any" ? `side=${rule.side}` : null,
+    rule.tokens.length > 0 ? `tokens=${rule.tokens.length}` : null,
+    rule.deployers.length > 0 ? `deployers=${rule.deployers.length}` : null,
+    rule.rateLimit ? `rate=${JSON.stringify(rule.rateLimit)}` : null,
+    `filters=${ruleComplexity(rule)}`
+  ].filter((part) => part !== null);
+  return parts.join(" ");
+}
+function createCommandRouter(deps) {
+  const now = deps.now ?? Date.now;
+  const newId = deps.newId ?? randomUUID;
+  function subscriptionsOf(context) {
+    return deps.store.listSubscriptionsFor(context.subscriberId);
+  }
+  function firstSubscription(context) {
+    return subscriptionsOf(context)[0] ?? null;
+  }
+  async function handleSubscribe(context) {
+    const target = context.args[0]?.trim() || context.defaultTarget;
+    if (!target) {
+      return reply(
+        "I could not work out where to send alerts. Pass a target: /subscribe <discord webhook URL or channel id>"
+      );
+    }
+    const existing = subscriptionsOf(context);
+    if (existing.some((sub) => sub.target === target)) {
+      return reply(`This target is already subscribed. Use /rules to edit it, or /unsubscribe to stop.`);
+    }
+    const decision = await deps.gate.checkAddSubscription(context.subscriberId, existing.length);
+    if (!decision.allowed) return reply(`Cannot subscribe: ${decision.reason}`);
+    const { policy } = await deps.gate.resolve(context.subscriberId);
+    const rules = defaultRules().filter(
+      (rule) => rule.kinds.every((kind) => policy.allowedKinds.includes(kind))
+    );
+    const subscription = parseSubscription({
+      id: newId(),
+      subscriberId: context.subscriberId,
+      platform: context.platform,
+      target,
+      enabled: true,
+      rules: rules.slice(0, policy.maxRulesPerSubscription),
+      createdAtMs: now()
+    });
+    deps.store.saveSubscription(subscription);
+    return html(
+      [
+        `<b>Subscribed.</b> Alerts will arrive here.`,
+        `Subscription id: <code>${escapeHtml(subscription.id)}</code>`,
+        `Tier: <b>${policy.tier}</b> (delivery delay ${policy.deliveryDelayMs / 1e3}s, ${policy.maxAlertsPerHour} alerts/hour)`,
+        "",
+        "Starter rules:",
+        ...subscription.rules.map((rule) => `\u2022 <code>${escapeHtml(ruleSummary(rule))}</code>`),
+        "",
+        "Edit them with /threshold, /watch and /rule. See /help."
+      ].join("\n"),
+      `Subscribed. id=${subscription.id} tier=${policy.tier}`
+    );
+  }
+  async function handleUnsubscribe(context) {
+    const subs = subscriptionsOf(context);
+    if (subs.length === 0) return reply("You have no subscriptions. Use /subscribe to start one.");
+    const id = context.args[0]?.trim();
+    if (!id) {
+      if (subs.length > 1) {
+        return html(
+          [
+            "You have several subscriptions. Name the one to remove:",
+            ...subs.map((sub) => `\u2022 <code>${escapeHtml(sub.id)}</code> \u2192 ${escapeHtml(sub.target)}`),
+            "",
+            "Usage: /unsubscribe &lt;subscription id&gt;"
+          ].join("\n"),
+          "Name the subscription to remove: " + subs.map((sub) => sub.id).join(", ")
+        );
+      }
+      const only = subs[0];
+      deps.store.deleteSubscription(only.id);
+      return reply("Unsubscribed. No more alerts will be delivered here.");
+    }
+    const match = subs.find((sub) => sub.id === id);
+    if (!match) return reply(`No subscription with id "${id}". Use /status to list yours.`);
+    deps.store.deleteSubscription(match.id);
+    return reply(`Unsubscribed ${match.id}.`);
+  }
+  function handleRules(context) {
+    const subs = subscriptionsOf(context);
+    if (subs.length === 0) return reply("You have no subscriptions yet. Use /subscribe to start one.");
+    const lines = [];
+    for (const sub of subs) {
+      lines.push(`<b>${escapeHtml(sub.target)}</b> (<code>${escapeHtml(sub.id)}</code>)`);
+      if (sub.rules.length === 0) lines.push("  no rules: nothing will be delivered");
+      for (const rule of sub.rules) lines.push(`  \u2022 <code>${escapeHtml(ruleSummary(rule))}</code>`);
+    }
+    return html(lines.join("\n"), lines.join("\n").replace(/<[^>]+>/g, ""));
+  }
+  async function handleRule(context) {
+    const action = context.args[0]?.toLowerCase();
+    const subscription = firstSubscription(context);
+    if (!subscription) return reply("Subscribe first with /subscribe, then add rules.");
+    if (action === "add") {
+      const json = context.rest.slice(context.rest.indexOf("add") + 3).trim();
+      if (!json) {
+        return html(
+          [
+            'Usage: <code>/rule add {"id":"big-whales","kinds":["whale_trade"],"minUsd":25000}</code>',
+            "",
+            "Fields: id, name, enabled, kinds, launchpads, minUsd, maxUsd, minLiquidityUsd,",
+            "maxLiquidityUsd, tokens, deployers, excludeDeployers, side, reputation, rateLimit."
+          ].join("\n"),
+          'Usage: /rule add {"id":"big-whales","kinds":["whale_trade"],"minUsd":25000}'
+        );
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(json);
+      } catch {
+        return reply('That is not valid JSON. Example: /rule add {"id":"whales","kinds":["whale_trade"],"minUsd":5000}');
+      }
+      const result = safeParseRule(parsed);
+      if (!result.success) return reply(`Rule rejected: ${formatValidationError(result.error)}`);
+      const rule = result.data;
+      if (subscription.rules.some((existing) => existing.id === rule.id)) {
+        return reply(`A rule with id "${rule.id}" already exists. Remove it first with /rule rm ${rule.id}.`);
+      }
+      const decision = await deps.gate.checkAddRule(context.subscriberId, rule, subscription.rules.length);
+      if (!decision.allowed) return reply(`Rule rejected: ${decision.reason}`);
+      subscription.rules.push(rule);
+      deps.store.saveSubscription(subscription);
+      return html(
+        `Rule added: <code>${escapeHtml(ruleSummary(rule))}</code>`,
+        `Rule added: ${ruleSummary(rule)}`
+      );
+    }
+    if (action === "rm" || action === "remove" || action === "delete") {
+      const id = context.args[1]?.trim();
+      if (!id) return reply("Usage: /rule rm <rule id>. List them with /rules.");
+      const index = subscription.rules.findIndex((rule) => rule.id === id);
+      if (index === -1) return reply(`No rule with id "${id}". List them with /rules.`);
+      subscription.rules.splice(index, 1);
+      deps.store.saveSubscription(subscription);
+      return reply(`Rule ${id} removed.`);
+    }
+    if (action === "on" || action === "off") {
+      const id = context.args[1]?.trim();
+      if (!id) return reply(`Usage: /rule ${action} <rule id>. List them with /rules.`);
+      const rule = subscription.rules.find((entry) => entry.id === id);
+      if (!rule) return reply(`No rule with id "${id}". List them with /rules.`);
+      rule.enabled = action === "on";
+      deps.store.saveSubscription(subscription);
+      return reply(`Rule ${id} is now ${rule.enabled ? "enabled" : "disabled"}.`);
+    }
+    return html(
+      [
+        "Usage:",
+        "\u2022 <code>/rule add {json}</code>",
+        "\u2022 <code>/rule rm &lt;id&gt;</code>",
+        "\u2022 <code>/rule on &lt;id&gt;</code>",
+        "\u2022 <code>/rule off &lt;id&gt;</code>"
+      ].join("\n"),
+      "Usage: /rule add {json} | /rule rm <id> | /rule on <id> | /rule off <id>"
+    );
+  }
+  async function handleThreshold(context) {
+    const subscription = firstSubscription(context);
+    if (!subscription) return reply("Subscribe first with /subscribe.");
+    const [ruleId, rawUsd] = context.args;
+    if (!ruleId || !rawUsd) {
+      return reply("Usage: /threshold <rule id> <usd>. Example: /threshold whales 5000");
+    }
+    const rule = subscription.rules.find((entry) => entry.id === ruleId);
+    if (!rule) return reply(`No rule with id "${ruleId}". List them with /rules.`);
+    const usd = Number(rawUsd);
+    if (!Number.isFinite(usd) || usd < 0) {
+      return reply(`"${rawUsd}" is not a valid amount. Use a positive number, for example /threshold ${ruleId} 5000`);
+    }
+    if (rule.maxUsd !== void 0 && usd > rule.maxUsd) {
+      return reply(`minUsd ${usd} would exceed this rule's maxUsd ${rule.maxUsd}. Lower it or raise maxUsd first.`);
+    }
+    rule.minUsd = usd;
+    const decision = await deps.gate.checkRule(context.subscriberId, rule);
+    if (!decision.allowed) return reply(`Change rejected: ${decision.reason}`);
+    deps.store.saveSubscription(subscription);
+    return reply(`Rule ${ruleId} now requires at least $${usd} of value.`);
+  }
+  async function handleWatch(context, add) {
+    const subscription = firstSubscription(context);
+    if (!subscription) return reply("Subscribe first with /subscribe.");
+    const rawToken = context.args[0]?.trim();
+    if (!rawToken) {
+      return reply(`Usage: /${add ? "watch" : "unwatch"} <token address> [rule id]`);
+    }
+    if (!/^0x[0-9a-fA-F]{40}$/.test(rawToken)) {
+      return reply(`"${rawToken}" is not a token address. Pass the 0x contract address from the alert.`);
+    }
+    const token = getAddress(rawToken).toLowerCase();
+    const ruleId = context.args[1]?.trim();
+    const rule = ruleId ? subscription.rules.find((entry) => entry.id === ruleId) : subscription.rules[0];
+    if (!rule) {
+      return reply(
+        ruleId ? `No rule with id "${ruleId}". List them with /rules.` : "This subscription has no rules yet. Add one with /rule add."
+      );
+    }
+    if (add) {
+      if (rule.tokens.includes(token)) return reply(`${rawToken} is already on rule ${rule.id}.`);
+      rule.tokens.push(token);
+      const decision = await deps.gate.checkRule(context.subscriberId, rule);
+      if (!decision.allowed) {
+        rule.tokens.pop();
+        return reply(`Cannot add: ${decision.reason}`);
+      }
+      deps.store.saveSubscription(subscription);
+      return reply(`Watching ${rawToken} on rule ${rule.id} (${rule.tokens.length} tokens).`);
+    }
+    const index = rule.tokens.indexOf(token);
+    if (index === -1) return reply(`${rawToken} is not on rule ${rule.id}.`);
+    rule.tokens.splice(index, 1);
+    deps.store.saveSubscription(subscription);
+    return reply(`Stopped watching ${rawToken} on rule ${rule.id}.`);
+  }
+  async function handleTier(context) {
+    const { entitlement, policy } = await deps.gate.resolve(context.subscriberId);
+    const expiry = entitlement.expiresAtMs === null ? "no expiry" : `expires ${new Date(entitlement.expiresAtMs).toISOString()}`;
+    const lines = [
+      `<b>Tier: ${escapeHtml(policy.tier)}</b> (${escapeHtml(expiry)}, source ${escapeHtml(entitlement.source)})`,
+      `Subscriptions: up to ${policy.maxSubscriptions}`,
+      `Rules per subscription: up to ${policy.maxRulesPerSubscription}`,
+      `Filters per rule: up to ${policy.maxRuleComplexity}`,
+      `Watchlist size: up to ${policy.maxWatchlistTokens}`,
+      `Alerts per hour: up to ${policy.maxAlertsPerHour}`,
+      `Delivery delay: ${policy.deliveryDelayMs / 1e3}s`,
+      `Liquidity and reputation filters: ${policy.allowOnChainLookupFilters ? "included" : "premium only"}`,
+      `Event kinds: ${policy.allowedKinds.join(", ")}`
+    ];
+    return html(lines.join("\n"), lines.join("\n").replace(/<[^>]+>/g, ""));
+  }
+  async function handleStatus(context) {
+    const subs = subscriptionsOf(context);
+    if (subs.length === 0) return reply("No subscriptions. Use /subscribe to start one.");
+    const delivered = deps.store.countDeliveriesForSubscriber(context.subscriberId, now() - 36e5);
+    const { policy } = await deps.gate.resolve(context.subscriberId);
+    const lines = [
+      `<b>${subs.length} subscription${subs.length === 1 ? "" : "s"}</b>, ${delivered} alerts in the last hour (cap ${policy.maxAlertsPerHour})`,
+      ...subs.map(
+        (sub) => `\u2022 <code>${escapeHtml(sub.id)}</code> \u2192 ${escapeHtml(sub.target)} (${sub.rules.length} rules, ${sub.enabled ? "enabled" : "disabled"})`
+      )
+    ];
+    return html(lines.join("\n"), lines.join("\n").replace(/<[^>]+>/g, ""));
+  }
+  async function handleLink(context) {
+    const [address, signature] = context.args;
+    if (!address) {
+      const nonce2 = deps.store.issueLinkNonce(context.subscriberId, newId());
+      const message = linkMessage(context.subscriberId, nonce2);
+      return html(
+        [
+          "Sign this exact message with the wallet that pays, then send",
+          `<code>/link &lt;address&gt; &lt;signature&gt;</code>`,
+          "",
+          `<pre>${escapeHtml(message)}</pre>`
+        ].join("\n"),
+        `Sign this message and reply with /link <address> <signature>:
+${message}`
+      );
+    }
+    if (!signature) {
+      return reply("Usage: /link <address> <signature>. Send /link on its own to get the message to sign.");
+    }
+    const nonce = deps.store.getLinkNonce(context.subscriberId);
+    if (!nonce) {
+      return reply("No pending link request. Send /link on its own first to get a fresh message to sign.");
+    }
+    const verified = await verifyWalletLink(context.subscriberId, nonce, address, signature);
+    if (!verified) {
+      return reply("That signature does not match. Sign the exact message from /link with the wallet you named.");
+    }
+    deps.store.linkWallet(context.subscriberId, verified);
+    deps.store.clearLinkNonce(context.subscriberId);
+    return reply(`Wallet ${verified} linked. Payments from it now count towards your subscription.`);
+  }
+  function handleUpgrade() {
+    if (!deps.upgradeInstructions) {
+      return reply(
+        "This deployment does not sell premium access. The operator grants it through configuration; ask them."
+      );
+    }
+    return html(escapeHtml(deps.upgradeInstructions), deps.upgradeInstructions);
+  }
+  function handleHelp() {
+    const header = "hood-alerts: Robinhood Chain memecoin alerts.";
+    const kinds = "Event kinds: launch, curve_trade, graduation, whale_trade.";
+    const lifecycle = "NOXA lists instantly (no bonding curve), so it never produces curve_trade or graduation. The Odyssey produces all four.";
+    return html(
+      [
+        `<b>${escapeHtml(header)}</b>`,
+        "",
+        ...COMMANDS.map(
+          (command) => `<code>${escapeHtml(command.usage)}</code> - ${escapeHtml(command.description)}`
+        ),
+        "",
+        escapeHtml(kinds),
+        escapeHtml(lifecycle)
+      ].join("\n"),
+      [
+        header,
+        "",
+        ...COMMANDS.map((command) => `${command.usage} - ${command.description}`),
+        "",
+        kinds,
+        lifecycle
+      ].join("\n")
+    );
+  }
+  return {
+    commands: COMMANDS,
+    async handle(command, context) {
+      const name = command.replace(/^\//, "").split("@")[0]?.toLowerCase() ?? "";
+      try {
+        switch (name) {
+          case "start":
+          case "help":
+            return handleHelp();
+          case "subscribe":
+            return await handleSubscribe(context);
+          case "unsubscribe":
+            return await handleUnsubscribe(context);
+          case "rules":
+            return handleRules(context);
+          case "rule":
+            return await handleRule(context);
+          case "threshold":
+            return await handleThreshold(context);
+          case "watch":
+            return await handleWatch(context, true);
+          case "unwatch":
+            return await handleWatch(context, false);
+          case "tier":
+            return await handleTier(context);
+          case "status":
+            return await handleStatus(context);
+          case "link":
+            return await handleLink(context);
+          case "upgrade":
+            return handleUpgrade();
+          default:
+            return reply(`Unknown command "${name}". Send /help for the list.`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return reply(`That command failed: ${message}. Try /help, or report this if it keeps happening.`);
+      }
+    }
+  };
+}
+
+// src/service/logger.ts
+var LEVELS = ["debug", "info", "warn", "error"];
+function safeStringify(value) {
+  return JSON.stringify(value, (_key, raw) => {
+    if (typeof raw === "bigint") return raw.toString();
+    if (raw instanceof Error) return { name: raw.name, message: raw.message, stack: raw.stack };
+    return raw;
+  });
+}
+function createLogger(options = {}) {
+  const minimum = LEVELS.indexOf(options.level ?? "info");
+  const write = options.write ?? ((line) => console.log(line));
+  const now = options.now ?? Date.now;
+  const base = options.base ?? {};
+  const emit = (level, message, fields) => {
+    if (LEVELS.indexOf(level) < minimum) return;
+    write(
+      safeStringify({
+        time: new Date(now()).toISOString(),
+        level,
+        message,
+        ...base,
+        ...fields ?? {}
+      })
+    );
+  };
+  return {
+    debug: (message, fields) => emit("debug", message, fields),
+    info: (message, fields) => emit("info", message, fields),
+    warn: (message, fields) => emit("warn", message, fields),
+    error: (message, fields) => emit("error", message, fields),
+    child(fields) {
+      return createLogger({ ...options, base: { ...base, ...fields } });
+    }
+  };
+}
+function createSilentLogger() {
+  const silent = {
+    debug: () => void 0,
+    info: () => void 0,
+    warn: () => void 0,
+    error: () => void 0,
+    child: () => silent
+  };
+  return silent;
+}
+
+// src/bot/telegram-bot.ts
+function parseCommand(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const [head, ...tail] = trimmed.split(/\s+/);
+  if (!head) return null;
+  return { command: head, args: tail, rest: trimmed.slice(head.length).trim() };
+}
+function createTelegramBot(options) {
+  const client = options.client ?? createTelegramClient(options);
+  const logger = options.logger ?? createSilentLogger();
+  const pollTimeout = options.pollTimeoutSeconds ?? 30;
+  let offset = options.offsetStore?.get() ?? 0;
+  let running = false;
+  async function handleUpdate(update) {
+    const message = update.message;
+    const text = message?.text;
+    const chatId = message?.chat?.id;
+    const fromId = message?.from?.id;
+    if (!text || chatId === void 0 || fromId === void 0 || message?.from?.is_bot === true) return;
+    const parsed = parseCommand(text);
+    if (!parsed) return;
+    const context = {
+      subscriberId: `telegram:${fromId}`,
+      platform: "telegram",
+      defaultTarget: String(chatId),
+      args: parsed.args,
+      rest: parsed.rest
+    };
+    const reply2 = await options.router.handle(parsed.command, context);
+    const response = await client.call("sendMessage", {
+      chat_id: chatId,
+      text: reply2.html,
+      parse_mode: "HTML",
+      link_preview_options: { is_disabled: true }
+    });
+    if (!response.ok) {
+      logger.warn("telegram reply failed", {
+        chatId,
+        command: parsed.command,
+        error: response.description
+      });
+    }
+  }
+  return {
+    async publishCommands() {
+      const response = await client.call("setMyCommands", {
+        commands: options.router.commands.map((command) => ({
+          command: command.name,
+          description: command.description.slice(0, 256)
+        }))
+      });
+      if (!response.ok) logger.warn("setMyCommands failed", { error: response.description });
+      return response.ok;
+    },
+    async pollOnce() {
+      const response = await client.call("getUpdates", {
+        ...offset > 0 ? { offset } : {},
+        timeout: pollTimeout,
+        allowed_updates: ["message"]
+      });
+      if (!response.ok) {
+        logger.warn("getUpdates failed", { error: response.description });
+        return 0;
+      }
+      const updates = Array.isArray(response.result) ? response.result : [];
+      for (const update of updates) {
+        try {
+          await handleUpdate(update);
+        } catch (error) {
+          logger.error("telegram update handler threw", {
+            updateId: update.update_id,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        offset = update.update_id + 1;
+        options.offsetStore?.set(offset);
+      }
+      return updates.length;
+    },
+    async start() {
+      running = true;
+      logger.info("telegram bot started", { offset });
+      while (running) {
+        try {
+          await this.pollOnce();
+        } catch (error) {
+          logger.error("telegram poll failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
+        }
+      }
+      logger.info("telegram bot stopped");
+    },
+    stop() {
+      running = false;
+    }
+  };
+}
+
+// src/bot/discord-bot.ts
+import { createPublicKey, verify as cryptoVerify } from "crypto";
+var INTERACTION_TYPE = { PING: 1, APPLICATION_COMMAND: 2 };
+var CALLBACK_TYPE = { PONG: 1, CHANNEL_MESSAGE_WITH_SOURCE: 4 };
+var EPHEMERAL_FLAG = 1 << 6;
+var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+function verifyDiscordSignature(publicKey, signature, timestamp, rawBody) {
+  if (!/^[0-9a-fA-F]{64}$/.test(publicKey)) return false;
+  if (!/^[0-9a-fA-F]{128}$/.test(signature)) return false;
+  if (!timestamp) return false;
+  try {
+    const key = createPublicKey({
+      key: Buffer.concat([ED25519_SPKI_PREFIX, Buffer.from(publicKey, "hex")]),
+      format: "der",
+      type: "spki"
+    });
+    return cryptoVerify(
+      null,
+      Buffer.from(timestamp + rawBody, "utf8"),
+      key,
+      Buffer.from(signature, "hex")
+    );
+  } catch {
+    return false;
+  }
+}
+function discordCommandDefinitions(commands) {
+  return commands.map((command) => ({
+    name: command.name,
+    // Discord caps descriptions at 100 characters and rejects the whole
+    // registration if any one is longer.
+    description: truncate(command.description, 100),
+    ...command.options && command.options.length > 0 ? {
+      options: command.options.map((option) => ({
+        type: 3,
+        name: option.name,
+        description: truncate(option.description, 100),
+        required: option.required
+      }))
+    } : {}
+  }));
+}
+async function registerDiscordCommands(commands, options) {
+  const fetchImpl = resolveFetch(options.fetch);
+  const apiBase = (options.apiBase ?? "https://discord.com/api/v10").replace(/\/+$/, "");
+  const url = options.guildId ? `${apiBase}/applications/${options.applicationId}/guilds/${options.guildId}/commands` : `${apiBase}/applications/${options.applicationId}/commands`;
+  const response = await fetchImpl(url, {
+    method: "PUT",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bot ${options.botToken}`
+    },
+    body: JSON.stringify(discordCommandDefinitions(commands))
+  });
+  const raw = await response.text();
+  if (!response.ok) {
+    throw new Error(`hood-alerts: Discord rejected the command registration (${response.status}): ${raw}`);
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.length : 0;
+  } catch {
+    return 0;
+  }
+}
+function createDiscordInteractionHandler(options) {
+  const ephemeral = options.ephemeral ?? true;
+  return {
+    async handle(request) {
+      if (!request.signature || !request.timestamp || !verifyDiscordSignature(options.publicKey, request.signature, request.timestamp, request.rawBody)) {
+        return { status: 401, body: { error: "invalid request signature" } };
+      }
+      let interaction;
+      try {
+        interaction = JSON.parse(request.rawBody);
+      } catch {
+        return { status: 400, body: { error: "body is not JSON" } };
+      }
+      if (interaction.type === INTERACTION_TYPE.PING) {
+        return { status: 200, body: { type: CALLBACK_TYPE.PONG } };
+      }
+      if (interaction.type !== INTERACTION_TYPE.APPLICATION_COMMAND) {
+        return { status: 400, body: { error: `unsupported interaction type ${interaction.type}` } };
+      }
+      const name = interaction.data?.name;
+      if (!name) return { status: 400, body: { error: "interaction carried no command name" } };
+      const values = (interaction.data?.options ?? []).map((option) => option.value === void 0 ? "" : String(option.value)).filter((value) => value.length > 0);
+      const rest = values.join(" ");
+      const args = values.length === 1 ? values[0].split(/\s+/) : values;
+      const userId = interaction.member?.user?.id ?? interaction.user?.id ?? "";
+      const context = {
+        // A guild pays once for all its channels; a DM is billed to the user.
+        subscriberId: `discord:${interaction.guild_id ?? userId}`,
+        platform: "discord",
+        defaultTarget: interaction.channel_id ?? "",
+        args,
+        rest: `${name} ${rest}`.trim()
+      };
+      const reply2 = await options.router.handle(name, context);
+      return {
+        status: 200,
+        body: {
+          type: CALLBACK_TYPE.CHANNEL_MESSAGE_WITH_SOURCE,
+          data: {
+            // Discord hard-caps message content at 2000 characters.
+            content: truncate(reply2.text, 1900),
+            ...ephemeral ? { flags: EPHEMERAL_FLAG } : {}
+          }
+        }
+      };
+    }
+  };
+}
+
+export {
+  COMMANDS,
+  createCommandRouter,
+  LEVELS,
+  createLogger,
+  createSilentLogger,
+  createTelegramBot,
+  INTERACTION_TYPE,
+  CALLBACK_TYPE,
+  EPHEMERAL_FLAG,
+  verifyDiscordSignature,
+  discordCommandDefinitions,
+  registerDiscordCommands,
+  createDiscordInteractionHandler
+};
+//# sourceMappingURL=chunk-32GS6XVE.js.map