@sendly/cli 3.8.2 → 3.11.0

package/dist/commands/templates/create.d.ts

@@ -0,0 +1,12 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TemplatesCreate 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>;
+        text: 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/templates/create.js

@@ -0,0 +1,65 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, colors, spinner, isJsonMode, } from "../../lib/output.js";
+export default class TemplatesCreate extends AuthenticatedCommand {
+    static description = "Create a new SMS template";
+    static examples = [
+        '<%= config.bin %> templates create --name "My OTP" --text "Your code is {{code}}"',
+        '<%= config.bin %> templates create --name "Login" --text "{{code}} is your {{app_name}} login code"',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        name: Flags.string({
+            char: "n",
+            description: "Template name",
+            required: true,
+        }),
+        text: Flags.string({
+            char: "t",
+            description: "Message text (use {{code}} and {{app_name}} variables)",
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TemplatesCreate);
+        const createSpinner = spinner("Creating template...");
+        if (!isJsonMode()) {
+            createSpinner.start();
+        }
+        try {
+            const response = await apiClient.post("/api/v1/templates", {
+                name: flags.name,
+                text: flags.text,
+            });
+            createSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Template created", {
+                ID: colors.code(response.id),
+                Name: response.name,
+                Status: colors.dim(response.status),
+                Variables: response.variables
+                    .map((v) => colors.code(`{{${v.key}}}`))
+                    .join(", ") || colors.dim("none"),
+            });
+            console.log();
+            console.log(colors.dim(`Publish with: ${colors.code(`sendly templates publish ${response.id}`)}`));
+        }
+        catch (err) {
+            createSpinner.stop();
+            if (err.message?.includes("1600 characters")) {
+                error("Template text too long", {
+                    hint: "Maximum 1600 characters (10 SMS segments)",
+                });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/templates/delete.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TemplatesDelete extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        force: 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/templates/delete.js

@@ -0,0 +1,68 @@
+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, spinner, isJsonMode, } from "../../lib/output.js";
+import { confirm } from "@inquirer/prompts";
+export default class TemplatesDelete extends AuthenticatedCommand {
+    static description = "Delete a template";
+    static examples = [
+        "<%= config.bin %> templates delete tpl_xxx",
+        "<%= config.bin %> templates delete tpl_xxx --force",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Template ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        force: Flags.boolean({
+            char: "f",
+            description: "Skip confirmation",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TemplatesDelete);
+        if (!flags.force && !isJsonMode()) {
+            const confirmed = await confirm({
+                message: `Delete template ${args.id}?`,
+                default: false,
+            });
+            if (!confirmed) {
+                console.log(colors.dim("Cancelled"));
+                return;
+            }
+        }
+        const deleteSpinner = spinner("Deleting template...");
+        if (!isJsonMode()) {
+            deleteSpinner.start();
+        }
+        try {
+            await apiClient.delete(`/api/v1/templates/${args.id}`);
+            deleteSpinner.stop();
+            if (isJsonMode()) {
+                json({ success: true, id: args.id });
+                return;
+            }
+            success("Template deleted", {
+                ID: colors.code(args.id),
+            });
+        }
+        catch (err) {
+            deleteSpinner.stop();
+            if (err.message?.includes("preset")) {
+                error("Cannot delete preset templates");
+            }
+            else if (err.message?.includes("not_found")) {
+                error("Template not found");
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/templates/get.d.ts

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

package/dist/commands/templates/get.js

@@ -0,0 +1,69 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, colors, spinner, isJsonMode } from "../../lib/output.js";
+export default class TemplatesGet extends AuthenticatedCommand {
+    static description = "Get template details";
+    static examples = [
+        "<%= config.bin %> templates get tpl_xxx",
+        "<%= config.bin %> templates get tpl_preset_2fa",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Template ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(TemplatesGet);
+        const getSpinner = spinner("Fetching template...");
+        if (!isJsonMode()) {
+            getSpinner.start();
+        }
+        try {
+            const response = await apiClient.get(`/api/v1/templates/${args.id}`);
+            getSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            const statusDisplay = response.is_preset
+                ? colors.primary("preset")
+                : response.status === "published"
+                    ? colors.success("published")
+                    : colors.dim("draft");
+            success("Template details", {
+                ID: colors.code(response.id),
+                Name: response.name,
+                Type: statusDisplay,
+                Version: String(response.version),
+                ...(response.preset_slug && { Slug: response.preset_slug }),
+            });
+            console.log();
+            console.log(colors.bold("Message Text:"));
+            console.log(colors.dim("  " + response.text));
+            if (response.variables.length > 0) {
+                console.log();
+                console.log(colors.bold("Variables:"));
+                for (const v of response.variables) {
+                    const fallback = v.fallback
+                        ? ` (default: ${colors.dim(String(v.fallback))})`
+                        : "";
+                    console.log(`  ${colors.code(`{{${v.key}}}`)} - ${v.type}${fallback}`);
+                }
+            }
+            if (!response.is_preset && response.status === "draft") {
+                console.log();
+                console.log(colors.dim(`Publish with: ${colors.code(`sendly templates publish ${response.id}`)}`));
+            }
+        }
+        catch (err) {
+            getSpinner.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/templates/list.d.ts

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TemplatesList 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/templates/list.js

@@ -0,0 +1,49 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, colors, spinner, isJsonMode, table } from "../../lib/output.js";
+export default class TemplatesList extends AuthenticatedCommand {
+    static description = "List your SMS templates";
+    static examples = [
+        "<%= config.bin %> templates list",
+        "<%= config.bin %> templates list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(TemplatesList);
+        const listSpinner = spinner("Fetching templates...");
+        if (!isJsonMode()) {
+            listSpinner.start();
+        }
+        try {
+            const response = await apiClient.get("/api/v1/templates");
+            listSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            if (response.templates.length === 0) {
+                console.log(colors.dim("No templates found."));
+                console.log(colors.dim(`View presets with: ${colors.code("sendly templates presets")}`));
+                return;
+            }
+            const rows = response.templates.map((t) => ({
+                ...t,
+                typeDisplay: t.is_preset ? colors.primary("preset") : t.status === "published" ? colors.success("published") : colors.dim("draft"),
+            }));
+            table(rows, [
+                { header: "ID", key: "id", width: 20, formatter: (v) => colors.code(String(v).slice(0, 16) + "...") },
+                { header: "Name", key: "name", width: 20 },
+                { header: "Type", key: "typeDisplay", width: 12 },
+                { header: "Ver", key: "version", width: 5 },
+                { header: "Text", key: "text", width: 40, formatter: (v) => String(v).length > 40 ? String(v).slice(0, 37) + "..." : String(v) },
+            ]);
+        }
+        catch (err) {
+            listSpinner.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/templates/presets.d.ts

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class TemplatesPresets 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/templates/presets.js

@@ -0,0 +1,45 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, colors, spinner, isJsonMode } from "../../lib/output.js";
+export default class TemplatesPresets extends AuthenticatedCommand {
+    static description = "List available preset templates";
+    static examples = [
+        "<%= config.bin %> templates presets",
+        "<%= config.bin %> templates presets --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(TemplatesPresets);
+        const listSpinner = spinner("Fetching preset templates...");
+        if (!isJsonMode()) {
+            listSpinner.start();
+        }
+        try {
+            const response = await apiClient.get("/api/v1/templates/presets", {}, false);
+            listSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            console.log(colors.bold("\nAvailable Preset Templates\n"));
+            console.log(colors.dim("Use these directly with verify send or clone to customize.\n"));
+            for (const template of response.templates) {
+                console.log(colors.bold(template.name));
+                console.log(`  ID: ${colors.code(template.id)}`);
+                console.log(`  Slug: ${colors.primary(template.preset_slug)}`);
+                console.log(`  Text: ${colors.dim(template.text)}`);
+                console.log(`  Variables: ${template.variables.map((v) => colors.code(`{{${v.key}}}`)).join(", ")}`);
+                console.log();
+            }
+            console.log(colors.dim("Usage example:"));
+            console.log(colors.code('  sendly verify send --to "+1234567890" --template tpl_preset_2fa'));
+        }
+        catch (err) {
+            listSpinner.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/templates/publish.d.ts

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

package/dist/commands/templates/publish.js

@@ -0,0 +1,57 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, colors, spinner, isJsonMode, } from "../../lib/output.js";
+export default class TemplatesPublish extends AuthenticatedCommand {
+    static description = "Publish a draft template (locks it for use)";
+    static examples = ["<%= config.bin %> templates publish tpl_xxx"];
+    static args = {
+        id: Args.string({
+            description: "Template ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(TemplatesPublish);
+        const publishSpinner = spinner("Publishing template...");
+        if (!isJsonMode()) {
+            publishSpinner.start();
+        }
+        try {
+            const response = await apiClient.post(`/api/v1/templates/${args.id}/publish`);
+            publishSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Template published", {
+                ID: colors.code(response.id),
+                Name: response.name,
+                Status: colors.success(response.status),
+                "Published At": new Date(response.published_at).toLocaleString(),
+            });
+            console.log();
+            console.log(colors.dim(`Use with: ${colors.code(`sendly verify send --to "+1234567890" --template ${response.id}`)}`));
+        }
+        catch (err) {
+            publishSpinner.stop();
+            if (err.message?.includes("already published")) {
+                error("Template already published");
+            }
+            else if (err.message?.includes("preset")) {
+                error("Cannot publish preset templates");
+            }
+            else if (err.message?.includes("not_found")) {
+                error("Template not found");
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/verify/check.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class VerifyCheck extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        code: 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/verify/check.js

@@ -0,0 +1,86 @@
+import { Flags, Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, colors, spinner, isJsonMode, } from "../../lib/output.js";
+export default class VerifyCheck extends AuthenticatedCommand {
+    static description = "Verify an OTP code";
+    static examples = [
+        "<%= config.bin %> verify check ver_xxx --code 123456",
+        "<%= config.bin %> verify check ver_xxx -c 123456",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Verification ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        code: Flags.string({
+            char: "c",
+            description: "The OTP code to verify",
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(VerifyCheck);
+        const checkSpinner = spinner("Verifying code...");
+        if (!isJsonMode()) {
+            checkSpinner.start();
+        }
+        try {
+            const response = await apiClient.post(`/api/v1/verify/${args.id}/check`, { code: flags.code });
+            checkSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            if (response.status === "verified") {
+                success("Code verified successfully", {
+                    "Verification ID": colors.code(response.id),
+                    Phone: response.phone,
+                    Status: colors.success("verified"),
+                    "Verified At": response.verified_at
+                        ? new Date(response.verified_at).toLocaleString()
+                        : "now",
+                });
+            }
+            else {
+                error("Verification failed", {
+                    Status: response.status,
+                });
+            }
+        }
+        catch (err) {
+            checkSpinner.stop();
+            if (err.message?.includes("invalid_code")) {
+                const remaining = err.details?.remaining_attempts;
+                error("Invalid code", {
+                    hint: remaining
+                        ? `${remaining} attempt(s) remaining`
+                        : "Try again with the correct code",
+                });
+            }
+            else if (err.message?.includes("expired")) {
+                error("Verification expired", {
+                    hint: "Request a new verification code",
+                });
+            }
+            else if (err.message?.includes("max_attempts")) {
+                error("Maximum attempts exceeded", {
+                    hint: "Request a new verification code",
+                });
+            }
+            else if (err.message?.includes("not_found")) {
+                error("Verification not found", {
+                    hint: "Check the verification ID is correct",
+                });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/verify/list.d.ts

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