@chainalert/cli 0.0.1

package/dist/alerts-STXD4TE5.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import {
+  spinner
+} from "./chunk-CE4DKHAY.js";
+import {
+  getAlert,
+  getAlertStats,
+  listAlerts
+} from "./chunk-IC5RERFB.js";
+import "./chunk-K2BGDX7X.js";
+import {
+  dim,
+  print,
+  printError,
+  printJson,
+  printKV,
+  printTable
+} from "./chunk-WPW7UBVR.js";
+
+// src/commands/alerts.ts
+async function run(args, flags) {
+  const sub = args[0] ?? "list";
+  switch (sub) {
+    case "list": {
+      try {
+        spinner.start("Fetching alerts...");
+        const result = await listAlerts({
+          severity: flags.severity,
+          detectionId: flags.detection,
+          from: flags.from,
+          to: flags.to,
+          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 alerts found.");
+          return;
+        }
+        printTable(
+          ["ID", "Detection", "Severity", "Title", "Fired At"],
+          result.data.map((a) => [
+            String(a.id),
+            a.detectionId ?? a.detectionName ?? "",
+            a.severity ?? "",
+            a.title ?? a.message ?? "",
+            a.firedAt ?? a.createdAt ?? ""
+          ])
+        );
+        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 alerts.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "get": {
+      const id = args[1];
+      if (!id) {
+        printError("Usage: chainalert alerts get <id>");
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        spinner.start("Fetching alert...");
+        const result = await getAlert(id);
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        const a = result.data;
+        printKV([
+          ["ID", String(a.id)],
+          ["Detection", a.detectionId ?? a.detectionName ?? ""],
+          ["Severity", a.severity ?? ""],
+          ["Title", a.title ?? a.message ?? ""],
+          ["Fired At", a.firedAt ?? a.createdAt ?? ""],
+          ["Block", a.blockNumber ? String(a.blockNumber) : dim("(n/a)")],
+          ["Tx Hash", a.txHash ?? dim("(n/a)")]
+        ]);
+        if (a.details) {
+          print("");
+          print(JSON.stringify(a.details, null, 2));
+        }
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to fetch alert.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "stats": {
+      try {
+        spinner.start("Fetching alert stats...");
+        const result = await getAlertStats();
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        const stats = result.data ?? result;
+        const pairs = [];
+        for (const [key, value] of Object.entries(stats)) {
+          pairs.push([key, String(value)]);
+        }
+        if (pairs.length === 0) {
+          print("No stats available.");
+          return;
+        }
+        printKV(pairs);
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to fetch alert stats.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    default:
+      printError(`Unknown subcommand: ${sub}. Use: list, get, stats`);
+      process.exitCode = 1;
+  }
+}
+export {
+  run
+};

package/dist/auth-6LTJFNU2.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import {
+  ask
+} from "./chunk-6FDEYAAT.js";
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-K2BGDX7X.js";
+import {
+  dim,
+  print,
+  printError,
+  printJson,
+  printKV,
+  printSuccess
+} from "./chunk-WPW7UBVR.js";
+
+// src/commands/auth.ts
+async function run(args, flags) {
+  const sub = args[0];
+  switch (sub) {
+    case "login": {
+      const apiKey = await ask("API key: ");
+      if (!apiKey) {
+        printError("API key cannot be empty.");
+        process.exitCode = 1;
+        return;
+      }
+      const config = loadConfig();
+      config.apiKey = apiKey;
+      saveConfig(config);
+      printSuccess("API key saved.");
+      break;
+    }
+    case "logout": {
+      const config = loadConfig();
+      delete config.apiKey;
+      saveConfig(config);
+      printSuccess("API key removed.");
+      break;
+    }
+    case "whoami": {
+      const config = loadConfig();
+      if (!config.apiKey) {
+        printError("Not logged in. Run `chainalert auth login` to set an API key.");
+        process.exitCode = 1;
+        return;
+      }
+      if (flags.json) {
+        printJson({
+          apiKeyPrefix: config.apiKey.slice(0, 10) + "...",
+          apiUrl: config.apiUrl ?? "(default)"
+        });
+        return;
+      }
+      printKV([
+        ["API Key", config.apiKey.slice(0, 10) + "..."],
+        ["API URL", config.apiUrl ?? dim("(default)")]
+      ]);
+      break;
+    }
+    default:
+      printError(`Unknown auth subcommand: ${sub ?? "(none)"}. Use login, logout, or whoami.`);
+      process.exitCode = 1;
+  }
+}
+var VALID_CONFIG_KEYS = {
+  "api-url": "apiUrl",
+  "openai-key": "openaiKey"
+};
+async function runConfig(args, flags) {
+  const sub = args[0];
+  switch (sub) {
+    case "set": {
+      const key = args[1];
+      const value = args[2];
+      if (!key || !value) {
+        printError("Usage: chainalert config set <key> <value>");
+        process.exitCode = 1;
+        return;
+      }
+      const configKey = VALID_CONFIG_KEYS[key];
+      if (!configKey) {
+        printError(`Unknown config key: ${key}. Valid keys: ${Object.keys(VALID_CONFIG_KEYS).join(", ")}`);
+        process.exitCode = 1;
+        return;
+      }
+      const config = loadConfig();
+      config[configKey] = value;
+      saveConfig(config);
+      printSuccess(`${key} set.`);
+      break;
+    }
+    case "get": {
+      const key = args[1];
+      if (!key) {
+        printError("Usage: chainalert config get <key>");
+        process.exitCode = 1;
+        return;
+      }
+      const configKey = VALID_CONFIG_KEYS[key];
+      if (!configKey) {
+        printError(`Unknown config key: ${key}. Valid keys: ${Object.keys(VALID_CONFIG_KEYS).join(", ")}`);
+        process.exitCode = 1;
+        return;
+      }
+      const config = loadConfig();
+      const value = config[configKey];
+      if (flags.json) {
+        printJson({ [key]: value ?? null });
+        return;
+      }
+      print(value ?? dim("(not set)"));
+      break;
+    }
+    default:
+      printError(`Unknown config subcommand: ${sub ?? "(none)"}. Use set or get.`);
+      process.exitCode = 1;
+  }
+}
+export {
+  run,
+  runConfig
+};

package/dist/channels-C5JZON37.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import {
+  confirm
+} from "./chunk-6FDEYAAT.js";
+import {
+  spinner
+} from "./chunk-CE4DKHAY.js";
+import {
+  createChannel,
+  deleteChannel,
+  listChannels,
+  testChannel
+} from "./chunk-IC5RERFB.js";
+import "./chunk-K2BGDX7X.js";
+import {
+  print,
+  printError,
+  printJson,
+  printSuccess,
+  printTable
+} from "./chunk-WPW7UBVR.js";
+
+// src/commands/channels.ts
+async function run(args, flags) {
+  const sub = args[0] ?? "list";
+  switch (sub) {
+    case "list": {
+      try {
+        spinner.start("Fetching channels...");
+        const result = await listChannels({
+          type: flags.type
+        });
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        if (!result.data.length) {
+          print("No channels found.");
+          return;
+        }
+        printTable(
+          ["ID", "Name", "Type", "Enabled"],
+          result.data.map((c) => [
+            String(c.id),
+            c.name ?? "",
+            c.type ?? "",
+            c.enabled !== false ? "Yes" : "No"
+          ])
+        );
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to fetch channels.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "create": {
+      if (!flags.name) {
+        printError("--name is required.");
+        process.exitCode = 1;
+        return;
+      }
+      if (!flags.type) {
+        printError("--type is required.");
+        process.exitCode = 1;
+        return;
+      }
+      let config;
+      switch (flags.type) {
+        case "webhook":
+          if (!flags.url) {
+            printError("--url is required for webhook channels.");
+            process.exitCode = 1;
+            return;
+          }
+          config = { url: flags.url };
+          break;
+        case "email":
+          if (!flags.recipients) {
+            printError("--recipients is required for email channels.");
+            process.exitCode = 1;
+            return;
+          }
+          config = { recipients: flags.recipients.split(",").map((r) => r.trim()) };
+          break;
+        case "slack":
+          if (!flags.url) {
+            printError("--url is required for slack channels.");
+            process.exitCode = 1;
+            return;
+          }
+          config = { webhookUrl: flags.url };
+          break;
+        default:
+          config = {};
+          if (flags.url) config.url = flags.url;
+          if (flags.recipients) config.recipients = flags.recipients.split(",").map((r) => r.trim());
+          break;
+      }
+      try {
+        spinner.start("Creating channel...");
+        const result = await createChannel({
+          name: flags.name,
+          type: flags.type,
+          config
+        });
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        printSuccess(`Channel created: ${result.data.id}`);
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to create channel.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "test": {
+      const id = args[1];
+      if (!id) {
+        printError("Usage: chainalert channels test <id>");
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        spinner.start("Testing channel...");
+        const result = await testChannel(id);
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        printSuccess("Test notification sent.");
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to test channel.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "delete": {
+      const id = args[1];
+      if (!id) {
+        printError("Usage: chainalert channels delete <id>");
+        process.exitCode = 1;
+        return;
+      }
+      const ok = await confirm(`Delete channel ${id}?`);
+      if (!ok) {
+        print("Cancelled.");
+        return;
+      }
+      try {
+        spinner.start("Deleting channel...");
+        const result = await deleteChannel(id);
+        spinner.stop();
+        if (flags.json) {
+          printJson(result);
+          return;
+        }
+        printSuccess(`Channel ${id} deleted.`);
+      } catch (err) {
+        spinner.stop();
+        printError(err.message ?? "Failed to delete channel.");
+        process.exitCode = 1;
+      }
+      break;
+    }
+    default:
+      printError(`Unknown subcommand: ${sub}. Use: list, create, test, delete`);
+      process.exitCode = 1;
+  }
+}
+export {
+  run
+};

package/dist/chunk-6FDEYAAT.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// src/util/prompt.ts
+import { createInterface } from "readline";
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(`${question} [y/N] `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export {
+  confirm,
+  ask
+};

package/dist/chunk-CE4DKHAY.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+// src/util/spinner.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var Spinner = class {
+  interval = null;
+  frame = 0;
+  start(msg) {
+    this.stop();
+    process.stdout.write(`${FRAMES[0]} ${msg}`);
+    this.interval = setInterval(() => {
+      this.frame = (this.frame + 1) % FRAMES.length;
+      process.stdout.write(`\r${FRAMES[this.frame]} ${msg}`);
+    }, 80);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+      process.stdout.write("\r\x1B[K");
+    }
+  }
+};
+var spinner = new Spinner();
+
+export {
+  spinner
+};

package/dist/chunk-IC5RERFB.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import {
+  getApiKey,
+  getApiUrl
+} from "./chunk-K2BGDX7X.js";
+
+// src/client/http.ts
+var ApiError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+  }
+};
+async function request(method, path, opts) {
+  const baseUrl = getApiUrl();
+  if (!baseUrl) {
+    throw new Error("API URL not configured. Run `chainalert config set apiUrl <url>` first.");
+  }
+  const url = new URL(path, baseUrl);
+  if (opts?.params) {
+    for (const [key, value] of Object.entries(opts.params)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const apiKey = getApiKey();
+  if (apiKey) {
+    headers["X-API-Key"] = apiKey;
+  }
+  const res = await fetch(url.toString(), {
+    method,
+    headers,
+    body: opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0
+  });
+  if (!res.ok) {
+    let message = `HTTP ${res.status}`;
+    try {
+      const err = await res.json();
+      if (typeof err.error === "string") message = err.error;
+      else if (typeof err.message === "string") message = err.message;
+    } catch {
+    }
+    throw new ApiError(res.status, message);
+  }
+  return await res.json();
+}
+function get(path, params) {
+  return request("GET", path, { params });
+}
+function post(path, body) {
+  return request("POST", path, { body });
+}
+function patch(path, body) {
+  return request("PATCH", path, { body });
+}
+function del(path) {
+  return request("DELETE", path);
+}
+
+// src/client/api.ts
+async function getHealth() {
+  return get("/health");
+}
+async function listNetworks() {
+  return get("/networks");
+}
+async function listTemplates(params) {
+  return get("/templates", params);
+}
+async function getTemplate(slug) {
+  return get(`/templates/${slug}`);
+}
+async function listDetections(params) {
+  return get("/detections", params);
+}
+async function getDetection(id) {
+  return get(`/detections/${id}`);
+}
+async function createDetection(body) {
+  return post("/detections", body);
+}
+async function updateDetection(id, body) {
+  return patch(`/detections/${id}`, body);
+}
+async function deleteDetection(id) {
+  return del(`/detections/${id}`);
+}
+async function testDetection(id, body) {
+  return post(`/detections/${id}/test`, body);
+}
+async function listAlerts(params) {
+  return get("/alerts", params);
+}
+async function getAlert(id) {
+  return get(`/alerts/${id}`);
+}
+async function getAlertStats() {
+  return get("/alerts/stats");
+}
+async function listEvents(params) {
+  return get("/events", params);
+}
+async function getEvent(id) {
+  return get(`/events/${id}`);
+}
+async function listStateChanges(params) {
+  return get("/state-changes", params);
+}
+async function listChannels(params) {
+  return get("/channels", params);
+}
+async function createChannel(body) {
+  return post("/channels", body);
+}
+async function deleteChannel(id) {
+  return del(`/channels/${id}`);
+}
+async function testChannel(id) {
+  return post(`/channels/${id}/test`);
+}
+async function resolveContract(body) {
+  return post("/contracts/resolve", body);
+}
+async function getStorageSlots(id) {
+  return get(`/contracts/${id}/storage-slots`);
+}
+async function listOrgContracts(params) {
+  return get("/org-contracts", params);
+}
+async function getOrgContract(id) {
+  return get(`/org-contracts/${id}`);
+}
+async function registerOrgContract(body) {
+  return post("/org-contracts", body);
+}
+async function getOrgContractTraits(id) {
+  return get(`/org-contracts/${id}/traits`);
+}
+async function listRpcConfigs() {
+  return get("/rpc-configs");
+}
+async function addRpcConfig(body) {
+  return post("/rpc-configs", body);
+}
+async function testRpcConfig(id) {
+  return post(`/rpc-configs/${id}/test`);
+}
+
+export {
+  getHealth,
+  listNetworks,
+  listTemplates,
+  getTemplate,
+  listDetections,
+  getDetection,
+  createDetection,
+  updateDetection,
+  deleteDetection,
+  testDetection,
+  listAlerts,
+  getAlert,
+  getAlertStats,
+  listEvents,
+  getEvent,
+  listStateChanges,
+  listChannels,
+  createChannel,
+  deleteChannel,
+  testChannel,
+  resolveContract,
+  getStorageSlots,
+  listOrgContracts,
+  getOrgContract,
+  registerOrgContract,
+  getOrgContractTraits,
+  listRpcConfigs,
+  addRpcConfig,
+  testRpcConfig
+};

package/dist/chunk-K2BGDX7X.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  DEFAULT_API_URL
+} from "./chunk-WPW7UBVR.js";
+
+// src/config/store.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+function ensureDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+function getApiUrl() {
+  return loadConfig().apiUrl ?? DEFAULT_API_URL;
+}
+function getApiKey() {
+  return loadConfig().apiKey;
+}
+
+export {
+  loadConfig,
+  saveConfig,
+  getApiUrl,
+  getApiKey
+};