@sendly/cli 3.37.1 → 3.38.0

package/dist/commands/whatsapp/templates/create.js

@@ -0,0 +1,205 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient, ApiError, ValidationError, } from "../../../lib/api-client.js";
+import { success, error, warn, json, colors, spinner, isJsonMode, } from "../../../lib/output.js";
+const TEMPLATE_NAME_RE = /^[a-z0-9_]{1,512}$/;
+const BUTTON_TYPES = ["url", "quick_reply", "otp"];
+/**
+ * Parse a --button value: "quick_reply:Stop promotions",
+ * "url:Track order:https://example.com/{{1}}", or "otp:Copy code".
+ * Returns an error string on bad input.
+ */
+function parseButton(raw) {
+    const firstSep = raw.indexOf(":");
+    if (firstSep === -1) {
+        return `Invalid --button "${raw}" — use type:text (types: ${BUTTON_TYPES.join(", ")})`;
+    }
+    const type = raw.slice(0, firstSep).trim().toLowerCase();
+    const rest = raw.slice(firstSep + 1);
+    if (!BUTTON_TYPES.includes(type)) {
+        return `Invalid --button type "${type}" — must be one of: ${BUTTON_TYPES.join(", ")}`;
+    }
+    if (type === "url") {
+        const secondSep = rest.indexOf(":");
+        if (secondSep === -1) {
+            return `Invalid --button "${raw}" — url buttons need url:text:https://...`;
+        }
+        const text = rest.slice(0, secondSep).trim();
+        const url = rest.slice(secondSep + 1).trim();
+        if (!text || !url) {
+            return `Invalid --button "${raw}" — url buttons need url:text:https://...`;
+        }
+        return { type, text, url };
+    }
+    const text = rest.trim();
+    if (!text) {
+        return `Invalid --button "${raw}" — button text is required`;
+    }
+    return { type, text };
+}
+/** Parse repeatable n=value pairs into a variables/examples record. */
+function parseKeyValuePairs(raw, flagName) {
+    if (!raw || raw.length === 0)
+        return undefined;
+    const out = {};
+    for (const item of raw) {
+        const idx = item.indexOf("=");
+        if (idx <= 0) {
+            return `Invalid --${flagName} "${item}" — use n=value (e.g. 1=TinyFat)`;
+        }
+        out[item.slice(0, idx).trim()] = item.slice(idx + 1);
+    }
+    return out;
+}
+/** Unique {{n}} placeholders in a body, ascending. */
+function bodyPlaceholders(body) {
+    const seen = new Set();
+    const re = /\{\{(\d+)\}\}/g;
+    let m;
+    while ((m = re.exec(body || "")) !== null) {
+        seen.add(parseInt(m[1], 10));
+    }
+    return Array.from(seen).sort((a, b) => a - b);
+}
+export default class WhatsappTemplatesCreate extends AuthenticatedCommand {
+    static description = "Create a WhatsApp template and submit it to Meta for review";
+    static examples = [
+        '<%= config.bin %> whatsapp templates create --sender +15551234567 --name order_shipped --language en_US --category utility --body "Hi {{1}}, order {{2}} shipped!" --example 1=TinyFat --example 2=4821',
+        '<%= config.bin %> whatsapp templates create --sender +15551234567 --name summer_sale --language en_US --category marketing --body "Our sale is on!" --footer "Reply STOP to opt out" --button "quick_reply:Stop promotions"',
+        '<%= config.bin %> whatsapp templates create --sender +15551234567 --name login_code --language en_US --category authentication --body "{{1}} is your code" --example 1=123456 --button "otp:Copy code"',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        sender: Flags.string({
+            char: "s",
+            description: "WhatsApp-connected sender number (E.164 format)",
+            required: true,
+        }),
+        name: Flags.string({
+            char: "n",
+            description: "Template name (lowercase letters, numbers, and underscores)",
+            required: true,
+        }),
+        language: Flags.string({
+            char: "l",
+            description: "Template language code (e.g. en_US)",
+            required: true,
+        }),
+        category: Flags.string({
+            char: "c",
+            description: "Template category",
+            options: ["authentication", "utility", "marketing"],
+            required: true,
+        }),
+        body: Flags.string({
+            char: "b",
+            description: "Body text; use {{1}}, {{2}}, ... for variables",
+            required: true,
+        }),
+        footer: Flags.string({
+            description: "Footer text (optional)",
+        }),
+        header: Flags.string({
+            description: "Header text (optional)",
+        }),
+        button: Flags.string({
+            description: 'Button as "type:text" or "url:text:https://..." (types: quick_reply, url, otp). Repeatable.',
+            multiple: true,
+        }),
+        example: Flags.string({
+            description: "Example value for a body variable, as n=value (required for every {{n}}). Repeatable.",
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WhatsappTemplatesCreate);
+        if (!TEMPLATE_NAME_RE.test(flags.name)) {
+            error("Invalid template name", {
+                hint: "Use only lowercase letters, numbers, and underscores (e.g. order_shipped)",
+            });
+            this.exit(1);
+        }
+        const examples = parseKeyValuePairs(flags.example, "example");
+        if (typeof examples === "string") {
+            error(examples);
+            this.exit(1);
+        }
+        const missing = bodyPlaceholders(flags.body).filter((n) => !(examples && examples[String(n)]));
+        if (missing.length > 0) {
+            error(`Missing example value${missing.length === 1 ? "" : "s"} for {{${missing.join("}}, {{")}}}`, {
+                hint: `Meta requires an example for every variable: --example ${missing[0]}=value`,
+            });
+            this.exit(1);
+        }
+        const buttons = [];
+        for (const raw of flags.button ?? []) {
+            const parsed = parseButton(raw);
+            if (typeof parsed === "string") {
+                error(parsed);
+                this.exit(1);
+            }
+            buttons.push(parsed);
+        }
+        const createSpinner = spinner("Submitting template for review...");
+        if (!isJsonMode()) {
+            createSpinner.start();
+        }
+        try {
+            const response = await apiClient.post("/api/v1/whatsapp/templates", {
+                sender: flags.sender,
+                name: flags.name,
+                language: flags.language,
+                category: flags.category,
+                body: flags.body,
+                ...(flags.footer && { footer: flags.footer }),
+                ...(flags.header && { header: flags.header }),
+                ...(buttons.length > 0 && { buttons }),
+                ...(examples && { examples }),
+            });
+            createSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Template submitted for review", {
+                ID: colors.code(response.id),
+                Name: response.name,
+                Language: response.language,
+                Category: response.category,
+                Status: colors.warning(response.status),
+            });
+            (response.warnings ?? []).forEach((w) => warn(w));
+            console.log();
+            console.log(colors.dim(`Meta reviews new templates, usually within a day. Check with: ${colors.code("sendly whatsapp templates list")}`));
+        }
+        catch (err) {
+            createSpinner.stop();
+            if (err instanceof ApiError && err.code === "template_name_locked") {
+                error(err.message, {
+                    hint: "Edit the existing template instead: sendly whatsapp templates update <id>",
+                });
+            }
+            else if (err instanceof ApiError &&
+                err.code === "template_already_exists") {
+                error(err.message, {
+                    hint: "Pick a different name, or edit the existing template with `sendly whatsapp templates update`",
+                });
+            }
+            else if (err instanceof ValidationError && err.message === "HTTP 400") {
+                error("The template failed validation checks", {
+                    hint: "Every {{n}} needs an --example n=value; authentication templates can't contain links and need an otp button; names can't start with test/sample/demo",
+                });
+            }
+            else if (err.message?.includes("connected to WhatsApp")) {
+                error(err.message, {
+                    hint: `Connect it first: sendly whatsapp connect --number ${flags.sender}`,
+                });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../../src/commands/whatsapp/templates/create.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../../lib/base-command.js\";\nimport {\n  apiClient,\n  ApiError,\n  ValidationError,\n} from \"../../../lib/api-client.js\";\nimport {\n  success,\n  error,\n  warn,\n  json,\n  colors,\n  spinner,\n  isJsonMode,\n} from \"../../../lib/output.js\";\n\ninterface WhatsappTemplateResponse {\n  id: string;\n  name: string;\n  language: string;\n  category: string;\n  status: string;\n  qualityRating: string | null;\n  rejectionReason: string | null;\n  createdAt: string;\n  updatedAt: string;\n  warnings?: string[];\n}\n\ninterface TemplateButton {\n  type: string;\n  text: string;\n  url?: string;\n}\n\nconst TEMPLATE_NAME_RE = /^[a-z0-9_]{1,512}$/;\nconst BUTTON_TYPES = [\"url\", \"quick_reply\", \"otp\"];\n\n/**\n * Parse a --button value: \"quick_reply:Stop promotions\",\n * \"url:Track order:https://example.com/{{1}}\", or \"otp:Copy code\".\n * Returns an error string on bad input.\n */\nfunction parseButton(raw: string): TemplateButton | string {\n  const firstSep = raw.indexOf(\":\");\n  if (firstSep === -1) {\n    return `Invalid --button \"${raw}\" — use type:text (types: ${BUTTON_TYPES.join(\", \")})`;\n  }\n  const type = raw.slice(0, firstSep).trim().toLowerCase();\n  const rest = raw.slice(firstSep + 1);\n  if (!BUTTON_TYPES.includes(type)) {\n    return `Invalid --button type \"${type}\" — must be one of: ${BUTTON_TYPES.join(\", \")}`;\n  }\n  if (type === \"url\") {\n    const secondSep = rest.indexOf(\":\");\n    if (secondSep === -1) {\n      return `Invalid --button \"${raw}\" — url buttons need url:text:https://...`;\n    }\n    const text = rest.slice(0, secondSep).trim();\n    const url = rest.slice(secondSep + 1).trim();\n    if (!text || !url) {\n      return `Invalid --button \"${raw}\" — url buttons need url:text:https://...`;\n    }\n    return { type, text, url };\n  }\n  const text = rest.trim();\n  if (!text) {\n    return `Invalid --button \"${raw}\" — button text is required`;\n  }\n  return { type, text };\n}\n\n/** Parse repeatable n=value pairs into a variables/examples record. */\nfunction parseKeyValuePairs(\n  raw: string[] | undefined,\n  flagName: string,\n): Record<string, string> | string | undefined {\n  if (!raw || raw.length === 0) return undefined;\n  const out: Record<string, string> = {};\n  for (const item of raw) {\n    const idx = item.indexOf(\"=\");\n    if (idx <= 0) {\n      return `Invalid --${flagName} \"${item}\" — use n=value (e.g. 1=TinyFat)`;\n    }\n    out[item.slice(0, idx).trim()] = item.slice(idx + 1);\n  }\n  return out;\n}\n\n/** Unique {{n}} placeholders in a body, ascending. */\nfunction bodyPlaceholders(body: string): number[] {\n  const seen = new Set<number>();\n  const re = /\\{\\{(\\d+)\\}\\}/g;\n  let m: RegExpExecArray | null;\n  while ((m = re.exec(body || \"\")) !== null) {\n    seen.add(parseInt(m[1], 10));\n  }\n  return Array.from(seen).sort((a, b) => a - b);\n}\n\nexport default class WhatsappTemplatesCreate extends AuthenticatedCommand {\n  static description =\n    \"Create a WhatsApp template and submit it to Meta for review\";\n\n  static examples = [\n    '<%= config.bin %> whatsapp templates create --sender +15551234567 --name order_shipped --language en_US --category utility --body \"Hi {{1}}, order {{2}} shipped!\" --example 1=TinyFat --example 2=4821',\n    '<%= config.bin %> whatsapp templates create --sender +15551234567 --name summer_sale --language en_US --category marketing --body \"Our sale is on!\" --footer \"Reply STOP to opt out\" --button \"quick_reply:Stop promotions\"',\n    '<%= config.bin %> whatsapp templates create --sender +15551234567 --name login_code --language en_US --category authentication --body \"{{1}} is your code\" --example 1=123456 --button \"otp:Copy code\"',\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    sender: Flags.string({\n      char: \"s\",\n      description: \"WhatsApp-connected sender number (E.164 format)\",\n      required: true,\n    }),\n    name: Flags.string({\n      char: \"n\",\n      description:\n        \"Template name (lowercase letters, numbers, and underscores)\",\n      required: true,\n    }),\n    language: Flags.string({\n      char: \"l\",\n      description: \"Template language code (e.g. en_US)\",\n      required: true,\n    }),\n    category: Flags.string({\n      char: \"c\",\n      description: \"Template category\",\n      options: [\"authentication\", \"utility\", \"marketing\"],\n      required: true,\n    }),\n    body: Flags.string({\n      char: \"b\",\n      description: \"Body text; use {{1}}, {{2}}, ... for variables\",\n      required: true,\n    }),\n    footer: Flags.string({\n      description: \"Footer text (optional)\",\n    }),\n    header: Flags.string({\n      description: \"Header text (optional)\",\n    }),\n    button: Flags.string({\n      description:\n        'Button as \"type:text\" or \"url:text:https://...\" (types: quick_reply, url, otp). Repeatable.',\n      multiple: true,\n    }),\n    example: Flags.string({\n      description:\n        \"Example value for a body variable, as n=value (required for every {{n}}). Repeatable.\",\n      multiple: true,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(WhatsappTemplatesCreate);\n\n    if (!TEMPLATE_NAME_RE.test(flags.name)) {\n      error(\"Invalid template name\", {\n        hint: \"Use only lowercase letters, numbers, and underscores (e.g. order_shipped)\",\n      });\n      this.exit(1);\n    }\n\n    const examples = parseKeyValuePairs(flags.example, \"example\");\n    if (typeof examples === \"string\") {\n      error(examples);\n      this.exit(1);\n    }\n\n    const missing = bodyPlaceholders(flags.body).filter(\n      (n) => !(examples && examples[String(n)]),\n    );\n    if (missing.length > 0) {\n      error(\n        `Missing example value${missing.length === 1 ? \"\" : \"s\"} for {{${missing.join(\"}}, {{\")}}}`,\n        {\n          hint: `Meta requires an example for every variable: --example ${missing[0]}=value`,\n        },\n      );\n      this.exit(1);\n    }\n\n    const buttons: TemplateButton[] = [];\n    for (const raw of flags.button ?? []) {\n      const parsed = parseButton(raw);\n      if (typeof parsed === \"string\") {\n        error(parsed);\n        this.exit(1);\n      }\n      buttons.push(parsed as TemplateButton);\n    }\n\n    const createSpinner = spinner(\"Submitting template for review...\");\n    if (!isJsonMode()) {\n      createSpinner.start();\n    }\n\n    try {\n      const response = await apiClient.post<WhatsappTemplateResponse>(\n        \"/api/v1/whatsapp/templates\",\n        {\n          sender: flags.sender,\n          name: flags.name,\n          language: flags.language,\n          category: flags.category,\n          body: flags.body,\n          ...(flags.footer && { footer: flags.footer }),\n          ...(flags.header && { header: flags.header }),\n          ...(buttons.length > 0 && { buttons }),\n          ...(examples && { examples }),\n        },\n      );\n\n      createSpinner.stop();\n\n      if (isJsonMode()) {\n        json(response);\n        return;\n      }\n\n      success(\"Template submitted for review\", {\n        ID: colors.code(response.id),\n        Name: response.name,\n        Language: response.language,\n        Category: response.category,\n        Status: colors.warning(response.status),\n      });\n\n      (response.warnings ?? []).forEach((w) => warn(w));\n\n      console.log();\n      console.log(\n        colors.dim(\n          `Meta reviews new templates, usually within a day. Check with: ${colors.code(\"sendly whatsapp templates list\")}`,\n        ),\n      );\n    } catch (err: any) {\n      createSpinner.stop();\n\n      if (err instanceof ApiError && err.code === \"template_name_locked\") {\n        error(err.message, {\n          hint: \"Edit the existing template instead: sendly whatsapp templates update <id>\",\n        });\n      } else if (\n        err instanceof ApiError &&\n        err.code === \"template_already_exists\"\n      ) {\n        error(err.message, {\n          hint: \"Pick a different name, or edit the existing template with `sendly whatsapp templates update`\",\n        });\n      } else if (err instanceof ValidationError && err.message === \"HTTP 400\") {\n        error(\"The template failed validation checks\", {\n          hint: \"Every {{n}} needs an --example n=value; authentication templates can't contain links and need an otp button; names can't start with test/sample/demo\",\n        });\n      } else if (err.message?.includes(\"connected to WhatsApp\")) {\n        error(err.message, {\n          hint: `Connect it first: sendly whatsapp connect --number ${flags.sender}`,\n        });\n      } else {\n        throw err;\n      }\n      this.exit(1);\n    }\n  }\n}\n"]}

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

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

@@ -0,0 +1,69 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient, NotFoundError } from "../../../lib/api-client.js";
+import { success, error, json, colors, spinner, isJsonMode, } from "../../../lib/output.js";
+import { confirm } from "@inquirer/prompts";
+export default class WhatsappTemplatesDelete extends AuthenticatedCommand {
+    static description = "Delete a WhatsApp template";
+    static examples = [
+        "<%= config.bin %> whatsapp templates delete 3f6a1c9e-0000-0000-0000-000000000000",
+        "<%= config.bin %> whatsapp templates delete 3f6a1c9e-0000-0000-0000-000000000000 --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(WhatsappTemplatesDelete);
+        if (!flags.force && !isJsonMode()) {
+            const confirmed = await confirm({
+                message: `Delete WhatsApp template ${args.id}? Its name stays reserved for up to 30 days.`,
+                default: false,
+            });
+            if (!confirmed) {
+                console.log(colors.dim("Cancelled"));
+                return;
+            }
+        }
+        const deleteSpinner = spinner("Deleting template...");
+        if (!isJsonMode()) {
+            deleteSpinner.start();
+        }
+        try {
+            const response = await apiClient.delete(`/api/v1/whatsapp/templates/${encodeURIComponent(args.id)}`);
+            deleteSpinner.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Template deleted", {
+                ID: colors.code(response.id),
+            });
+            console.log();
+            console.log(colors.dim("WhatsApp reserves a deleted template's name for up to 30 days — edit an existing template rather than re-creating one under the same name."));
+        }
+        catch (err) {
+            deleteSpinner.stop();
+            if (err instanceof NotFoundError) {
+                error("Template not found", {
+                    hint: "Run `sendly whatsapp templates list` to see template ids",
+                });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

@@ -0,0 +1,77 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+import { apiClient } from "../../../lib/api-client.js";
+import { json, info, table, colors, spinner, isJsonMode, formatRelativeTime, } from "../../../lib/output.js";
+function formatTemplateStatus(status) {
+    switch (String(status).toUpperCase()) {
+        case "APPROVED":
+            return colors.success(status);
+        case "REJECTED":
+        case "DISABLED":
+            return colors.error(status);
+        case "PENDING":
+        case "PAUSED":
+            return colors.warning(status);
+        default:
+            return status;
+    }
+}
+export default class WhatsappTemplatesList extends AuthenticatedCommand {
+    static description = "List your WhatsApp message templates";
+    static examples = [
+        "<%= config.bin %> whatsapp templates list",
+        "<%= config.bin %> whatsapp templates list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        await this.parse(WhatsappTemplatesList);
+        const listSpinner = spinner("Fetching WhatsApp templates...");
+        if (!isJsonMode()) {
+            listSpinner.start();
+        }
+        const response = await apiClient
+            .get("/api/v1/whatsapp/templates")
+            .finally(() => listSpinner.stop());
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        const templates = response.templates ?? [];
+        if (templates.length === 0) {
+            info("No WhatsApp templates yet");
+            console.log(colors.dim(`Create one with: ${colors.code('sendly whatsapp templates create --sender +15551234567 --name order_update --language en_US --category utility --body "Your order {{1}} shipped" --example 1=4821')}`));
+            return;
+        }
+        table(templates, [
+            { header: "ID", key: "id", formatter: (v) => colors.code(String(v)) },
+            { header: "Name", key: "name" },
+            { header: "Language", key: "language" },
+            { header: "Category", key: "category" },
+            {
+                header: "Status",
+                key: "status",
+                formatter: (v) => formatTemplateStatus(String(v)),
+            },
+            {
+                header: "Quality",
+                key: "qualityRating",
+                formatter: (v) => (v ? String(v) : colors.dim("—")),
+            },
+            {
+                header: "Updated",
+                key: "updatedAt",
+                formatter: (v) => formatRelativeTime(String(v)),
+            },
+        ]);
+        const rejected = templates.filter((t) => t.rejectionReason);
+        if (rejected.length > 0) {
+            console.log();
+            rejected.forEach((t) => {
+                console.log(`${colors.error("✗")} ${t.name} (${t.language}): ${colors.dim(t.rejectionReason)}`);
+            });
+            console.log(colors.dim(`Edit a rejected template to resubmit it: ${colors.code("sendly whatsapp templates update <id> --body ...")}`));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../../src/commands/whatsapp/templates/list.ts"],"names":[],"mappings":"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","sourcesContent":["import { AuthenticatedCommand } from \"../../../lib/base-command.js\";\nimport { apiClient } from \"../../../lib/api-client.js\";\nimport {\n  json,\n  info,\n  table,\n  colors,\n  spinner,\n  isJsonMode,\n  formatRelativeTime,\n} from \"../../../lib/output.js\";\n\ninterface WhatsappTemplate {\n  id: string;\n  name: string;\n  language: string;\n  category: string;\n  status: string;\n  qualityRating: string | null;\n  rejectionReason: string | null;\n  createdAt: string;\n  updatedAt: string;\n}\n\ninterface ListTemplatesResponse {\n  templates: WhatsappTemplate[];\n}\n\nfunction formatTemplateStatus(status: string): string {\n  switch (String(status).toUpperCase()) {\n    case \"APPROVED\":\n      return colors.success(status);\n    case \"REJECTED\":\n    case \"DISABLED\":\n      return colors.error(status);\n    case \"PENDING\":\n    case \"PAUSED\":\n      return colors.warning(status);\n    default:\n      return status;\n  }\n}\n\nexport default class WhatsappTemplatesList extends AuthenticatedCommand {\n  static description = \"List your WhatsApp message templates\";\n\n  static examples = [\n    \"<%= config.bin %> whatsapp templates list\",\n    \"<%= config.bin %> whatsapp templates list --json\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n  };\n\n  async run(): Promise<void> {\n    await this.parse(WhatsappTemplatesList);\n\n    const listSpinner = spinner(\"Fetching WhatsApp templates...\");\n    if (!isJsonMode()) {\n      listSpinner.start();\n    }\n\n    const response = await apiClient\n      .get<ListTemplatesResponse>(\"/api/v1/whatsapp/templates\")\n      .finally(() => listSpinner.stop());\n\n    if (isJsonMode()) {\n      json(response);\n      return;\n    }\n\n    const templates = response.templates ?? [];\n    if (templates.length === 0) {\n      info(\"No WhatsApp templates yet\");\n      console.log(\n        colors.dim(\n          `Create one with: ${colors.code('sendly whatsapp templates create --sender +15551234567 --name order_update --language en_US --category utility --body \"Your order {{1}} shipped\" --example 1=4821')}`,\n        ),\n      );\n      return;\n    }\n\n    table(templates, [\n      { header: \"ID\", key: \"id\", formatter: (v) => colors.code(String(v)) },\n      { header: \"Name\", key: \"name\" },\n      { header: \"Language\", key: \"language\" },\n      { header: \"Category\", key: \"category\" },\n      {\n        header: \"Status\",\n        key: \"status\",\n        formatter: (v) => formatTemplateStatus(String(v)),\n      },\n      {\n        header: \"Quality\",\n        key: \"qualityRating\",\n        formatter: (v) => (v ? String(v) : colors.dim(\"—\")),\n      },\n      {\n        header: \"Updated\",\n        key: \"updatedAt\",\n        formatter: (v) => formatRelativeTime(String(v)),\n      },\n    ]);\n\n    const rejected = templates.filter((t) => t.rejectionReason);\n    if (rejected.length > 0) {\n      console.log();\n      rejected.forEach((t) => {\n        console.log(\n          `${colors.error(\"✗\")} ${t.name} (${t.language}): ${colors.dim(t.rejectionReason!)}`,\n        );\n      });\n      console.log(\n        colors.dim(\n          `Edit a rejected template to resubmit it: ${colors.code(\"sendly whatsapp templates update <id> --body ...\")}`,\n        ),\n      );\n    }\n  }\n}\n"]}

package/dist/commands/whatsapp/templates/update.d.ts

@@ -0,0 +1,18 @@
+import { AuthenticatedCommand } from "../../../lib/base-command.js";
+export default class WhatsappTemplatesUpdate 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: {
+        body: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        footer: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        header: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        button: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        example: 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>;
+}