@curviate/cli 0.1.0

package/dist/webhook-QM5LGAUF.js

@@ -0,0 +1,445 @@
+#!/usr/bin/env node
+import {
+  buildPreviewOutput
+} from "./chunk-R3VLWLVV.js";
+import {
+  streamAll
+} from "./chunk-SND3NHCT.js";
+import {
+  createClient,
+  renderError,
+  renderSuccess,
+  renderUnexpectedError,
+  resolveEffectiveConfig
+} from "./chunk-2NCPJJPC.js";
+import {
+  GLOBAL_FLAGS
+} from "./chunk-6JNCLLNY.js";
+
+// src/commands/webhook.ts
+import { defineCommand } from "citty";
+import { readFileSync } from "fs";
+function rejectPreviewOnRead(preview, out) {
+  if (preview) {
+    out.stderr.write("error: --preview is only valid on write commands (mutations). Reads just run.\n");
+    process.exit(2);
+  }
+}
+function rejectAllOnNonPaginated(all, out) {
+  if (all) {
+    out.stderr.write("error: --all is not supported on non-paginated commands.\n");
+    process.exit(2);
+  }
+}
+function buildOutputStreams() {
+  return {
+    stdout: { write: (s) => process.stdout.write(s) },
+    stderr: { write: (s) => process.stderr.write(s) }
+  };
+}
+function resolveOutputOpts(flags) {
+  return {
+    json: (flags.json ?? false) || !process.stdout.isTTY,
+    isTTY: process.stdout.isTTY ?? false,
+    fields: flags.fields
+  };
+}
+async function handleError(err, outOpts, out) {
+  const { CurviateError } = await import("@curviate/sdk");
+  if (err instanceof CurviateError) {
+    const { getExitCode } = await import("./exit-codes-NFIR57ZA.js");
+    renderError(err, outOpts, out);
+    process.exit(getExitCode(err.code));
+  }
+  renderUnexpectedError(err, out);
+  process.exit(1);
+}
+async function runWebhookCreate(client, flags, out) {
+  if (!flags.source) {
+    out.stderr.write("error: --source is required (messaging | user | account_status).\n");
+    process.exit(2);
+  }
+  if (!flags["request-url"]) {
+    out.stderr.write("error: --request-url is required (HTTPS URL for webhook deliveries).\n");
+    process.exit(2);
+  }
+  if (!flags["account-ids"]) {
+    out.stderr.write("error: --account-ids is required (comma-separated list of acc_\u2026 ids).\n");
+    process.exit(2);
+  }
+  const accountIds = flags["account-ids"].split(",").map((s) => s.trim()).filter(Boolean);
+  const body = {
+    source: flags.source,
+    request_url: flags["request-url"],
+    account_ids: accountIds
+  };
+  if (flags.name) body["name"] = flags.name;
+  if (flags.format) body["format"] = flags.format;
+  if (flags.enabled !== void 0) body["enabled"] = flags.enabled;
+  if (flags.events) {
+    body["events"] = flags.events.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (flags.data) {
+    body["data"] = flags.data.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({ method: "webhooks.create", args: {}, body });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.webhooks.create(body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runWebhookList(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const outOpts = resolveOutputOpts(flags);
+  const all = flags.all ?? false;
+  const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+  const limit = flags.limit ? parseInt(flags.limit, 10) : void 0;
+  const cursor = flags.cursor;
+  const params = {};
+  if (limit !== void 0) params["limit"] = limit;
+  if (cursor) params["cursor"] = cursor;
+  try {
+    if (all) {
+      const fn = (p) => client.webhooks.list(p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        onTruncated: (msg) => out.stderr.write(msg + "\n")
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+    } else {
+      const result = await client.webhooks.list(params);
+      renderSuccess(result, outOpts, out);
+    }
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runWebhookEvents(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  rejectAllOnNonPaginated(flags.all, out);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await client.webhooks.listEvents();
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runWebhookUpdate(client, flags, out) {
+  if (flags.source !== void 0) {
+    out.stderr.write("error: --source cannot be changed after creation (source is immutable).\n");
+    process.exit(2);
+  }
+  const id = flags.id ?? "";
+  const body = {};
+  if (flags.name !== void 0) body["name"] = flags.name;
+  if (flags["request-url"]) body["request_url"] = flags["request-url"];
+  if (flags.enabled !== void 0) body["enabled"] = flags.enabled;
+  if (flags.format) body["format"] = flags.format;
+  if (flags.events) {
+    body["events"] = flags.events.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (flags.data) {
+    body["data"] = flags.data.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (flags["account-ids"]) {
+    body["account_ids"] = flags["account-ids"].split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({
+      method: "webhooks.update",
+      args: { id },
+      body
+    });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.webhooks.update(id, body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runWebhookDelete(client, flags, out) {
+  const id = flags.id ?? "";
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({
+      method: "webhooks.delete",
+      args: { id },
+      body: {}
+    });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.webhooks.delete(id);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runWebhookStateDiff(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = flags["account-id"] ?? "";
+  const outOpts = resolveOutputOpts(flags);
+  const query = {};
+  if (flags.cursor) query["cursor"] = flags.cursor;
+  try {
+    const result = await client.webhooks.getStateDiff(accountId, query);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runWebhookVerify(input, out) {
+  const { constructEvent, WebhookSignatureError } = await import("@curviate/sdk");
+  try {
+    const event = await constructEvent(
+      input.rawBody,
+      input.signatureHeader,
+      input.secret,
+      ...input.replayWindowSecs !== void 0 ? [{ replayWindowSecs: input.replayWindowSecs }] : []
+    );
+    out.stdout.write(JSON.stringify(event) + "\n");
+  } catch (err) {
+    if (err instanceof WebhookSignatureError) {
+      const envelope = {
+        error: {
+          name: "WebhookSignatureError",
+          reason: err.reason,
+          message: err.message
+        }
+      };
+      out.stdout.write(JSON.stringify(envelope) + "\n");
+      out.stderr.write(`error: webhook verification failed \u2014 ${err.reason}: ${err.message}
+`);
+      process.exit(2);
+    }
+    out.stderr.write(`error: unexpected error during webhook verification: ${String(err)}
+`);
+    process.exit(1);
+  }
+}
+var webhookCreateCommand = defineCommand({
+  meta: { name: "create", description: "Register a new webhook endpoint." },
+  args: {
+    ...GLOBAL_FLAGS,
+    source: { type: "string", description: "Event source: messaging | user | account_status.", required: true },
+    "request-url": { type: "string", description: "HTTPS URL to receive webhook deliveries.", required: true },
+    "account-ids": { type: "string", description: "Comma-separated account ids to target (required).", required: true },
+    name: { type: "string", description: "Human-readable name (1\u2013100 chars)." },
+    format: { type: "string", description: "Delivery encoding: json | form (default: json)." },
+    enabled: { type: "boolean", description: "Create as enabled (default: true).", default: true },
+    events: { type: "string", description: "Comma-separated event names to subscribe to." },
+    data: { type: "string", description: "Comma-separated field-remapping keys." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runWebhookCreate(client, flags, out);
+  }
+});
+var webhookListCommand = defineCommand({
+  meta: { name: "list", description: "List registered webhooks." },
+  args: { ...GLOBAL_FLAGS },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runWebhookList(client, flags, out);
+  }
+});
+var webhookEventsCommand = defineCommand({
+  meta: { name: "events", description: "List the canonical webhook event catalogue." },
+  args: { ...GLOBAL_FLAGS },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runWebhookEvents(client, flags, out);
+  }
+});
+var webhookUpdateCommand = defineCommand({
+  meta: { name: "update", description: "Update a webhook in place (source is immutable)." },
+  args: {
+    ...GLOBAL_FLAGS,
+    id: { type: "positional", description: "Webhook id (wh_\u2026)." },
+    "request-url": { type: "string", description: "Replace the delivery URL." },
+    name: { type: "string", description: "Replace the name (or clear with empty string)." },
+    enabled: { type: "boolean", description: "Enable or disable the webhook." },
+    format: { type: "string", description: "Replace the delivery encoding: json | form." },
+    events: { type: "string", description: "Replace subscribed events (comma-separated)." },
+    data: { type: "string", description: "Replace field-remapping keys (comma-separated)." },
+    "account-ids": { type: "string", description: "Replace targeted accounts (comma-separated)." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runWebhookUpdate(client, flags, out);
+  }
+});
+var webhookDeleteCommand = defineCommand({
+  meta: { name: "delete", description: "Permanently remove a webhook subscription." },
+  args: {
+    ...GLOBAL_FLAGS,
+    id: { type: "positional", description: "Webhook id (wh_\u2026)." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runWebhookDelete(client, flags, out);
+  }
+});
+var webhookStateDiffCommand = defineCommand({
+  meta: { name: "state-diff", description: "Get the set of changes for an account since the last known version." },
+  args: {
+    ...GLOBAL_FLAGS,
+    "account-id": { type: "positional", description: "Account id (acc_\u2026)." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runWebhookStateDiff(client, flags, out);
+  }
+});
+var webhookVerifyCommand = defineCommand({
+  meta: { name: "verify", description: "Verify a webhook signature offline (no network call)." },
+  args: {
+    ...GLOBAL_FLAGS,
+    secret: {
+      type: "string",
+      description: "The webhook signing secret from your webhook registration.",
+      required: true
+    },
+    header: {
+      type: "string",
+      description: "The full X-Curviate-Signature header value (t=\u2026,v1=\u2026). Reads from stdin if omitted."
+    },
+    body: {
+      type: "string",
+      description: "Path to a file containing the raw webhook body, or - for stdin."
+    },
+    "max-age-secs": {
+      type: "string",
+      description: "Maximum event age in seconds before rejecting as replay (default: 300)."
+    }
+  },
+  async run({ args }) {
+    const flags = args;
+    const out = buildOutputStreams();
+    let rawBody = "";
+    if (flags.body) {
+      if (flags.body === "-") {
+        rawBody = readFileSync("/dev/stdin", "utf8");
+      } else {
+        rawBody = readFileSync(flags.body, "utf8");
+      }
+    }
+    const signatureHeader = flags.header ?? "";
+    const secret = flags.secret ?? "";
+    const replayWindowSecs = flags["max-age-secs"] ? parseInt(flags["max-age-secs"], 10) : void 0;
+    await runWebhookVerify({ secret, signatureHeader, rawBody, replayWindowSecs }, out);
+  }
+});
+var webhookCommand = defineCommand({
+  meta: { name: "webhook", description: "Webhook management and signature verification." },
+  subCommands: {
+    create: webhookCreateCommand,
+    list: webhookListCommand,
+    events: webhookEventsCommand,
+    update: webhookUpdateCommand,
+    delete: webhookDeleteCommand,
+    "state-diff": webhookStateDiffCommand,
+    verify: webhookVerifyCommand
+  },
+  async run() {
+    process.stderr.write(
+      "Usage: curviate webhook <subcommand>\n  create | list | events | update | delete | state-diff | verify\n"
+    );
+  }
+});
+export {
+  runWebhookCreate,
+  runWebhookDelete,
+  runWebhookEvents,
+  runWebhookList,
+  runWebhookStateDiff,
+  runWebhookUpdate,
+  runWebhookVerify,
+  webhookCommand
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@curviate/cli",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Official command-line interface for the Curviate API.",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://docs.curviate.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/curviate/cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/curviate/cli/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "curviate": "./dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepack": "node scripts/check-clean.mjs && tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src test",
+    "check:clean": "node scripts/check-clean.mjs",
+    "verify:dist": "pnpm build && node scripts/verify-dist.mjs",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  },
+  "dependencies": {
+    "@curviate/sdk": "^0.1.1",
+    "citty": "^0.1.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "eslint": "^9.0.0",
+    "typescript-eslint": "^8.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^3.2.2"
+  }
+}