@sendly/cli 3.32.0 → 3.34.0

package/dist/commands/webhooks/backfill.d.ts

@@ -0,0 +1,17 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksBackfill extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        since: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        until: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "event-types": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/backfill.js

@@ -0,0 +1,73 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, spinner, json, isJsonMode } from "../../lib/output.js";
+export default class WebhooksBackfill extends AuthenticatedCommand {
+    static description = "Synthesize missed webhook events from the message log. Use when an outage left events with no audit row.";
+    static examples = [
+        "<%= config.bin %> webhooks backfill whk_abc123",
+        "<%= config.bin %> webhooks backfill whk_abc123 --since 2026-05-01T00:00:00Z --limit 5000",
+        "<%= config.bin %> webhooks backfill whk_abc123 --event-types message.delivered,message.failed",
+    ];
+    static args = {
+        id: Args.string({ description: "Webhook ID", required: true }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        since: Flags.string({
+            description: "Earliest message time (ISO-8601). Default: now − 24h.",
+        }),
+        until: Flags.string({
+            description: "Latest message time (ISO-8601). Default: now.",
+        }),
+        "event-types": Flags.string({
+            description: "Comma-separated event types to backfill (message.sent, message.delivered, message.failed)",
+        }),
+        limit: Flags.integer({
+            description: "Maximum events to synthesize (max 10000)",
+            default: 1000,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WebhooksBackfill);
+        const body = {};
+        if (flags.since)
+            body.since = flags.since;
+        if (flags.until)
+            body.until = flags.until;
+        if (flags["event-types"])
+            body.event_types = flags["event-types"]
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+        if (flags.limit !== undefined)
+            body.limit = flags.limit;
+        const sp = spinner("Synthesizing missed deliveries...");
+        sp.start();
+        try {
+            const result = await apiClient.post(`/api/v1/webhooks/${args.id}/backfill`, body);
+            sp.stop();
+            if (isJsonMode()) {
+                json(result);
+                return;
+            }
+            const byType = Object.entries(result.by_type ?? {})
+                .map(([k, v]) => `${k}=${v}`)
+                .join(", ");
+            success(result.message || "Backfill complete", {
+                Synthesized: String(result.synthesized),
+                "By Type": byType || "(none)",
+                "Candidates Scanned": String(result.candidates_scanned),
+                Truncated: result.truncated ? "yes (more eligible than limit)" : "no",
+                Window: `${result.since} → ${result.until}`,
+                Limit: String(result.limit),
+            });
+        }
+        catch (err) {
+            sp.stop();
+            error(`Failed to backfill: ${err instanceof Error ? err.message : String(err)}`);
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/webhooks/redeliver.d.ts

@@ -0,0 +1,18 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksRedeliver extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        since: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        until: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "event-types": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        statuses: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/redeliver.js

@@ -0,0 +1,78 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, spinner, json, isJsonMode } from "../../lib/output.js";
+export default class WebhooksRedeliver extends AuthenticatedCommand {
+    static description = "Replay failed or cancelled webhook deliveries from the audit log. Reset the circuit first if it's open.";
+    static examples = [
+        "<%= config.bin %> webhooks redeliver whk_abc123",
+        "<%= config.bin %> webhooks redeliver whk_abc123 --since 2026-05-01T00:00:00Z --limit 5000",
+        "<%= config.bin %> webhooks redeliver whk_abc123 --event-types message.delivered,message.failed",
+    ];
+    static args = {
+        id: Args.string({ description: "Webhook ID", required: true }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        since: Flags.string({
+            description: "Earliest delivery time (ISO-8601). Default: now − 24h.",
+        }),
+        until: Flags.string({
+            description: "Latest delivery time (ISO-8601). Default: now.",
+        }),
+        "event-types": Flags.string({
+            description: "Comma-separated event types to filter on",
+        }),
+        statuses: Flags.string({
+            description: "Comma-separated delivery statuses to replay. Default: failed,cancelled",
+        }),
+        limit: Flags.integer({
+            description: "Maximum deliveries to requeue (max 10000)",
+            default: 1000,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WebhooksRedeliver);
+        const body = {};
+        if (flags.since)
+            body.since = flags.since;
+        if (flags.until)
+            body.until = flags.until;
+        if (flags["event-types"])
+            body.event_types = flags["event-types"]
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+        if (flags.statuses)
+            body.statuses = flags.statuses
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+        if (flags.limit !== undefined)
+            body.limit = flags.limit;
+        const sp = spinner("Requeuing deliveries...");
+        sp.start();
+        try {
+            const result = await apiClient.post(`/api/v1/webhooks/${args.id}/redeliver`, body);
+            sp.stop();
+            if (isJsonMode()) {
+                json(result);
+                return;
+            }
+            success(result.message || "Redeliver complete", {
+                Requeued: String(result.requeued),
+                Skipped: String(result.skipped),
+                Truncated: result.truncated ? "yes (window larger than limit)" : "no",
+                "Window Size": String(result.window_size),
+                Window: `${result.since} → ${result.until}`,
+                Limit: String(result.limit),
+            });
+        }
+        catch (err) {
+            sp.stop();
+            error(`Failed to redeliver: ${err instanceof Error ? err.message : String(err)}`);
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redeliver.js","sourceRoot":"","sources":["../../../src/commands/webhooks/redeliver.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport { success, error, spinner, json, isJsonMode } from \"../../lib/output.js\";\n\ninterface RedeliverResponse {\n  message: string;\n  requeued: number;\n  skipped: number;\n  truncated: boolean;\n  window_size: number;\n  delivery_ids: string[];\n  since: string;\n  until: string;\n  limit: number;\n}\n\nexport default class WebhooksRedeliver extends AuthenticatedCommand {\n  static description =\n    \"Replay failed or cancelled webhook deliveries from the audit log. Reset the circuit first if it's open.\";\n\n  static examples = [\n    \"<%= config.bin %> webhooks redeliver whk_abc123\",\n    \"<%= config.bin %> webhooks redeliver whk_abc123 --since 2026-05-01T00:00:00Z --limit 5000\",\n    \"<%= config.bin %> webhooks redeliver whk_abc123 --event-types message.delivered,message.failed\",\n  ];\n\n  static args = {\n    id: Args.string({ description: \"Webhook ID\", required: true }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    since: Flags.string({\n      description: \"Earliest delivery time (ISO-8601). Default: now − 24h.\",\n    }),\n    until: Flags.string({\n      description: \"Latest delivery time (ISO-8601). Default: now.\",\n    }),\n    \"event-types\": Flags.string({\n      description: \"Comma-separated event types to filter on\",\n    }),\n    statuses: Flags.string({\n      description:\n        \"Comma-separated delivery statuses to replay. Default: failed,cancelled\",\n    }),\n    limit: Flags.integer({\n      description: \"Maximum deliveries to requeue (max 10000)\",\n      default: 1000,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(WebhooksRedeliver);\n\n    const body: Record<string, unknown> = {};\n    if (flags.since) body.since = flags.since;\n    if (flags.until) body.until = flags.until;\n    if (flags[\"event-types\"])\n      body.event_types = flags[\"event-types\"]\n        .split(\",\")\n        .map((s) => s.trim())\n        .filter(Boolean);\n    if (flags.statuses)\n      body.statuses = flags.statuses\n        .split(\",\")\n        .map((s) => s.trim())\n        .filter(Boolean);\n    if (flags.limit !== undefined) body.limit = flags.limit;\n\n    const sp = spinner(\"Requeuing deliveries...\");\n    sp.start();\n\n    try {\n      const result = await apiClient.post<RedeliverResponse>(\n        `/api/v1/webhooks/${args.id}/redeliver`,\n        body,\n      );\n\n      sp.stop();\n\n      if (isJsonMode()) {\n        json(result);\n        return;\n      }\n\n      success(result.message || \"Redeliver complete\", {\n        Requeued: String(result.requeued),\n        Skipped: String(result.skipped),\n        Truncated: result.truncated ? \"yes (window larger than limit)\" : \"no\",\n        \"Window Size\": String(result.window_size),\n        Window: `${result.since} → ${result.until}`,\n        Limit: String(result.limit),\n      });\n    } catch (err) {\n      sp.stop();\n      error(\n        `Failed to redeliver: ${err instanceof Error ? err.message : String(err)}`,\n      );\n      this.exit(1);\n    }\n  }\n}\n"]}

package/dist/commands/webhooks/reset-circuit.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksResetCircuit extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/reset-circuit.js

@@ -0,0 +1,44 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, spinner, json, isJsonMode } from "../../lib/output.js";
+export default class WebhooksResetCircuit extends AuthenticatedCommand {
+    static description = "Reset the circuit breaker for a webhook";
+    static examples = [
+        "<%= config.bin %> webhooks reset-circuit whk_abc123",
+        "<%= config.bin %> webhooks reset-circuit whk_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Webhook ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(WebhooksResetCircuit);
+        const sp = spinner("Resetting circuit breaker...");
+        sp.start();
+        try {
+            const result = await apiClient.post(`/api/v1/webhooks/${args.id}/reset-circuit`);
+            sp.stop();
+            if (isJsonMode()) {
+                json(result);
+                return;
+            }
+            success(result.message || "Circuit breaker reset", {
+                "Webhook ID": result.webhook?.id || args.id,
+                "Circuit State": result.webhook?.circuit_state || "closed",
+                "Failure Count": String(result.webhook?.failure_count ?? 0),
+            });
+        }
+        catch (err) {
+            sp.stop();
+            error(`Failed to reset circuit: ${err instanceof Error ? err.message : String(err)}`);
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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