@sendly/cli 3.17.0 → 3.18.2

package/dist/commands/enterprise/transfer-credits.js

@@ -0,0 +1,76 @@
+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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

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

@@ -0,0 +1,11 @@
+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>;
+}

package/dist/commands/enterprise/webhooks/delete.js

@@ -0,0 +1,44 @@
+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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

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

@@ -0,0 +1,10 @@
+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>;
+}

package/dist/commands/enterprise/webhooks/get.js

@@ -0,0 +1,38 @@
+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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

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

@@ -0,0 +1,12 @@
+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>;
+}

package/dist/commands/enterprise/webhooks/set.js

@@ -0,0 +1,48 @@
+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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

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

@@ -0,0 +1,10 @@
+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>;
+}

package/dist/commands/enterprise/webhooks/test.js

@@ -0,0 +1,42 @@
+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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

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

@@ -0,0 +1,11 @@
+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>;
+}

package/dist/commands/enterprise/workspaces/create.js

@@ -0,0 +1,37 @@
+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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

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

@@ -0,0 +1,14 @@
+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>;
+}

package/dist/commands/enterprise/workspaces/delete.js

@@ -0,0 +1,58 @@
+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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

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

@@ -0,0 +1,13 @@
+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>;
+}

package/dist/commands/enterprise/workspaces/get.js

@@ -0,0 +1,49 @@
+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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

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

@@ -0,0 +1,10 @@
+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>;
+}