@sendly/cli 3.24.0 → 3.29.0

package/dist/commands/campaigns/schedule.js

@@ -1,12 +1,14 @@
 import { Args, Flags } from "@oclif/core";
 import { AuthenticatedCommand } from "../../lib/base-command.js";
 import { apiClient } from "../../lib/api-client.js";
-import { json, success, colors, isJsonMode, keyValue, } from "../../lib/output.js";
+import { json, success, colors, isJsonMode, keyValue, info, } from "../../lib/output.js";
+import * as chrono from "chrono-node";
 export default class CampaignsSchedule extends AuthenticatedCommand {
-    static description = "Schedule a campaign for later";
+    static description = 'Schedule a campaign for later. Supports natural language dates like "tomorrow at 9am".';
     static examples = [
-        '<%= config.bin %> campaigns schedule cmp_xxx --at "2024-01-15T10:00:00Z"',
-        '<%= config.bin %> campaigns schedule cmp_xxx --at "2024-01-15T10:00:00" --timezone "America/New_York"',
+        '<%= config.bin %> campaigns schedule cmp_xxx --at "tomorrow at 9am"',
+        '<%= config.bin %> campaigns schedule cmp_xxx --at "next Monday 10am" --timezone "America/New_York"',
+        '<%= config.bin %> campaigns schedule cmp_xxx --at "2026-04-01T10:00:00Z"',
     ];
     static args = {
         id: Args.string({
@@ -17,7 +19,7 @@ export default class CampaignsSchedule extends AuthenticatedCommand {
     static flags = {
         ...AuthenticatedCommand.baseFlags,
         at: Flags.string({
-            description: "When to send (ISO 8601 datetime)",
+            description: 'When to send — ISO 8601 or natural language ("tomorrow at 9am", "in 2 hours")',
             required: true,
         }),
         timezone: Flags.string({
@@ -27,15 +29,23 @@ export default class CampaignsSchedule extends AuthenticatedCommand {
     };
     async run() {
         const { args, flags } = await this.parse(CampaignsSchedule);
-        const scheduledAt = new Date(flags.at);
+        let scheduledAt = new Date(flags.at);
         if (isNaN(scheduledAt.getTime())) {
-            this.error("Invalid date format. Use ISO 8601 format (e.g., 2024-01-15T10:00:00Z)");
+            const parsed = chrono.parseDate(flags.at, new Date(), { forwardDate: true });
+            if (!parsed) {
+                this.error('Could not understand the date. Try: "tomorrow at 9am", "in 2 hours", or ISO 8601: 2026-04-01T10:00:00Z');
+            }
+            scheduledAt = parsed;
+            const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            if (!isJsonMode()) {
+                info(`Interpreted "${flags.at}" as ${scheduledAt.toLocaleString()} (${tz})`);
+            }
         }
         if (scheduledAt <= new Date()) {
-            this.error("Scheduled time must be in the future");
+            this.error('That time is in the past. Try: "tomorrow at 9am" or "in 2 hours"');
         }
         const campaign = await apiClient.post(`/api/v1/campaigns/${args.id}/schedule`, {
-            scheduledAt: flags.at,
+            scheduledAt: scheduledAt.toISOString(),
             timezone: flags.timezone,
         });
         if (isJsonMode()) {
@@ -58,4 +68,4 @@ export default class CampaignsSchedule extends AuthenticatedCommand {
         console.log(`  ${colors.code(`sendly campaigns cancel ${campaign.id}`)}`);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/contacts/bulk-mark-valid.d.ts

@@ -0,0 +1,12 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ContactsBulkMarkValid extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        ids: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        list: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/contacts/bulk-mark-valid.js

@@ -0,0 +1,46 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, isJsonMode, error } from "../../lib/output.js";
+export default class ContactsBulkMarkValid extends AuthenticatedCommand {
+    static description = "Clear the invalid flag on many contacts at once. Pass --ids (comma-separated, up to 10,000) OR --list <id>, not both. Escape hatch for when auto-mark misclassifies at scale.";
+    static examples = [
+        "<%= config.bin %> contacts bulk-mark-valid --ids cnt_abc,cnt_def,cnt_ghi",
+        "<%= config.bin %> contacts bulk-mark-valid --list lst_xxx",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        ids: Flags.string({
+            description: "Comma-separated contact IDs to clear (max 10,000 per call)",
+            exclusive: ["list"],
+        }),
+        list: Flags.string({
+            description: "Clear every flagged member of this list ID",
+            exclusive: ["ids"],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ContactsBulkMarkValid);
+        if (!flags.ids && !flags.list) {
+            error("Provide either --ids or --list");
+            this.exit(1);
+        }
+        const body = flags.ids
+            ? {
+                ids: flags.ids
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean),
+            }
+            : { listId: flags.list };
+        const result = await apiClient.post("/api/contacts/bulk-mark-valid", body);
+        if (isJsonMode()) {
+            json(result);
+            return;
+        }
+        success(result.cleared === 0
+            ? "No flagged contacts matched the selection"
+            : `${result.cleared} contact${result.cleared === 1 ? "" : "s"} marked as valid`, { Cleared: result.cleared });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/contacts/check-numbers.d.ts

@@ -0,0 +1,12 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ContactsCheckNumbers extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        list: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        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/contacts/check-numbers.js

@@ -0,0 +1,41 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, isJsonMode, info } from "../../lib/output.js";
+export default class ContactsCheckNumbers extends AuthenticatedCommand {
+    static description = "Trigger a background carrier lookup across your contacts. Landlines and other non-SMS-capable numbers are auto-excluded from future campaigns. Runs asynchronously — results populate line_type / carrier_name / invalid_reason on affected contacts within a few minutes.";
+    static examples = [
+        "<%= config.bin %> contacts check-numbers",
+        "<%= config.bin %> contacts check-numbers --list lst_xxx",
+        "<%= config.bin %> contacts check-numbers --force",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        list: Flags.string({
+            char: "l",
+            description: "Scope the lookup to a single contact list",
+        }),
+        force: Flags.boolean({
+            description: "Re-check contacts even if already looked up",
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ContactsCheckNumbers);
+        const response = await apiClient.post("/api/contacts/lookup", {
+            listId: flags.list ?? null,
+            force: flags.force,
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("Carrier lookup started", {
+            Scope: flags.list ? `list ${flags.list}` : "all un-checked contacts",
+            Force: flags.force ? "yes" : "no",
+        });
+        info(response.message ??
+            "Results will appear on contacts within a few minutes. Run `sendly contacts list` to check progress.");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2stbnVtYmVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy9jb250YWN0cy9jaGVjay1udW1iZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDcEMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDakUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BELE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV0RSxNQUFNLENBQUMsT0FBTyxPQUFPLG9CQUFxQixTQUFRLG9CQUFvQjtJQUNwRSxNQUFNLENBQUMsV0FBVyxHQUNoQiw0UUFBNFEsQ0FBQztJQUUvUSxNQUFNLENBQUMsUUFBUSxHQUFHO1FBQ2hCLDBDQUEwQztRQUMxQyx5REFBeUQ7UUFDekQsa0RBQWtEO0tBQ25ELENBQUM7SUFFRixNQUFNLENBQUMsS0FBSyxHQUFHO1FBQ2IsR0FBRyxvQkFBb0IsQ0FBQyxTQUFTO1FBQ2pDLElBQUksRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDO1lBQ2pCLElBQUksRUFBRSxHQUFHO1lBQ1QsV0FBVyxFQUFFLDJDQUEyQztTQUN6RCxDQUFDO1FBQ0YsS0FBSyxFQUFFLEtBQUssQ0FBQyxPQUFPLENBQUM7WUFDbkIsV0FBVyxFQUFFLDZDQUE2QztZQUMxRCxPQUFPLEVBQUUsS0FBSztTQUNmLENBQUM7S0FDSCxDQUFDO0lBRUYsS0FBSyxDQUFDLEdBQUc7UUFDUCxNQUFNLEVBQUUsS0FBSyxFQUFFLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLG9CQUFvQixDQUFDLENBQUM7UUFFekQsTUFBTSxRQUFRLEdBQUcsTUFBTSxTQUFTLENBQUMsSUFBSSxDQUdsQyxzQkFBc0IsRUFBRTtZQUN6QixNQUFNLEVBQUUsS0FBSyxDQUFDLElBQUksSUFBSSxJQUFJO1lBQzFCLEtBQUssRUFBRSxLQUFLLENBQUMsS0FBSztTQUNuQixDQUFDLENBQUM7UUFFSCxJQUFJLFVBQVUsRUFBRSxFQUFFLENBQUM7WUFDakIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ2YsT0FBTztRQUNULENBQUM7UUFFRCxPQUFPLENBQUMsd0JBQXdCLEVBQUU7WUFDaEMsS0FBSyxFQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLFFBQVEsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyx5QkFBeUI7WUFDcEUsS0FBSyxFQUFFLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsSUFBSTtTQUNsQyxDQUFDLENBQUM7UUFDSCxJQUFJLENBQ0YsUUFBUSxDQUFDLE9BQU87WUFDZCxxR0FBcUcsQ0FDeEcsQ0FBQztJQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGbGFncyB9IGZyb20gXCJAb2NsaWYvY29yZVwiO1xuaW1wb3J0IHsgQXV0aGVudGljYXRlZENvbW1hbmQgfSBmcm9tIFwiLi4vLi4vbGliL2Jhc2UtY29tbWFuZC5qc1wiO1xuaW1wb3J0IHsgYXBpQ2xpZW50IH0gZnJvbSBcIi4uLy4uL2xpYi9hcGktY2xpZW50LmpzXCI7XG5pbXBvcnQgeyBzdWNjZXNzLCBqc29uLCBpc0pzb25Nb2RlLCBpbmZvIH0gZnJvbSBcIi4uLy4uL2xpYi9vdXRwdXQuanNcIjtcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQ29udGFjdHNDaGVja051bWJlcnMgZXh0ZW5kcyBBdXRoZW50aWNhdGVkQ29tbWFuZCB7XG4gIHN0YXRpYyBkZXNjcmlwdGlvbiA9XG4gICAgXCJUcmlnZ2VyIGEgYmFja2dyb3VuZCBjYXJyaWVyIGxvb2t1cCBhY3Jvc3MgeW91ciBjb250YWN0cy4gTGFuZGxpbmVzIGFuZCBvdGhlciBub24tU01TLWNhcGFibGUgbnVtYmVycyBhcmUgYXV0by1leGNsdWRlZCBmcm9tIGZ1dHVyZSBjYW1wYWlnbnMuIFJ1bnMgYXN5bmNocm9ub3VzbHkg4oCUIHJlc3VsdHMgcG9wdWxhdGUgbGluZV90eXBlIC8gY2Fycmllcl9uYW1lIC8gaW52YWxpZF9yZWFzb24gb24gYWZmZWN0ZWQgY29udGFjdHMgd2l0aGluIGEgZmV3IG1pbnV0ZXMuXCI7XG5cbiAgc3RhdGljIGV4YW1wbGVzID0gW1xuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gY29udGFjdHMgY2hlY2stbnVtYmVyc1wiLFxuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gY29udGFjdHMgY2hlY2stbnVtYmVycyAtLWxpc3QgbHN0X3h4eFwiLFxuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gY29udGFjdHMgY2hlY2stbnVtYmVycyAtLWZvcmNlXCIsXG4gIF07XG5cbiAgc3RhdGljIGZsYWdzID0ge1xuICAgIC4uLkF1dGhlbnRpY2F0ZWRDb21tYW5kLmJhc2VGbGFncyxcbiAgICBsaXN0OiBGbGFncy5zdHJpbmcoe1xuICAgICAgY2hhcjogXCJsXCIsXG4gICAgICBkZXNjcmlwdGlvbjogXCJTY29wZSB0aGUgbG9va3VwIHRvIGEgc2luZ2xlIGNvbnRhY3QgbGlzdFwiLFxuICAgIH0pLFxuICAgIGZvcmNlOiBGbGFncy5ib29sZWFuKHtcbiAgICAgIGRlc2NyaXB0aW9uOiBcIlJlLWNoZWNrIGNvbnRhY3RzIGV2ZW4gaWYgYWxyZWFkeSBsb29rZWQgdXBcIixcbiAgICAgIGRlZmF1bHQ6IGZhbHNlLFxuICAgIH0pLFxuICB9O1xuXG4gIGFzeW5jIHJ1bigpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBjb25zdCB7IGZsYWdzIH0gPSBhd2FpdCB0aGlzLnBhcnNlKENvbnRhY3RzQ2hlY2tOdW1iZXJzKTtcblxuICAgIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgYXBpQ2xpZW50LnBvc3Q8e1xuICAgICAgc3VjY2VzczogYm9vbGVhbjtcbiAgICAgIG1lc3NhZ2U/OiBzdHJpbmc7XG4gICAgfT4oXCIvYXBpL2NvbnRhY3RzL2xvb2t1cFwiLCB7XG4gICAgICBsaXN0SWQ6IGZsYWdzLmxpc3QgPz8gbnVsbCxcbiAgICAgIGZvcmNlOiBmbGFncy5mb3JjZSxcbiAgICB9KTtcblxuICAgIGlmIChpc0pzb25Nb2RlKCkpIHtcbiAgICAgIGpzb24ocmVzcG9uc2UpO1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIHN1Y2Nlc3MoXCJDYXJyaWVyIGxvb2t1cCBzdGFydGVkXCIsIHtcbiAgICAgIFNjb3BlOiBmbGFncy5saXN0ID8gYGxpc3QgJHtmbGFncy5saXN0fWAgOiBcImFsbCB1bi1jaGVja2VkIGNvbnRhY3RzXCIsXG4gICAgICBGb3JjZTogZmxhZ3MuZm9yY2UgPyBcInllc1wiIDogXCJub1wiLFxuICAgIH0pO1xuICAgIGluZm8oXG4gICAgICByZXNwb25zZS5tZXNzYWdlID8/XG4gICAgICAgIFwiUmVzdWx0cyB3aWxsIGFwcGVhciBvbiBjb250YWN0cyB3aXRoaW4gYSBmZXcgbWludXRlcy4gUnVuIGBzZW5kbHkgY29udGFjdHMgbGlzdGAgdG8gY2hlY2sgcHJvZ3Jlc3MuXCIsXG4gICAgKTtcbiAgfVxufVxuIl19

package/dist/commands/contacts/mark-valid.d.ts

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

package/dist/commands/contacts/mark-valid.js

@@ -0,0 +1,32 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, isJsonMode } from "../../lib/output.js";
+export default class ContactsMarkValid extends AuthenticatedCommand {
+    static description = "Clear the invalid flag on a contact so future campaigns include it again. Use when you disagree with an auto-exclusion (e.g. the recipient ported from a landline to mobile).";
+    static examples = [
+        "<%= config.bin %> contacts mark-valid cnt_xxx",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Contact ID to clear the invalid flag on",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ContactsMarkValid);
+        const contact = await apiClient.post(`/api/contacts/${args.id}/mark-valid`);
+        if (isJsonMode()) {
+            json(contact);
+            return;
+        }
+        success("Contact marked as valid — future campaigns will include it", {
+            ID: contact.id,
+            Phone: contact.phoneNumber ?? contact.phone_number ?? "—",
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/conversations/context.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ConversationsContext 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: {
+        "max-messages": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        raw: 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/conversations/context.js

@@ -0,0 +1,55 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, header, colors, isJsonMode, } from "../../lib/output.js";
+export default class ConversationsContext extends AuthenticatedCommand {
+    static description = "Get LLM-ready conversation context. Returns pre-formatted text with timestamped messages, AI classification, and business context.";
+    static examples = [
+        "<%= config.bin %> conversations context conv_abc123",
+        "<%= config.bin %> conversations context conv_abc123 --max-messages 10",
+        "<%= config.bin %> conversations context conv_abc123 --json",
+        "<%= config.bin %> conversations context conv_abc123 --raw",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        "max-messages": Flags.integer({
+            char: "m",
+            description: "Maximum number of messages to include",
+            default: 20,
+        }),
+        raw: Flags.boolean({
+            description: "Output only the context text (for piping to LLMs)",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ConversationsContext);
+        const result = await apiClient.get(`/api/v1/conversations/${encodeURIComponent(args.id)}/context`, { max_messages: flags["max-messages"] });
+        if (flags.raw) {
+            process.stdout.write(result.context);
+            return;
+        }
+        if (isJsonMode()) {
+            json(result);
+            return;
+        }
+        header("Conversation Context");
+        if (result.business) {
+            console.log(colors.bold(result.business.name));
+            if (result.business.useCase) {
+                console.log(colors.dim(result.business.useCase));
+            }
+            console.log();
+        }
+        console.log(result.context);
+        console.log();
+        console.log(colors.dim(`${result.conversation.messageCount} messages · ${result.tokenEstimate} tokens · ${result.conversation.status}`));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy9jb252ZXJzYXRpb25zL2NvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDMUMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDakUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BELE9BQU8sRUFDTCxJQUFJLEVBQ0osTUFBTSxFQUNOLE1BQU0sRUFDTixVQUFVLEdBQ1gsTUFBTSxxQkFBcUIsQ0FBQztBQWtCN0IsTUFBTSxDQUFDLE9BQU8sT0FBTyxvQkFBcUIsU0FBUSxvQkFBb0I7SUFDcEUsTUFBTSxDQUFDLFdBQVcsR0FDaEIsb0lBQW9JLENBQUM7SUFFdkksTUFBTSxDQUFDLFFBQVEsR0FBRztRQUNoQixxREFBcUQ7UUFDckQsdUVBQXVFO1FBQ3ZFLDREQUE0RDtRQUM1RCwyREFBMkQ7S0FDNUQsQ0FBQztJQUVGLE1BQU0sQ0FBQyxJQUFJLEdBQUc7UUFDWixFQUFFLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQztZQUNkLFdBQVcsRUFBRSxpQkFBaUI7WUFDOUIsUUFBUSxFQUFFLElBQUk7U0FDZixDQUFDO0tBQ0gsQ0FBQztJQUVGLE1BQU0sQ0FBQyxLQUFLLEdBQUc7UUFDYixHQUFHLG9CQUFvQixDQUFDLFNBQVM7UUFDakMsY0FBYyxFQUFFLEtBQUssQ0FBQyxPQUFPLENBQUM7WUFDNUIsSUFBSSxFQUFFLEdBQUc7WUFDVCxXQUFXLEVBQUUsdUNBQXVDO1lBQ3BELE9BQU8sRUFBRSxFQUFFO1NBQ1osQ0FBQztRQUNGLEdBQUcsRUFBRSxLQUFLLENBQUMsT0FBTyxDQUFDO1lBQ2pCLFdBQVcsRUFBRSxtREFBbUQ7WUFDaEUsT0FBTyxFQUFFLEtBQUs7U0FDZixDQUFDO0tBQ0gsQ0FBQztJQUVGLEtBQUssQ0FBQyxHQUFHO1FBQ1AsTUFBTSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsb0JBQW9CLENBQUMsQ0FBQztRQUUvRCxNQUFNLE1BQU0sR0FBRyxNQUFNLFNBQVMsQ0FBQyxHQUFHLENBQ2hDLHlCQUF5QixrQkFBa0IsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLFVBQVUsRUFDOUQsRUFBRSxZQUFZLEVBQUUsS0FBSyxDQUFDLGNBQWMsQ0FBQyxFQUFFLENBQ3hDLENBQUM7UUFFRixJQUFJLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNkLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUNyQyxPQUFPO1FBQ1QsQ0FBQztRQUVELElBQUksVUFBVSxFQUFFLEVBQUUsQ0FBQztZQUNqQixJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDYixPQUFPO1FBQ1QsQ0FBQztRQUVELE1BQU0sQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO1FBRS9CLElBQUksTUFBTSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ3BCLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7WUFDL0MsSUFBSSxNQUFNLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSxDQUFDO2dCQUM1QixPQUFPLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO1lBQ25ELENBQUM7WUFDRCxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDaEIsQ0FBQztRQUVELE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzVCLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNkLE9BQU8sQ0FBQyxHQUFHLENBQ1QsTUFBTSxDQUFDLEdBQUcsQ0FDUixHQUFHLE1BQU0sQ0FBQyxZQUFZLENBQUMsWUFBWSxlQUFlLE1BQU0sQ0FBQyxhQUFhLGFBQWEsTUFBTSxDQUFDLFlBQVksQ0FBQyxNQUFNLEVBQUUsQ0FDaEgsQ0FDRixDQUFDO0lBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFyZ3MsIEZsYWdzIH0gZnJvbSBcIkBvY2xpZi9jb3JlXCI7XG5pbXBvcnQgeyBBdXRoZW50aWNhdGVkQ29tbWFuZCB9IGZyb20gXCIuLi8uLi9saWIvYmFzZS1jb21tYW5kLmpzXCI7XG5pbXBvcnQgeyBhcGlDbGllbnQgfSBmcm9tIFwiLi4vLi4vbGliL2FwaS1jbGllbnQuanNcIjtcbmltcG9ydCB7XG4gIGpzb24sXG4gIGhlYWRlcixcbiAgY29sb3JzLFxuICBpc0pzb25Nb2RlLFxufSBmcm9tIFwiLi4vLi4vbGliL291dHB1dC5qc1wiO1xuXG5pbnRlcmZhY2UgQ29udGV4dFJlc3BvbnNlIHtcbiAgY29udGV4dDogc3RyaW5nO1xuICBjb252ZXJzYXRpb246IHtcbiAgICBpZDogc3RyaW5nO1xuICAgIHBob25lTnVtYmVyOiBzdHJpbmc7XG4gICAgc3RhdHVzOiBzdHJpbmc7XG4gICAgbWVzc2FnZUNvdW50OiBudW1iZXI7XG4gICAgdW5yZWFkQ291bnQ6IG51bWJlcjtcbiAgfTtcbiAgdG9rZW5Fc3RpbWF0ZTogbnVtYmVyO1xuICBidXNpbmVzcz86IHtcbiAgICBuYW1lOiBzdHJpbmc7XG4gICAgdXNlQ2FzZT86IHN0cmluZztcbiAgfTtcbn1cblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQ29udmVyc2F0aW9uc0NvbnRleHQgZXh0ZW5kcyBBdXRoZW50aWNhdGVkQ29tbWFuZCB7XG4gIHN0YXRpYyBkZXNjcmlwdGlvbiA9XG4gICAgXCJHZXQgTExNLXJlYWR5IGNvbnZlcnNhdGlvbiBjb250ZXh0LiBSZXR1cm5zIHByZS1mb3JtYXR0ZWQgdGV4dCB3aXRoIHRpbWVzdGFtcGVkIG1lc3NhZ2VzLCBBSSBjbGFzc2lmaWNhdGlvbiwgYW5kIGJ1c2luZXNzIGNvbnRleHQuXCI7XG5cbiAgc3RhdGljIGV4YW1wbGVzID0gW1xuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gY29udmVyc2F0aW9ucyBjb250ZXh0IGNvbnZfYWJjMTIzXCIsXG4gICAgXCI8JT0gY29uZmlnLmJpbiAlPiBjb252ZXJzYXRpb25zIGNvbnRleHQgY29udl9hYmMxMjMgLS1tYXgtbWVzc2FnZXMgMTBcIixcbiAgICBcIjwlPSBjb25maWcuYmluICU+IGNvbnZlcnNhdGlvbnMgY29udGV4dCBjb252X2FiYzEyMyAtLWpzb25cIixcbiAgICBcIjwlPSBjb25maWcuYmluICU+IGNvbnZlcnNhdGlvbnMgY29udGV4dCBjb252X2FiYzEyMyAtLXJhd1wiLFxuICBdO1xuXG4gIHN0YXRpYyBhcmdzID0ge1xuICAgIGlkOiBBcmdzLnN0cmluZyh7XG4gICAgICBkZXNjcmlwdGlvbjogXCJDb252ZXJzYXRpb24gSURcIixcbiAgICAgIHJlcXVpcmVkOiB0cnVlLFxuICAgIH0pLFxuICB9O1xuXG4gIHN0YXRpYyBmbGFncyA9IHtcbiAgICAuLi5BdXRoZW50aWNhdGVkQ29tbWFuZC5iYXNlRmxhZ3MsXG4gICAgXCJtYXgtbWVzc2FnZXNcIjogRmxhZ3MuaW50ZWdlcih7XG4gICAgICBjaGFyOiBcIm1cIixcbiAgICAgIGRlc2NyaXB0aW9uOiBcIk1heGltdW0gbnVtYmVyIG9mIG1lc3NhZ2VzIHRvIGluY2x1ZGVcIixcbiAgICAgIGRlZmF1bHQ6IDIwLFxuICAgIH0pLFxuICAgIHJhdzogRmxhZ3MuYm9vbGVhbih7XG4gICAgICBkZXNjcmlwdGlvbjogXCJPdXRwdXQgb25seSB0aGUgY29udGV4dCB0ZXh0IChmb3IgcGlwaW5nIHRvIExMTXMpXCIsXG4gICAgICBkZWZhdWx0OiBmYWxzZSxcbiAgICB9KSxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgeyBhcmdzLCBmbGFncyB9ID0gYXdhaXQgdGhpcy5wYXJzZShDb252ZXJzYXRpb25zQ29udGV4dCk7XG5cbiAgICBjb25zdCByZXN1bHQgPSBhd2FpdCBhcGlDbGllbnQuZ2V0PENvbnRleHRSZXNwb25zZT4oXG4gICAgICBgL2FwaS92MS9jb252ZXJzYXRpb25zLyR7ZW5jb2RlVVJJQ29tcG9uZW50KGFyZ3MuaWQpfS9jb250ZXh0YCxcbiAgICAgIHsgbWF4X21lc3NhZ2VzOiBmbGFnc1tcIm1heC1tZXNzYWdlc1wiXSB9LFxuICAgICk7XG5cbiAgICBpZiAoZmxhZ3MucmF3KSB7XG4gICAgICBwcm9jZXNzLnN0ZG91dC53cml0ZShyZXN1bHQuY29udGV4dCk7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgaWYgKGlzSnNvbk1vZGUoKSkge1xuICAgICAganNvbihyZXN1bHQpO1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIGhlYWRlcihcIkNvbnZlcnNhdGlvbiBDb250ZXh0XCIpO1xuXG4gICAgaWYgKHJlc3VsdC5idXNpbmVzcykge1xuICAgICAgY29uc29sZS5sb2coY29sb3JzLmJvbGQocmVzdWx0LmJ1c2luZXNzLm5hbWUpKTtcbiAgICAgIGlmIChyZXN1bHQuYnVzaW5lc3MudXNlQ2FzZSkge1xuICAgICAgICBjb25zb2xlLmxvZyhjb2xvcnMuZGltKHJlc3VsdC5idXNpbmVzcy51c2VDYXNlKSk7XG4gICAgICB9XG4gICAgICBjb25zb2xlLmxvZygpO1xuICAgIH1cblxuICAgIGNvbnNvbGUubG9nKHJlc3VsdC5jb250ZXh0KTtcbiAgICBjb25zb2xlLmxvZygpO1xuICAgIGNvbnNvbGUubG9nKFxuICAgICAgY29sb3JzLmRpbShcbiAgICAgICAgYCR7cmVzdWx0LmNvbnZlcnNhdGlvbi5tZXNzYWdlQ291bnR9IG1lc3NhZ2VzIMK3ICR7cmVzdWx0LnRva2VuRXN0aW1hdGV9IHRva2VucyDCtyAke3Jlc3VsdC5jb252ZXJzYXRpb24uc3RhdHVzfWAsXG4gICAgICApLFxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/dist/commands/conversations/suggest-replies.d.ts

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

package/dist/commands/conversations/suggest-replies.js

@@ -0,0 +1,50 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { json, spinner, isJsonMode, colors, } from "../../lib/output.js";
+export default class ConversationsSuggestReplies extends AuthenticatedCommand {
+    static description = "Get AI-suggested replies for a conversation";
+    static examples = [
+        "<%= config.bin %> conversations suggest-replies conv_abc123",
+        "<%= config.bin %> conversations suggest-replies conv_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(ConversationsSuggestReplies);
+        const spin = spinner("Generating suggestions...");
+        spin.start();
+        try {
+            const response = await apiClient.post(`/api/v1/conversations/${encodeURIComponent(args.id)}/suggest-replies`);
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            if (!response.suggestions || response.suggestions.length === 0) {
+                console.log(colors.dim("No suggestions available for this conversation."));
+                return;
+            }
+            console.log();
+            console.log(colors.bold("Suggested Replies"));
+            console.log();
+            response.suggestions.forEach((suggestion, index) => {
+                const toneLabel = colors.dim(`[${suggestion.tone}]`);
+                console.log(`  ${colors.primary(`${index + 1}.`)} ${suggestion.text} ${toneLabel}`);
+                console.log();
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/conversations/update.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class ConversationsUpdate 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: {
+        metadata: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        tags: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/conversations/update.js

@@ -0,0 +1,56 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, json, spinner, isJsonMode, } from "../../lib/output.js";
+export default class ConversationsUpdate extends AuthenticatedCommand {
+    static description = "Update a conversation";
+    static examples = [
+        '<%= config.bin %> conversations update conv_abc123 --metadata \'{"priority":"high"}\'',
+        "<%= config.bin %> conversations update conv_abc123 --tags vip,urgent",
+        '<%= config.bin %> conversations update conv_abc123 --metadata \'{"note":"follow up"}\' --tags support',
+    ];
+    static args = {
+        id: Args.string({
+            description: "Conversation ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        metadata: Flags.string({
+            char: "m",
+            description: "Metadata as JSON string",
+        }),
+        tags: Flags.string({
+            char: "t",
+            description: "Comma-separated list of tags",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ConversationsUpdate);
+        const spin = spinner("Updating conversation...");
+        spin.start();
+        try {
+            const body = {};
+            if (flags.metadata)
+                body.metadata = JSON.parse(flags.metadata);
+            if (flags.tags)
+                body.tags = flags.tags.split(",").map((t) => t.trim());
+            const response = await apiClient.patch(`/api/v1/conversations/${encodeURIComponent(args.id)}`, body);
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Conversation updated", {
+                ID: response.id,
+                Status: response.status,
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/doctor.d.ts

@@ -19,5 +19,6 @@ export default class Doctor extends BaseCommand {
     private checkCredits;
     private checkEnvironment;
     private checkConfig;
+    private checkAiAgents;
     private generateReport;
 }