@hasna/events 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,811 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli/index.ts
+import { readFileSync } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/filter.ts
+function getPathValue(input, path) {
+  return path.split(".").reduce((value, part) => {
+    if (value && typeof value === "object" && part in value) {
+      return value[part];
+    }
+    return;
+  }, input);
+}
+function wildcardToRegExp(pattern) {
+  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function matchString(value, matcher) {
+  if (matcher === undefined)
+    return true;
+  if (value === undefined)
+    return false;
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.some((item) => wildcardToRegExp(item).test(value));
+}
+function matchRecord(input, matcher) {
+  if (!matcher)
+    return true;
+  return Object.entries(matcher).every(([path, expected]) => {
+    const actual = getPathValue(input, path);
+    if (typeof expected === "string" || Array.isArray(expected)) {
+      return matchString(actual === undefined ? undefined : String(actual), expected);
+    }
+    return actual === expected;
+  });
+}
+function eventMatchesFilter(event, filter) {
+  return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
+}
+function channelMatchesEvent(channel, event) {
+  if (!channel.enabled)
+    return false;
+  if (!channel.filters || channel.filters.length === 0)
+    return true;
+  return channel.filters.some((filter) => eventMatchesFilter(event, filter));
+}
+
+// src/storage.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR";
+var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
+function getEventsDataDir(override) {
+  return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join(homedir(), ".hasna", "events");
+}
+
+class JsonEventsStore {
+  dataDir;
+  channelsPath;
+  eventsPath;
+  deliveriesPath;
+  constructor(dataDir = getEventsDataDir()) {
+    this.dataDir = dataDir;
+    this.channelsPath = join(dataDir, "channels.json");
+    this.eventsPath = join(dataDir, "events.json");
+    this.deliveriesPath = join(dataDir, "deliveries.json");
+  }
+  async init() {
+    await mkdir(this.dataDir, { recursive: true });
+    await this.ensureArrayFile(this.channelsPath);
+    await this.ensureArrayFile(this.eventsPath);
+    await this.ensureArrayFile(this.deliveriesPath);
+  }
+  async addChannel(channel) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const index = channels.findIndex((item) => item.id === channel.id);
+    if (index >= 0) {
+      channels[index] = { ...channel, createdAt: channels[index].createdAt, updatedAt: new Date().toISOString() };
+    } else {
+      channels.push(channel);
+    }
+    await this.writeJson(this.channelsPath, channels);
+    return index >= 0 ? channels[index] : channel;
+  }
+  async listChannels() {
+    await this.init();
+    return this.readJson(this.channelsPath, []);
+  }
+  async getChannel(id) {
+    const channels = await this.listChannels();
+    return channels.find((channel) => channel.id === id);
+  }
+  async removeChannel(id) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const next = channels.filter((channel) => channel.id !== id);
+    await this.writeJson(this.channelsPath, next);
+    return next.length !== channels.length;
+  }
+  async appendEvent(event) {
+    await this.init();
+    const events = await this.readJson(this.eventsPath, []);
+    events.push(event);
+    await this.writeJson(this.eventsPath, events);
+    return event;
+  }
+  async listEvents() {
+    await this.init();
+    return this.readJson(this.eventsPath, []);
+  }
+  async findEventByIdentity(identity) {
+    const events = await this.listEvents();
+    return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
+  }
+  async appendDelivery(result) {
+    await this.init();
+    const deliveries = await this.readJson(this.deliveriesPath, []);
+    deliveries.push(result);
+    await this.writeJson(this.deliveriesPath, deliveries);
+    return result;
+  }
+  async listDeliveries() {
+    await this.init();
+    return this.readJson(this.deliveriesPath, []);
+  }
+  async exportData() {
+    return {
+      channels: await this.listChannels(),
+      events: await this.listEvents(),
+      deliveries: await this.listDeliveries()
+    };
+  }
+  async ensureArrayFile(path) {
+    if (!existsSync(path)) {
+      await writeFile(path, `[]
+`, "utf-8");
+    }
+  }
+  async readJson(path, fallback) {
+    try {
+      const raw = await readFile(path, "utf-8");
+      if (!raw.trim())
+        return fallback;
+      return JSON.parse(raw);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return fallback;
+      throw error;
+    }
+  }
+  async writeJson(path, value) {
+    const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+    await rename(tempPath, path);
+  }
+}
+
+// src/transports.ts
+import { randomUUID } from "crypto";
+import { spawn } from "child_process";
+
+// src/signing.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function buildSignatureBase(timestamp, body) {
+  return `${timestamp}.${body}`;
+}
+function signPayload(secret, timestamp, body) {
+  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
+  return `sha256=${digest}`;
+}
+
+// src/transports.ts
+function now() {
+  return new Date().toISOString();
+}
+function truncate(value, max = 4096) {
+  return value.length > max ? `${value.slice(0, max)}...` : value;
+}
+function buildWebhookRequest(event, channel) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const body = JSON.stringify(event);
+  const timestamp = event.time;
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "@hasna/events",
+    "X-Hasna-Event-Id": event.id,
+    "X-Hasna-Event-Type": event.type,
+    "X-Hasna-Timestamp": timestamp,
+    ...channel.webhook.headers
+  };
+  if (channel.webhook.secret) {
+    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
+  }
+  return { body, headers };
+}
+async function dispatchWebhook(event, channel, options = {}) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const startedAt = now();
+  const { body, headers } = buildWebhookRequest(event, channel);
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
+  try {
+    const response = await (options.fetchImpl ?? fetch)(channel.webhook.url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal
+    });
+    const responseBody = truncate(await response.text());
+    return {
+      attempt: 1,
+      status: response.ok ? "success" : "failed",
+      startedAt,
+      completedAt: now(),
+      responseStatus: response.status,
+      responseBody,
+      error: response.ok ? undefined : `Webhook returned HTTP ${response.status}`
+    };
+  } catch (error) {
+    return {
+      attempt: 1,
+      status: "failed",
+      startedAt,
+      completedAt: now(),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function dispatchCommand(event, channel) {
+  if (!channel.command)
+    throw new Error(`Channel ${channel.id} has no command config`);
+  const startedAt = now();
+  const eventJson = JSON.stringify(event);
+  const env = {
+    ...process.env,
+    ...channel.command.env,
+    HASNA_CHANNEL_ID: channel.id,
+    HASNA_EVENT_ID: event.id,
+    HASNA_EVENT_TYPE: event.type,
+    HASNA_EVENT_SOURCE: event.source,
+    HASNA_EVENT_SUBJECT: event.subject ?? "",
+    HASNA_EVENT_SEVERITY: event.severity,
+    HASNA_EVENT_TIME: event.time,
+    HASNA_EVENT_DEDUPE_KEY: event.dedupeKey ?? "",
+    HASNA_EVENT_SCHEMA_VERSION: event.schemaVersion,
+    HASNA_EVENT_JSON: eventJson
+  };
+  return new Promise((resolve) => {
+    const child = spawn(channel.command.command, channel.command.args ?? [], {
+      cwd: channel.command.cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = setTimeout(() => child.kill("SIGTERM"), channel.command.timeoutMs ?? 15000);
+    child.stdin.end(eventJson);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      resolve({
+        attempt: 1,
+        status: "failed",
+        startedAt,
+        completedAt: now(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: error.message
+      });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      const success = code === 0;
+      resolve({
+        attempt: 1,
+        status: success ? "success" : "failed",
+        startedAt,
+        completedAt: now(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: success ? undefined : `Command exited with ${signal ? `signal ${signal}` : `code ${code}`}`
+      });
+    });
+  });
+}
+async function dispatchChannel(event, channel, options = {}) {
+  if (channel.transport === "webhook")
+    return dispatchWebhook(event, channel, options);
+  if (channel.transport === "command")
+    return dispatchCommand(event, channel);
+  return {
+    attempt: 1,
+    status: "skipped",
+    startedAt: now(),
+    completedAt: now(),
+    error: `Unsupported transport: ${channel.transport}`
+  };
+}
+function createDeliveryResult(event, channel, attempts) {
+  const status = attempts.some((attempt) => attempt.status === "success") ? "success" : attempts.every((attempt) => attempt.status === "skipped") ? "skipped" : "failed";
+  return {
+    id: randomUUID(),
+    eventId: event.id,
+    channelId: channel.id,
+    transport: channel.transport,
+    status,
+    attempts,
+    createdAt: attempts[0]?.startedAt ?? now(),
+    completedAt: attempts.at(-1)?.completedAt ?? now()
+  };
+}
+
+// src/index.ts
+function createEvent(input) {
+  return {
+    id: input.id ?? randomUUID2(),
+    source: input.source,
+    type: input.type,
+    time: normalizeTime(input.time),
+    subject: input.subject,
+    severity: input.severity ?? "info",
+    data: input.data ?? {},
+    message: input.message,
+    dedupeKey: input.dedupeKey,
+    schemaVersion: input.schemaVersion ?? "1.0",
+    metadata: input.metadata ?? {}
+  };
+}
+
+class EventsClient {
+  store;
+  redactors;
+  transportOptions;
+  constructor(options = {}) {
+    this.store = options.store ?? new JsonEventsStore(options.dataDir);
+    this.redactors = options.redactors ?? [];
+    this.transportOptions = { fetchImpl: options.fetchImpl };
+  }
+  async addChannel(input) {
+    const timestamp = new Date().toISOString();
+    return this.store.addChannel({
+      ...input,
+      createdAt: input.createdAt ?? timestamp,
+      updatedAt: input.updatedAt ?? timestamp
+    });
+  }
+  async listChannels() {
+    return this.store.listChannels();
+  }
+  async removeChannel(id) {
+    return this.store.removeChannel(id);
+  }
+  async emit(input, options = {}) {
+    const event = createEvent(input);
+    if (options.dedupe !== false) {
+      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
+      if (existing) {
+        return { event: existing, deliveries: [], deduped: true };
+      }
+    }
+    await this.store.appendEvent(event);
+    const deliveries = options.deliver === false ? [] : await this.deliver(event);
+    return { event, deliveries, deduped: false };
+  }
+  async listEvents() {
+    return this.store.listEvents();
+  }
+  async listDeliveries() {
+    return this.store.listDeliveries();
+  }
+  async deliver(event) {
+    const channels = await this.store.listChannels();
+    const selected = channels.filter((channel) => channelMatchesEvent(channel, event));
+    const deliveries = [];
+    for (const channel of selected) {
+      const eventForChannel = await this.applyRedaction(event, channel);
+      const result = await this.deliverWithRetry(eventForChannel, channel);
+      await this.store.appendDelivery(result);
+      deliveries.push(result);
+    }
+    return deliveries;
+  }
+  async testChannel(id, input = {}) {
+    const channel = await this.store.getChannel(id);
+    if (!channel)
+      throw new Error(`Channel not found: ${id}`);
+    const event = createEvent({
+      source: input.source ?? "hasna.events",
+      type: input.type ?? "events.test",
+      subject: input.subject ?? id,
+      severity: input.severity ?? "info",
+      data: input.data ?? { test: true },
+      message: input.message ?? "Hasna events test delivery",
+      dedupeKey: input.dedupeKey,
+      schemaVersion: input.schemaVersion,
+      metadata: input.metadata,
+      time: input.time,
+      id: input.id
+    });
+    const eventForChannel = await this.applyRedaction(event, channel);
+    const result = await this.deliverWithRetry(eventForChannel, channel);
+    await this.store.appendDelivery(result);
+    return result;
+  }
+  async replay(options = {}) {
+    const events = (await this.store.listEvents()).filter((event) => {
+      if (options.eventId && event.id !== options.eventId)
+        return false;
+      if (options.source && event.source !== options.source)
+        return false;
+      if (options.type && event.type !== options.type)
+        return false;
+      return true;
+    });
+    if (options.dryRun)
+      return { events, deliveries: [] };
+    const deliveries = [];
+    for (const event of events) {
+      deliveries.push(...await this.deliver(event));
+    }
+    return { events, deliveries };
+  }
+  async applyRedaction(event, channel) {
+    let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
+    for (const redactor of this.redactors) {
+      next = await redactor(next, channel);
+    }
+    return next;
+  }
+  async deliverWithRetry(event, channel) {
+    const policy = normalizeRetryPolicy(channel.retry);
+    const attempts = [];
+    for (let index = 0;index < policy.maxAttempts; index += 1) {
+      const attempt = await dispatchChannel(event, channel, this.transportOptions);
+      attempt.attempt = index + 1;
+      if (attempt.status === "failed" && index + 1 < policy.maxAttempts) {
+        attempt.nextBackoffMs = Math.round(policy.backoffMs * policy.multiplier ** index);
+      }
+      attempts.push(attempt);
+      if (attempt.status !== "failed")
+        break;
+      if (attempt.nextBackoffMs)
+        await Bun.sleep(attempt.nextBackoffMs);
+    }
+    return createDeliveryResult(event, channel, attempts);
+  }
+}
+function redactPaths(event, paths, replacement = "[REDACTED]") {
+  if (paths.length === 0)
+    return event;
+  const copy = structuredClone(event);
+  for (const path of paths) {
+    setPath(copy, path, replacement);
+  }
+  return copy;
+}
+function sanitizeChannelForOutput(channel) {
+  const copy = structuredClone(channel);
+  if (copy.webhook?.secret)
+    copy.webhook.secret = "[REDACTED]";
+  if (copy.command?.env) {
+    copy.command.env = Object.fromEntries(Object.entries(copy.command.env).map(([key, value]) => [key, shouldRedactKey(key) ? "[REDACTED]" : value]));
+  }
+  return copy;
+}
+function sanitizeChannelsForOutput(channels) {
+  return channels.map(sanitizeChannelForOutput);
+}
+function shouldRedactKey(key) {
+  return /secret|token|password|api[_-]?key|authorization/i.test(key);
+}
+function setPath(input, path, replacement) {
+  const parts = path.split(".");
+  let cursor = input;
+  for (const part of parts.slice(0, -1)) {
+    const next = cursor[part];
+    if (!next || typeof next !== "object")
+      return;
+    cursor = next;
+  }
+  const last = parts.at(-1);
+  if (last && last in cursor)
+    cursor[last] = replacement;
+}
+function normalizeTime(value) {
+  if (!value)
+    return new Date().toISOString();
+  return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeRetryPolicy(policy) {
+  return {
+    maxAttempts: Math.max(1, policy?.maxAttempts ?? 1),
+    backoffMs: Math.max(0, policy?.backoffMs ?? 250),
+    multiplier: Math.max(1, policy?.multiplier ?? 2)
+  };
+}
+
+// src/cli/index.ts
+function version() {
+  try {
+    const packagePath = join2(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    return JSON.parse(readFileSync(packagePath, "utf-8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function parseGlobalArgs(argv) {
+  const rest = [];
+  let json = false;
+  let dir;
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--json" || arg === "-j") {
+      json = true;
+    } else if (arg === "--dir") {
+      dir = argv[++index];
+    } else {
+      rest.push(arg);
+    }
+  }
+  return { json, dir, rest };
+}
+function takeOption(args, name) {
+  const index = args.indexOf(name);
+  if (index === -1)
+    return;
+  const value = args[index + 1];
+  args.splice(index, 2);
+  return value;
+}
+function takeFlag(args, name) {
+  const index = args.indexOf(name);
+  if (index === -1)
+    return false;
+  args.splice(index, 1);
+  return true;
+}
+function takeMany(args, name) {
+  const values = [];
+  while (args.includes(name)) {
+    const value = takeOption(args, name);
+    if (value !== undefined)
+      values.push(value);
+  }
+  return values;
+}
+function parseJsonOption(value, fallback) {
+  if (!value)
+    return fallback;
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Expected a JSON object");
+  }
+  return parsed;
+}
+function parseFilter(args) {
+  const filter2 = {};
+  const type = takeOption(args, "--type") ?? takeOption(args, "--event-type");
+  const source = takeOption(args, "--source");
+  const subject = takeOption(args, "--subject");
+  const severity = takeOption(args, "--severity");
+  if (type)
+    filter2.type = type;
+  if (source)
+    filter2.source = source;
+  if (subject)
+    filter2.subject = subject;
+  if (severity)
+    filter2.severity = severity;
+  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
+}
+function parseHeaders(values) {
+  if (values.length === 0)
+    return;
+  const headers = {};
+  for (const value of values) {
+    const separator = value.indexOf("=");
+    if (separator === -1)
+      throw new Error(`Invalid header, expected name=value: ${value}`);
+    headers[value.slice(0, separator)] = value.slice(separator + 1);
+  }
+  return headers;
+}
+function output(parsed, value, human) {
+  if (parsed.json) {
+    console.log(JSON.stringify(value, null, 2));
+    return;
+  }
+  human();
+}
+function printHelp() {
+  console.log(`events ${version()}
+
+Usage:
+  events [--dir <path>] [--json] webhooks add <url|command> [options]
+  events [--dir <path>] [--json] webhooks list
+  events [--dir <path>] [--json] webhooks remove <id>
+  events [--dir <path>] [--json] webhooks test <id>
+  events [--dir <path>] [--json] events emit <type> --source <source> [options]
+  events [--dir <path>] [--json] events list [--limit <n>]
+  events [--dir <path>] [--json] events replay [--id <event-id>] [--dry-run]
+
+Environment:
+  HASNA_EVENTS_DIR or HASNA_EVENTS_HOME overrides the default ${getEventsDataDir()}`);
+}
+async function main(argv = process.argv.slice(2)) {
+  const parsed = parseGlobalArgs(argv);
+  const [group, command, ...tail] = parsed.rest;
+  if (!group || group === "--help" || group === "-h") {
+    printHelp();
+    return;
+  }
+  if (group === "--version" || group === "-v") {
+    console.log(version());
+    return;
+  }
+  const store = new JsonEventsStore(parsed.dir);
+  const client = new EventsClient({ store });
+  if (group === "webhooks") {
+    await handleWebhooks(client, command, tail, parsed);
+    return;
+  }
+  if (group === "events") {
+    await handleEvents(client, command, tail, parsed);
+    return;
+  }
+  throw new Error(`Unknown command group: ${group}`);
+}
+async function handleWebhooks(client, command, tail, parsed) {
+  if (command === "add") {
+    const args = [...tail];
+    const transport = takeOption(args, "--transport") ?? "webhook";
+    const id = takeOption(args, "--id") ?? crypto.randomUUID();
+    const name = takeOption(args, "--name");
+    const secret = takeOption(args, "--secret");
+    const timeoutMs = numberOption(takeOption(args, "--timeout-ms"));
+    const retryAttempts = numberOption(takeOption(args, "--retry-attempts"));
+    const retryBackoffMs = numberOption(takeOption(args, "--retry-backoff-ms"));
+    const disabled = takeFlag(args, "--disabled");
+    const headerValues = takeMany(args, "--header");
+    const redactions = takeMany(args, "--redact");
+    const filters = parseFilter(args);
+    const target = args[0];
+    if (!target)
+      throw new Error("webhooks add requires a URL or command target");
+    const now2 = new Date().toISOString();
+    const channel = {
+      id,
+      name,
+      enabled: !disabled,
+      transport,
+      filters,
+      retry: retryAttempts || retryBackoffMs ? { maxAttempts: retryAttempts, backoffMs: retryBackoffMs } : undefined,
+      redact: redactions.length > 0 ? { paths: redactions } : undefined,
+      createdAt: now2,
+      updatedAt: now2
+    };
+    if (transport === "webhook") {
+      channel.webhook = { url: target, secret, headers: parseHeaders(headerValues), timeoutMs };
+    } else if (transport === "command") {
+      channel.command = { command: target, args: args.slice(1), timeoutMs };
+    } else {
+      throw new Error(`Transport ${transport} is reserved for future use and cannot be added yet`);
+    }
+    const saved = await client.addChannel(channel);
+    output(parsed, sanitizeChannelForOutput(saved), () => console.log(`Added ${saved.transport} channel ${saved.id}`));
+    return;
+  }
+  if (command === "list") {
+    const channels = await client.listChannels();
+    output(parsed, sanitizeChannelsForOutput(channels), () => {
+      if (channels.length === 0) {
+        console.log("No channels configured.");
+        return;
+      }
+      for (const channel of channels) {
+        const target = channel.webhook?.url ?? channel.command?.command ?? channel.transport;
+        console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${target}`);
+      }
+    });
+    return;
+  }
+  if (command === "remove") {
+    const id = tail[0];
+    if (!id)
+      throw new Error("webhooks remove requires a channel id");
+    const removed = await client.removeChannel(id);
+    output(parsed, { removed }, () => console.log(removed ? `Removed ${id}` : `Channel not found: ${id}`));
+    return;
+  }
+  if (command === "test") {
+    const args = [...tail];
+    const id = args.shift();
+    if (!id)
+      throw new Error("webhooks test requires a channel id");
+    const result = await client.testChannel(id, {
+      source: takeOption(args, "--source") ?? "hasna.events",
+      type: takeOption(args, "--type") ?? "events.test",
+      subject: takeOption(args, "--subject") ?? id,
+      data: parseJsonOption(takeOption(args, "--data"), { test: true })
+    });
+    output(parsed, result, () => console.log(`${result.status}: ${result.channelId}`));
+    return;
+  }
+  throw new Error(`Unknown webhooks command: ${command ?? ""}`);
+}
+async function handleEvents(client, command, tail, parsed) {
+  if (command === "emit") {
+    const args = [...tail];
+    const type = args.shift();
+    if (!type)
+      throw new Error("events emit requires an event type");
+    const source = takeOption(args, "--source");
+    if (!source)
+      throw new Error("events emit requires --source");
+    const noDeliver = takeFlag(args, "--no-deliver");
+    const result = await client.emit({
+      type,
+      source,
+      subject: takeOption(args, "--subject"),
+      severity: severityOption(takeOption(args, "--severity")),
+      message: takeOption(args, "--message"),
+      dedupeKey: takeOption(args, "--dedupe-key"),
+      data: parseJsonOption(takeOption(args, "--data"), {}),
+      metadata: parseJsonOption(takeOption(args, "--metadata"), {})
+    }, { deliver: !noDeliver });
+    output(parsed, result, () => console.log(`${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`));
+    return;
+  }
+  if (command === "list") {
+    const args = [...tail];
+    const limit = numberOption(takeOption(args, "--limit"));
+    const type = takeOption(args, "--type");
+    const source = takeOption(args, "--source");
+    let events = await client.listEvents();
+    if (type)
+      events = events.filter((event) => event.type === type);
+    if (source)
+      events = events.filter((event) => event.source === source);
+    if (limit)
+      events = events.slice(-limit);
+    output(parsed, events, () => {
+      if (events.length === 0) {
+        console.log("No events recorded.");
+        return;
+      }
+      for (const event of events) {
+        console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
+      }
+    });
+    return;
+  }
+  if (command === "replay") {
+    const args = [...tail];
+    const result = await client.replay({
+      eventId: takeOption(args, "--id"),
+      source: takeOption(args, "--source"),
+      type: takeOption(args, "--type"),
+      dryRun: takeFlag(args, "--dry-run")
+    });
+    output(parsed, result, () => console.log(`Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`));
+    return;
+  }
+  throw new Error(`Unknown events command: ${command ?? ""}`);
+}
+function numberOption(value) {
+  if (value === undefined)
+    return;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed))
+    throw new Error(`Expected a number, got ${value}`);
+  return parsed;
+}
+function severityOption(value) {
+  if (!value)
+    return;
+  const allowed = new Set(["debug", "info", "notice", "warning", "error", "critical"]);
+  if (!allowed.has(value))
+    throw new Error(`Invalid severity: ${value}`);
+  return value;
+}
+main().catch((error) => {
+  const parsed = parseGlobalArgs(process.argv.slice(2));
+  const message = error instanceof Error ? error.message : String(error);
+  if (parsed.json) {
+    console.log(JSON.stringify({ error: message }, null, 2));
+  } else {
+    console.error(message);
+  }
+  process.exit(1);
+});