conduyt 1.57.0 → 1.58.1

package/README.md

@@ -40,6 +40,11 @@ conduyt insights summary                # run an AI insight query
 conduyt insights saved_report --report "Lead Activity" --period last_7_days   # run any saved report as a tool
 conduyt insights dashboard --dashboard Floor --period today                   # run every tile of a board
 conduyt insights report_catalog                                                # what this key can run
+conduyt sequences list --type sms --on   # Email and SMS sequences (--archived, --summary)
+conduyt sequences senders sms           # who can send an SMS sequence (each member's line)
+conduyt sequences stats <id>            # sends, opens, clicks in total and per step
+conduyt sequences people <id> --all-active   # every live run; status and endedReason per run
+conduyt sequences check <id> <contactId...>  # who is eligible before enrolling
 conduyt messages transports             # what a workflow Send SMS step can speak through today (Twilio numbers, Project Blue lines, the WhatsApp sender)
 conduyt whatsapp status                 # WhatsApp via your Twilio: connected? from which sender
 conduyt whatsapp senders                # the senders Twilio lists for the account (ONLINE = connectable)

package/dist/index.js

@@ -953,7 +953,7 @@ messages
 })}`)));
 messages
     .command("send")
-    .description("Log/create a message (POST /messages). NOTE: outbound SMS is rejected here — use `messages send-sms` for real SMS delivery")
+    .description("Log/create a message (POST /messages). NOTE: outbound SMS is rejected here — use `messages send-sms` for real SMS delivery. An inbound SMS STOP or START with --from records that number's opt-out or opt-in: STOP blocks only the --from number; only when --from is the contact's PRIMARY number does STOP also end the contact's drips and the SMS sequences configured to stop on opt-out (autoUnenrollOnUnsubscribe) — a secondary number's STOP blocks that number alone, nothing else. The answer then carries smsConsent {keyword, fromNumber, applied, reason: number_not_on_contact | number_not_canonicalizable}")
     .option("--contact <id>", "contact UUID (required)")
     .option("--channel <channel>", "sms | email (required)")
     .option("--direction <direction>", "inbound | outbound (required)")
@@ -1458,7 +1458,7 @@ automations
     .action(run(async (client, opts) => client.post("/api/v1/automations/validate", bodyFromJsonOrFile(opts))));
 automations
     .command("import")
-    .description("Create a workflow (with optional name resolution). Provide the body via --json or --file (needs name + triggerEvent + graph)")
+    .description("Create a workflow (with optional name resolution). Provide the body via --json or --file (needs name + triggerEvent + graph). A sequence step is the action enroll_in_sequence with config {sequenceId, enrollAction: add (default) | remove}; add needs the sequence to allow automation enrollment")
     .option("--json <json>", "full request body as JSON")
     .option("--file <path>", "read the request body from a JSON file")
     .option("--resolve-names", "set resolveNames=true so name fields in node configs are converted to ids")
@@ -2143,6 +2143,275 @@ webhooks
     .option("--resend", "send the step again (duplicate risk: needs --acknowledge-duplicate-risk; refused 409 step_already_sent when the step already carries sent evidence: use --skip)")
     .option("--acknowledge-duplicate-risk", "you accept the step may be delivered twice")
     .action(run(async (client, id, opts) => client.post(`/api/v1/webhook-logs/${uuidArg(id, "id")}/cancel`, barrierBody(opts))));
+// ---------------------------------------------------------------------------
+// Sequences (one model for Email and SMS since 2026-09-30): steps send saved templates of the sequence's channel a
+// number of days apart inside a send window; a run stops on a reply, a booked meeting, an opt-out, a closed deal or a
+// removal. Provider drip timetables are the `drip-enrollments` group, a different thing.
+// ---------------------------------------------------------------------------
+const sequences = program.command("sequences").description("Email and SMS sequences built from saved templates: list, create, settings, On/Off, archive, enroll with a check first, who is in them and how each run ended");
+const SEQUENCE_SETTING_FLAGS = [
+    ["--sender <userId>", "the team member the messages are from (must be an active member): email from their on-domain address, SMS from their assigned line; pass none for the workspace default"],
+    ["--stop-on-reply <on|off>", "stop a contact's run when they reply to any message of the sequence (default on)"],
+    ["--stop-on-meeting <on|off>", "stop the run when a meeting is booked through any Conduyt calendar (default on)"],
+    ["--stop-on-opt-out <on|off>", "stop the run when the contact opts out: unsubscribe, or STOP for SMS (default on)"],
+    ["--stop-on-bounce <on|off>", "email only: stop the run on a hard bounce; a soft bounce waits and retries (default on)"],
+    ["--stop-on-deal-closed <on|off>", "stop a contact's run when any of their deals closes, won or lost, on any stage of a closed kind (default on)"],
+    ["--allow-automation-enroll <on|off>", "let the automation action enroll_in_sequence put contacts in (default on)"],
+    ["--allow-reenroll <on|off>", "let a contact go through it again once their earlier run ENDED (default off); a live or paused run is never restarted"],
+    ["--weekdays-only <on|off>", "send Monday to Friday only, in the contact's time zone (default on)"],
+    ["--send-from <hour>", "first hour of the send window, 0-23 local (default 9)"],
+    ["--send-until <hour>", "end of the send window, 1-24 local, exclusive (default 17); a step due outside the window waits for the next opening"],
+];
+function sequenceSettingsBody(opts) {
+    const body = {};
+    if (opts.sender !== undefined)
+        body.senderUserId = opts.sender === "none" ? null : uuidArg(opts.sender, "--sender");
+    if (opts.stopOnReply !== undefined)
+        body.autoUnenrollOnReply = onOffArg(opts.stopOnReply, "--stop-on-reply");
+    if (opts.stopOnMeeting !== undefined)
+        body.autoUnenrollOnMeeting = onOffArg(opts.stopOnMeeting, "--stop-on-meeting");
+    if (opts.stopOnOptOut !== undefined)
+        body.autoUnenrollOnUnsubscribe = onOffArg(opts.stopOnOptOut, "--stop-on-opt-out");
+    if (opts.stopOnBounce !== undefined)
+        body.autoUnenrollOnBounce = onOffArg(opts.stopOnBounce, "--stop-on-bounce");
+    if (opts.stopOnDealClosed !== undefined)
+        body.autoUnenrollOnDealClosed = onOffArg(opts.stopOnDealClosed, "--stop-on-deal-closed");
+    if (opts.allowAutomationEnroll !== undefined)
+        body.allowAutomationEnroll = onOffArg(opts.allowAutomationEnroll, "--allow-automation-enroll");
+    if (opts.allowReenroll !== undefined)
+        body.allowReenroll = onOffArg(opts.allowReenroll, "--allow-reenroll");
+    if (opts.weekdaysOnly !== undefined)
+        body.weekdaysOnly = onOffArg(opts.weekdaysOnly, "--weekdays-only");
+    for (const [flag, key, lo, hi] of [["sendFrom", "sendStartHour", 0, 23], ["sendUntil", "sendEndHour", 1, 24]]) {
+        const raw = opts[flag];
+        if (raw === undefined)
+            continue;
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < lo || n > hi)
+            throw new Error(`--${flag === "sendFrom" ? "send-from" : "send-until"} must be a whole hour, ${lo} to ${hi}.`);
+        body[key] = n;
+    }
+    return body;
+}
+/** --steps: JSON array of {templateId, waitDays}, or "tpl-id:days,tpl-id:days" (the first step's wait is 0) */
+function sequenceStepsArg(raw) {
+    const t = raw.trim();
+    if (t.startsWith("[")) {
+        let v;
+        try {
+            v = JSON.parse(t);
+        }
+        catch {
+            throw new Error("--steps must be a JSON array of {templateId, waitDays} or a list like id:0,id:3.");
+        }
+        if (!Array.isArray(v) || v.length === 0)
+            throw new Error("--steps needs at least one step.");
+        return v.map((row, i) => {
+            const r = (row ?? {});
+            if (typeof r.templateId !== "string")
+                throw new Error(`--steps[${i}] needs a templateId.`);
+            const wait = r.waitDays === undefined ? (i === 0 ? 0 : 1) : Number(r.waitDays);
+            if (!Number.isInteger(wait) || wait < 0)
+                throw new Error(`--steps[${i}].waitDays must be a whole number of days.`);
+            return { templateId: r.templateId, waitDays: i === 0 ? 0 : wait };
+        });
+    }
+    const parts = t.split(",").map((p) => p.trim()).filter(Boolean);
+    if (parts.length === 0)
+        throw new Error("--steps needs at least one step.");
+    return parts.map((p, i) => {
+        const [id, days] = p.split(":");
+        const wait = days === undefined ? (i === 0 ? 0 : 1) : Number(days);
+        if (!Number.isInteger(wait) || wait < 0)
+            throw new Error(`--steps step ${i + 1}: the wait must be a whole number of days (templateId:days).`);
+        return { templateId: uuidArg(id, "--steps"), waitDays: i === 0 ? 0 : wait };
+    });
+}
+function withSequenceSettingFlags(cmd) {
+    let c = cmd;
+    for (const [flag, desc] of SEQUENCE_SETTING_FLAGS)
+        c = c.option(flag, desc);
+    return c;
+}
+sequences
+    .command("list")
+    .description("List sequences (GET /emails/sequences), newest first: type (email | sms), isActive (On/Off), steps, senderUserId and sender, the stop rules, allowAutomationEnroll, allowReenroll, weekdaysOnly, sendStartHour, sendEndHour, archivedAt, people in it now. Archived ones are left out unless --archived. An API key sees only the channel(s) it is scoped to")
+    .option("--type <email|sms>", "only this channel")
+    .option("--on", "only sequences that are On")
+    .option("--off", "only sequences that are Off")
+    .option("--archived", "archived sequences only")
+    .option("--summary", "a light row per sequence (view=summary): id, name, type, isActive, dates, enrolledCount, description cut to 300 characters, stepCount")
+    .option("--page <n>", "page number")
+    .option("--limit <n>", "results per page (per_page, max 200)")
+    .action(run(async (client, opts) => {
+    const params = {};
+    if (opts.type !== undefined) {
+        if (opts.type !== "email" && opts.type !== "sms")
+            throw new Error("--type must be email or sms.");
+        params.type = opts.type;
+    }
+    if (opts.on && opts.off)
+        throw new Error("--on and --off exclude each other.");
+    if (opts.on)
+        params.is_active = "true";
+    if (opts.off)
+        params.is_active = "false";
+    if (opts.archived)
+        params.archived = "true";
+    if (opts.summary)
+        params.view = "summary";
+    if (opts.page !== undefined)
+        params.page = opts.page;
+    if (opts.limit !== undefined)
+        params.per_page = opts.limit;
+    return client.get(`/api/v1/emails/sequences${buildQuery(params)}`);
+}));
+sequences
+    .command("get <id>")
+    .description("One sequence with its steps (template per step, wait in days), sender, send window, stop rules, enrollment switches, archivedAt, people in it now and enrollmentStats (people per run status)")
+    .action(run(async (client, id) => client.get(`/api/v1/emails/sequences/${uuidArg(id, "id")}`)));
+withSequenceSettingFlags(sequences
+    .command("create <name>")
+    .description("Create an Email or SMS sequence from saved templates (POST /emails/sequences). Created Off unless --on. The type cannot change afterwards")
+    .option("--type <email|sms>", "the channel (default email)")
+    .option("--steps <steps>", "the steps in order: templateId:days,templateId:days (the first step's wait is 0) or a JSON array of {templateId, waitDays}")
+    .option("--description <text>", "description")
+    .option("--on", "turn it On right away")
+    .option("--json <json>", "full JSON body, merged over the flags")).action(run(async (client, name, opts) => {
+    const body = { name, ...sequenceSettingsBody(opts) };
+    if (opts.type !== undefined) {
+        if (opts.type !== "email" && opts.type !== "sms")
+            throw new Error("--type must be email or sms.");
+        body.type = opts.type;
+    }
+    if (opts.steps !== undefined)
+        body.steps = sequenceStepsArg(opts.steps);
+    if (opts.description !== undefined)
+        body.description = opts.description;
+    if (opts.on)
+        body.isActive = true;
+    if (opts.json !== undefined)
+        Object.assign(body, jsonArg(opts.json, "--json"));
+    if (!Array.isArray(body.steps) || body.steps.length === 0)
+        throw new Error("--steps is required: at least one template.");
+    return client.post("/api/v1/emails/sequences", body);
+}));
+withSequenceSettingFlags(sequences
+    .command("update <id>")
+    .description("Change a sequence (PATCH /emails/sequences/:id): name, steps, sender, send window, stop rules, enrollment switches. The type cannot change. While people are in it, the steps they already received cannot be changed, removed or reordered (409 sequence_steps_in_use); later steps change and new ones append")
+    .option("--name <name>", "new name")
+    .option("--description <text>", "description")
+    .option("--steps <steps>", "the whole step list, in order (replaces the current steps): templateId:days,... or a JSON array")
+    .option("--json <json>", "full JSON body, merged over the flags")).action(run(async (client, id, opts) => {
+    const body = sequenceSettingsBody(opts);
+    if (opts.name !== undefined)
+        body.name = opts.name;
+    if (opts.description !== undefined)
+        body.description = opts.description;
+    if (opts.steps !== undefined)
+        body.steps = sequenceStepsArg(opts.steps);
+    if (opts.json !== undefined)
+        Object.assign(body, jsonArg(opts.json, "--json"));
+    if (Object.keys(body).length === 0)
+        throw new Error("Nothing to change: pass at least one flag.");
+    return client.patch(`/api/v1/emails/sequences/${uuidArg(id, "id")}`, body);
+}));
+sequences
+    .command("on <id>")
+    .description("Turn a sequence On: its runs continue from where they are")
+    .action(run(async (client, id) => client.patch(`/api/v1/emails/sequences/${uuidArg(id, "id")}`, { isActive: true })));
+sequences
+    .command("off <id>")
+    .description("Turn a sequence Off: every run stays where it is, nothing sends, until it is turned On again")
+    .action(run(async (client, id) => client.patch(`/api/v1/emails/sequences/${uuidArg(id, "id")}`, { isActive: false })));
+sequences
+    .command("archive <id>")
+    .description("Archive a sequence: Off and hidden from lists (see `sequences list --archived`)")
+    .option("--restore", "bring an archived sequence back (stays Off until turned On)")
+    .action(run(async (client, id, opts) => client.patch(`/api/v1/emails/sequences/${uuidArg(id, "id")}`, { archived: !opts.restore })));
+sequences
+    .command("check <id> <contactIds...>")
+    .description("Check contacts BEFORE enrolling them (POST /emails/sequences/:id/preflight, up to 500): total, eligible, skipped, errors (blockers: Off, archived, a missing template, an unverified domain; any blocker makes nobody eligible), warnings, contacts [{contactId, eligible, reasons}]. Nothing is written")
+    .action(run(async (client, id, contactIds) => client.post(`/api/v1/emails/sequences/${uuidArg(id, "id")}/preflight`, { contactIds: sequenceContactIds(contactIds) })));
+sequences
+    .command("senders <channel>")
+    .description("Who can be a sequence's sender (GET /emails/sequences/senders), for email or sms: every active member who accepted their invite; sms lists each one's assigned line (an SMS sequence needs one), email each one's address")
+    .action(run(async (client, channel) => {
+    if (channel !== "email" && channel !== "sms")
+        throw new Error("channel must be email or sms.");
+    return client.get(`/api/v1/emails/sequences/senders?channel=${channel}`);
+}));
+sequences
+    .command("pick-list <id>")
+    .description("Who of a saved list goes into the sequence next (POST /emails/sequences/:id/pick-from-list): the server walks the list in a stable order, leaves out whoever is already in, checks the rest, and returns up to --limit eligible contacts plus a cursor. Enroll the ids, then call again with --cursor until exhausted. Nothing is written")
+    .option("--smart-view <id>", "the Smart View to pick from (one of --smart-view / --smart-list)")
+    .option("--smart-list <id>", "the Smart List to pick from")
+    .option("--limit <n>", "eligible contacts to return, 1-500 (default 500)")
+    .option("--cursor <cursor>", "where to continue, from the previous call")
+    .action(run(async (client, id, opts) => {
+    if (!opts.smartView && !opts.smartList)
+        throw new Error("Pass --smart-view or --smart-list.");
+    if (opts.smartView && opts.smartList)
+        throw new Error("Pass one of --smart-view or --smart-list.");
+    const body = {};
+    if (opts.smartView)
+        body.smartViewId = uuidArg(opts.smartView, "--smart-view");
+    if (opts.smartList)
+        body.smartListId = uuidArg(opts.smartList, "--smart-list");
+    if (opts.limit !== undefined) {
+        const n = Number(opts.limit);
+        if (!Number.isInteger(n) || n < 1 || n > 500)
+            throw new Error("--limit must be 1 to 500.");
+        body.limit = n;
+    }
+    if (opts.cursor !== undefined)
+        body.cursor = opts.cursor;
+    return client.post(`/api/v1/emails/sequences/${uuidArg(id, "id")}/pick-from-list`, body);
+}));
+sequences
+    .command("enroll <id> <contactIds...>")
+    .description("Enroll contacts (POST /emails/sequences/:id/enroll, up to 500; the sequence must be On and not archived): skips anyone with no address for the channel, opted out, or already in it; with re-enrollment allowed, an ENDED run starts over (a live or paused one never restarts). Returns enrolled, skipped, duplicates, total, skippedDetails")
+    .action(run(async (client, id, contactIds) => client.post(`/api/v1/emails/sequences/${uuidArg(id, "id")}/enroll`, { contactIds: sequenceContactIds(contactIds) })));
+sequences
+    .command("unenroll <id> <contactId>")
+    .description("Remove a contact from a sequence (POST /emails/sequences/:id/unenroll): their live, paused or failed run ends (status cancelled, endedReason removed). Returns contactId, unenrolled, currentStatus")
+    .action(run(async (client, id, contactId) => client.post(`/api/v1/emails/sequences/${uuidArg(id, "id")}/unenroll`, { contactId: uuidArg(contactId, "contactId") })));
+const SEQUENCE_RUN_STATUSES = ["active", "paused", "completed", "failed", "cancelled", "unsubscribed"];
+sequences
+    .command("people <id>")
+    .description("Who is in a sequence (GET /emails/sequences/:id/enrollments), newest run first: contact, currentStep, nextSendAt, engagement, status (active | paused | completed | failed | cancelled | unsubscribed) and endedReason (completed | replied | meeting | opted_out | bounced | deal_closed | removed; null while live). A paused run with no endedReason is live: it resumes when the sequence is turned On")
+    .option("--status <status>", "active | paused | completed | failed | cancelled | unsubscribed")
+    .option("--all-active", "every live run in one answer (all_active=true): no paging, no engagement; refused past 5,000")
+    .option("--page <n>", "page number")
+    .option("--limit <n>", "results per page (per_page, max 200)")
+    .action(run(async (client, id, opts) => {
+    const params = {};
+    if (opts.status !== undefined) {
+        if (!SEQUENCE_RUN_STATUSES.includes(opts.status))
+            throw new Error(`--status must be one of ${SEQUENCE_RUN_STATUSES.join(", ")}.`);
+        params.status = opts.status;
+    }
+    if (opts.allActive)
+        params.all_active = "true";
+    if (opts.page !== undefined)
+        params.page = opts.page;
+    if (opts.limit !== undefined)
+        params.per_page = opts.limit;
+    return client.get(`/api/v1/emails/sequences/${uuidArg(id, "id")}/enrollments${buildQuery(params)}`);
+}));
+sequences
+    .command("stats <id>")
+    .description("Performance of a sequence (GET /emails/sequences/:id/stats): totals {enrolled (runs started, all time), contacts (people in it now), sent, opened, clicked, loggedSends, openRate, clickRate}, perStep and removedSteps")
+    .action(run(async (client, id) => client.get(`/api/v1/emails/sequences/${uuidArg(id, "id")}/stats`)));
+/** contact ids as given, or a comma-separated list in one argument; 1 to 500 UUIDs */
+function sequenceContactIds(args) {
+    const ids = args.flatMap((a) => a.split(",")).map((s) => s.trim()).filter(Boolean);
+    if (ids.length === 0)
+        throw new Error("Pass at least one contact id.");
+    if (ids.length > 500)
+        throw new Error("At most 500 contacts per call.");
+    return ids.map((id) => uuidArg(id, "contactId"));
+}
 const dripEnrollments = program.command("drip-enrollments").description("Drip enrollment recovery");
 dripEnrollments
     .command("cancel-barrier <id>")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt",
-  "version": "1.57.0",
+  "version": "1.58.1",
   "description": "Command-line interface for Conduyt CRM — manage contacts, deals, pipelines, and run insight queries from your terminal.",
   "type": "module",
   "main": "dist/index.js",