@sendly/cli - npm Package Compare versions

Comparing version 3.18.0 to 3.18.2

dist/commands/enterprise/analytics/credits.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class AnalyticsCredits extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        period: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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>;
+}

dist/commands/enterprise/analytics/credits.js

+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, table, colors, header, isJsonMode, formatCredits, } from "../../../lib/output.js";
+export default class AnalyticsCredits extends AuthenticatedCommand {
+    static description = "Get credit usage analytics over time";
+    static examples = [
+        "<%= config.bin %> enterprise analytics credits",
+        "<%= config.bin %> enterprise analytics credits --period 30d",
+        "<%= config.bin %> enterprise analytics credits --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        period: Flags.string({
+            char: "p",
+            description: "Time period (7d, 30d, 90d)",
+            options: ["7d", "30d", "90d"],
+            default: "7d",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AnalyticsCredits);
+        const response = await apiClient.get("/api/v1/enterprise/analytics/credits", { period: flags.period });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        header(`Credit Usage (${flags.period})`);
+        console.log();
+        console.log(`  ${colors.dim("Total Used:")} ${formatCredits(response.totals.totalUsed)}  ` +
+            `${colors.dim("Allocated:")} ${formatCredits(response.totals.totalAllocated)}  ` +
+            `${colors.dim("Balance:")} ${colors.primary(formatCredits(response.totals.currentBalance))}`);
+        console.log();
+        table(response.data, [
+            { header: "Date", key: "date", width: 12 },
+            {
+                header: "Used",
+                key: "used",
+                width: 12,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Allocated",
+                key: "allocated",
+                width: 12,
+                formatter: (v) => Number(v) > 0
+                    ? colors.success(`+${Number(v).toLocaleString()}`)
+                    : colors.dim("0"),
+            },
+            {
+                header: "Balance",
+                key: "balance",
+                width: 12,
+                formatter: (v) => colors.primary(Number(v).toLocaleString()),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/analytics/delivery.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class AnalyticsDelivery extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    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>;
+}

dist/commands/enterprise/analytics/delivery.js

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, table, colors, header, isJsonMode, } from "../../../lib/output.js";
+export default class AnalyticsDelivery extends AuthenticatedCommand {
+    static description = "Get delivery rate analytics by workspace";
+    static examples = [
+        "<%= config.bin %> enterprise analytics delivery",
+        "<%= config.bin %> enterprise analytics delivery --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const response = await apiClient.get("/api/v1/enterprise/analytics/delivery");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        header("Delivery Rates by Workspace");
+        console.log();
+        table(response.workspaces, [
+            { header: "Workspace", key: "workspaceName", width: 24 },
+            {
+                header: "Sent",
+                key: "sent",
+                width: 10,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Delivered",
+                key: "delivered",
+                width: 10,
+                formatter: (v) => colors.success(Number(v).toLocaleString()),
+            },
+            {
+                header: "Failed",
+                key: "failed",
+                width: 10,
+                formatter: (v) => Number(v) > 0
+                    ? colors.error(Number(v).toLocaleString())
+                    : colors.dim("0"),
+            },
+            {
+                header: "Rate",
+                key: "deliveryRate",
+                width: 8,
+                formatter: (v) => {
+                    const rate = Number(v);
+                    const text = `${rate.toFixed(1)}%`;
+                    return rate >= 95
+                        ? colors.success(text)
+                        : rate >= 80
+                            ? colors.warning(text)
+                            : colors.error(text);
+                },
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/analytics/messages.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class AnalyticsMessages extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        period: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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>;
+}

dist/commands/enterprise/analytics/messages.js

+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, table, colors, header, isJsonMode, } from "../../../lib/output.js";
+export default class AnalyticsMessages extends AuthenticatedCommand {
+    static description = "Get message analytics across all workspaces";
+    static examples = [
+        "<%= config.bin %> enterprise analytics messages",
+        "<%= config.bin %> enterprise analytics messages --period 30d",
+        "<%= config.bin %> enterprise analytics messages --period 90d --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        period: Flags.string({
+            char: "p",
+            description: "Time period (7d, 30d, 90d)",
+            options: ["7d", "30d", "90d"],
+            default: "7d",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AnalyticsMessages);
+        const response = await apiClient.get("/api/v1/enterprise/analytics/messages", { period: flags.period });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        header(`Message Analytics (${flags.period})`);
+        console.log();
+        console.log(`  ${colors.dim("Totals:")} ${response.totals.sent.toLocaleString()} sent, ` +
+            `${colors.success(response.totals.delivered.toLocaleString() + " delivered")}, ` +
+            `${response.totals.failed > 0 ? colors.error(response.totals.failed.toLocaleString() + " failed") : colors.dim("0 failed")}`);
+        console.log();
+        table(response.data, [
+            { header: "Date", key: "date", width: 12 },
+            {
+                header: "Sent",
+                key: "sent",
+                width: 10,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Delivered",
+                key: "delivered",
+                width: 10,
+                formatter: (v) => colors.success(Number(v).toLocaleString()),
+            },
+            {
+                header: "Failed",
+                key: "failed",
+                width: 10,
+                formatter: (v) => Number(v) > 0
+                    ? colors.error(Number(v).toLocaleString())
+                    : colors.dim("0"),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/analytics/overview.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class AnalyticsOverview extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    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>;
+}

dist/commands/enterprise/analytics/overview.js

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, formatCredits, } from "../../../lib/output.js";
+export default class AnalyticsOverview extends AuthenticatedCommand {
+    static description = "Get enterprise-wide analytics overview";
+    static examples = [
+        "<%= config.bin %> enterprise analytics overview",
+        "<%= config.bin %> enterprise analytics overview --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const overview = await apiClient.get("/api/v1/enterprise/analytics/overview");
+        if (isJsonMode()) {
+            json(overview);
+            return;
+        }
+        header("Enterprise Overview");
+        keyValue({
+            "Total Workspaces": String(overview.totalWorkspaces),
+            Active: colors.success(String(overview.activeWorkspaces)),
+            Suspended: overview.suspendedWorkspaces > 0
+                ? colors.error(String(overview.suspendedWorkspaces))
+                : colors.dim("0"),
+        });
+        console.log();
+        header("Messaging");
+        keyValue({
+            "Messages Sent": overview.totalMessagesSent.toLocaleString(),
+            "Messages Delivered": overview.totalMessagesDelivered.toLocaleString(),
+            "Delivery Rate": `${overview.deliveryRate.toFixed(1)}%`,
+        });
+        console.log();
+        header("Credits");
+        keyValue({
+            "Credits Used": formatCredits(overview.totalCreditsUsed),
+            "Credits Remaining": colors.primary(formatCredits(overview.totalCreditsRemaining)),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/billing.d.ts

+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseBilling extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        page: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, 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>;
+}

dist/commands/enterprise/billing.js

+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, table, colors, header, isJsonMode, } from "../../lib/output.js";
+export default class EnterpriseBilling extends AuthenticatedCommand {
+    static description = "Get billing breakdown by workspace";
+    static examples = [
+        "<%= config.bin %> enterprise billing",
+        "<%= config.bin %> enterprise billing --page 2",
+        "<%= config.bin %> enterprise billing --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        page: Flags.integer({
+            description: "Page number",
+            default: 1,
+        }),
+        limit: Flags.integer({
+            description: "Results per page",
+            default: 20,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnterpriseBilling);
+        const response = await apiClient.get("/api/v1/enterprise/billing/workspace-breakdown", { page: flags.page, limit: flags.limit });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        header("Billing Breakdown");
+        console.log();
+        console.log(`  ${colors.dim("Platform Fee:")}  $${response.platformFee.toFixed(2)}/mo`);
+        console.log(`  ${colors.dim("Seat Fees:")}     $${response.totalSeatFees.toFixed(2)}/mo`);
+        console.log(`  ${colors.dim("Credits:")}       $${response.totalCreditsPurchased.toFixed(2)}`);
+        console.log(`  ${colors.bold("Total:")}         ${colors.primary("$" + response.totalAmount.toFixed(2))}`);
+        console.log();
+        table(response.workspaces, [
+            { header: "Workspace", key: "workspaceName", width: 24 },
+            {
+                header: "Seat Fee",
+                key: "seatFee",
+                width: 10,
+                formatter: (v) => `$${Number(v).toFixed(2)}`,
+            },
+            {
+                header: "Credits Bought",
+                key: "creditsPurchased",
+                width: 14,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Credits Used",
+                key: "creditsUsed",
+                width: 12,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+            {
+                header: "Messages",
+                key: "messagesCount",
+                width: 10,
+                formatter: (v) => Number(v).toLocaleString(),
+            },
+        ]);
+        if (response.totalPages > 1) {
+            console.log();
+            console.log(colors.dim(`  Page ${response.page} of ${response.totalPages}. Use --page to navigate.`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/credits.d.ts

+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseCredits extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: 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>;
+}

dist/commands/enterprise/credits.js

+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, formatCredits, } from "../../lib/output.js";
+export default class EnterpriseCredits extends AuthenticatedCommand {
+    static description = "Check credit balance for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise credits org_abc123",
+        "<%= config.bin %> enterprise credits org_abc123 --json",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(EnterpriseCredits);
+        const credits = await apiClient.get(`/api/v1/enterprise/workspaces/${args.workspaceId}/credits`);
+        if (isJsonMode()) {
+            json(credits);
+            return;
+        }
+        header("Workspace Credits");
+        keyValue({
+            Available: colors.primary(formatCredits(credits.availableBalance)),
+            Reserved: credits.reservedBalance > 0
+                ? colors.warning(formatCredits(credits.reservedBalance))
+                : colors.dim("0 credits"),
+            "Total Balance": formatCredits(credits.balance),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/keys/create.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class EnterpriseKeysCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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>;
+}

dist/commands/enterprise/keys/create.js

+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, warn, json, colors, codeBlock, isJsonMode, } from "../../../lib/output.js";
+export default class EnterpriseKeysCreate extends AuthenticatedCommand {
+    static description = "Create an API key for an enterprise workspace";
+    static examples = [
+        '<%= config.bin %> enterprise keys create org_abc123 --name "Production"',
+        '<%= config.bin %> enterprise keys create org_abc123 --name "CI" --type test',
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Name for the API key",
+            required: true,
+        }),
+        type: Flags.string({
+            char: "t",
+            description: "Key type (test or live)",
+            options: ["test", "live"],
+            default: "live",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnterpriseKeysCreate);
+        const response = await apiClient.post(`/api/v1/enterprise/workspaces/${args.workspaceId}/keys`, {
+            name: flags.name,
+            type: flags.type,
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("API key created", {
+            Name: response.name,
+            "Key ID": response.id,
+            Type: flags.type === "test"
+                ? colors.warning("test")
+                : colors.success("live"),
+        });
+        console.log();
+        warn("Copy your API key now. You won't be able to see it again!");
+        codeBlock(response.key);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/keys/list.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class EnterpriseKeysList extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: 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>;
+}

dist/commands/enterprise/keys/list.js

+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { table, json, info, colors, isJsonMode, formatRelativeTime, } from "../../../lib/output.js";
+export default class EnterpriseKeysList extends AuthenticatedCommand {
+    static description = "List API keys for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise keys list org_abc123",
+        "<%= config.bin %> enterprise keys list org_abc123 --json",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(EnterpriseKeysList);
+        const response = await apiClient.get(`/api/v1/enterprise/workspaces/${args.workspaceId}/keys`);
+        if (isJsonMode()) {
+            json(response.keys);
+            return;
+        }
+        if (response.keys.length === 0) {
+            info("No API keys found for this workspace");
+            console.log();
+            console.log(`  Create one with ${colors.code(`sendly enterprise keys create ${args.workspaceId}`)}`);
+            return;
+        }
+        console.log();
+        table(response.keys, [
+            { header: "Name", key: "name", width: 20 },
+            {
+                header: "Key ID",
+                key: "id",
+                width: 18,
+                formatter: (v) => colors.dim(String(v).slice(0, 16)),
+            },
+            {
+                header: "Prefix",
+                key: "prefix",
+                width: 16,
+                formatter: (v) => colors.code(String(v)),
+            },
+            {
+                header: "Type",
+                key: "type",
+                width: 8,
+                formatter: (v) => v === "test" ? colors.warning("test") : colors.success("live"),
+            },
+            {
+                header: "Status",
+                key: "isActive",
+                width: 10,
+                formatter: (v) => v ? colors.success("active") : colors.error("revoked"),
+            },
+            {
+                header: "Last Used",
+                key: "lastUsedAt",
+                width: 12,
+                formatter: (v) => v ? formatRelativeTime(String(v)) : colors.dim("never"),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/keys/revoke.d.ts

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

dist/commands/enterprise/keys/revoke.js

+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, error, json, isJsonMode } from "../../../lib/output.js";
+import inquirer from "inquirer";
+export default class EnterpriseKeysRevoke extends AuthenticatedCommand {
+    static description = "Revoke an API key for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise keys revoke org_abc123 key_xyz",
+        "<%= config.bin %> enterprise keys revoke org_abc123 key_xyz --yes",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+        keyId: Args.string({
+            description: "API key ID to revoke",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnterpriseKeysRevoke);
+        if (!flags.yes && !isJsonMode()) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Revoke API key ${args.keyId}? This cannot be undone.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Revocation cancelled");
+                return;
+            }
+        }
+        await apiClient.delete(`/api/v1/enterprise/workspaces/${args.workspaceId}/keys/${args.keyId}`);
+        if (isJsonMode()) {
+            json({ success: true, keyId: args.keyId });
+            return;
+        }
+        success("API key revoked", {
+            "Key ID": args.keyId,
+            Workspace: args.workspaceId,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/provision.d.ts

+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseProvision extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        credits: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "inherit-from": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "webhook-url": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "create-key": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        bulk: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, 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>;
+    private bulkProvision;
+}

dist/commands/enterprise/provision.js

+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, table, colors, isJsonMode, spinner, } from "../../lib/output.js";
+import * as fs from "node:fs";
+export default class EnterpriseProvision extends AuthenticatedCommand {
+    static description = "Provision a new workspace with full setup, or bulk provision from a JSON file";
+    static examples = [
+        '<%= config.bin %> enterprise provision --name "Acme Corp" --credits 1000',
+        '<%= config.bin %> enterprise provision --name "Acme Corp" --credits 500 --inherit-from org_abc123 --webhook-url https://example.com/hook',
+        "<%= config.bin %> enterprise provision --bulk workspaces.json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Workspace name (single provision)",
+        }),
+        credits: Flags.integer({
+            char: "c",
+            description: "Initial credits to allocate",
+        }),
+        "inherit-from": Flags.string({
+            description: "Workspace ID to inherit verification from",
+        }),
+        "webhook-url": Flags.string({
+            description: "Webhook URL for the workspace",
+        }),
+        "create-key": Flags.boolean({
+            description: "Create an API key for the workspace",
+            default: false,
+        }),
+        bulk: Flags.string({
+            char: "b",
+            description: "Path to JSON file for bulk provisioning (up to 50 workspaces)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnterpriseProvision);
+        if (flags.bulk) {
+            await this.bulkProvision(flags.bulk);
+            return;
+        }
+        if (!flags.name) {
+            this.error("--name is required for single provisioning. Use --bulk for batch provisioning.");
+        }
+        const spin = spinner("Provisioning workspace...");
+        spin.start();
+        const body = { name: flags.name };
+        if (flags.credits)
+            body.credits = flags.credits;
+        if (flags["inherit-from"])
+            body.inheritVerificationFrom = flags["inherit-from"];
+        if (flags["webhook-url"])
+            body.webhookUrl = flags["webhook-url"];
+        if (flags["create-key"])
+            body.createApiKey = true;
+        const response = await apiClient.post("/api/v1/enterprise/workspaces/provision", body);
+        spin.succeed("Workspace provisioned");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const details = {
+            ID: response.organization.id,
+            Name: response.organization.name,
+            Slug: response.organization.slug,
+        };
+        if (response.verification) {
+            details["Verification"] = response.verification.status === "approved"
+                ? colors.success("inherited")
+                : colors.warning(response.verification.status);
+        }
+        if (response.credits) {
+            details["Credits"] = `${response.credits.balance.toLocaleString()} credits`;
+        }
+        if (response.apiKey) {
+            details["API Key"] = response.apiKey.key;
+        }
+        if (response.webhook) {
+            details["Webhook"] = response.webhook.url;
+        }
+        success("Workspace provisioned", details);
+        if (response.apiKey) {
+            console.log();
+            console.log(colors.warning("  Save the API key now — it won't be shown again."));
+        }
+    }
+    async bulkProvision(filePath) {
+        if (!fs.existsSync(filePath)) {
+            this.error(`File not found: ${filePath}`);
+        }
+        const content = fs.readFileSync(filePath, "utf-8");
+        let workspaces;
+        try {
+            workspaces = JSON.parse(content);
+        }
+        catch {
+            this.error("Invalid JSON file. Expected an array of workspace objects.");
+        }
+        if (!Array.isArray(workspaces)) {
+            this.error("JSON file must contain an array of workspace objects.");
+        }
+        if (workspaces.length > 50) {
+            this.error("Bulk provisioning supports up to 50 workspaces at a time.");
+        }
+        const spin = spinner(`Provisioning ${workspaces.length} workspaces...`);
+        spin.start();
+        const response = await apiClient.post("/api/v1/enterprise/workspaces/provision/bulk", { workspaces });
+        spin.succeed(`Provisioned ${response.totalCreated}/${response.totalRequested} workspaces`);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        console.log();
+        table(response.results, [
+            { header: "Name", key: "name", width: 24 },
+            {
+                header: "Status",
+                key: "success",
+                width: 10,
+                formatter: (v) => v ? colors.success("created") : colors.error("failed"),
+            },
+            {
+                header: "Workspace ID",
+                key: "workspaceId",
+                width: 20,
+                formatter: (v) => (v ? colors.dim(String(v)) : colors.dim("—")),
+            },
+            {
+                header: "Error",
+                key: "error",
+                width: 30,
+                formatter: (v) => (v ? colors.error(String(v)) : ""),
+            },
+        ]);
+        if (response.totalFailed > 0) {
+            console.log();
+            console.log(colors.warning(`  ${response.totalFailed} workspace(s) failed to provision.`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provision.js","sourceRoot":"","sources":["../../../src/commands/enterprise/provision.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  success,\n  json,\n  table,\n  colors,\n  isJsonMode,\n  spinner,\n} from \"../../lib/output.js\";\nimport * as fs from \"node:fs\";\n\ninterface ProvisionResponse {\n  organization: { id: string; name: string; slug: string };\n  verification?: { status: string };\n  credits?: { balance: number };\n  apiKey?: { id: string; key: string; prefix: string };\n  webhook?: { url: string };\n  optInPage?: { id: string; slug: string };\n}\n\ninterface BulkProvisionItem {\n  name: string;\n  credits?: number;\n  inheritVerificationFrom?: string;\n  webhookUrl?: string;\n  createApiKey?: boolean;\n}\n\ninterface BulkResultItem {\n  name: string;\n  success: boolean;\n  workspaceId?: string;\n  error?: string;\n}\n\ninterface BulkProvisionResponse {\n  results: BulkResultItem[];\n  totalRequested: number;\n  totalCreated: number;\n  totalFailed: number;\n}\n\nexport default class EnterpriseProvision extends AuthenticatedCommand {\n  static description = \"Provision a new workspace with full setup, or bulk provision from a JSON file\";\n\n  static examples = [\n    '<%= config.bin %> enterprise provision --name \"Acme Corp\" --credits 1000',\n    '<%= config.bin %> enterprise provision --name \"Acme Corp\" --credits 500 --inherit-from org_abc123 --webhook-url https://example.com/hook',\n    \"<%= config.bin %> enterprise provision --bulk workspaces.json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    name: Flags.string({\n      char: \"n\",\n      description: \"Workspace name (single provision)\",\n    }),\n    credits: Flags.integer({\n      char: \"c\",\n      description: \"Initial credits to allocate\",\n    }),\n    \"inherit-from\": Flags.string({\n      description: \"Workspace ID to inherit verification from\",\n    }),\n    \"webhook-url\": Flags.string({\n      description: \"Webhook URL for the workspace\",\n    }),\n    \"create-key\": Flags.boolean({\n      description: \"Create an API key for the workspace\",\n      default: false,\n    }),\n    bulk: Flags.string({\n      char: \"b\",\n      description: \"Path to JSON file for bulk provisioning (up to 50 workspaces)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(EnterpriseProvision);\n\n    if (flags.bulk) {\n      await this.bulkProvision(flags.bulk);\n      return;\n    }\n\n    if (!flags.name) {\n      this.error(\"--name is required for single provisioning. Use --bulk for batch provisioning.\");\n    }\n\n    const spin = spinner(\"Provisioning workspace...\");\n    spin.start();\n\n    const body: Record<string, unknown> = { name: flags.name };\n    if (flags.credits) body.credits = flags.credits;\n    if (flags[\"inherit-from\"]) body.inheritVerificationFrom = flags[\"inherit-from\"];\n    if (flags[\"webhook-url\"]) body.webhookUrl = flags[\"webhook-url\"];\n    if (flags[\"create-key\"]) body.createApiKey = true;\n\n    const response = await apiClient.post<ProvisionResponse>(\n      \"/api/v1/enterprise/workspaces/provision\",\n      body,\n    );\n\n    spin.succeed(\"Workspace provisioned\");\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    const details: Record<string, string> = {\n      ID: response.organization.id,\n      Name: response.organization.name,\n      Slug: response.organization.slug,\n    };\n\n    if (response.verification) {\n      details[\"Verification\"] = response.verification.status === \"approved\"\n        ? colors.success(\"inherited\")\n        : colors.warning(response.verification.status);\n    }\n    if (response.credits) {\n      details[\"Credits\"] = `${response.credits.balance.toLocaleString()} credits`;\n    }\n    if (response.apiKey) {\n      details[\"API Key\"] = response.apiKey.key;\n    }\n    if (response.webhook) {\n      details[\"Webhook\"] = response.webhook.url;\n    }\n\n    success(\"Workspace provisioned\", details);\n\n    if (response.apiKey) {\n      console.log();\n      console.log(\n        colors.warning(\"  Save the API key now — it won't be shown again.\"),\n      );\n    }\n  }\n\n  private async bulkProvision(filePath: string): Promise<void> {\n    if (!fs.existsSync(filePath)) {\n      this.error(`File not found: ${filePath}`);\n    }\n\n    const content = fs.readFileSync(filePath, \"utf-8\");\n    let workspaces: BulkProvisionItem[];\n\n    try {\n      workspaces = JSON.parse(content);\n    } catch {\n      this.error(\"Invalid JSON file. Expected an array of workspace objects.\");\n    }\n\n    if (!Array.isArray(workspaces)) {\n      this.error(\"JSON file must contain an array of workspace objects.\");\n    }\n\n    if (workspaces.length > 50) {\n      this.error(\"Bulk provisioning supports up to 50 workspaces at a time.\");\n    }\n\n    const spin = spinner(`Provisioning ${workspaces.length} workspaces...`);\n    spin.start();\n\n    const response = await apiClient.post<BulkProvisionResponse>(\n      \"/api/v1/enterprise/workspaces/provision/bulk\",\n      { workspaces },\n    );\n\n    spin.succeed(\n      `Provisioned ${response.totalCreated}/${response.totalRequested} workspaces`,\n    );\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    console.log();\n    table(response.results, [\n      { header: \"Name\", key: \"name\", width: 24 },\n      {\n        header: \"Status\",\n        key: \"success\",\n        width: 10,\n        formatter: (v) =>\n          v ? colors.success(\"created\") : colors.error(\"failed\"),\n      },\n      {\n        header: \"Workspace ID\",\n        key: \"workspaceId\",\n        width: 20,\n        formatter: (v) => (v ? colors.dim(String(v)) : colors.dim(\"—\")),\n      },\n      {\n        header: \"Error\",\n        key: \"error\",\n        width: 30,\n        formatter: (v) => (v ? colors.error(String(v)) : \"\"),\n      },\n    ]);\n\n    if (response.totalFailed > 0) {\n      console.log();\n      console.log(\n        colors.warning(\n          `  ${response.totalFailed} workspace(s) failed to provision.`,\n        ),\n      );\n    }\n  }\n}\n"]}

dist/commands/enterprise/quota/get.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class QuotaGet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: 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>;
+}

dist/commands/enterprise/quota/get.js

+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, } from "../../../lib/output.js";
+export default class QuotaGet extends AuthenticatedCommand {
+    static description = "Get message quota for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise quota get org_abc123",
+        "<%= config.bin %> enterprise quota get org_abc123 --json",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(QuotaGet);
+        const quota = await apiClient.get(`/api/v1/enterprise/workspaces/${args.workspaceId}/quota`);
+        if (isJsonMode()) {
+            json(quota);
+            return;
+        }
+        header("Workspace Quota");
+        keyValue({
+            "Daily Limit": quota.dailyLimit !== null
+                ? quota.dailyLimit.toLocaleString()
+                : colors.dim("unlimited"),
+            "Daily Used": `${quota.dailyUsed.toLocaleString()}${quota.dailyLimit ? ` / ${quota.dailyLimit.toLocaleString()}` : ""}`,
+            "Monthly Limit": quota.monthlyLimit !== null
+                ? quota.monthlyLimit.toLocaleString()
+                : colors.dim("unlimited"),
+            "Monthly Used": `${quota.monthlyUsed.toLocaleString()}${quota.monthlyLimit ? ` / ${quota.monthlyLimit.toLocaleString()}` : ""}`,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/quota/set.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class QuotaSet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        daily: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        monthly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, 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>;
+}

dist/commands/enterprise/quota/set.js

+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, json, colors, isJsonMode } from "../../../lib/output.js";
+export default class QuotaSet extends AuthenticatedCommand {
+    static description = "Set message quota for an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise quota set org_abc123 --daily 1000",
+        "<%= config.bin %> enterprise quota set org_abc123 --monthly 25000",
+        "<%= config.bin %> enterprise quota set org_abc123 --daily 1000 --monthly 25000",
+        "<%= config.bin %> enterprise quota set org_abc123 --daily unlimited",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        daily: Flags.string({
+            description: 'Daily message limit (number or "unlimited")',
+        }),
+        monthly: Flags.string({
+            description: 'Monthly message limit (number or "unlimited")',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(QuotaSet);
+        if (!flags.daily && !flags.monthly) {
+            this.error("Specify at least one of --daily or --monthly.");
+        }
+        const body = {};
+        if (flags.daily !== undefined) {
+            body.dailyLimit =
+                flags.daily === "unlimited" ? null : parseInt(flags.daily, 10);
+            if (flags.daily !== "unlimited" && isNaN(body.dailyLimit)) {
+                this.error('--daily must be a number or "unlimited".');
+            }
+        }
+        if (flags.monthly !== undefined) {
+            body.monthlyLimit =
+                flags.monthly === "unlimited" ? null : parseInt(flags.monthly, 10);
+            if (flags.monthly !== "unlimited" && isNaN(body.monthlyLimit)) {
+                this.error('--monthly must be a number or "unlimited".');
+            }
+        }
+        const quota = await apiClient.put(`/api/v1/enterprise/workspaces/${args.workspaceId}/quota`, body);
+        if (isJsonMode()) {
+            json(quota);
+            return;
+        }
+        const details = {};
+        if (flags.daily !== undefined) {
+            details["Daily Limit"] =
+                quota.dailyLimit !== null
+                    ? quota.dailyLimit.toLocaleString()
+                    : colors.dim("unlimited");
+        }
+        if (flags.monthly !== undefined) {
+            details["Monthly Limit"] =
+                quota.monthlyLimit !== null
+                    ? quota.monthlyLimit.toLocaleString()
+                    : colors.dim("unlimited");
+        }
+        success("Quota updated", details);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/status.d.ts

+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseStatus extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    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>;
+}

dist/commands/enterprise/status.js

+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, formatDate, formatCredits, } from "../../lib/output.js";
+export default class EnterpriseStatus extends AuthenticatedCommand {
+    static description = "Show enterprise account status";
+    static examples = [
+        "<%= config.bin %> enterprise status",
+        "<%= config.bin %> enterprise status --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const response = await apiClient.get("/api/v1/enterprise/account");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const { account, workspaceCount } = response;
+        header("Enterprise Account");
+        const statusColor = account.status === "active"
+            ? colors.success
+            : account.status === "pending"
+                ? colors.warning
+                : colors.error;
+        keyValue({
+            Company: colors.primary(account.companyName),
+            Status: statusColor(account.status),
+            Workspaces: `${workspaceCount} / ${account.maxWorkspaces}`,
+            "Credits Allocated": formatCredits(account.totalCreditsAllocated),
+            "Platform Fee": account.monthlyPlatformFee
+                ? `$${account.monthlyPlatformFee}/mo`
+                : colors.dim("not set"),
+            "Per-Workspace Fee": account.perWorkspaceFee
+                ? `$${account.perWorkspaceFee}/mo`
+                : colors.dim("not set"),
+            "Enterprise Webhook": account.webhookUrl || colors.dim("not configured"),
+            "Activated At": account.activatedAt
+                ? formatDate(account.activatedAt)
+                : colors.dim("pending"),
+            "Created At": formatDate(account.createdAt),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/transfer-credits.d.ts

+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class EnterpriseTransferCredits extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        from: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        amount: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

dist/commands/enterprise/transfer-credits.js

+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, colors, isJsonMode, spinner, } from "../../lib/output.js";
+import inquirer from "inquirer";
+export default class EnterpriseTransferCredits extends AuthenticatedCommand {
+    static description = "Transfer credits between enterprise workspaces";
+    static examples = [
+        "<%= config.bin %> enterprise transfer-credits --from org_abc --to org_xyz --amount 500",
+        "<%= config.bin %> enterprise transfer-credits --from org_abc --to org_xyz --amount 500 --yes",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        from: Flags.string({
+            description: "Source workspace ID",
+            required: true,
+        }),
+        to: Flags.string({
+            description: "Target workspace ID",
+            required: true,
+        }),
+        amount: Flags.integer({
+            char: "a",
+            description: "Number of credits to transfer",
+            required: true,
+        }),
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnterpriseTransferCredits);
+        if (flags.amount <= 0) {
+            this.error("Amount must be a positive integer.");
+        }
+        if (!flags.yes && !isJsonMode()) {
+            console.log();
+            console.log(`  ${colors.bold("Transfer Summary")}`);
+            console.log(`  ${colors.dim("From:")}    ${flags.from}`);
+            console.log(`  ${colors.dim("To:")}      ${flags.to}`);
+            console.log(`  ${colors.dim("Amount:")}  ${colors.primary(flags.amount.toLocaleString() + " credits")}`);
+            console.log();
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: "Proceed with transfer?",
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Transfer cancelled");
+                return;
+            }
+        }
+        const spin = spinner("Transferring credits...");
+        spin.start();
+        const result = await apiClient.post(`/api/v1/enterprise/workspaces/${flags.from}/transfer-credits`, {
+            targetWorkspaceId: flags.to,
+            amount: flags.amount,
+        });
+        spin.succeed("Transfer complete");
+        if (isJsonMode()) {
+            json(result);
+            return;
+        }
+        success("Credits transferred", {
+            Amount: `${flags.amount.toLocaleString()} credits`,
+            "Source balance": `${result.sourceBalance.toLocaleString()} credits`,
+            "Target balance": `${result.targetBalance.toLocaleString()} credits`,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/webhooks/delete.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class EnterpriseWebhooksDelete extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

dist/commands/enterprise/webhooks/delete.js

+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, error, json, isJsonMode } from "../../../lib/output.js";
+import inquirer from "inquirer";
+export default class EnterpriseWebhooksDelete extends AuthenticatedCommand {
+    static description = "Delete the enterprise webhook";
+    static examples = [
+        "<%= config.bin %> enterprise webhooks delete",
+        "<%= config.bin %> enterprise webhooks delete --yes",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnterpriseWebhooksDelete);
+        if (!flags.yes && !isJsonMode()) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: "Delete the enterprise webhook? You will stop receiving events.",
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Deletion cancelled");
+                return;
+            }
+        }
+        await apiClient.delete("/api/v1/enterprise/webhooks");
+        if (isJsonMode()) {
+            json({ success: true });
+            return;
+        }
+        success("Enterprise webhook deleted");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/webhooks/get.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class EnterpriseWebhooksGet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    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>;
+}

dist/commands/enterprise/webhooks/get.js

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, keyValue, info, colors, header, isJsonMode, } from "../../../lib/output.js";
+export default class EnterpriseWebhooksGet extends AuthenticatedCommand {
+    static description = "Get the enterprise webhook configuration";
+    static examples = [
+        "<%= config.bin %> enterprise webhooks get",
+        "<%= config.bin %> enterprise webhooks get --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const response = await apiClient.get("/api/v1/enterprise/webhooks");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (!response || !response.url) {
+            info("No enterprise webhook configured");
+            console.log();
+            console.log(`  Set one with ${colors.code("sendly enterprise webhooks set --url <url>")}`);
+            return;
+        }
+        header("Enterprise Webhook");
+        keyValue({
+            URL: response.url,
+            Events: response.events.length > 0
+                ? response.events.join(", ")
+                : colors.dim("all events"),
+            Status: response.isActive
+                ? colors.success("active")
+                : colors.warning("inactive"),
+            "Last Delivery": response.lastDeliveryAt || colors.dim("never"),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/webhooks/set.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class EnterpriseWebhooksSet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        url: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        events: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, 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>;
+}

dist/commands/enterprise/webhooks/set.js

+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, warn, json, colors, codeBlock, isJsonMode, } from "../../../lib/output.js";
+export default class EnterpriseWebhooksSet extends AuthenticatedCommand {
+    static description = "Create or update the enterprise-level webhook";
+    static examples = [
+        "<%= config.bin %> enterprise webhooks set --url https://example.com/webhook",
+        '<%= config.bin %> enterprise webhooks set --url https://example.com/webhook --events "message.sent,message.delivered"',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        url: Flags.string({
+            description: "Webhook endpoint URL",
+            required: true,
+        }),
+        events: Flags.string({
+            description: "Comma-separated list of event types to subscribe to",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnterpriseWebhooksSet);
+        const body = { url: flags.url };
+        if (flags.events) {
+            body.events = flags.events.split(",").map((e) => e.trim());
+        }
+        const response = await apiClient.post("/api/v1/enterprise/webhooks", body);
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("Enterprise webhook configured", {
+            URL: response.url,
+            Events: response.events.length > 0
+                ? response.events.join(", ")
+                : colors.dim("all events"),
+            Status: response.isActive
+                ? colors.success("active")
+                : colors.warning("inactive"),
+        });
+        if (response.secret) {
+            console.log();
+            warn("Save the webhook secret — it won't be shown again!");
+            codeBlock(response.secret);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/webhooks/test.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class EnterpriseWebhooksTest extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    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>;
+}

dist/commands/enterprise/webhooks/test.js

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, json, colors, isJsonMode, spinner } from "../../../lib/output.js";
+export default class EnterpriseWebhooksTest extends AuthenticatedCommand {
+    static description = "Send a test event to the enterprise webhook";
+    static examples = [
+        "<%= config.bin %> enterprise webhooks test",
+        "<%= config.bin %> enterprise webhooks test --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const spin = spinner("Sending test webhook...");
+        spin.start();
+        const response = await apiClient.post("/api/v1/enterprise/webhooks/test");
+        if (response.success) {
+            spin.succeed("Webhook delivered");
+        }
+        else {
+            spin.fail("Webhook delivery failed");
+        }
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.success) {
+            success("Test webhook delivered", {
+                "Status Code": String(response.statusCode),
+                "Response Time": `${response.responseTime}ms`,
+            });
+        }
+        else {
+            console.log();
+            console.log(`  ${colors.error("Status Code:")} ${response.statusCode}`);
+            if (response.error) {
+                console.log(`  ${colors.error("Error:")} ${response.error}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/workspaces/create.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class WorkspacesCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, 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>;
+}

dist/commands/enterprise/workspaces/create.js

+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, json, colors, isJsonMode, spinner } from "../../../lib/output.js";
+export default class WorkspacesCreate extends AuthenticatedCommand {
+    static description = "Create a new enterprise workspace";
+    static examples = [
+        '<%= config.bin %> enterprise workspaces create --name "Acme Corp"',
+        '<%= config.bin %> enterprise workspaces create --name "Acme Corp" --json',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Workspace name",
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkspacesCreate);
+        const spin = spinner("Creating workspace...");
+        spin.start();
+        const workspace = await apiClient.post("/api/v1/enterprise/workspaces", { name: flags.name });
+        spin.succeed("Workspace created");
+        if (isJsonMode()) {
+            json(workspace);
+            return;
+        }
+        success("Workspace created", {
+            ID: workspace.id,
+            Name: workspace.name,
+            Slug: workspace.slug,
+            Status: colors.success(workspace.status),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/workspaces/delete.d.ts

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

dist/commands/enterprise/workspaces/delete.js

+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, error, json, colors, isJsonMode, spinner, } from "../../../lib/output.js";
+import inquirer from "inquirer";
+export default class WorkspacesDelete extends AuthenticatedCommand {
+    static description = "Delete an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise workspaces delete org_abc123",
+        "<%= config.bin %> enterprise workspaces delete org_abc123 --yes",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkspacesDelete);
+        if (!flags.yes && !isJsonMode()) {
+            console.log();
+            console.log(colors.error("  This will permanently delete the workspace and all its data."));
+            console.log();
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Delete workspace ${args.workspaceId}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Deletion cancelled");
+                return;
+            }
+        }
+        const spin = spinner("Deleting workspace...");
+        spin.start();
+        await apiClient.delete(`/api/v1/enterprise/workspaces/${args.workspaceId}`);
+        spin.succeed("Workspace deleted");
+        if (isJsonMode()) {
+            json({ success: true, workspaceId: args.workspaceId });
+            return;
+        }
+        success("Workspace deleted", {
+            ID: args.workspaceId,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/workspaces/get.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class WorkspacesGet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: 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>;
+}

dist/commands/enterprise/workspaces/get.js

+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, keyValue, colors, header, isJsonMode, formatDate, formatCredits, } from "../../../lib/output.js";
+export default class WorkspacesGet extends AuthenticatedCommand {
+    static description = "Get details of an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise workspaces get org_abc123",
+        "<%= config.bin %> enterprise workspaces get org_abc123 --json",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(WorkspacesGet);
+        const workspace = await apiClient.get(`/api/v1/enterprise/workspaces/${args.workspaceId}`);
+        if (isJsonMode()) {
+            json(workspace);
+            return;
+        }
+        header(`Workspace: ${workspace.name}`);
+        const statusColor = workspace.status === "active" ? colors.success : colors.error;
+        keyValue({
+            ID: colors.dim(workspace.id),
+            Name: workspace.name,
+            Slug: workspace.slug,
+            Status: statusColor(workspace.status),
+            Verification: workspace.verificationStatus === "approved"
+                ? colors.success("verified")
+                : colors.warning(workspace.verificationStatus),
+            Phone: workspace.phoneNumber || colors.dim("not assigned"),
+            Credits: formatCredits(workspace.creditBalance),
+            Members: String(workspace.memberCount),
+            "Messages Sent": workspace.messagesSent.toLocaleString(),
+            "Messages Delivered": workspace.messagesDelivered.toLocaleString(),
+            "Delivery Rate": workspace.messagesSent > 0
+                ? `${((workspace.messagesDelivered / workspace.messagesSent) * 100).toFixed(1)}%`
+                : colors.dim("n/a"),
+            Created: formatDate(workspace.createdAt),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/workspaces/list.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class WorkspacesList extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    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>;
+}

dist/commands/enterprise/workspaces/list.js

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { table, json, info, colors, isJsonMode, formatRelativeTime, formatCredits, } from "../../../lib/output.js";
+export default class WorkspacesList extends AuthenticatedCommand {
+    static description = "List all enterprise workspaces";
+    static examples = [
+        "<%= config.bin %> enterprise workspaces list",
+        "<%= config.bin %> enterprise workspaces list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const workspaces = await apiClient.get("/api/v1/enterprise/workspaces");
+        if (isJsonMode()) {
+            json(workspaces);
+            return;
+        }
+        if (workspaces.length === 0) {
+            info("No workspaces found");
+            console.log();
+            console.log(`  Create one with ${colors.code("sendly enterprise workspaces create")}`);
+            return;
+        }
+        console.log();
+        table(workspaces, [
+            { header: "Name", key: "name", width: 24 },
+            {
+                header: "ID",
+                key: "id",
+                width: 18,
+                formatter: (v) => colors.dim(String(v).slice(0, 16)),
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 12,
+                formatter: (v) => v === "active"
+                    ? colors.success("active")
+                    : v === "suspended"
+                        ? colors.error("suspended")
+                        : colors.warning(String(v)),
+            },
+            {
+                header: "Verification",
+                key: "verificationStatus",
+                width: 14,
+                formatter: (v) => v === "approved"
+                    ? colors.success("verified")
+                    : v === "pending"
+                        ? colors.warning("pending")
+                        : colors.dim(String(v)),
+            },
+            {
+                header: "Credits",
+                key: "creditBalance",
+                width: 12,
+                formatter: (v) => formatCredits(Number(v)),
+            },
+            {
+                header: "Members",
+                key: "memberCount",
+                width: 8,
+            },
+            {
+                header: "Created",
+                key: "createdAt",
+                width: 12,
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/workspaces/resume.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class WorkspacesResume extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: 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>;
+}

dist/commands/enterprise/workspaces/resume.js

+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, json, isJsonMode, spinner } from "../../../lib/output.js";
+export default class WorkspacesResume extends AuthenticatedCommand {
+    static description = "Resume a suspended enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise workspaces resume org_abc123",
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(WorkspacesResume);
+        const spin = spinner("Resuming workspace...");
+        spin.start();
+        const response = await apiClient.post(`/api/v1/enterprise/workspaces/${args.workspaceId}/resume`);
+        spin.succeed("Workspace resumed");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("Workspace resumed", {
+            ID: args.workspaceId,
+            Status: "active",
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/enterprise/workspaces/suspend.d.ts

+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class WorkspacesSuspend extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspaceId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        reason: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

dist/commands/enterprise/workspaces/suspend.js

+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { success, error, json, isJsonMode, spinner } from "../../../lib/output.js";
+import inquirer from "inquirer";
+export default class WorkspacesSuspend extends AuthenticatedCommand {
+    static description = "Suspend an enterprise workspace";
+    static examples = [
+        "<%= config.bin %> enterprise workspaces suspend org_abc123",
+        '<%= config.bin %> enterprise workspaces suspend org_abc123 --reason "Policy violation"',
+    ];
+    static args = {
+        workspaceId: Args.string({
+            description: "Workspace ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        reason: Flags.string({
+            char: "r",
+            description: "Reason for suspension",
+        }),
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkspacesSuspend);
+        if (!flags.yes && !isJsonMode()) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Suspend workspace ${args.workspaceId}? This will halt all messaging.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Suspension cancelled");
+                return;
+            }
+        }
+        const spin = spinner("Suspending workspace...");
+        spin.start();
+        const response = await apiClient.post(`/api/v1/enterprise/workspaces/${args.workspaceId}/suspend`, flags.reason ? { reason: flags.reason } : undefined);
+        spin.succeed("Workspace suspended");
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("Workspace suspended", {
+            ID: args.workspaceId,
+            Status: "suspended",
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/commands/credits/balance.js

@@ -32,3 +32,3 @@ import { AuthenticatedCommand } from "../../lib/base-command.js";
         // Show approximate message capacity
-        const domesticMessages = Math.floor(availableCredits / 1);
+        const domesticMessages = Math.floor(availableCredits / 2);
         const internationalMessages = Math.floor(availableCredits / 2);
@@ -40,2 +40,2 @@ console.log(colors.dim("Estimated capacity:"));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

dist/lib/api-client.d.ts

@@ -63,2 +63,3 @@ /**
     patch<T>(path: string, body?: Record<string, unknown>, requireAuth?: boolean): Promise<T>;
+    put<T>(path: string, body?: Record<string, unknown>, requireAuth?: boolean): Promise<T>;
     delete<T>(path: string, requireAuth?: boolean): Promise<T>;
@@ -65,0 +66,0 @@ /**

dist/lib/api-client.js

@@ -6,3 +6,3 @@ /**
 import { createRequire } from "node:module";
-import { getAuthToken, getStoredAccessToken, getConfigValue, getEffectiveValue, setAuthTokens } from "./config.js";
+import { getAuthToken, getStoredAccessToken, getConfigValue, getEffectiveValue, setAuthTokens, } from "./config.js";
 // Read version from package.json
@@ -142,3 +142,3 @@ const require = createRequire(import.meta.url);
                     return false;
-                const data = await response.json();
+                const data = (await response.json());
                 setAuthTokens(data.accessToken, data.refreshToken, data.expiresIn, data.userId, data.email);
@@ -267,2 +267,5 @@ return true;
     }
+    async put(path, body, requireAuth = true) {
+        return this.request("PUT", path, { body, requireAuth });
+    }
     async delete(path, requireAuth = true) {
@@ -340,2 +343,2 @@ return this.request("DELETE", path, { requireAuth });
 export const apiClient = new ApiClient();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../../src/lib/api-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * API Client for Sendly CLI\n * Handles all HTTP requests to the Sendly API\n */\n\nimport { createRequire } from \"node:module\";\nimport { getAuthToken, getStoredAccessToken, getConfigValue, getEffectiveValue, setAuthTokens } from \"./config.js\";\n\n// Read version from package.json\nconst require = createRequire(import.meta.url);\nconst { version } = require(\"../../package.json\") as { version: string };\n\n/**\n * Sleep for a given number of milliseconds\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Check if an error is retryable (network errors or 5xx server errors)\n */\nfunction isRetryableError(error: unknown): boolean {\n  // Network errors\n  if (error instanceof TypeError && error.message.includes(\"fetch\")) {\n    return true;\n  }\n  // Server errors (5xx) are retryable\n  if (error instanceof ApiError && error.statusCode >= 500) {\n    return true;\n  }\n  return false;\n}\n\nexport interface ApiResponse<T> {\n  data?: T;\n  error?: {\n    code: string;\n    message: string;\n    details?: Record<string, unknown>;\n  };\n}\n\nexport interface RateLimitInfo {\n  limit: number;\n  remaining: number;\n  reset: number;\n}\n\nexport class ApiError extends Error {\n  public hint?: string;\n\n  constructor(\n    public code: string,\n    message: string,\n    public statusCode: number,\n    public details?: Record<string, unknown>,\n    hint?: string,\n  ) {\n    super(message);\n    this.name = \"ApiError\";\n    this.hint = hint;\n  }\n}\n\nexport class AuthenticationError extends ApiError {\n  constructor(\n    message: string = \"Authentication failed\",\n    hint: string = \"Run 'sendly login' to authenticate, or check your API key with 'sendly config show'\",\n  ) {\n    super(\"authentication_error\", message, 401, undefined, hint);\n    this.name = \"AuthenticationError\";\n  }\n}\n\nexport class ApiKeyRequiredError extends ApiError {\n  constructor(\n    message: string = \"API key required for this operation.\",\n    public hint: string = \"Set SENDLY_API_KEY environment variable or create a key with: sendly keys create --type test\",\n  ) {\n    super(\"api_key_required\", message, 401);\n    this.name = \"ApiKeyRequiredError\";\n  }\n}\n\nexport class RateLimitError extends ApiError {\n  constructor(\n    public retryAfter: number,\n    message: string = \"Rate limit exceeded\",\n  ) {\n    const hint = `Wait ${retryAfter} seconds before retrying, or upgrade your plan for higher limits`;\n    super(\"rate_limit_exceeded\", message, 429, undefined, hint);\n    this.name = \"RateLimitError\";\n  }\n}\n\nexport class InsufficientCreditsError extends ApiError {\n  constructor(message: string = \"Insufficient credits\") {\n    const hint =\n      \"Check your balance with 'sendly credits', or add credits at https://sendly.live/dashboard/billing\";\n    super(\"insufficient_credits\", message, 402, undefined, hint);\n    this.name = \"InsufficientCreditsError\";\n  }\n}\n\nexport class NotFoundError extends ApiError {\n  constructor(\n    message: string = \"Resource not found\",\n    hint: string = \"Verify the ID is correct, or use a list command to see available resources\",\n  ) {\n    super(\"not_found\", message, 404, undefined, hint);\n    this.name = \"NotFoundError\";\n  }\n}\n\nexport class ValidationError extends ApiError {\n  constructor(\n    message: string = \"Validation failed\",\n    details?: Record<string, unknown>,\n  ) {\n    const hint = \"Check the command help with --help for valid options and formats\";\n    super(\"validation_error\", message, 400, details, hint);\n    this.name = \"ValidationError\";\n  }\n}\n\nclass ApiClient {\n  private rateLimitInfo?: RateLimitInfo;\n  private refreshing: Promise<boolean> | null = null;\n\n  private getBaseUrl(): string {\n    return getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n  }\n\n  private async ensureAuth(): Promise<string> {\n    let token = getAuthToken();\n    if (token) return token;\n\n    const stored = getStoredAccessToken();\n    if (stored?.startsWith(\"cli_\")) {\n      const refreshed = await this.refreshTokens();\n      if (refreshed) {\n        token = getAuthToken();\n        if (token) return token;\n      }\n    }\n\n    throw new AuthenticationError();\n  }\n\n  private async getHeaders(requireAuth: boolean = true): Promise<Record<string, string>> {\n    const headers: Record<string, string> = {\n      \"Content-Type\": \"application/json\",\n      Accept: \"application/json\",\n      \"User-Agent\": `@sendly/cli/${version}`,\n    };\n\n    if (requireAuth) {\n      headers[\"Authorization\"] = `Bearer ${await this.ensureAuth()}`;\n    }\n\n    const orgId = getEffectiveValue(\"currentOrgId\");\n    if (orgId) {\n      headers[\"X-Organization-Id\"] = orgId;\n    }\n\n    return headers;\n  }\n\n  private async refreshTokens(): Promise<boolean> {\n    if (this.refreshing) return this.refreshing;\n\n    this.refreshing = (async () => {\n      const stored = getStoredAccessToken();\n      if (!stored) return false;\n\n      try {\n        const response = await fetch(`${this.getBaseUrl()}/api/cli/auth/refresh`, {\n          method: \"POST\",\n          headers: {\n            \"Content-Type\": \"application/json\",\n            \"User-Agent\": `@sendly/cli/${version}`,\n          },\n          body: JSON.stringify({ accessToken: stored }),\n        });\n\n        if (!response.ok) return false;\n\n        const data = await response.json() as {\n          accessToken: string;\n          refreshToken: string;\n          expiresIn: number;\n          userId: string;\n          email: string;\n        };\n\n        setAuthTokens(\n          data.accessToken,\n          data.refreshToken,\n          data.expiresIn,\n          data.userId,\n          data.email,\n        );\n\n        return true;\n      } catch {\n        return false;\n      }\n    })();\n\n    try {\n      return await this.refreshing;\n    } finally {\n      this.refreshing = null;\n    }\n  }\n\n  async request<T>(\n    method: string,\n    path: string,\n    options: {\n      body?: Record<string, unknown>;\n      query?: Record<string, string | number | boolean | undefined>;\n      requireAuth?: boolean;\n    } = {},\n  ): Promise<T> {\n    const { body, query, requireAuth = true } = options;\n    const maxRetries = getEffectiveValue(\"maxRetries\");\n    const timeout = getEffectiveValue(\"timeout\");\n\n    const url = new URL(`${this.getBaseUrl()}${path}`);\n    if (query) {\n      Object.entries(query).forEach(([key, value]) => {\n        if (value !== undefined) {\n          url.searchParams.append(key, String(value));\n        }\n      });\n    }\n\n    let lastError: Error | undefined;\n    let didRefresh = false;\n\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n        const response = await fetch(url.toString(), {\n          method,\n          headers: await this.getHeaders(requireAuth),\n          body: body ? JSON.stringify(body) : undefined,\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        this.updateRateLimitInfo(response.headers);\n\n        const data = await response.json().catch(() => ({}));\n\n        if (response.status === 401 && requireAuth && !didRefresh) {\n          didRefresh = true;\n          const refreshed = await this.refreshTokens();\n          if (refreshed) {\n            attempt--;\n            continue;\n          }\n        }\n\n        if (!response.ok) {\n          this.handleError(response.status, data);\n        }\n\n        return data as T;\n      } catch (error) {\n        lastError = error as Error;\n\n        if (!isRetryableError(error)) {\n          throw error;\n        }\n\n        if (attempt === maxRetries) {\n          throw error;\n        }\n\n        const backoffMs = Math.min(1000 * Math.pow(2, attempt), 10000);\n        await sleep(backoffMs);\n      }\n    }\n\n    throw lastError || new Error(\"Request failed\");\n  }\n\n  private updateRateLimitInfo(headers: Headers): void {\n    const limit = headers.get(\"X-RateLimit-Limit\");\n    const remaining = headers.get(\"X-RateLimit-Remaining\");\n    const reset = headers.get(\"X-RateLimit-Reset\");\n\n    if (limit && remaining && reset) {\n      this.rateLimitInfo = {\n        limit: parseInt(limit, 10),\n        remaining: parseInt(remaining, 10),\n        reset: parseInt(reset, 10),\n      };\n    }\n  }\n\n  private handleError(statusCode: number, data: any): never {\n    const error = data?.error || \"unknown_error\";\n    const message = data?.message || `HTTP ${statusCode}`;\n    const details = data?.details;\n\n    switch (statusCode) {\n      case 401:\n      case 403:\n        // Detect if this is an API key required error vs general auth error\n        if (\n          error === \"invalid_api_key\" ||\n          error === \"api_key_required\" ||\n          message?.toLowerCase().includes(\"api key\")\n        ) {\n          throw new ApiKeyRequiredError(\n            \"API key required for sending messages\",\n            \"Set SENDLY_API_KEY environment variable or create a key with:\\n  sendly keys create --type test\",\n          );\n        }\n        throw new AuthenticationError(message);\n      case 400:\n        throw new ValidationError(message, details);\n      case 402:\n        throw new InsufficientCreditsError(message);\n      case 404:\n        throw new NotFoundError(message);\n      case 429:\n        const retryAfter = data?.retryAfter || 60;\n        throw new RateLimitError(retryAfter, message);\n      default:\n        const defaultHint =\n          statusCode >= 500\n            ? \"This is a server error. Try again later or check https://status.sendly.live\"\n            : undefined;\n        throw new ApiError(error, message, statusCode, details, defaultHint);\n    }\n  }\n\n  getRateLimitInfo(): RateLimitInfo | undefined {\n    return this.rateLimitInfo;\n  }\n\n  // Convenience methods\n  async get<T>(\n    path: string,\n    query?: Record<string, string | number | boolean | undefined>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"GET\", path, { query, requireAuth });\n  }\n\n  async post<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"POST\", path, { body, requireAuth });\n  }\n\n  async patch<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"PATCH\", path, { body, requireAuth });\n  }\n\n  async delete<T>(path: string, requireAuth: boolean = true): Promise<T> {\n    return this.request<T>(\"DELETE\", path, { requireAuth });\n  }\n\n  /**\n   * Upload a file using multipart/form-data\n   * Used for batch CSV uploads to R2 storage\n   */\n  async uploadFile<T>(\n    path: string,\n    file: {\n      buffer: Buffer;\n      filename: string;\n      mimetype?: string;\n    },\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    const maxRetries = getEffectiveValue(\"maxRetries\");\n    const timeout = getEffectiveValue(\"timeout\");\n    const url = `${this.getBaseUrl()}${path}`;\n\n    // Build multipart form data manually (Node.js compatible)\n    const boundary = `----FormBoundary${Date.now()}${Math.random().toString(36).substring(2)}`;\n    const mimetype = file.mimetype || \"text/csv\";\n\n    const header = Buffer.from(\n      `--${boundary}\\r\\n` +\n        `Content-Disposition: form-data; name=\"file\"; filename=\"${file.filename}\"\\r\\n` +\n        `Content-Type: ${mimetype}\\r\\n\\r\\n`,\n    );\n    const footer = Buffer.from(`\\r\\n--${boundary}--\\r\\n`);\n    const body = Buffer.concat([header, file.buffer, footer]);\n\n    const headers: Record<string, string> = {\n      \"Content-Type\": `multipart/form-data; boundary=${boundary}`,\n      Accept: \"application/json\",\n      \"User-Agent\": `@sendly/cli/${version}`,\n    };\n\n    if (requireAuth) {\n      headers[\"Authorization\"] = `Bearer ${await this.ensureAuth()}`;\n    }\n\n    let lastError: Error | undefined;\n    let didRefresh = false;\n\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n        const response = await fetch(url, {\n          method: \"POST\",\n          headers,\n          body,\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        this.updateRateLimitInfo(response.headers);\n        const data = await response.json().catch(() => ({}));\n\n        if (response.status === 401 && requireAuth && !didRefresh) {\n          didRefresh = true;\n          const refreshed = await this.refreshTokens();\n          if (refreshed) {\n            headers[\"Authorization\"] = `Bearer ${getAuthToken()}`;\n            attempt--;\n            continue;\n          }\n        }\n\n        if (!response.ok) {\n          this.handleError(response.status, data);\n        }\n\n        return data as T;\n      } catch (error) {\n        lastError = error as Error;\n\n        if (!isRetryableError(error)) {\n          throw error;\n        }\n\n        if (attempt === maxRetries) {\n          throw error;\n        }\n\n        const backoffMs = Math.min(1000 * Math.pow(2, attempt), 10000);\n        await sleep(backoffMs);\n      }\n    }\n\n    throw lastError || new Error(\"Upload failed\");\n  }\n}\n\nexport const apiClient = new ApiClient();\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../../src/lib/api-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * API Client for Sendly CLI\n * Handles all HTTP requests to the Sendly API\n */\n\nimport { createRequire } from \"node:module\";\nimport {\n  getAuthToken,\n  getStoredAccessToken,\n  getConfigValue,\n  getEffectiveValue,\n  setAuthTokens,\n} from \"./config.js\";\n\n// Read version from package.json\nconst require = createRequire(import.meta.url);\nconst { version } = require(\"../../package.json\") as { version: string };\n\n/**\n * Sleep for a given number of milliseconds\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Check if an error is retryable (network errors or 5xx server errors)\n */\nfunction isRetryableError(error: unknown): boolean {\n  // Network errors\n  if (error instanceof TypeError && error.message.includes(\"fetch\")) {\n    return true;\n  }\n  // Server errors (5xx) are retryable\n  if (error instanceof ApiError && error.statusCode >= 500) {\n    return true;\n  }\n  return false;\n}\n\nexport interface ApiResponse<T> {\n  data?: T;\n  error?: {\n    code: string;\n    message: string;\n    details?: Record<string, unknown>;\n  };\n}\n\nexport interface RateLimitInfo {\n  limit: number;\n  remaining: number;\n  reset: number;\n}\n\nexport class ApiError extends Error {\n  public hint?: string;\n\n  constructor(\n    public code: string,\n    message: string,\n    public statusCode: number,\n    public details?: Record<string, unknown>,\n    hint?: string,\n  ) {\n    super(message);\n    this.name = \"ApiError\";\n    this.hint = hint;\n  }\n}\n\nexport class AuthenticationError extends ApiError {\n  constructor(\n    message: string = \"Authentication failed\",\n    hint: string = \"Run 'sendly login' to authenticate, or check your API key with 'sendly config show'\",\n  ) {\n    super(\"authentication_error\", message, 401, undefined, hint);\n    this.name = \"AuthenticationError\";\n  }\n}\n\nexport class ApiKeyRequiredError extends ApiError {\n  constructor(\n    message: string = \"API key required for this operation.\",\n    public hint: string = \"Set SENDLY_API_KEY environment variable or create a key with: sendly keys create --type test\",\n  ) {\n    super(\"api_key_required\", message, 401);\n    this.name = \"ApiKeyRequiredError\";\n  }\n}\n\nexport class RateLimitError extends ApiError {\n  constructor(\n    public retryAfter: number,\n    message: string = \"Rate limit exceeded\",\n  ) {\n    const hint = `Wait ${retryAfter} seconds before retrying, or upgrade your plan for higher limits`;\n    super(\"rate_limit_exceeded\", message, 429, undefined, hint);\n    this.name = \"RateLimitError\";\n  }\n}\n\nexport class InsufficientCreditsError extends ApiError {\n  constructor(message: string = \"Insufficient credits\") {\n    const hint =\n      \"Check your balance with 'sendly credits', or add credits at https://sendly.live/dashboard/billing\";\n    super(\"insufficient_credits\", message, 402, undefined, hint);\n    this.name = \"InsufficientCreditsError\";\n  }\n}\n\nexport class NotFoundError extends ApiError {\n  constructor(\n    message: string = \"Resource not found\",\n    hint: string = \"Verify the ID is correct, or use a list command to see available resources\",\n  ) {\n    super(\"not_found\", message, 404, undefined, hint);\n    this.name = \"NotFoundError\";\n  }\n}\n\nexport class ValidationError extends ApiError {\n  constructor(\n    message: string = \"Validation failed\",\n    details?: Record<string, unknown>,\n  ) {\n    const hint =\n      \"Check the command help with --help for valid options and formats\";\n    super(\"validation_error\", message, 400, details, hint);\n    this.name = \"ValidationError\";\n  }\n}\n\nclass ApiClient {\n  private rateLimitInfo?: RateLimitInfo;\n  private refreshing: Promise<boolean> | null = null;\n\n  private getBaseUrl(): string {\n    return getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n  }\n\n  private async ensureAuth(): Promise<string> {\n    let token = getAuthToken();\n    if (token) return token;\n\n    const stored = getStoredAccessToken();\n    if (stored?.startsWith(\"cli_\")) {\n      const refreshed = await this.refreshTokens();\n      if (refreshed) {\n        token = getAuthToken();\n        if (token) return token;\n      }\n    }\n\n    throw new AuthenticationError();\n  }\n\n  private async getHeaders(\n    requireAuth: boolean = true,\n  ): Promise<Record<string, string>> {\n    const headers: Record<string, string> = {\n      \"Content-Type\": \"application/json\",\n      Accept: \"application/json\",\n      \"User-Agent\": `@sendly/cli/${version}`,\n    };\n\n    if (requireAuth) {\n      headers[\"Authorization\"] = `Bearer ${await this.ensureAuth()}`;\n    }\n\n    const orgId = getEffectiveValue(\"currentOrgId\");\n    if (orgId) {\n      headers[\"X-Organization-Id\"] = orgId;\n    }\n\n    return headers;\n  }\n\n  private async refreshTokens(): Promise<boolean> {\n    if (this.refreshing) return this.refreshing;\n\n    this.refreshing = (async () => {\n      const stored = getStoredAccessToken();\n      if (!stored) return false;\n\n      try {\n        const response = await fetch(\n          `${this.getBaseUrl()}/api/cli/auth/refresh`,\n          {\n            method: \"POST\",\n            headers: {\n              \"Content-Type\": \"application/json\",\n              \"User-Agent\": `@sendly/cli/${version}`,\n            },\n            body: JSON.stringify({ accessToken: stored }),\n          },\n        );\n\n        if (!response.ok) return false;\n\n        const data = (await response.json()) as {\n          accessToken: string;\n          refreshToken: string;\n          expiresIn: number;\n          userId: string;\n          email: string;\n        };\n\n        setAuthTokens(\n          data.accessToken,\n          data.refreshToken,\n          data.expiresIn,\n          data.userId,\n          data.email,\n        );\n\n        return true;\n      } catch {\n        return false;\n      }\n    })();\n\n    try {\n      return await this.refreshing;\n    } finally {\n      this.refreshing = null;\n    }\n  }\n\n  async request<T>(\n    method: string,\n    path: string,\n    options: {\n      body?: Record<string, unknown>;\n      query?: Record<string, string | number | boolean | undefined>;\n      requireAuth?: boolean;\n    } = {},\n  ): Promise<T> {\n    const { body, query, requireAuth = true } = options;\n    const maxRetries = getEffectiveValue(\"maxRetries\");\n    const timeout = getEffectiveValue(\"timeout\");\n\n    const url = new URL(`${this.getBaseUrl()}${path}`);\n    if (query) {\n      Object.entries(query).forEach(([key, value]) => {\n        if (value !== undefined) {\n          url.searchParams.append(key, String(value));\n        }\n      });\n    }\n\n    let lastError: Error | undefined;\n    let didRefresh = false;\n\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n        const response = await fetch(url.toString(), {\n          method,\n          headers: await this.getHeaders(requireAuth),\n          body: body ? JSON.stringify(body) : undefined,\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        this.updateRateLimitInfo(response.headers);\n\n        const data = await response.json().catch(() => ({}));\n\n        if (response.status === 401 && requireAuth && !didRefresh) {\n          didRefresh = true;\n          const refreshed = await this.refreshTokens();\n          if (refreshed) {\n            attempt--;\n            continue;\n          }\n        }\n\n        if (!response.ok) {\n          this.handleError(response.status, data);\n        }\n\n        return data as T;\n      } catch (error) {\n        lastError = error as Error;\n\n        if (!isRetryableError(error)) {\n          throw error;\n        }\n\n        if (attempt === maxRetries) {\n          throw error;\n        }\n\n        const backoffMs = Math.min(1000 * Math.pow(2, attempt), 10000);\n        await sleep(backoffMs);\n      }\n    }\n\n    throw lastError || new Error(\"Request failed\");\n  }\n\n  private updateRateLimitInfo(headers: Headers): void {\n    const limit = headers.get(\"X-RateLimit-Limit\");\n    const remaining = headers.get(\"X-RateLimit-Remaining\");\n    const reset = headers.get(\"X-RateLimit-Reset\");\n\n    if (limit && remaining && reset) {\n      this.rateLimitInfo = {\n        limit: parseInt(limit, 10),\n        remaining: parseInt(remaining, 10),\n        reset: parseInt(reset, 10),\n      };\n    }\n  }\n\n  private handleError(statusCode: number, data: any): never {\n    const error = data?.error || \"unknown_error\";\n    const message = data?.message || `HTTP ${statusCode}`;\n    const details = data?.details;\n\n    switch (statusCode) {\n      case 401:\n      case 403:\n        // Detect if this is an API key required error vs general auth error\n        if (\n          error === \"invalid_api_key\" ||\n          error === \"api_key_required\" ||\n          message?.toLowerCase().includes(\"api key\")\n        ) {\n          throw new ApiKeyRequiredError(\n            \"API key required for sending messages\",\n            \"Set SENDLY_API_KEY environment variable or create a key with:\\n  sendly keys create --type test\",\n          );\n        }\n        throw new AuthenticationError(message);\n      case 400:\n        throw new ValidationError(message, details);\n      case 402:\n        throw new InsufficientCreditsError(message);\n      case 404:\n        throw new NotFoundError(message);\n      case 429:\n        const retryAfter = data?.retryAfter || 60;\n        throw new RateLimitError(retryAfter, message);\n      default:\n        const defaultHint =\n          statusCode >= 500\n            ? \"This is a server error. Try again later or check https://status.sendly.live\"\n            : undefined;\n        throw new ApiError(error, message, statusCode, details, defaultHint);\n    }\n  }\n\n  getRateLimitInfo(): RateLimitInfo | undefined {\n    return this.rateLimitInfo;\n  }\n\n  // Convenience methods\n  async get<T>(\n    path: string,\n    query?: Record<string, string | number | boolean | undefined>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"GET\", path, { query, requireAuth });\n  }\n\n  async post<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"POST\", path, { body, requireAuth });\n  }\n\n  async patch<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"PATCH\", path, { body, requireAuth });\n  }\n\n  async put<T>(\n    path: string,\n    body?: Record<string, unknown>,\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    return this.request<T>(\"PUT\", path, { body, requireAuth });\n  }\n\n  async delete<T>(path: string, requireAuth: boolean = true): Promise<T> {\n    return this.request<T>(\"DELETE\", path, { requireAuth });\n  }\n\n  /**\n   * Upload a file using multipart/form-data\n   * Used for batch CSV uploads to R2 storage\n   */\n  async uploadFile<T>(\n    path: string,\n    file: {\n      buffer: Buffer;\n      filename: string;\n      mimetype?: string;\n    },\n    requireAuth: boolean = true,\n  ): Promise<T> {\n    const maxRetries = getEffectiveValue(\"maxRetries\");\n    const timeout = getEffectiveValue(\"timeout\");\n    const url = `${this.getBaseUrl()}${path}`;\n\n    // Build multipart form data manually (Node.js compatible)\n    const boundary = `----FormBoundary${Date.now()}${Math.random().toString(36).substring(2)}`;\n    const mimetype = file.mimetype || \"text/csv\";\n\n    const header = Buffer.from(\n      `--${boundary}\\r\\n` +\n        `Content-Disposition: form-data; name=\"file\"; filename=\"${file.filename}\"\\r\\n` +\n        `Content-Type: ${mimetype}\\r\\n\\r\\n`,\n    );\n    const footer = Buffer.from(`\\r\\n--${boundary}--\\r\\n`);\n    const body = Buffer.concat([header, file.buffer, footer]);\n\n    const headers: Record<string, string> = {\n      \"Content-Type\": `multipart/form-data; boundary=${boundary}`,\n      Accept: \"application/json\",\n      \"User-Agent\": `@sendly/cli/${version}`,\n    };\n\n    if (requireAuth) {\n      headers[\"Authorization\"] = `Bearer ${await this.ensureAuth()}`;\n    }\n\n    let lastError: Error | undefined;\n    let didRefresh = false;\n\n    for (let attempt = 0; attempt <= maxRetries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), timeout);\n\n        const response = await fetch(url, {\n          method: \"POST\",\n          headers,\n          body,\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        this.updateRateLimitInfo(response.headers);\n        const data = await response.json().catch(() => ({}));\n\n        if (response.status === 401 && requireAuth && !didRefresh) {\n          didRefresh = true;\n          const refreshed = await this.refreshTokens();\n          if (refreshed) {\n            headers[\"Authorization\"] = `Bearer ${getAuthToken()}`;\n            attempt--;\n            continue;\n          }\n        }\n\n        if (!response.ok) {\n          this.handleError(response.status, data);\n        }\n\n        return data as T;\n      } catch (error) {\n        lastError = error as Error;\n\n        if (!isRetryableError(error)) {\n          throw error;\n        }\n\n        if (attempt === maxRetries) {\n          throw error;\n        }\n\n        const backoffMs = Math.min(1000 * Math.pow(2, attempt), 10000);\n        await sleep(backoffMs);\n      }\n    }\n\n    throw lastError || new Error(\"Upload failed\");\n  }\n}\n\nexport const apiClient = new ApiClient();\n"]}

package.json

 {
   "name": "@sendly/cli",
-  "version": "3.18.0",
+  "version": "3.18.2",
   "type": "module",
@@ -61,2 +61,20 @@ "description": "Sendly CLI - Send SMS from your terminal",
         "description": "Manage credits and transfers"
+      },
+      "enterprise": {
+        "description": "Manage enterprise workspaces, billing, and analytics"
+      },
+      "enterprise workspaces": {
+        "description": "Create, list, and manage enterprise workspaces"
+      },
+      "enterprise keys": {
+        "description": "Manage API keys for enterprise workspaces"
+      },
+      "enterprise webhooks": {
+        "description": "Manage enterprise-level webhooks"
+      },
+      "enterprise analytics": {
+        "description": "View enterprise analytics and reports"
+      },
+      "enterprise quota": {
+        "description": "Manage workspace message quotas"
       }
@@ -63,0 +81,0 @@ }

New alerts

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Fixed alerts

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Improved metrics

Total package byte prevSize

1501092

19.07%

Number of package files

226

26.97%

Lines of code

16490

20.97%

No dependency changes