@sendly/cli 3.37.1 → 3.39.0

package/dist/lib/rcs-registration.js

@@ -0,0 +1,734 @@
+/**
+ * RCS registration helpers
+ * Shapes, flag sets, body builders and output shared by the `sendly rcs`
+ * registration commands (registration, dossier, brands, agents)
+ */
+import { readFileSync } from "node:fs";
+import { Flags } from "@oclif/core";
+import { ApiError, AuthenticationError, NotFoundError, ValidationError, } from "./api-client.js";
+import { colors, error, isJsonMode, keyValue, table, formatRelativeTime, } from "./output.js";
+export const LEGAL_ENTITY_TYPES = [
+    "LIMITED_LIABILITY_COMPANY",
+    "CORPORATION",
+    "S_CORPORATION",
+    "PARTNERSHIP",
+    "SOLE_PROPRIETORSHIP",
+];
+export const ORGANIZATION_TYPES = [
+    "PRIVATE_PROFIT",
+    "PUBLIC_PROFIT",
+    "NON_PROFIT",
+    "GOVERNMENT",
+    "UNKNOWN",
+];
+export const AGENT_USE_CASES = [
+    "MULTI_USE",
+    "TRANSACTIONAL",
+    "PROMOTIONAL",
+    "OTP",
+];
+export const INTERACTION_TYPES = [
+    "TRANSACTIONAL_UPDATES",
+    "CUSTOMER_SUPPORT",
+    "ACCOUNT_ALERTS",
+    "LOYALTY_OR_REWARD",
+    "MARKETING_OR_PROMOTIONAL",
+    "TWO_WAY_CONVERSATION",
+    "OTHER",
+];
+export const OPT_IN_METHOD_TYPES = [
+    "WEBSITE",
+    "SMS",
+    "MOBILE_APP",
+    "QR_CODE",
+    "SALE_POINT",
+    "OTHER",
+];
+export const STAGE_LABELS = {
+    draft: "Draft",
+    in_review: "In review with Sendly",
+    changes_requested: "Action needed",
+    rejected: "Not approved",
+    brand_verification: "Brand verification",
+    agent_review: "Agent review",
+    testing: "Testing",
+    launch_review: "Launch review",
+    launching: "Launching",
+    launch_rejected: "Launch not approved",
+    live: "Live",
+    suspended: "Suspended",
+    failed: "Failed",
+};
+export const EARLY_ACCESS_HINT = "RCS is rolling out gradually — contact support@sendly.live for early access.";
+export const idempotencyKeyFlag = Flags.string({
+    description: "Idempotency key (1-255 printable ASCII characters). Re-running with the same key within 24 hours returns the original result instead of saving again.",
+});
+export const BRAND_FLAGS = {
+    "display-name": Flags.string({
+        description: "Brand name as customers will see it",
+    }),
+    "legal-name": Flags.string({ description: "Registered legal business name" }),
+    "legal-entity-type": Flags.string({
+        description: "Legal entity type",
+        options: [...LEGAL_ENTITY_TYPES],
+    }),
+    "organization-type": Flags.string({
+        description: "Organization type",
+        options: [...ORGANIZATION_TYPES],
+    }),
+    website: Flags.string({ description: "Business website (https)" }),
+    ein: Flags.string({ description: "EIN (123456789 or 12-3456789)" }),
+    "stock-symbol": Flags.string({
+        description: "EXCHANGE:TICKER, required for publicly traded companies",
+    }),
+    "address-line1": Flags.string({ description: "Street address" }),
+    "address-line2": Flags.string({ description: "Suite, floor, or unit" }),
+    city: Flags.string({ description: "City" }),
+    state: Flags.string({ description: "State (two-letter code)" }),
+    "postal-code": Flags.string({ description: "ZIP code" }),
+    country: Flags.string({
+        description: "Country code (US; RCS registration is US-only for now)",
+    }),
+    "contact-first-name": Flags.string({
+        description: "Brand contact first name",
+    }),
+    "contact-last-name": Flags.string({ description: "Brand contact last name" }),
+    "contact-title": Flags.string({ description: "Brand contact job title" }),
+    "contact-email": Flags.string({ description: "Brand contact email" }),
+    "contact-phone": Flags.string({
+        description: "Brand contact phone number (E.164)",
+    }),
+};
+export const BRAND_FIELD_PATHS = {
+    "display-name": ["displayName"],
+    "legal-name": ["legalName"],
+    "legal-entity-type": ["legalEntityType"],
+    "organization-type": ["organizationType"],
+    website: ["websiteUrl"],
+    ein: ["ein"],
+    "stock-symbol": ["stockSymbol"],
+    "address-line1": ["address", "line1"],
+    "address-line2": ["address", "line2"],
+    city: ["address", "city"],
+    state: ["address", "state"],
+    "postal-code": ["address", "postalCode"],
+    country: ["address", "countryCode"],
+    "contact-first-name": ["contact", "firstName"],
+    "contact-last-name": ["contact", "lastName"],
+    "contact-title": ["contact", "title"],
+    "contact-email": ["contact", "email"],
+    "contact-phone": ["contact", "phoneNumber"],
+};
+export const AGENT_BASICS_FLAGS = {
+    "display-name": Flags.string({
+        description: "Agent name shown in the conversation header (max 40 characters)",
+    }),
+    "use-case": Flags.string({
+        description: "What the agent sends",
+        options: [...AGENT_USE_CASES],
+    }),
+    description: Flags.string({
+        description: "Short description shown on the agent's info page (max 100 characters)",
+    }),
+    "logo-url": Flags.string({
+        description: "Public https:// URL of the agent logo",
+    }),
+    "hero-url": Flags.string({
+        description: "Public https:// URL of the agent hero image",
+    }),
+    "brand-color": Flags.string({ description: "Hex brand color, like #1E90FF" }),
+    "privacy-policy-url": Flags.string({
+        description: "Privacy policy URL (https)",
+    }),
+    "terms-url": Flags.string({ description: "Terms and conditions URL (https)" }),
+    phone: Flags.string({
+        description: "Contact phone number shown on the agent (E.164)",
+    }),
+    "phone-label": Flags.string({ description: "Label for the contact phone" }),
+    website: Flags.string({
+        description: "Contact website shown on the agent (https)",
+    }),
+    "website-label": Flags.string({ description: "Label for the contact website" }),
+    email: Flags.string({ description: "Contact email shown on the agent" }),
+    "email-label": Flags.string({ description: "Label for the contact email" }),
+};
+export const AGENT_BASICS_PATHS = {
+    "display-name": ["basics", "displayName"],
+    "use-case": ["basics", "useCase"],
+    description: ["basics", "description"],
+    "logo-url": ["basics", "logoUrl"],
+    "hero-url": ["basics", "heroUrl"],
+    "brand-color": ["basics", "brandColor"],
+    "privacy-policy-url": ["basics", "privacyPolicyUrl"],
+    "terms-url": ["basics", "termsAndConditionsUrl"],
+    phone: ["basics", "phoneNumber", "number"],
+    "phone-label": ["basics", "phoneNumber", "label"],
+    website: ["basics", "website", "url"],
+    "website-label": ["basics", "website", "label"],
+    email: ["basics", "email", "address"],
+    "email-label": ["basics", "email", "label"],
+};
+export const AGENT_CAMPAIGN_FLAGS = {
+    "company-overview": Flags.string({
+        description: "What your company does (launch requirement)",
+    }),
+    "agent-overview": Flags.string({
+        description: "What this agent will send and why (launch requirement)",
+    }),
+    "campaign-info": Flags.string({
+        description: "Anything else reviewers should know about the campaign",
+    }),
+    interaction: Flags.string({
+        description: 'Interaction type, optionally with a description as "TYPE=description" (repeatable; replaces the list). One of: ' +
+            INTERACTION_TYPES.join(", "),
+        multiple: true,
+    }),
+    "message-example": Flags.string({
+        description: "Example message a subscriber would receive (repeatable, at least 3 to launch; replaces the list)",
+        multiple: true,
+    }),
+    "opt-in-method": Flags.string({
+        description: 'How subscribers opt in, optionally with a description as "TYPE=description" (repeatable; replaces the list). One of: ' +
+            OPT_IN_METHOD_TYPES.join(", "),
+        multiple: true,
+    }),
+    "call-to-action": Flags.string({
+        description: "The opt-in call to action subscribers see",
+    }),
+    "call-to-action-url": Flags.string({
+        description: "Where the call to action lives (https; required for WEBSITE opt-in)",
+    }),
+    "call-to-action-media-url": Flags.string({
+        description: "Public https:// URL of a screenshot of the opt-in (required for WEBSITE and MOBILE_APP opt-in)",
+    }),
+    "double-opt-in": Flags.boolean({
+        description: "Subscribers confirm their opt-in (disable with --no-double-opt-in)",
+        allowNo: true,
+    }),
+    "double-opt-in-message": Flags.string({
+        description: "Confirmation message sent when double opt-in is enabled",
+    }),
+    "opt-in-message": Flags.string({
+        description: "Welcome message sent after opt-in",
+    }),
+    "help-response": Flags.string({ description: "Reply sent to HELP" }),
+    "opt-out-response": Flags.string({ description: "Reply sent to STOP" }),
+};
+export const AGENT_CAMPAIGN_PATHS = {
+    "company-overview": ["campaign", "companyOverview"],
+    "agent-overview": ["campaign", "agentOverview"],
+    "campaign-info": ["campaign", "additionalInformation"],
+    "call-to-action": ["campaign", "consentSettings", "callToAction"],
+    "call-to-action-url": ["campaign", "consentSettings", "callToActionUrl"],
+    "call-to-action-media-url": [
+        "campaign",
+        "consentSettings",
+        "callToActionMediaUrl",
+    ],
+    "double-opt-in-message": ["campaign", "consentSettings", "doubleOptInMessage"],
+    "opt-in-message": ["campaign", "consentSettings", "optInMessage"],
+    "help-response": ["campaign", "consentSettings", "helpResponse"],
+    "opt-out-response": ["campaign", "consentSettings", "optOutResponse"],
+};
+export const AGENT_TESTING_FLAGS = {
+    "test-url": Flags.string({
+        description: "Public https:// URL of a screen recording or screenshots of the agent on a test device",
+    }),
+    "test-message-id": Flags.string({
+        description: "Id of a message sent to a test device",
+    }),
+    "testing-info": Flags.string({
+        description: "Anything else reviewers should know about testing",
+    }),
+};
+export const AGENT_TESTING_PATHS = {
+    "test-url": ["testing", "testUrl"],
+    "test-message-id": ["testing", "messageId"],
+    "testing-info": ["testing", "additionalInformation"],
+};
+export function isDict(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function setPath(target, path, value) {
+    let current = target;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (!isDict(current[key]))
+            current[key] = {};
+        current = current[key];
+    }
+    current[path[path.length - 1]] = value;
+}
+export function getPath(source, path) {
+    let current = source;
+    for (const key of path) {
+        if (!isDict(current))
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+export function readJsonBody(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf8");
+    }
+    catch {
+        throw new ValidationError(`File not found: ${filePath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new ValidationError(`Invalid JSON in ${filePath}. Expected a JSON object.`);
+    }
+    if (!isDict(parsed)) {
+        throw new ValidationError(`Invalid JSON in ${filePath}. Expected a JSON object.`);
+    }
+    return parsed;
+}
+function unwrap(body, key) {
+    const inner = body[key];
+    return isDict(inner) ? { ...inner } : { ...body };
+}
+function applyTextFlags(body, flags, paths, clearEmpty) {
+    let touched = false;
+    for (const [flag, path] of Object.entries(paths)) {
+        const value = flags[flag];
+        if (typeof value !== "string")
+            continue;
+        if (value === "" && !clearEmpty)
+            continue;
+        setPath(body, path, value === "" ? null : value);
+        touched = true;
+    }
+    return touched;
+}
+export function buildBrandBody(flags, options) {
+    const fromJson = flags["from-json"];
+    const body = typeof fromJson === "string" ? unwrap(readJsonBody(fromJson), "brand") : {};
+    applyTextFlags(body, flags, BRAND_FIELD_PATHS, options.clearEmpty);
+    return body;
+}
+export function parseTypedList(raw, typeKey, allowed, flagName) {
+    if (!raw || raw.length === 0)
+        return [];
+    const out = [];
+    for (const item of raw) {
+        const idx = item.indexOf("=");
+        const type = (idx === -1 ? item : item.slice(0, idx)).trim().toUpperCase();
+        const description = idx === -1 ? "" : item.slice(idx + 1).trim();
+        if (!allowed.includes(type)) {
+            return `Invalid --${flagName} "${item}" — use one of ${allowed.join(", ")}, optionally as TYPE=description`;
+        }
+        const entry = { [typeKey]: type };
+        if (description)
+            entry.description = description;
+        out.push(entry);
+    }
+    return out;
+}
+export function buildAgentBody(flags, options) {
+    const fromJson = flags["from-json"];
+    const body = typeof fromJson === "string" ? unwrap(readJsonBody(fromJson), "agent") : {};
+    applyTextFlags(body, flags, AGENT_BASICS_PATHS, options.clearEmpty);
+    applyTextFlags(body, flags, AGENT_CAMPAIGN_PATHS, options.clearEmpty);
+    applyTextFlags(body, flags, AGENT_TESTING_PATHS, options.clearEmpty);
+    const interactions = parseTypedList(flags.interaction, "interactionType", INTERACTION_TYPES, "interaction");
+    if (typeof interactions === "string")
+        return interactions;
+    if (interactions.length > 0) {
+        setPath(body, ["campaign", "interactions"], interactions);
+    }
+    const optInMethods = parseTypedList(flags["opt-in-method"], "methodType", OPT_IN_METHOD_TYPES, "opt-in-method");
+    if (typeof optInMethods === "string")
+        return optInMethods;
+    if (optInMethods.length > 0) {
+        setPath(body, ["campaign", "consentSettings", "optInMethods"], optInMethods);
+    }
+    const examples = flags["message-example"];
+    if (Array.isArray(examples) && examples.length > 0) {
+        setPath(body, ["campaign", "messageExamples"], examples);
+    }
+    if (typeof flags["double-opt-in"] === "boolean") {
+        setPath(body, ["campaign", "consentSettings", "doubleOptIn"], flags["double-opt-in"]);
+    }
+    if (flags["clear-campaign"] === true)
+        body.campaign = null;
+    if (flags["clear-testing"] === true)
+        body.testing = null;
+    return body;
+}
+export function parseDeviceFlags(raw) {
+    if (!raw || raw.length === 0)
+        return [];
+    const out = [];
+    for (const item of raw) {
+        const idx = item.indexOf("=");
+        const phoneNumber = (idx === -1 ? item : item.slice(0, idx)).trim();
+        const label = idx === -1 ? "" : item.slice(idx + 1).trim();
+        if (!phoneNumber) {
+            return `Invalid --phone "${item}" — use +13125550100 or "+13125550100=Label"`;
+        }
+        out.push(label ? { phoneNumber, label } : { phoneNumber });
+    }
+    return out;
+}
+export function stageLabel(stage) {
+    return STAGE_LABELS[stage] ?? stage;
+}
+export function formatStage(stage) {
+    const label = stageLabel(stage);
+    switch (stage) {
+        case "live":
+            return colors.success(label);
+        case "rejected":
+        case "failed":
+        case "suspended":
+            return colors.error(label);
+        case "changes_requested":
+        case "launch_rejected":
+            return colors.warning(label);
+        case "testing":
+            return colors.primary(label);
+        case "draft":
+            return colors.dim(label);
+        default:
+            return colors.info(label);
+    }
+}
+export function formatReviewStatus(status) {
+    switch (status) {
+        case "rejected":
+        case "failed":
+            return colors.error(status);
+        case "changes_requested":
+        case "launch_rejected":
+            return colors.warning(status);
+        case "approved_for_carrier":
+        case "launch_submitted":
+            return colors.success(status);
+        case "draft":
+            return colors.dim(status);
+        default:
+            return colors.info(status);
+    }
+}
+export function formatSendStatus(status) {
+    switch (status) {
+        case "approved":
+            return colors.success(status);
+        case "suspended":
+            return colors.error(status);
+        case "testing":
+            return colors.primary(status);
+        case "draft":
+            return colors.dim(status);
+        default:
+            return colors.info(status);
+    }
+}
+export function nextStepFor(stage, ids) {
+    const agent = ids.agentId ?? "<agentId>";
+    const brand = ids.brandId ?? "<brandId>";
+    const code = (s) => colors.code(s);
+    switch (stage) {
+        case "draft":
+            if (!ids.brandId) {
+                return [
+                    `Prefill from what's on file: ${code("sendly rcs dossier --json > brand.json")}`,
+                    `Then draft the brand:        ${code("sendly rcs brands create --from-json brand.json")}`,
+                ];
+            }
+            if (!ids.agentId) {
+                return [
+                    `Draft the agent: ${code(`sendly rcs agents create --brand ${brand} --display-name "Acme" --use-case TRANSACTIONAL ...`)}`,
+                ];
+            }
+            return [
+                `Fill in anything missing: ${code(`sendly rcs agents update ${agent} ...`)}`,
+                `Then send it for review:  ${code(`sendly rcs agents submit ${agent}`)}`,
+            ];
+        case "in_review":
+            return [
+                "Sendly is reviewing your brand and agent; we'll email you if anything needs changing.",
+                `Check back with ${code("sendly rcs registration")}.`,
+            ];
+        case "changes_requested":
+            return [
+                "See the review note above, then update and resubmit:",
+                `  ${code(`sendly rcs brands update ${brand} ...`)} / ${code(`sendly rcs agents update ${agent} ...`)}`,
+                `  ${code(`sendly rcs agents submit ${agent}`)}`,
+            ];
+        case "rejected":
+            return [
+                "This registration wasn't approved. Reply to the review email or contact support@sendly.live.",
+            ];
+        case "brand_verification":
+        case "agent_review":
+            return [
+                "The carrier network is reviewing your registration; we'll email you when it moves.",
+                `Check back with ${code("sendly rcs registration")}.`,
+            ];
+        case "testing":
+            return [
+                `Invite test devices:   ${code(`sendly rcs agents devices set ${agent} --phone +13125550100`)}`,
+                `Send a test message:   ${code('sendly rcs send --to +13125550100 --text "Hello from testing"')}`,
+                `Then request launch:   ${code(`sendly rcs agents request-launch ${agent} --test-url https://...`)}`,
+            ];
+        case "launch_review":
+            return [
+                "Sendly is reviewing your launch request before sending it to the carrier network.",
+                `Check back with ${code("sendly rcs registration")}.`,
+            ];
+        case "launching":
+            return [
+                "The carrier network is reviewing the launch; we'll email you when the agent goes live.",
+            ];
+        case "launch_rejected":
+            return [
+                "The launch wasn't approved. See the note above, update the campaign, then request launch again:",
+                `  ${code(`sendly rcs agents update ${agent} ...`)}`,
+                `  ${code(`sendly rcs agents request-launch ${agent}`)}`,
+            ];
+        case "live":
+            return [
+                `Send with: ${code('sendly rcs send --to +13125550100 --text "Hello!"')}`,
+            ];
+        case "suspended":
+        case "failed":
+            return ["Contact support@sendly.live to get this registration moving again."];
+        default:
+            return [];
+    }
+}
+export function printNextSteps(lines) {
+    if (lines.length === 0)
+        return;
+    console.log();
+    console.log(colors.dim("Next steps:"));
+    lines.forEach((line) => console.log(`  ${line}`));
+}
+function row(key, value) {
+    return value ? [[key, value]] : [];
+}
+function printNotes(item) {
+    if (item.reviewNote) {
+        console.log();
+        console.log(colors.warning("Review note:"));
+        console.log(`  ${item.reviewNote}`);
+    }
+    if (item.rejectionReason) {
+        console.log();
+        console.log(colors.error("Rejection reason:"));
+        console.log(`  ${item.rejectionReason}`);
+    }
+}
+export function printBrand(brand) {
+    const address = brand.address ?? {};
+    const contact = brand.contact ?? {};
+    const addressLine = [
+        address.line1,
+        address.line2,
+        address.city,
+        address.state,
+        address.postalCode,
+        address.countryCode,
+    ]
+        .filter(Boolean)
+        .join(", ");
+    const contactName = [contact.firstName, contact.lastName]
+        .filter(Boolean)
+        .join(" ");
+    console.log(colors.bold(`Brand: ${brand.displayName || brand.legalName || brand.id}`));
+    console.log();
+    keyValue([
+        ["ID", brand.id],
+        ["Stage", formatStage(brand.customerStage)],
+        ["Review", formatReviewStatus(brand.reviewStatus)],
+        ...row("Legal name", brand.legalName),
+        ...row("Entity type", brand.legalEntityType),
+        ...row("Organization", brand.organizationType),
+        ...row("EIN", brand.ein),
+        ...row("Stock symbol", brand.stockSymbol),
+        ...row("Website", brand.websiteUrl),
+        ...row("Address", addressLine),
+        ...row("Contact", contactName
+            ? `${contactName}${contact.title ? `, ${contact.title}` : ""}`
+            : ""),
+        ...row("Contact email", contact.email),
+        ...row("Contact phone", contact.phoneNumber),
+        ...row("Submitted", brand.submittedForReviewAt
+            ? new Date(brand.submittedForReviewAt).toLocaleString()
+            : ""),
+        ...row("Verified", brand.verifiedAt ? new Date(brand.verifiedAt).toLocaleString() : ""),
+        ["Updated", new Date(brand.updatedAt).toLocaleString()],
+    ]);
+    printNotes(brand);
+}
+function contactLine(primary, label) {
+    if (!primary)
+        return "";
+    return label ? `${primary} (${label})` : primary;
+}
+export function printAgent(agent) {
+    const basics = agent.basics ?? {};
+    console.log(colors.bold(`Agent: ${agent.displayName || agent.id}`));
+    console.log();
+    keyValue([
+        ["ID", agent.id],
+        ["Brand", agent.brandId ?? colors.dim("—")],
+        ["Stage", formatStage(agent.customerStage)],
+        ["Review", formatReviewStatus(agent.reviewStatus)],
+        ["Send status", formatSendStatus(agent.status)],
+        ["Use case", agent.useCase ?? colors.dim("—")],
+        ...row("Description", basics.description),
+        ...row("Logo", basics.logoUrl),
+        ...row("Hero", basics.heroUrl),
+        ...row("Brand color", basics.brandColor),
+        ...row("Privacy policy", basics.privacyPolicyUrl),
+        ...row("Terms", basics.termsAndConditionsUrl),
+        ...row("Phone", contactLine(basics.phoneNumber?.number, basics.phoneNumber?.label)),
+        ...row("Website", contactLine(basics.website?.url, basics.website?.label)),
+        ...row("Email", contactLine(basics.email?.address, basics.email?.label)),
+        ...row("Test URL", agent.testing?.testUrl ? String(agent.testing.testUrl) : ""),
+        ...row("Submitted", agent.submittedForReviewAt
+            ? new Date(agent.submittedForReviewAt).toLocaleString()
+            : ""),
+        ...row("Live since", agent.liveAt ? new Date(agent.liveAt).toLocaleString() : ""),
+        ["Updated", new Date(agent.updatedAt).toLocaleString()],
+    ]);
+    const campaign = agent.campaign;
+    if (campaign) {
+        const interactions = (campaign.interactions ?? [])
+            .map((i) => i?.interactionType)
+            .filter(Boolean);
+        const examples = (campaign.messageExamples ?? []).filter(Boolean);
+        const methods = (campaign.consentSettings?.optInMethods ?? [])
+            .map((m) => m?.methodType)
+            .filter(Boolean);
+        console.log();
+        console.log(colors.dim("Campaign:"));
+        keyValue([
+            ...row("Company overview", campaign.companyOverview),
+            ...row("Agent overview", campaign.agentOverview),
+            ...row("Interactions", interactions.join(", ")),
+            ...row("Message examples", examples.length ? String(examples.length) : ""),
+            ...row("Opt-in methods", methods.join(", ")),
+            ...row("Call to action", campaign.consentSettings?.callToAction),
+            ...row("Double opt-in", typeof campaign.consentSettings?.doubleOptIn === "boolean"
+                ? campaign.consentSettings.doubleOptIn
+                    ? "yes"
+                    : "no"
+                : ""),
+        ]);
+    }
+    printNotes(agent);
+}
+export function formatInviteStatus(status) {
+    if (!status)
+        return colors.dim("not invited");
+    switch (status.toUpperCase()) {
+        case "ACCEPTED":
+        case "ACTIVE":
+            return colors.success(status);
+        case "REJECTED":
+        case "FAILED":
+        case "EXPIRED":
+            return colors.error(status);
+        default:
+            return colors.warning(status);
+    }
+}
+export function printDevices(devices) {
+    console.log();
+    console.log(colors.dim(`Test devices (${devices.length})`));
+    if (devices.length === 0) {
+        console.log(colors.dim("  none invited yet"));
+        return;
+    }
+    table(devices, [
+        {
+            header: "Phone",
+            key: "phoneNumber",
+            formatter: (v) => colors.code(String(v)),
+        },
+        {
+            header: "Label",
+            key: "label",
+            formatter: (v) => (v ? String(v) : colors.dim("—")),
+        },
+        {
+            header: "Invite",
+            key: "inviteStatus",
+            formatter: (v) => formatInviteStatus(v ? String(v) : null),
+        },
+        {
+            header: "Added",
+            key: "createdAt",
+            formatter: (v) => formatRelativeTime(String(v)),
+        },
+    ]);
+}
+export function reportRcsError(err) {
+    if (err instanceof NotFoundError) {
+        if (/isn't enabled/i.test(err.message)) {
+            error(err.message, { code: "rcs_not_enabled", hint: EARLY_ACCESS_HINT });
+            return true;
+        }
+        return false;
+    }
+    if (err instanceof AuthenticationError &&
+        /missing required scopes/i.test(err.message)) {
+        error(err.message, {
+            code: "insufficient_permissions",
+            hint: "Use an API key with the rcs:read and rcs:write scopes, or sign in with `sendly login`",
+        });
+        return true;
+    }
+    if (!(err instanceof ApiError))
+        return false;
+    switch (err.code) {
+        case "rcs_invalid_content": {
+            const fieldErrors = err.fieldErrors ?? [];
+            if (isJsonMode()) {
+                error(err.message, { code: err.code, errors: fieldErrors });
+                return true;
+            }
+            error(err.message, { code: err.code });
+            fieldErrors.forEach((issue) => console.error(`  ${colors.dim(issue.path)}  ${issue.message}`));
+            return true;
+        }
+        case "rcs_field_locked":
+            error(err.message, {
+                code: err.code,
+                hint: "Check where the registration stands with `sendly rcs registration`",
+            });
+            return true;
+        case "rcs_launch_not_ready":
+            error(err.message, {
+                code: err.code,
+                hint: "Invite a device with `sendly rcs agents devices set <agentId> --phone +13125550100`, send it a test message with `sendly rcs send`, then request launch",
+            });
+            return true;
+        case "rcs_brand_not_verified":
+            error(err.message, {
+                code: err.code,
+                hint: "See the reason with `sendly rcs registration`, fix the brand with `sendly rcs brands update <brandId>`, then submit again",
+            });
+            return true;
+        case "rcs_us_only":
+            error(err.message, { code: err.code });
+            return true;
+        case "idempotency_key_mismatch":
+            error(err.message, {
+                code: err.code,
+                hint: "An idempotency key can only replay an identical request; use a new key for a changed body",
+            });
+            return true;
+        default:
+            return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rcs-registration.js","sourceRoot":"","sources":["../../src/lib/rcs-registration.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RCS registration helpers\n * Shapes, flag sets, body builders and output shared by the `sendly rcs`\n * registration commands (registration, dossier, brands, agents)\n */\n\nimport { readFileSync } from \"node:fs\";\nimport { Flags } from \"@oclif/core\";\nimport {\n  ApiError,\n  AuthenticationError,\n  NotFoundError,\n  ValidationError,\n} from \"./api-client.js\";\nimport {\n  colors,\n  error,\n  isJsonMode,\n  keyValue,\n  table,\n  formatRelativeTime,\n} from \"./output.js\";\n\nexport type CustomerStage =\n  | \"draft\"\n  | \"in_review\"\n  | \"changes_requested\"\n  | \"rejected\"\n  | \"brand_verification\"\n  | \"agent_review\"\n  | \"testing\"\n  | \"launch_review\"\n  | \"launching\"\n  | \"launch_rejected\"\n  | \"live\"\n  | \"suspended\"\n  | \"failed\";\n\nexport interface PublicRcsBrand {\n  id: string;\n  reviewStatus: string;\n  customerStage: CustomerStage;\n  displayName: string;\n  legalName: string;\n  legalEntityType: string;\n  organizationType: string;\n  stockSymbol: string | null;\n  websiteUrl: string;\n  ein: string;\n  address: {\n    line1: string;\n    line2: string | null;\n    city: string;\n    state: string;\n    postalCode: string;\n    countryCode: string;\n  };\n  contact: {\n    firstName: string;\n    lastName: string;\n    title: string | null;\n    email: string;\n    phoneNumber: string;\n  };\n  reviewNote: string | null;\n  rejectionReason: string | null;\n  submittedForReviewAt: string | null;\n  sentToCarrierAt: string | null;\n  verifiedAt: string | null;\n  createdAt: string;\n  updatedAt: string;\n}\n\nexport interface PublicRcsTestDevice {\n  id: string;\n  phoneNumber: string;\n  label: string | null;\n  inviteStatus: string | null;\n  createdAt: string;\n}\n\nexport interface RcsAgentBasics {\n  displayName?: string | null;\n  useCase?: string | null;\n  hostingRegion?: string | null;\n  description?: string | null;\n  logoUrl?: string | null;\n  heroUrl?: string | null;\n  brandColor?: string | null;\n  privacyPolicyUrl?: string | null;\n  termsAndConditionsUrl?: string | null;\n  phoneNumber?: { number?: string | null; label?: string | null } | null;\n  website?: { url?: string | null; label?: string | null } | null;\n  email?: { address?: string | null; label?: string | null } | null;\n}\n\nexport interface RcsCampaign {\n  companyOverview?: string | null;\n  agentOverview?: string | null;\n  interactions?: Array<{\n    interactionType?: string | null;\n    description?: string | null;\n  } | null> | null;\n  messageExamples?: Array<string | null> | null;\n  consentSettings?: {\n    optInMethods?: Array<{\n      methodType?: string | null;\n      description?: string | null;\n    } | null> | null;\n    callToAction?: string | null;\n    callToActionUrl?: string | null;\n    callToActionMediaUrl?: string | null;\n    doubleOptIn?: boolean | null;\n    doubleOptInMessage?: string | null;\n    optInMessage?: string | null;\n    helpResponse?: string | null;\n    optOutResponse?: string | null;\n  } | null;\n  additionalInformation?: string | null;\n}\n\nexport interface RcsTesting {\n  testUrl?: string | null;\n  messageId?: string | null;\n  additionalInformation?: string | null;\n}\n\nexport interface PublicRcsAgent {\n  id: string;\n  brandId: string | null;\n  status: string;\n  reviewStatus: string;\n  customerStage: CustomerStage;\n  displayName: string;\n  useCase: string | null;\n  hostingRegion: string | null;\n  basics: RcsAgentBasics;\n  campaign: RcsCampaign | null;\n  testing: RcsTesting | null;\n  reviewNote: string | null;\n  rejectionReason: string | null;\n  testDevices: PublicRcsTestDevice[];\n  submittedForReviewAt: string | null;\n  basicsSubmittedAt: string | null;\n  launchSubmittedAt: string | null;\n  liveAt: string | null;\n  createdAt: string;\n  updatedAt: string;\n}\n\nexport interface RegistrationResponse {\n  brand: PublicRcsBrand | null;\n  agent: PublicRcsAgent | null;\n  devices: PublicRcsTestDevice[];\n  stage: CustomerStage;\n  usEligible: boolean;\n}\n\nexport interface DossierResponse {\n  brand: Record<string, unknown>;\n  usEligible: boolean;\n  source: \"tendlc\" | \"verification\" | \"none\";\n}\n\nexport type Dict = Record<string, unknown>;\n\nexport const LEGAL_ENTITY_TYPES = [\n  \"LIMITED_LIABILITY_COMPANY\",\n  \"CORPORATION\",\n  \"S_CORPORATION\",\n  \"PARTNERSHIP\",\n  \"SOLE_PROPRIETORSHIP\",\n] as const;\n\nexport const ORGANIZATION_TYPES = [\n  \"PRIVATE_PROFIT\",\n  \"PUBLIC_PROFIT\",\n  \"NON_PROFIT\",\n  \"GOVERNMENT\",\n  \"UNKNOWN\",\n] as const;\n\nexport const AGENT_USE_CASES = [\n  \"MULTI_USE\",\n  \"TRANSACTIONAL\",\n  \"PROMOTIONAL\",\n  \"OTP\",\n] as const;\n\nexport const INTERACTION_TYPES = [\n  \"TRANSACTIONAL_UPDATES\",\n  \"CUSTOMER_SUPPORT\",\n  \"ACCOUNT_ALERTS\",\n  \"LOYALTY_OR_REWARD\",\n  \"MARKETING_OR_PROMOTIONAL\",\n  \"TWO_WAY_CONVERSATION\",\n  \"OTHER\",\n] as const;\n\nexport const OPT_IN_METHOD_TYPES = [\n  \"WEBSITE\",\n  \"SMS\",\n  \"MOBILE_APP\",\n  \"QR_CODE\",\n  \"SALE_POINT\",\n  \"OTHER\",\n] as const;\n\nexport const STAGE_LABELS: Record<CustomerStage, string> = {\n  draft: \"Draft\",\n  in_review: \"In review with Sendly\",\n  changes_requested: \"Action needed\",\n  rejected: \"Not approved\",\n  brand_verification: \"Brand verification\",\n  agent_review: \"Agent review\",\n  testing: \"Testing\",\n  launch_review: \"Launch review\",\n  launching: \"Launching\",\n  launch_rejected: \"Launch not approved\",\n  live: \"Live\",\n  suspended: \"Suspended\",\n  failed: \"Failed\",\n};\n\nexport const EARLY_ACCESS_HINT =\n  \"RCS is rolling out gradually — contact support@sendly.live for early access.\";\n\nexport const idempotencyKeyFlag = Flags.string({\n  description:\n    \"Idempotency key (1-255 printable ASCII characters). Re-running with the same key within 24 hours returns the original result instead of saving again.\",\n});\n\nexport const BRAND_FLAGS = {\n  \"display-name\": Flags.string({\n    description: \"Brand name as customers will see it\",\n  }),\n  \"legal-name\": Flags.string({ description: \"Registered legal business name\" }),\n  \"legal-entity-type\": Flags.string({\n    description: \"Legal entity type\",\n    options: [...LEGAL_ENTITY_TYPES],\n  }),\n  \"organization-type\": Flags.string({\n    description: \"Organization type\",\n    options: [...ORGANIZATION_TYPES],\n  }),\n  website: Flags.string({ description: \"Business website (https)\" }),\n  ein: Flags.string({ description: \"EIN (123456789 or 12-3456789)\" }),\n  \"stock-symbol\": Flags.string({\n    description: \"EXCHANGE:TICKER, required for publicly traded companies\",\n  }),\n  \"address-line1\": Flags.string({ description: \"Street address\" }),\n  \"address-line2\": Flags.string({ description: \"Suite, floor, or unit\" }),\n  city: Flags.string({ description: \"City\" }),\n  state: Flags.string({ description: \"State (two-letter code)\" }),\n  \"postal-code\": Flags.string({ description: \"ZIP code\" }),\n  country: Flags.string({\n    description: \"Country code (US; RCS registration is US-only for now)\",\n  }),\n  \"contact-first-name\": Flags.string({\n    description: \"Brand contact first name\",\n  }),\n  \"contact-last-name\": Flags.string({ description: \"Brand contact last name\" }),\n  \"contact-title\": Flags.string({ description: \"Brand contact job title\" }),\n  \"contact-email\": Flags.string({ description: \"Brand contact email\" }),\n  \"contact-phone\": Flags.string({\n    description: \"Brand contact phone number (E.164)\",\n  }),\n};\n\nexport const BRAND_FIELD_PATHS: Record<string, string[]> = {\n  \"display-name\": [\"displayName\"],\n  \"legal-name\": [\"legalName\"],\n  \"legal-entity-type\": [\"legalEntityType\"],\n  \"organization-type\": [\"organizationType\"],\n  website: [\"websiteUrl\"],\n  ein: [\"ein\"],\n  \"stock-symbol\": [\"stockSymbol\"],\n  \"address-line1\": [\"address\", \"line1\"],\n  \"address-line2\": [\"address\", \"line2\"],\n  city: [\"address\", \"city\"],\n  state: [\"address\", \"state\"],\n  \"postal-code\": [\"address\", \"postalCode\"],\n  country: [\"address\", \"countryCode\"],\n  \"contact-first-name\": [\"contact\", \"firstName\"],\n  \"contact-last-name\": [\"contact\", \"lastName\"],\n  \"contact-title\": [\"contact\", \"title\"],\n  \"contact-email\": [\"contact\", \"email\"],\n  \"contact-phone\": [\"contact\", \"phoneNumber\"],\n};\n\nexport const AGENT_BASICS_FLAGS = {\n  \"display-name\": Flags.string({\n    description: \"Agent name shown in the conversation header (max 40 characters)\",\n  }),\n  \"use-case\": Flags.string({\n    description: \"What the agent sends\",\n    options: [...AGENT_USE_CASES],\n  }),\n  description: Flags.string({\n    description: \"Short description shown on the agent's info page (max 100 characters)\",\n  }),\n  \"logo-url\": Flags.string({\n    description: \"Public https:// URL of the agent logo\",\n  }),\n  \"hero-url\": Flags.string({\n    description: \"Public https:// URL of the agent hero image\",\n  }),\n  \"brand-color\": Flags.string({ description: \"Hex brand color, like #1E90FF\" }),\n  \"privacy-policy-url\": Flags.string({\n    description: \"Privacy policy URL (https)\",\n  }),\n  \"terms-url\": Flags.string({ description: \"Terms and conditions URL (https)\" }),\n  phone: Flags.string({\n    description: \"Contact phone number shown on the agent (E.164)\",\n  }),\n  \"phone-label\": Flags.string({ description: \"Label for the contact phone\" }),\n  website: Flags.string({\n    description: \"Contact website shown on the agent (https)\",\n  }),\n  \"website-label\": Flags.string({ description: \"Label for the contact website\" }),\n  email: Flags.string({ description: \"Contact email shown on the agent\" }),\n  \"email-label\": Flags.string({ description: \"Label for the contact email\" }),\n};\n\nexport const AGENT_BASICS_PATHS: Record<string, string[]> = {\n  \"display-name\": [\"basics\", \"displayName\"],\n  \"use-case\": [\"basics\", \"useCase\"],\n  description: [\"basics\", \"description\"],\n  \"logo-url\": [\"basics\", \"logoUrl\"],\n  \"hero-url\": [\"basics\", \"heroUrl\"],\n  \"brand-color\": [\"basics\", \"brandColor\"],\n  \"privacy-policy-url\": [\"basics\", \"privacyPolicyUrl\"],\n  \"terms-url\": [\"basics\", \"termsAndConditionsUrl\"],\n  phone: [\"basics\", \"phoneNumber\", \"number\"],\n  \"phone-label\": [\"basics\", \"phoneNumber\", \"label\"],\n  website: [\"basics\", \"website\", \"url\"],\n  \"website-label\": [\"basics\", \"website\", \"label\"],\n  email: [\"basics\", \"email\", \"address\"],\n  \"email-label\": [\"basics\", \"email\", \"label\"],\n};\n\nexport const AGENT_CAMPAIGN_FLAGS = {\n  \"company-overview\": Flags.string({\n    description: \"What your company does (launch requirement)\",\n  }),\n  \"agent-overview\": Flags.string({\n    description: \"What this agent will send and why (launch requirement)\",\n  }),\n  \"campaign-info\": Flags.string({\n    description: \"Anything else reviewers should know about the campaign\",\n  }),\n  interaction: Flags.string({\n    description:\n      'Interaction type, optionally with a description as \"TYPE=description\" (repeatable; replaces the list). One of: ' +\n      INTERACTION_TYPES.join(\", \"),\n    multiple: true,\n  }),\n  \"message-example\": Flags.string({\n    description:\n      \"Example message a subscriber would receive (repeatable, at least 3 to launch; replaces the list)\",\n    multiple: true,\n  }),\n  \"opt-in-method\": Flags.string({\n    description:\n      'How subscribers opt in, optionally with a description as \"TYPE=description\" (repeatable; replaces the list). One of: ' +\n      OPT_IN_METHOD_TYPES.join(\", \"),\n    multiple: true,\n  }),\n  \"call-to-action\": Flags.string({\n    description: \"The opt-in call to action subscribers see\",\n  }),\n  \"call-to-action-url\": Flags.string({\n    description: \"Where the call to action lives (https; required for WEBSITE opt-in)\",\n  }),\n  \"call-to-action-media-url\": Flags.string({\n    description:\n      \"Public https:// URL of a screenshot of the opt-in (required for WEBSITE and MOBILE_APP opt-in)\",\n  }),\n  \"double-opt-in\": Flags.boolean({\n    description: \"Subscribers confirm their opt-in (disable with --no-double-opt-in)\",\n    allowNo: true,\n  }),\n  \"double-opt-in-message\": Flags.string({\n    description: \"Confirmation message sent when double opt-in is enabled\",\n  }),\n  \"opt-in-message\": Flags.string({\n    description: \"Welcome message sent after opt-in\",\n  }),\n  \"help-response\": Flags.string({ description: \"Reply sent to HELP\" }),\n  \"opt-out-response\": Flags.string({ description: \"Reply sent to STOP\" }),\n};\n\nexport const AGENT_CAMPAIGN_PATHS: Record<string, string[]> = {\n  \"company-overview\": [\"campaign\", \"companyOverview\"],\n  \"agent-overview\": [\"campaign\", \"agentOverview\"],\n  \"campaign-info\": [\"campaign\", \"additionalInformation\"],\n  \"call-to-action\": [\"campaign\", \"consentSettings\", \"callToAction\"],\n  \"call-to-action-url\": [\"campaign\", \"consentSettings\", \"callToActionUrl\"],\n  \"call-to-action-media-url\": [\n    \"campaign\",\n    \"consentSettings\",\n    \"callToActionMediaUrl\",\n  ],\n  \"double-opt-in-message\": [\"campaign\", \"consentSettings\", \"doubleOptInMessage\"],\n  \"opt-in-message\": [\"campaign\", \"consentSettings\", \"optInMessage\"],\n  \"help-response\": [\"campaign\", \"consentSettings\", \"helpResponse\"],\n  \"opt-out-response\": [\"campaign\", \"consentSettings\", \"optOutResponse\"],\n};\n\nexport const AGENT_TESTING_FLAGS = {\n  \"test-url\": Flags.string({\n    description:\n      \"Public https:// URL of a screen recording or screenshots of the agent on a test device\",\n  }),\n  \"test-message-id\": Flags.string({\n    description: \"Id of a message sent to a test device\",\n  }),\n  \"testing-info\": Flags.string({\n    description: \"Anything else reviewers should know about testing\",\n  }),\n};\n\nexport const AGENT_TESTING_PATHS: Record<string, string[]> = {\n  \"test-url\": [\"testing\", \"testUrl\"],\n  \"test-message-id\": [\"testing\", \"messageId\"],\n  \"testing-info\": [\"testing\", \"additionalInformation\"],\n};\n\nexport function isDict(value: unknown): value is Dict {\n  return !!value && typeof value === \"object\" && !Array.isArray(value);\n}\n\nexport function setPath(target: Dict, path: string[], value: unknown): void {\n  let current = target;\n  for (let i = 0; i < path.length - 1; i++) {\n    const key = path[i];\n    if (!isDict(current[key])) current[key] = {};\n    current = current[key] as Dict;\n  }\n  current[path[path.length - 1]] = value;\n}\n\nexport function getPath(source: Dict, path: string[]): unknown {\n  let current: unknown = source;\n  for (const key of path) {\n    if (!isDict(current)) return undefined;\n    current = current[key];\n  }\n  return current;\n}\n\nexport function readJsonBody(filePath: string): Dict {\n  let raw: string;\n  try {\n    raw = readFileSync(filePath, \"utf8\");\n  } catch {\n    throw new ValidationError(`File not found: ${filePath}`);\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch {\n    throw new ValidationError(\n      `Invalid JSON in ${filePath}. Expected a JSON object.`,\n    );\n  }\n  if (!isDict(parsed)) {\n    throw new ValidationError(\n      `Invalid JSON in ${filePath}. Expected a JSON object.`,\n    );\n  }\n  return parsed;\n}\n\nfunction unwrap(body: Dict, key: string): Dict {\n  const inner = body[key];\n  return isDict(inner) ? { ...inner } : { ...body };\n}\n\nfunction applyTextFlags(\n  body: Dict,\n  flags: Dict,\n  paths: Record<string, string[]>,\n  clearEmpty: boolean,\n): boolean {\n  let touched = false;\n  for (const [flag, path] of Object.entries(paths)) {\n    const value = flags[flag];\n    if (typeof value !== \"string\") continue;\n    if (value === \"\" && !clearEmpty) continue;\n    setPath(body, path, value === \"\" ? null : value);\n    touched = true;\n  }\n  return touched;\n}\n\nexport interface BuildOptions {\n  clearEmpty: boolean;\n}\n\nexport function buildBrandBody(flags: Dict, options: BuildOptions): Dict {\n  const fromJson = flags[\"from-json\"];\n  const body: Dict =\n    typeof fromJson === \"string\" ? unwrap(readJsonBody(fromJson), \"brand\") : {};\n  applyTextFlags(body, flags, BRAND_FIELD_PATHS, options.clearEmpty);\n  return body;\n}\n\nexport function parseTypedList(\n  raw: string[] | undefined,\n  typeKey: string,\n  allowed: readonly string[],\n  flagName: string,\n): Array<Record<string, string>> | string {\n  if (!raw || raw.length === 0) return [];\n  const out: Array<Record<string, string>> = [];\n  for (const item of raw) {\n    const idx = item.indexOf(\"=\");\n    const type = (idx === -1 ? item : item.slice(0, idx)).trim().toUpperCase();\n    const description = idx === -1 ? \"\" : item.slice(idx + 1).trim();\n    if (!allowed.includes(type)) {\n      return `Invalid --${flagName} \"${item}\" — use one of ${allowed.join(\", \")}, optionally as TYPE=description`;\n    }\n    const entry: Record<string, string> = { [typeKey]: type };\n    if (description) entry.description = description;\n    out.push(entry);\n  }\n  return out;\n}\n\nexport function buildAgentBody(\n  flags: Dict,\n  options: BuildOptions,\n): Dict | string {\n  const fromJson = flags[\"from-json\"];\n  const body: Dict =\n    typeof fromJson === \"string\" ? unwrap(readJsonBody(fromJson), \"agent\") : {};\n\n  applyTextFlags(body, flags, AGENT_BASICS_PATHS, options.clearEmpty);\n  applyTextFlags(body, flags, AGENT_CAMPAIGN_PATHS, options.clearEmpty);\n  applyTextFlags(body, flags, AGENT_TESTING_PATHS, options.clearEmpty);\n\n  const interactions = parseTypedList(\n    flags.interaction as string[] | undefined,\n    \"interactionType\",\n    INTERACTION_TYPES,\n    \"interaction\",\n  );\n  if (typeof interactions === \"string\") return interactions;\n  if (interactions.length > 0) {\n    setPath(body, [\"campaign\", \"interactions\"], interactions);\n  }\n\n  const optInMethods = parseTypedList(\n    flags[\"opt-in-method\"] as string[] | undefined,\n    \"methodType\",\n    OPT_IN_METHOD_TYPES,\n    \"opt-in-method\",\n  );\n  if (typeof optInMethods === \"string\") return optInMethods;\n  if (optInMethods.length > 0) {\n    setPath(body, [\"campaign\", \"consentSettings\", \"optInMethods\"], optInMethods);\n  }\n\n  const examples = flags[\"message-example\"];\n  if (Array.isArray(examples) && examples.length > 0) {\n    setPath(body, [\"campaign\", \"messageExamples\"], examples);\n  }\n\n  if (typeof flags[\"double-opt-in\"] === \"boolean\") {\n    setPath(\n      body,\n      [\"campaign\", \"consentSettings\", \"doubleOptIn\"],\n      flags[\"double-opt-in\"],\n    );\n  }\n\n  if (flags[\"clear-campaign\"] === true) body.campaign = null;\n  if (flags[\"clear-testing\"] === true) body.testing = null;\n\n  return body;\n}\n\nexport function parseDeviceFlags(\n  raw: string[] | undefined,\n): Array<{ phoneNumber: string; label?: string }> | string {\n  if (!raw || raw.length === 0) return [];\n  const out: Array<{ phoneNumber: string; label?: string }> = [];\n  for (const item of raw) {\n    const idx = item.indexOf(\"=\");\n    const phoneNumber = (idx === -1 ? item : item.slice(0, idx)).trim();\n    const label = idx === -1 ? \"\" : item.slice(idx + 1).trim();\n    if (!phoneNumber) {\n      return `Invalid --phone \"${item}\" — use +13125550100 or \"+13125550100=Label\"`;\n    }\n    out.push(label ? { phoneNumber, label } : { phoneNumber });\n  }\n  return out;\n}\n\nexport function stageLabel(stage: string): string {\n  return STAGE_LABELS[stage as CustomerStage] ?? stage;\n}\n\nexport function formatStage(stage: string): string {\n  const label = stageLabel(stage);\n  switch (stage) {\n    case \"live\":\n      return colors.success(label);\n    case \"rejected\":\n    case \"failed\":\n    case \"suspended\":\n      return colors.error(label);\n    case \"changes_requested\":\n    case \"launch_rejected\":\n      return colors.warning(label);\n    case \"testing\":\n      return colors.primary(label);\n    case \"draft\":\n      return colors.dim(label);\n    default:\n      return colors.info(label);\n  }\n}\n\nexport function formatReviewStatus(status: string): string {\n  switch (status) {\n    case \"rejected\":\n    case \"failed\":\n      return colors.error(status);\n    case \"changes_requested\":\n    case \"launch_rejected\":\n      return colors.warning(status);\n    case \"approved_for_carrier\":\n    case \"launch_submitted\":\n      return colors.success(status);\n    case \"draft\":\n      return colors.dim(status);\n    default:\n      return colors.info(status);\n  }\n}\n\nexport function formatSendStatus(status: string): string {\n  switch (status) {\n    case \"approved\":\n      return colors.success(status);\n    case \"suspended\":\n      return colors.error(status);\n    case \"testing\":\n      return colors.primary(status);\n    case \"draft\":\n      return colors.dim(status);\n    default:\n      return colors.info(status);\n  }\n}\n\nexport function nextStepFor(\n  stage: string,\n  ids: { brandId?: string | null; agentId?: string | null },\n): string[] {\n  const agent = ids.agentId ?? \"<agentId>\";\n  const brand = ids.brandId ?? \"<brandId>\";\n  const code = (s: string) => colors.code(s);\n  switch (stage) {\n    case \"draft\":\n      if (!ids.brandId) {\n        return [\n          `Prefill from what's on file: ${code(\"sendly rcs dossier --json > brand.json\")}`,\n          `Then draft the brand:        ${code(\"sendly rcs brands create --from-json brand.json\")}`,\n        ];\n      }\n      if (!ids.agentId) {\n        return [\n          `Draft the agent: ${code(`sendly rcs agents create --brand ${brand} --display-name \"Acme\" --use-case TRANSACTIONAL ...`)}`,\n        ];\n      }\n      return [\n        `Fill in anything missing: ${code(`sendly rcs agents update ${agent} ...`)}`,\n        `Then send it for review:  ${code(`sendly rcs agents submit ${agent}`)}`,\n      ];\n    case \"in_review\":\n      return [\n        \"Sendly is reviewing your brand and agent; we'll email you if anything needs changing.\",\n        `Check back with ${code(\"sendly rcs registration\")}.`,\n      ];\n    case \"changes_requested\":\n      return [\n        \"See the review note above, then update and resubmit:\",\n        `  ${code(`sendly rcs brands update ${brand} ...`)} / ${code(`sendly rcs agents update ${agent} ...`)}`,\n        `  ${code(`sendly rcs agents submit ${agent}`)}`,\n      ];\n    case \"rejected\":\n      return [\n        \"This registration wasn't approved. Reply to the review email or contact support@sendly.live.\",\n      ];\n    case \"brand_verification\":\n    case \"agent_review\":\n      return [\n        \"The carrier network is reviewing your registration; we'll email you when it moves.\",\n        `Check back with ${code(\"sendly rcs registration\")}.`,\n      ];\n    case \"testing\":\n      return [\n        `Invite test devices:   ${code(`sendly rcs agents devices set ${agent} --phone +13125550100`)}`,\n        `Send a test message:   ${code('sendly rcs send --to +13125550100 --text \"Hello from testing\"')}`,\n        `Then request launch:   ${code(`sendly rcs agents request-launch ${agent} --test-url https://...`)}`,\n      ];\n    case \"launch_review\":\n      return [\n        \"Sendly is reviewing your launch request before sending it to the carrier network.\",\n        `Check back with ${code(\"sendly rcs registration\")}.`,\n      ];\n    case \"launching\":\n      return [\n        \"The carrier network is reviewing the launch; we'll email you when the agent goes live.\",\n      ];\n    case \"launch_rejected\":\n      return [\n        \"The launch wasn't approved. See the note above, update the campaign, then request launch again:\",\n        `  ${code(`sendly rcs agents update ${agent} ...`)}`,\n        `  ${code(`sendly rcs agents request-launch ${agent}`)}`,\n      ];\n    case \"live\":\n      return [\n        `Send with: ${code('sendly rcs send --to +13125550100 --text \"Hello!\"')}`,\n      ];\n    case \"suspended\":\n    case \"failed\":\n      return [\"Contact support@sendly.live to get this registration moving again.\"];\n    default:\n      return [];\n  }\n}\n\nexport function printNextSteps(lines: string[]): void {\n  if (lines.length === 0) return;\n  console.log();\n  console.log(colors.dim(\"Next steps:\"));\n  lines.forEach((line) => console.log(`  ${line}`));\n}\n\nfunction row(key: string, value: string | null | undefined): [string, string][] {\n  return value ? [[key, value]] : [];\n}\n\nfunction printNotes(item: {\n  reviewNote: string | null;\n  rejectionReason: string | null;\n}): void {\n  if (item.reviewNote) {\n    console.log();\n    console.log(colors.warning(\"Review note:\"));\n    console.log(`  ${item.reviewNote}`);\n  }\n  if (item.rejectionReason) {\n    console.log();\n    console.log(colors.error(\"Rejection reason:\"));\n    console.log(`  ${item.rejectionReason}`);\n  }\n}\n\nexport function printBrand(brand: PublicRcsBrand): void {\n  const address = brand.address ?? {};\n  const contact = brand.contact ?? {};\n  const addressLine = [\n    address.line1,\n    address.line2,\n    address.city,\n    address.state,\n    address.postalCode,\n    address.countryCode,\n  ]\n    .filter(Boolean)\n    .join(\", \");\n  const contactName = [contact.firstName, contact.lastName]\n    .filter(Boolean)\n    .join(\" \");\n\n  console.log(\n    colors.bold(`Brand: ${brand.displayName || brand.legalName || brand.id}`),\n  );\n  console.log();\n  keyValue([\n    [\"ID\", brand.id],\n    [\"Stage\", formatStage(brand.customerStage)],\n    [\"Review\", formatReviewStatus(brand.reviewStatus)],\n    ...row(\"Legal name\", brand.legalName),\n    ...row(\"Entity type\", brand.legalEntityType),\n    ...row(\"Organization\", brand.organizationType),\n    ...row(\"EIN\", brand.ein),\n    ...row(\"Stock symbol\", brand.stockSymbol),\n    ...row(\"Website\", brand.websiteUrl),\n    ...row(\"Address\", addressLine),\n    ...row(\n      \"Contact\",\n      contactName\n        ? `${contactName}${contact.title ? `, ${contact.title}` : \"\"}`\n        : \"\",\n    ),\n    ...row(\"Contact email\", contact.email),\n    ...row(\"Contact phone\", contact.phoneNumber),\n    ...row(\n      \"Submitted\",\n      brand.submittedForReviewAt\n        ? new Date(brand.submittedForReviewAt).toLocaleString()\n        : \"\",\n    ),\n    ...row(\n      \"Verified\",\n      brand.verifiedAt ? new Date(brand.verifiedAt).toLocaleString() : \"\",\n    ),\n    [\"Updated\", new Date(brand.updatedAt).toLocaleString()],\n  ]);\n  printNotes(brand);\n}\n\nfunction contactLine(\n  primary: string | null | undefined,\n  label: string | null | undefined,\n): string {\n  if (!primary) return \"\";\n  return label ? `${primary} (${label})` : primary;\n}\n\nexport function printAgent(agent: PublicRcsAgent): void {\n  const basics = agent.basics ?? {};\n  console.log(colors.bold(`Agent: ${agent.displayName || agent.id}`));\n  console.log();\n  keyValue([\n    [\"ID\", agent.id],\n    [\"Brand\", agent.brandId ?? colors.dim(\"—\")],\n    [\"Stage\", formatStage(agent.customerStage)],\n    [\"Review\", formatReviewStatus(agent.reviewStatus)],\n    [\"Send status\", formatSendStatus(agent.status)],\n    [\"Use case\", agent.useCase ?? colors.dim(\"—\")],\n    ...row(\"Description\", basics.description),\n    ...row(\"Logo\", basics.logoUrl),\n    ...row(\"Hero\", basics.heroUrl),\n    ...row(\"Brand color\", basics.brandColor),\n    ...row(\"Privacy policy\", basics.privacyPolicyUrl),\n    ...row(\"Terms\", basics.termsAndConditionsUrl),\n    ...row(\n      \"Phone\",\n      contactLine(basics.phoneNumber?.number, basics.phoneNumber?.label),\n    ),\n    ...row(\"Website\", contactLine(basics.website?.url, basics.website?.label)),\n    ...row(\"Email\", contactLine(basics.email?.address, basics.email?.label)),\n    ...row(\n      \"Test URL\",\n      agent.testing?.testUrl ? String(agent.testing.testUrl) : \"\",\n    ),\n    ...row(\n      \"Submitted\",\n      agent.submittedForReviewAt\n        ? new Date(agent.submittedForReviewAt).toLocaleString()\n        : \"\",\n    ),\n    ...row(\n      \"Live since\",\n      agent.liveAt ? new Date(agent.liveAt).toLocaleString() : \"\",\n    ),\n    [\"Updated\", new Date(agent.updatedAt).toLocaleString()],\n  ]);\n\n  const campaign = agent.campaign;\n  if (campaign) {\n    const interactions = (campaign.interactions ?? [])\n      .map((i) => i?.interactionType)\n      .filter(Boolean);\n    const examples = (campaign.messageExamples ?? []).filter(Boolean);\n    const methods = (campaign.consentSettings?.optInMethods ?? [])\n      .map((m) => m?.methodType)\n      .filter(Boolean);\n    console.log();\n    console.log(colors.dim(\"Campaign:\"));\n    keyValue([\n      ...row(\"Company overview\", campaign.companyOverview),\n      ...row(\"Agent overview\", campaign.agentOverview),\n      ...row(\"Interactions\", interactions.join(\", \")),\n      ...row(\"Message examples\", examples.length ? String(examples.length) : \"\"),\n      ...row(\"Opt-in methods\", methods.join(\", \")),\n      ...row(\"Call to action\", campaign.consentSettings?.callToAction),\n      ...row(\n        \"Double opt-in\",\n        typeof campaign.consentSettings?.doubleOptIn === \"boolean\"\n          ? campaign.consentSettings.doubleOptIn\n            ? \"yes\"\n            : \"no\"\n          : \"\",\n      ),\n    ]);\n  }\n\n  printNotes(agent);\n}\n\nexport function formatInviteStatus(status: string | null): string {\n  if (!status) return colors.dim(\"not invited\");\n  switch (status.toUpperCase()) {\n    case \"ACCEPTED\":\n    case \"ACTIVE\":\n      return colors.success(status);\n    case \"REJECTED\":\n    case \"FAILED\":\n    case \"EXPIRED\":\n      return colors.error(status);\n    default:\n      return colors.warning(status);\n  }\n}\n\nexport function printDevices(devices: PublicRcsTestDevice[]): void {\n  console.log();\n  console.log(colors.dim(`Test devices (${devices.length})`));\n  if (devices.length === 0) {\n    console.log(colors.dim(\"  none invited yet\"));\n    return;\n  }\n  table(devices, [\n    {\n      header: \"Phone\",\n      key: \"phoneNumber\",\n      formatter: (v) => colors.code(String(v)),\n    },\n    {\n      header: \"Label\",\n      key: \"label\",\n      formatter: (v) => (v ? String(v) : colors.dim(\"—\")),\n    },\n    {\n      header: \"Invite\",\n      key: \"inviteStatus\",\n      formatter: (v) => formatInviteStatus(v ? String(v) : null),\n    },\n    {\n      header: \"Added\",\n      key: \"createdAt\",\n      formatter: (v) => formatRelativeTime(String(v)),\n    },\n  ]);\n}\n\nexport function reportRcsError(err: unknown): boolean {\n  if (err instanceof NotFoundError) {\n    if (/isn't enabled/i.test(err.message)) {\n      error(err.message, { code: \"rcs_not_enabled\", hint: EARLY_ACCESS_HINT });\n      return true;\n    }\n    return false;\n  }\n\n  if (\n    err instanceof AuthenticationError &&\n    /missing required scopes/i.test(err.message)\n  ) {\n    error(err.message, {\n      code: \"insufficient_permissions\",\n      hint: \"Use an API key with the rcs:read and rcs:write scopes, or sign in with `sendly login`\",\n    });\n    return true;\n  }\n\n  if (!(err instanceof ApiError)) return false;\n\n  switch (err.code) {\n    case \"rcs_invalid_content\": {\n      const fieldErrors = err.fieldErrors ?? [];\n      if (isJsonMode()) {\n        error(err.message, { code: err.code, errors: fieldErrors });\n        return true;\n      }\n      error(err.message, { code: err.code });\n      fieldErrors.forEach((issue) =>\n        console.error(`  ${colors.dim(issue.path)}  ${issue.message}`),\n      );\n      return true;\n    }\n    case \"rcs_field_locked\":\n      error(err.message, {\n        code: err.code,\n        hint: \"Check where the registration stands with `sendly rcs registration`\",\n      });\n      return true;\n    case \"rcs_launch_not_ready\":\n      error(err.message, {\n        code: err.code,\n        hint: \"Invite a device with `sendly rcs agents devices set <agentId> --phone +13125550100`, send it a test message with `sendly rcs send`, then request launch\",\n      });\n      return true;\n    case \"rcs_brand_not_verified\":\n      error(err.message, {\n        code: err.code,\n        hint: \"See the reason with `sendly rcs registration`, fix the brand with `sendly rcs brands update <brandId>`, then submit again\",\n      });\n      return true;\n    case \"rcs_us_only\":\n      error(err.message, { code: err.code });\n      return true;\n    case \"idempotency_key_mismatch\":\n      error(err.message, {\n        code: err.code,\n        hint: \"An idempotency key can only replay an identical request; use a new key for a changed body\",\n      });\n      return true;\n    default:\n      return false;\n  }\n}\n"]}