@sendly/cli 3.8.2 → 3.9.0

package/dist/commands/verify/list.js

@@ -0,0 +1,74 @@
+import { Flags } from "@oclif/core";
+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 VerifyList extends AuthenticatedCommand {
+    static description = "List recent verifications";
+    static examples = [
+        "<%= config.bin %> verify list",
+        "<%= config.bin %> verify list --limit 10",
+        "<%= config.bin %> verify list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "n",
+            description: "Number of verifications to show",
+            default: 20,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(VerifyList);
+        const listSpinner = spinner("Fetching verifications...");
+        if (!isJsonMode()) {
+            listSpinner.start();
+        }
+        try {
+            const response = await apiClient.get("/api/v1/verify", {
+                limit: flags.limit,
+            });
+            listSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            if (response.verifications.length === 0) {
+                console.log(colors.dim("No verifications found."));
+                console.log(colors.dim(`Send one with: ${colors.code('sendly verify send --to "+1234567890"')}`));
+                return;
+            }
+            const statusColor = (status) => {
+                switch (status) {
+                    case "verified":
+                        return colors.success(status);
+                    case "pending":
+                        return colors.primary(status);
+                    case "expired":
+                        return colors.dim(status);
+                    default:
+                        return colors.error(status);
+                }
+            };
+            const rows = response.verifications.map((v) => ({
+                ...v,
+                attemptsDisplay: `${v.attempts}/${v.max_attempts}`,
+            }));
+            table(rows, [
+                { header: "ID", key: "id", width: 20, formatter: (v) => colors.code(String(v).slice(0, 16) + "...") },
+                { header: "Phone", key: "phone", width: 16 },
+                { header: "Status", key: "status", width: 12, formatter: (v) => statusColor(String(v)) },
+                { header: "Attempts", key: "attemptsDisplay", width: 10 },
+                { header: "Sandbox", key: "sandbox", width: 8, formatter: (v) => v ? colors.dim("yes") : "" },
+                { header: "Created", key: "created_at", width: 20, formatter: (v) => new Date(String(v)).toLocaleString() },
+            ]);
+            if (response.pagination.has_more) {
+                console.log(colors.dim(`\nShowing ${response.verifications.length} verifications. Use --limit to see more.`));
+            }
+        }
+        catch (err) {
+            listSpinner.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../src/commands/verify/list.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 { json, colors, spinner, isJsonMode, table } from \"../../lib/output.js\";\n\ninterface Verification {\n  id: string;\n  status: string;\n  phone: string;\n  delivery_status: string;\n  attempts: number;\n  max_attempts: number;\n  expires_at: string;\n  verified_at: string | null;\n  created_at: string;\n  sandbox: boolean;\n}\n\ninterface ListResponse {\n  verifications: Verification[];\n  pagination: {\n    limit: number;\n    has_more: boolean;\n  };\n}\n\nexport default class VerifyList extends AuthenticatedCommand {\n  static description = \"List recent verifications\";\n\n  static examples = [\n    \"<%= config.bin %> verify list\",\n    \"<%= config.bin %> verify list --limit 10\",\n    \"<%= config.bin %> verify list --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    limit: Flags.integer({\n      char: \"n\",\n      description: \"Number of verifications to show\",\n      default: 20,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(VerifyList);\n\n    const listSpinner = spinner(\"Fetching verifications...\");\n\n    if (!isJsonMode()) {\n      listSpinner.start();\n    }\n\n    try {\n      const response = await apiClient.get<ListResponse>(\"/api/v1/verify\", {\n        limit: flags.limit,\n      });\n\n      listSpinner.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      if (response.verifications.length === 0) {\n        console.log(colors.dim(\"No verifications found.\"));\n        console.log(\n          colors.dim(\n            `Send one with: ${colors.code('sendly verify send --to \"+1234567890\"')}`,\n          ),\n        );\n        return;\n      }\n\n      const statusColor = (status: string) => {\n        switch (status) {\n          case \"verified\":\n            return colors.success(status);\n          case \"pending\":\n            return colors.primary(status);\n          case \"expired\":\n            return colors.dim(status);\n          default:\n            return colors.error(status);\n        }\n      };\n\n      const rows = response.verifications.map((v) => ({\n        ...v,\n        attemptsDisplay: `${v.attempts}/${v.max_attempts}`,\n      }));\n\n      table(rows, [\n        { header: \"ID\", key: \"id\", width: 20, formatter: (v) => colors.code(String(v).slice(0, 16) + \"...\") },\n        { header: \"Phone\", key: \"phone\", width: 16 },\n        { header: \"Status\", key: \"status\", width: 12, formatter: (v) => statusColor(String(v)) },\n        { header: \"Attempts\", key: \"attemptsDisplay\", width: 10 },\n        { header: \"Sandbox\", key: \"sandbox\", width: 8, formatter: (v) => v ? colors.dim(\"yes\") : \"\" },\n        { header: \"Created\", key: \"created_at\", width: 20, formatter: (v) => new Date(String(v)).toLocaleString() },\n      ]);\n\n      if (response.pagination.has_more) {\n        console.log(\n          colors.dim(\n            `\\nShowing ${response.verifications.length} verifications. Use --limit to see more.`,\n          ),\n        );\n      }\n    } catch (err: any) {\n      listSpinner.stop();\n      throw err;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class VerifyResend 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/verify/resend.js

@@ -0,0 +1,83 @@
+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 VerifyResend extends AuthenticatedCommand {
+    static description = "Resend an OTP verification code";
+    static examples = [
+        "<%= config.bin %> verify resend ver_xxx",
+        "<%= config.bin %> verify resend ver_xxx --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Verification ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(VerifyResend);
+        const resendSpinner = spinner("Resending verification code...");
+        if (!isJsonMode()) {
+            resendSpinner.start();
+        }
+        try {
+            const response = await apiClient.post(`/api/v1/verify/${args.id}/resend`, {});
+            resendSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            if (response.sandbox) {
+                success("Verification resent (Sandbox)", {
+                    "Verification ID": colors.code(response.id),
+                    Phone: response.phone,
+                    "Sandbox Code": colors.success(response.sandbox_code || ""),
+                    "Expires At": new Date(response.expires_at).toLocaleString(),
+                });
+            }
+            else {
+                success("Verification resent", {
+                    "Verification ID": colors.code(response.id),
+                    Phone: response.phone,
+                    "Expires At": new Date(response.expires_at).toLocaleString(),
+                });
+            }
+        }
+        catch (err) {
+            resendSpinner.stop();
+            if (err.message?.includes("already_verified")) {
+                error("Verification already completed", {
+                    hint: "This phone number has already been verified",
+                });
+            }
+            else if (err.message?.includes("expired")) {
+                error("Verification expired", {
+                    hint: "Request a new verification instead",
+                });
+            }
+            else if (err.message?.includes("max_resends")) {
+                error("Maximum resends exceeded", {
+                    hint: "Request a new verification instead",
+                });
+            }
+            else if (err.message?.includes("not_found")) {
+                error("Verification not found", {
+                    hint: "Check the verification ID is correct",
+                });
+            }
+            else if (err.message?.includes("rate_limit")) {
+                error("Too many resend requests", {
+                    hint: "Wait a moment before trying again",
+                });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,16 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class VerifySend extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "app-name": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        template: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        profile: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "code-length": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        timeout: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | 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/verify/send.js

@@ -0,0 +1,105 @@
+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 VerifySend extends AuthenticatedCommand {
+    static description = "Send an OTP verification code";
+    static examples = [
+        '<%= config.bin %> verify send --to "+1234567890"',
+        '<%= config.bin %> verify send --to "+1234567890" --app-name "MyApp"',
+        '<%= config.bin %> verify send --to "+1234567890" --template tpl_preset_2fa',
+        '<%= config.bin %> verify send --to "+1234567890" --profile vp_xxx',
+        '<%= config.bin %> verify send --to "+1234567890" --code-length 8 --timeout 120',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        to: Flags.string({
+            char: "t",
+            description: "Recipient phone number (E.164 format)",
+            required: true,
+        }),
+        "app-name": Flags.string({
+            char: "a",
+            description: "App name shown in message (defaults to your business name)",
+        }),
+        template: Flags.string({
+            description: "Template ID to use (defaults to tpl_preset_otp)",
+        }),
+        profile: Flags.string({
+            char: "p",
+            description: "Verify profile ID for preconfigured settings",
+        }),
+        "code-length": Flags.integer({
+            description: "Length of OTP code (4-10, default: 6)",
+        }),
+        timeout: Flags.integer({
+            description: "Code validity in seconds (60-3600, default: 300)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(VerifySend);
+        const sendSpinner = spinner("Sending verification code...");
+        if (!isJsonMode()) {
+            sendSpinner.start();
+        }
+        try {
+            const response = await apiClient.post("/api/v1/verify", {
+                to: flags.to,
+                ...(flags["app-name"] && { app_name: flags["app-name"] }),
+                ...(flags.template && { template_id: flags.template }),
+                ...(flags.profile && { profile_id: flags.profile }),
+                ...(flags["code-length"] && { code_length: flags["code-length"] }),
+                ...(flags.timeout && { timeout_secs: flags.timeout }),
+            });
+            sendSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            if (response.sandbox) {
+                success("Verification sent (Sandbox)", {
+                    "Verification ID": colors.code(response.id),
+                    Phone: response.phone,
+                    "Sandbox Code": colors.success(response.sandbox_code || ""),
+                    "Expires At": new Date(response.expires_at).toLocaleString(),
+                    "": "",
+                    Note: colors.dim("Sandbox mode: SMS not sent. Use sandbox code to verify."),
+                });
+                console.log();
+                console.log(colors.dim(`Check with: ${colors.code(`sendly verify check ${response.id} --code ${response.sandbox_code}`)}`));
+            }
+            else {
+                success("Verification sent", {
+                    "Verification ID": colors.code(response.id),
+                    Phone: response.phone,
+                    "Expires At": new Date(response.expires_at).toLocaleString(),
+                });
+                console.log();
+                console.log(colors.dim(`Check with: ${colors.code(`sendly verify check ${response.id} --code <code>`)}`));
+            }
+        }
+        catch (err) {
+            sendSpinner.stop();
+            if (err.message?.includes("insufficient_credits")) {
+                error("Insufficient credits", {
+                    hint: `Run ${colors.code("sendly credits balance")} to check your balance`,
+                });
+            }
+            else if (err.message?.includes("verification_required")) {
+                error("Business verification required", {
+                    hint: "Complete verification at https://sendly.live/dashboard/verification",
+                });
+            }
+            else if (err.message?.includes("invalid_phone")) {
+                error("Invalid phone number format", {
+                    hint: "Use E.164 format: +1234567890",
+                });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../../../src/commands/verify/send.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  error,\n  json,\n  colors,\n  spinner,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface VerifyResponse {\n  id: string;\n  status: string;\n  phone: string;\n  expires_at: string;\n  sandbox: boolean;\n  sandbox_code?: string;\n  message?: string;\n}\n\nexport default class VerifySend extends AuthenticatedCommand {\n  static description = \"Send an OTP verification code\";\n\n  static examples = [\n    '<%= config.bin %> verify send --to \"+1234567890\"',\n    '<%= config.bin %> verify send --to \"+1234567890\" --app-name \"MyApp\"',\n    '<%= config.bin %> verify send --to \"+1234567890\" --template tpl_preset_2fa',\n    '<%= config.bin %> verify send --to \"+1234567890\" --profile vp_xxx',\n    '<%= config.bin %> verify send --to \"+1234567890\" --code-length 8 --timeout 120',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    to: Flags.string({\n      char: \"t\",\n      description: \"Recipient phone number (E.164 format)\",\n      required: true,\n    }),\n    \"app-name\": Flags.string({\n      char: \"a\",\n      description: \"App name shown in message (defaults to your business name)\",\n    }),\n    template: Flags.string({\n      description: \"Template ID to use (defaults to tpl_preset_otp)\",\n    }),\n    profile: Flags.string({\n      char: \"p\",\n      description: \"Verify profile ID for preconfigured settings\",\n    }),\n    \"code-length\": Flags.integer({\n      description: \"Length of OTP code (4-10, default: 6)\",\n    }),\n    timeout: Flags.integer({\n      description: \"Code validity in seconds (60-3600, default: 300)\",\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(VerifySend);\n\n    const sendSpinner = spinner(\"Sending verification code...\");\n\n    if (!isJsonMode()) {\n      sendSpinner.start();\n    }\n\n    try {\n      const response = await apiClient.post<VerifyResponse>(\"/api/v1/verify\", {\n        to: flags.to,\n        ...(flags[\"app-name\"] && { app_name: flags[\"app-name\"] }),\n        ...(flags.template && { template_id: flags.template }),\n        ...(flags.profile && { profile_id: flags.profile }),\n        ...(flags[\"code-length\"] && { code_length: flags[\"code-length\"] }),\n        ...(flags.timeout && { timeout_secs: flags.timeout }),\n      });\n\n      sendSpinner.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      if (response.sandbox) {\n        success(\"Verification sent (Sandbox)\", {\n          \"Verification ID\": colors.code(response.id),\n          Phone: response.phone,\n          \"Sandbox Code\": colors.success(response.sandbox_code || \"\"),\n          \"Expires At\": new Date(response.expires_at).toLocaleString(),\n          \"\": \"\",\n          Note: colors.dim(\n            \"Sandbox mode: SMS not sent. Use sandbox code to verify.\",\n          ),\n        });\n        console.log();\n        console.log(\n          colors.dim(\n            `Check with: ${colors.code(`sendly verify check ${response.id} --code ${response.sandbox_code}`)}`,\n          ),\n        );\n      } else {\n        success(\"Verification sent\", {\n          \"Verification ID\": colors.code(response.id),\n          Phone: response.phone,\n          \"Expires At\": new Date(response.expires_at).toLocaleString(),\n        });\n        console.log();\n        console.log(\n          colors.dim(\n            `Check with: ${colors.code(`sendly verify check ${response.id} --code <code>`)}`,\n          ),\n        );\n      }\n    } catch (err: any) {\n      sendSpinner.stop();\n\n      if (err.message?.includes(\"insufficient_credits\")) {\n        error(\"Insufficient credits\", {\n          hint: `Run ${colors.code(\"sendly credits balance\")} to check your balance`,\n        });\n      } else if (err.message?.includes(\"verification_required\")) {\n        error(\"Business verification required\", {\n          hint: \"Complete verification at https://sendly.live/dashboard/verification\",\n        });\n      } else if (err.message?.includes(\"invalid_phone\")) {\n        error(\"Invalid phone number format\", {\n          hint: \"Use E.164 format: +1234567890\",\n        });\n      } else {\n        throw err;\n      }\n      this.exit(1);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class VerifyStatus 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/verify/status.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, json, colors, spinner, isJsonMode } from "../../lib/output.js";
+export default class VerifyStatus extends AuthenticatedCommand {
+    static description = "Get verification status";
+    static examples = [
+        "<%= config.bin %> verify status ver_xxx",
+        "<%= config.bin %> verify status ver_xxx --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Verification ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(VerifyStatus);
+        const statusSpinner = spinner("Fetching verification status...");
+        if (!isJsonMode()) {
+            statusSpinner.start();
+        }
+        try {
+            const response = await apiClient.get(`/api/v1/verify/${args.id}`);
+            statusSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            const statusColor = response.status === "verified"
+                ? colors.success
+                : response.status === "pending"
+                    ? colors.primary
+                    : colors.error;
+            success("Verification status", {
+                "Verification ID": colors.code(response.id),
+                Phone: response.phone,
+                Status: statusColor(response.status),
+                "Delivery Status": response.delivery_status,
+                Attempts: `${response.attempts}/${response.max_attempts}`,
+                "Expires At": new Date(response.expires_at).toLocaleString(),
+                ...(response.verified_at && {
+                    "Verified At": new Date(response.verified_at).toLocaleString(),
+                }),
+                Sandbox: response.sandbox ? colors.dim("yes") : "no",
+            });
+        }
+        catch (err) {
+            statusSpinner.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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