hookflare 0.0.1

package/dist/index.js

@@ -0,0 +1,387 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/output.ts
+var jsonMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+}
+function output(data) {
+  if (jsonMode) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(data);
+  }
+}
+function outputTable(rows) {
+  if (jsonMode) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log("No results.");
+    return;
+  }
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map(
+    (k) => Math.max(k.length, ...rows.map((r) => String(r[k] ?? "").length))
+  );
+  const header = keys.map((k, i) => k.padEnd(widths[i])).join("  ");
+  const separator = widths.map((w) => "-".repeat(w)).join("  ");
+  console.log(header);
+  console.log(separator);
+  for (const row of rows) {
+    const line = keys.map((k, i) => String(row[k] ?? "").padEnd(widths[i])).join("  ");
+    console.log(line);
+  }
+}
+function outputSuccess(message) {
+  if (jsonMode) {
+    console.log(JSON.stringify({ success: true, message }));
+  } else {
+    console.log(`\u2713 ${message}`);
+  }
+}
+function outputError(message) {
+  if (jsonMode) {
+    console.error(JSON.stringify({ success: false, error: message }));
+  } else {
+    console.error(`\u2717 ${message}`);
+  }
+}
+
+// src/commands/config.ts
+import { Command } from "commander";
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".hookflare");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  api_url: "http://localhost:8787"
+};
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG };
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  const current = loadConfig();
+  const merged = { ...current, ...config };
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n");
+  return merged;
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+// src/commands/config.ts
+var configCommand = new Command("config").description("Manage CLI configuration");
+configCommand.command("set").description("Set a configuration value").argument("<key>", "Config key (api_url, token)").argument("<value>", "Config value").action((key, value) => {
+  if (!["api_url", "token"].includes(key)) {
+    throw new Error(`Unknown config key: ${key}. Valid keys: api_url, token`);
+  }
+  saveConfig({ [key]: value });
+  outputSuccess(`${key} = ${key === "token" ? "****" : value}`);
+});
+configCommand.command("get").description("Show current configuration").action(() => {
+  const config = loadConfig();
+  const display = {
+    ...config,
+    token: config.token ? "****" : void 0,
+    config_path: getConfigPath()
+  };
+  output(display);
+});
+
+// src/commands/sources.ts
+import { Command as Command2 } from "commander";
+
+// src/client.ts
+var HookflareClient = class {
+  baseUrl;
+  token;
+  constructor(opts) {
+    const config = loadConfig();
+    this.baseUrl = (opts?.apiUrl ?? config.api_url).replace(/\/$/, "");
+    this.token = opts?.token ?? config.token;
+  }
+  headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.token) h["Authorization"] = `Bearer ${this.token}`;
+    return h;
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const res = await fetch(url, {
+      method,
+      headers: this.headers(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const json = await res.json();
+    if (!res.ok) {
+      const msg = json.error?.message ?? `HTTP ${res.status}`;
+      throw new Error(msg);
+    }
+    return json;
+  }
+  // Sources
+  listSources() {
+    return this.request("GET", "/api/v1/sources");
+  }
+  getSource(id) {
+    return this.request("GET", `/api/v1/sources/${id}`);
+  }
+  createSource(body) {
+    return this.request("POST", "/api/v1/sources", body);
+  }
+  updateSource(id, body) {
+    return this.request("PUT", `/api/v1/sources/${id}`, body);
+  }
+  deleteSource(id) {
+    return this.request("DELETE", `/api/v1/sources/${id}`);
+  }
+  // Destinations
+  listDestinations() {
+    return this.request("GET", "/api/v1/destinations");
+  }
+  getDestination(id) {
+    return this.request("GET", `/api/v1/destinations/${id}`);
+  }
+  createDestination(body) {
+    return this.request("POST", "/api/v1/destinations", body);
+  }
+  updateDestination(id, body) {
+    return this.request("PUT", `/api/v1/destinations/${id}`, body);
+  }
+  deleteDestination(id) {
+    return this.request("DELETE", `/api/v1/destinations/${id}`);
+  }
+  // Subscriptions
+  listSubscriptions() {
+    return this.request("GET", "/api/v1/subscriptions");
+  }
+  createSubscription(body) {
+    return this.request("POST", "/api/v1/subscriptions", body);
+  }
+  deleteSubscription(id) {
+    return this.request("DELETE", `/api/v1/subscriptions/${id}`);
+  }
+  // Events
+  listEvents(opts) {
+    const params = new URLSearchParams();
+    if (opts?.source_id) params.set("source_id", opts.source_id);
+    if (opts?.limit) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    return this.request("GET", `/api/v1/events${qs ? `?${qs}` : ""}`);
+  }
+  getEvent(id) {
+    return this.request("GET", `/api/v1/events/${id}`);
+  }
+  getEventDeliveries(eventId) {
+    return this.request("GET", `/api/v1/events/${eventId}/deliveries`);
+  }
+  replayEvent(id) {
+    return this.request("POST", `/api/v1/events/${id}/replay`);
+  }
+  // Health
+  health() {
+    return this.request("GET", "/health");
+  }
+};
+
+// src/commands/sources.ts
+var sourcesCommand = new Command2("sources").description("Manage webhook sources");
+sourcesCommand.command("list").alias("ls").description("List all sources").action(async () => {
+  const client = new HookflareClient();
+  const res = await client.listSources();
+  const sources = res.data;
+  outputTable(
+    sources.map((s) => ({
+      id: s.id,
+      name: s.name,
+      verification: s.verification_type ?? "none",
+      created_at: s.created_at
+    }))
+  );
+});
+sourcesCommand.command("get").description("Get source details").argument("<id>", "Source ID").action(async (id) => {
+  const client = new HookflareClient();
+  const res = await client.getSource(id);
+  output(res.data);
+});
+sourcesCommand.command("create").description("Create a new source").requiredOption("--name <name>", "Source name").option("--verification-type <type>", "Signature verification type (hmac-sha256, hmac-sha1)").option("--verification-secret <secret>", "Shared secret for signature verification").action(async (opts) => {
+  const client = new HookflareClient();
+  const body = { name: opts.name };
+  if (opts.verificationType) {
+    body.verification = {
+      type: opts.verificationType,
+      secret: opts.verificationSecret
+    };
+  }
+  const res = await client.createSource(body);
+  output(res.data);
+  outputSuccess("Source created");
+});
+sourcesCommand.command("delete").alias("rm").description("Delete a source").argument("<id>", "Source ID").action(async (id) => {
+  const client = new HookflareClient();
+  await client.deleteSource(id);
+  outputSuccess(`Source ${id} deleted`);
+});
+
+// src/commands/destinations.ts
+import { Command as Command3 } from "commander";
+var destinationsCommand = new Command3("destinations").alias("dest").description("Manage webhook destinations");
+destinationsCommand.command("list").alias("ls").description("List all destinations").action(async () => {
+  const client = new HookflareClient();
+  const res = await client.listDestinations();
+  const dests = res.data;
+  outputTable(
+    dests.map((d) => ({
+      id: d.id,
+      name: d.name,
+      url: d.url,
+      max_retries: d.max_retries,
+      created_at: d.created_at
+    }))
+  );
+});
+destinationsCommand.command("get").description("Get destination details").argument("<id>", "Destination ID").action(async (id) => {
+  const client = new HookflareClient();
+  const res = await client.getDestination(id);
+  output(res.data);
+});
+destinationsCommand.command("create").description("Create a new destination").requiredOption("--name <name>", "Destination name").requiredOption("--url <url>", "Target URL").option("--max-retries <n>", "Maximum retry attempts", "5").option("--timeout-ms <n>", "Request timeout in ms", "30000").action(async (opts) => {
+  const client = new HookflareClient();
+  const res = await client.createDestination({
+    name: opts.name,
+    url: opts.url,
+    retry_policy: {
+      max_retries: parseInt(opts.maxRetries, 10),
+      timeout_ms: parseInt(opts.timeoutMs, 10)
+    }
+  });
+  output(res.data);
+  outputSuccess("Destination created");
+});
+destinationsCommand.command("delete").alias("rm").description("Delete a destination").argument("<id>", "Destination ID").action(async (id) => {
+  const client = new HookflareClient();
+  await client.deleteDestination(id);
+  outputSuccess(`Destination ${id} deleted`);
+});
+
+// src/commands/subscriptions.ts
+import { Command as Command4 } from "commander";
+var subscriptionsCommand = new Command4("subscriptions").alias("subs").description("Manage webhook subscriptions (source \u2192 destination routing)");
+subscriptionsCommand.command("list").alias("ls").description("List all subscriptions").action(async () => {
+  const client = new HookflareClient();
+  const res = await client.listSubscriptions();
+  const subs = res.data;
+  outputTable(
+    subs.map((s) => ({
+      id: s.id,
+      source_id: s.source_id,
+      destination_id: s.destination_id,
+      event_types: s.event_types,
+      enabled: s.enabled
+    }))
+  );
+});
+subscriptionsCommand.command("create").description("Create a new subscription").requiredOption("--source <id>", "Source ID").requiredOption("--destination <id>", "Destination ID").option("--events <types...>", "Event type filters (default: *)").action(async (opts) => {
+  const client = new HookflareClient();
+  const res = await client.createSubscription({
+    source_id: opts.source,
+    destination_id: opts.destination,
+    event_types: opts.events ?? ["*"]
+  });
+  output(res.data);
+  outputSuccess("Subscription created");
+});
+subscriptionsCommand.command("delete").alias("rm").description("Delete a subscription").argument("<id>", "Subscription ID").action(async (id) => {
+  const client = new HookflareClient();
+  await client.deleteSubscription(id);
+  outputSuccess(`Subscription ${id} deleted`);
+});
+
+// src/commands/events.ts
+import { Command as Command5 } from "commander";
+var eventsCommand = new Command5("events").description("View webhook events and deliveries");
+eventsCommand.command("list").alias("ls").description("List received events").option("--source <id>", "Filter by source ID").option("--limit <n>", "Max results", "20").action(async (opts) => {
+  const client = new HookflareClient();
+  const res = await client.listEvents({
+    source_id: opts.source,
+    limit: parseInt(opts.limit, 10)
+  });
+  const events = res.data;
+  outputTable(
+    events.map((e) => ({
+      id: e.id,
+      source_id: e.source_id,
+      event_type: e.event_type ?? "-",
+      received_at: e.received_at
+    }))
+  );
+});
+eventsCommand.command("get").description("Get event details with payload").argument("<id>", "Event ID").action(async (id) => {
+  const client = new HookflareClient();
+  const res = await client.getEvent(id);
+  output(res.data);
+});
+eventsCommand.command("deliveries").description("List delivery attempts for an event").argument("<event_id>", "Event ID").action(async (eventId) => {
+  const client = new HookflareClient();
+  const res = await client.getEventDeliveries(eventId);
+  const deliveries = res.data;
+  outputTable(
+    deliveries.map((d) => ({
+      id: d.id,
+      destination_id: d.destination_id,
+      status: d.status,
+      attempt: d.attempt,
+      status_code: d.status_code ?? "-",
+      latency_ms: d.latency_ms ?? "-"
+    }))
+  );
+});
+eventsCommand.command("replay").description("Replay an event to its destinations").argument("<id>", "Event ID").action(async (id) => {
+  const client = new HookflareClient();
+  await client.replayEvent(id);
+  outputSuccess(`Event ${id} replayed`);
+});
+
+// src/index.ts
+var program = new Command6();
+program.name("hookflare").description("CLI for hookflare \u2014 open-source webhook infrastructure").version("0.0.1").option("--json", "Output in JSON format (agent-friendly)").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.optsWithGlobals();
+  if (opts.json) setJsonMode(true);
+});
+program.command("health").description("Check connection to hookflare server").action(async () => {
+  const client = new HookflareClient();
+  const res = await client.health();
+  console.log(JSON.stringify(res, null, 2));
+});
+program.addCommand(configCommand);
+program.addCommand(sourcesCommand);
+program.addCommand(destinationsCommand);
+program.addCommand(subscriptionsCommand);
+program.addCommand(eventsCommand);
+program.exitOverride();
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err instanceof Error && err.message !== "(outputHelp)") {
+      outputError(err.message);
+      process.exit(1);
+    }
+  }
+}
+main();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "hookflare",
+  "version": "0.0.1",
+  "description": "CLI for hookflare — open-source webhook infrastructure",
+  "type": "module",
+  "bin": {
+    "hookflare": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^13.1.0",
+    "@hookflare/shared": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  },
+  "keywords": [
+    "webhook",
+    "hookflare",
+    "cloudflare",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hookedge/hookflare",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/hookedge/hookflare",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}