@chainalert/cli 0.0.1

package/dist/chunk-WPW7UBVR.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+// src/config/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var VERSION = "0.0.1";
+var DEFAULT_API_URL = "https://api.chainalert.dev";
+var CONFIG_DIR = join(homedir(), ".chainalert");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+// src/util/output.ts
+var RESET = "\x1B[0m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var CYAN = "\x1B[36m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+function print(msg) {
+  process.stdout.write(msg + "\n");
+}
+function printError(msg) {
+  process.stderr.write(`${RED}Error: ${msg}${RESET}
+`);
+}
+function printSuccess(msg) {
+  print(`${GREEN}${msg}${RESET}`);
+}
+function printWarn(msg) {
+  print(`${YELLOW}${msg}${RESET}`);
+}
+function printDim(msg) {
+  print(`${DIM}${msg}${RESET}`);
+}
+function bold(s) {
+  return `${BOLD}${s}${RESET}`;
+}
+function cyan(s) {
+  return `${CYAN}${s}${RESET}`;
+}
+function dim(s) {
+  return `${DIM}${s}${RESET}`;
+}
+function green(s) {
+  return `${GREEN}${s}${RESET}`;
+}
+function red(s) {
+  return `${RED}${s}${RESET}`;
+}
+function yellow(s) {
+  return `${YELLOW}${s}${RESET}`;
+}
+function printTable(headers, rows) {
+  const widths = headers.map((h, i) => {
+    const colMax = rows.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
+    return Math.max(h.length, colMax);
+  });
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500");
+  print(`${BOLD}${headerLine}${RESET}`);
+  print(`${DIM}${separator}${RESET}`);
+  for (const row of rows) {
+    print(row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join("  "));
+  }
+}
+function printKV(pairs) {
+  const maxKey = pairs.reduce((max, [k]) => Math.max(max, k.length), 0);
+  for (const [key, value] of pairs) {
+    print(`${BOLD}${key.padEnd(maxKey)}${RESET}  ${value}`);
+  }
+}
+function printJson(data) {
+  print(JSON.stringify(data, null, 2));
+}
+
+export {
+  VERSION,
+  DEFAULT_API_URL,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  print,
+  printError,
+  printSuccess,
+  printWarn,
+  printDim,
+  bold,
+  cyan,
+  dim,
+  green,
+  red,
+  yellow,
+  printTable,
+  printKV,
+  printJson
+};

package/dist/contracts-J7JYPQXP.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import {
+  spinner
+} from "./chunk-CE4DKHAY.js";
+import {
+  getStorageSlots,
+  resolveContract
+} from "./chunk-IC5RERFB.js";
+import "./chunk-K2BGDX7X.js";
+import {
+  bold,
+  dim,
+  print,
+  printError,
+  printJson,
+  printKV
+} from "./chunk-WPW7UBVR.js";
+
+// src/commands/contracts.ts
+async function run(args, flags) {
+  const sub = args[0];
+  switch (sub) {
+    case "resolve": {
+      if (!flags.address) {
+        printError("--address is required.");
+        process.exitCode = 1;
+        return;
+      }
+      if (!flags.network) {
+        printError("--network is required.");
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        spinner.start("Resolving contract...");
+        const result = await resolveContract({
+          address: flags.address,
+          networkId: flags.network
+        });
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        const c = result.data;
+        printKV([
+          ["Address", c.address ?? flags.address],
+          ["Network", c.networkId ?? flags.network],
+          ["Name", c.name ?? dim("(unknown)")],
+          ["Verified", c.verified !== void 0 ? String(c.verified) : dim("(unknown)")],
+          ["Proxy", c.isProxy !== void 0 ? String(c.isProxy) : dim("(unknown)")]
+        ]);
+        if (c.abi) {
+          print("");
+          print(bold("ABI:") + ` ${Array.isArray(c.abi) ? `${c.abi.length} entries` : "available"}`);
+        }
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to resolve contract.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "storage-slots": {
+      const id = args[1];
+      if (!id) {
+        printError("Usage: chainalert contracts storage-slots <id>");
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        spinner.start("Fetching storage slots...");
+        const result = await getStorageSlots(id);
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        const slots = result.data;
+        if (Array.isArray(slots) && slots.length > 0) {
+          for (const slot of slots) {
+            printKV([
+              ["Slot", slot.slot ?? slot.key ?? ""],
+              ["Label", slot.label ?? slot.name ?? dim("(unnamed)")],
+              ["Type", slot.type ?? dim("(unknown)")]
+            ]);
+            print("");
+          }
+        } else if (slots && typeof slots === "object") {
+          print(JSON.stringify(slots, null, 2));
+        } else {
+          print("No storage slots found.");
+        }
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to fetch storage slots.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    default:
+      printError(`Unknown subcommand: ${sub ?? "(none)"}. Use: resolve, storage-slots`);
+      process.exitCode = 1;
+  }
+}
+export {
+  run
+};

package/dist/detections-QSMNEXXI.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+import {
+  confirm
+} from "./chunk-6FDEYAAT.js";
+import {
+  spinner
+} from "./chunk-CE4DKHAY.js";
+import {
+  createDetection,
+  deleteDetection,
+  getDetection,
+  listDetections,
+  testDetection,
+  updateDetection
+} from "./chunk-IC5RERFB.js";
+import "./chunk-K2BGDX7X.js";
+import {
+  bold,
+  dim,
+  green,
+  print,
+  printError,
+  printJson,
+  printKV,
+  printSuccess,
+  printTable,
+  red,
+  yellow
+} from "./chunk-WPW7UBVR.js";
+
+// src/commands/detections.ts
+async function run(args, flags) {
+  const sub = args[0] ?? "list";
+  switch (sub) {
+    case "list": {
+      try {
+        spinner.start("Fetching detections...");
+        const result = await listDetections({
+          status: flags.status,
+          networkId: flags.network,
+          page: flags.page ? Number(flags.page) : void 0,
+          limit: flags.limit ? Number(flags.limit) : void 0
+        });
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        if (!result.data.length) {
+          print("No detections found.");
+          return;
+        }
+        printTable(
+          ["ID", "Name", "Template", "Network", "Status"],
+          result.data.map((d) => [
+            String(d.id),
+            d.name ?? "",
+            d.templateSlug ?? "",
+            d.networkSlug ?? d.networkId ?? "",
+            d.status ?? ""
+          ])
+        );
+        if (result.meta) {
+          print(dim(`
+Page ${result.meta.page ?? 1} of ${result.meta.totalPages ?? "?"}  (${result.meta.total ?? "?"} total)`));
+        }
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to fetch detections.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "get": {
+      const id = args[1];
+      if (!id) {
+        printError("Usage: chainalert detections get <id>");
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        spinner.start("Fetching detection...");
+        const result = await getDetection(id);
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        const d = result.data;
+        printKV([
+          ["ID", String(d.id)],
+          ["Name", d.name ?? ""],
+          ["Template", d.templateSlug ?? ""],
+          ["Network", d.networkSlug ?? d.networkId ?? ""],
+          ["Contract", d.contractAddress ?? dim("(none)")],
+          ["Status", d.status ?? ""],
+          ["Severity", d.severity ?? ""],
+          ["Cooldown", d.cooldownMinutes ? `${d.cooldownMinutes} min` : dim("(default)")],
+          ["Created", d.createdAt ?? ""]
+        ]);
+        if (d.inputs && Object.keys(d.inputs).length > 0) {
+          print("");
+          print(bold("Inputs:"));
+          for (const [key, value] of Object.entries(d.inputs)) {
+            print(`  ${bold(key)}: ${String(value)}`);
+          }
+        }
+        if (d.channelIds && d.channelIds.length > 0) {
+          print("");
+          print(bold("Channels:") + " " + d.channelIds.join(", "));
+        }
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to fetch detection.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "create": {
+      if (!flags.template) {
+        printError("--template is required.");
+        process.exitCode = 1;
+        return;
+      }
+      if (!flags.name) {
+        printError("--name is required.");
+        process.exitCode = 1;
+        return;
+      }
+      if (!flags.network) {
+        printError("--network is required.");
+        process.exitCode = 1;
+        return;
+      }
+      const inputs = {};
+      for (const [key, value] of Object.entries(flags)) {
+        if (key.startsWith("input.")) {
+          inputs[key.slice(6)] = value;
+        }
+      }
+      const channelIds = flags.channel ? flags.channel.split(",").map((s) => s.trim()) : void 0;
+      try {
+        spinner.start("Creating detection...");
+        const result = await createDetection({
+          templateSlug: flags.template,
+          name: flags.name,
+          networkId: flags.network,
+          contractAddress: flags.contract,
+          inputs,
+          channelIds,
+          severity: flags.severity,
+          cooldownMinutes: flags.cooldown ? Number(flags.cooldown) : void 0,
+          testBlockNumber: flags.block ? Number(flags.block) : void 0
+        });
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        printSuccess(`Detection created: ${result.data.id}`);
+        if (result.testPassed !== void 0) {
+          if (result.testPassed) {
+            print(green("Test passed."));
+          } else {
+            print(yellow("Test did not pass."));
+          }
+        }
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to create detection.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "update": {
+      const id = args[1];
+      if (!id) {
+        printError("Usage: chainalert detections update <id> [--name] [--status]");
+        process.exitCode = 1;
+        return;
+      }
+      const body = {};
+      if (flags.name) body.name = flags.name;
+      if (flags.status) body.status = flags.status;
+      const inputs = {};
+      for (const [key, value] of Object.entries(flags)) {
+        if (key.startsWith("input.")) {
+          inputs[key.slice(6)] = value;
+        }
+      }
+      if (Object.keys(inputs).length > 0) body.inputs = inputs;
+      if (flags.channel) body.channelIds = flags.channel.split(",").map((s) => s.trim());
+      if (flags.cooldown) body.cooldownMinutes = Number(flags.cooldown);
+      try {
+        spinner.start("Updating detection...");
+        const result = await updateDetection(id, body);
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        printSuccess(`Detection ${id} updated.`);
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to update detection.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "delete": {
+      const id = args[1];
+      if (!id) {
+        printError("Usage: chainalert detections delete <id>");
+        process.exitCode = 1;
+        return;
+      }
+      const ok = await confirm(`Delete detection ${id}?`);
+      if (!ok) {
+        print("Cancelled.");
+        return;
+      }
+      try {
+        spinner.start("Deleting detection...");
+        const result = await deleteDetection(id);
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        printSuccess(`Detection ${id} deleted.`);
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to delete detection.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "test": {
+      const id = args[1];
+      if (!id) {
+        printError("Usage: chainalert detections test <id> --block=<number>");
+        process.exitCode = 1;
+        return;
+      }
+      if (!flags.block) {
+        printError("--block is required.");
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        spinner.start("Testing detection...");
+        const result = await testDetection(id, { blockNumber: Number(flags.block) });
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        if (result.testPassed) {
+          printSuccess("Test passed.");
+        } else {
+          print(red("Test did not pass."));
+        }
+        if (result.testResult) {
+          print("");
+          print(bold("Result:"));
+          print(JSON.stringify(result.testResult, null, 2));
+        }
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to test detection.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    default:
+      printError(`Unknown subcommand: ${sub}. Use: list, get, create, update, delete, test`);
+      process.exitCode = 1;
+  }
+}
+export {
+  run
+};

package/dist/events-FM7VK5VH.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import {
+  spinner
+} from "./chunk-CE4DKHAY.js";
+import {
+  getEvent,
+  listEvents
+} from "./chunk-IC5RERFB.js";
+import "./chunk-K2BGDX7X.js";
+import {
+  dim,
+  print,
+  printError,
+  printJson,
+  printKV,
+  printTable
+} from "./chunk-WPW7UBVR.js";
+
+// src/commands/events.ts
+async function run(args, flags) {
+  const sub = args[0] ?? "list";
+  switch (sub) {
+    case "list": {
+      try {
+        spinner.start("Fetching events...");
+        const result = await listEvents({
+          detectionId: flags.detection,
+          page: flags.page ? Number(flags.page) : void 0,
+          limit: flags.limit ? Number(flags.limit) : void 0
+        });
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        if (!result.data.length) {
+          print("No events found.");
+          return;
+        }
+        printTable(
+          ["ID", "Detection", "Event Name", "Block", "Tx Hash"],
+          result.data.map((e) => [
+            String(e.id),
+            e.detectionId ?? "",
+            e.eventName ?? "",
+            e.blockNumber ? String(e.blockNumber) : "",
+            e.txHash ?? ""
+          ])
+        );
+        if (result.meta) {
+          print(dim(`
+Page ${result.meta.page ?? 1} of ${result.meta.totalPages ?? "?"}  (${result.meta.total ?? "?"} total)`));
+        }
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to fetch events.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "get": {
+      const id = args[1];
+      if (!id) {
+        printError("Usage: chainalert events get <id>");
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        spinner.start("Fetching event...");
+        const result = await getEvent(id);
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        const e = result.data;
+        printKV([
+          ["ID", String(e.id)],
+          ["Detection", e.detectionId ?? ""],
+          ["Event Name", e.eventName ?? ""],
+          ["Block", e.blockNumber ? String(e.blockNumber) : dim("(n/a)")],
+          ["Tx Hash", e.txHash ?? dim("(n/a)")],
+          ["Log Index", e.logIndex !== void 0 ? String(e.logIndex) : dim("(n/a)")],
+          ["Created", e.createdAt ?? ""]
+        ]);
+        if (e.args || e.data) {
+          print("");
+          print(JSON.stringify(e.args ?? e.data, null, 2));
+        }
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to fetch event.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    default:
+      printError(`Unknown subcommand: ${sub}. Use: list, get`);
+      process.exitCode = 1;
+  }
+}
+export {
+  run
+};

package/dist/health-7R5HLRCZ.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import {
+  spinner
+} from "./chunk-CE4DKHAY.js";
+import {
+  getHealth
+} from "./chunk-IC5RERFB.js";
+import "./chunk-K2BGDX7X.js";
+import {
+  print,
+  printError,
+  printJson,
+  printSuccess,
+  red
+} from "./chunk-WPW7UBVR.js";
+
+// src/commands/health.ts
+async function run(args, flags) {
+  try {
+    spinner.start("Checking API health...");
+    const result = await getHealth();
+    spinner.stop();
+    if (flags.json) {
+      printJson(result);
+      return;
+    }
+    if (result.status === "ok") {
+      printSuccess("API is healthy.");
+    } else {
+      print(`Status: ${red(result.status)}`);
+    }
+  } catch (err) {
+    spinner.stop();
+    printError(err.message ?? "Failed to reach API.");
+    process.exitCode = 1;
+  }
+}
+export {
+  run
+};