@dench.com/cli 3.11.6 → 3.11.7

package/lib/campaign-agent.ts

@@ -215,7 +215,15 @@ const RECIPIENT_ALIASES: Record<string, RecipientField> = {
 };
 
 const MAX_PEOPLE_FILE_RECIPIENTS = 300;
-const PEOPLE_BATCH_SIZE = 50;
+/**
+ * People per `addEnrollments` call, as the app's Add people sends them
+ * (`DIRECT_ENROLL_CHUNK`): a row that matches or creates a Lead is costly,
+ * and a 50-person call ran past the mutation limit on staging and was
+ * also the long transaction background CRM work kept conflicting with.
+ */
+const PEOPLE_BATCH_SIZE = 20;
+/** Rows `add --list` reads at most looking past duplicates (50 pages). */
+const MAX_LIST_ROWS_READ = 5000;
 
 function aliasKey(key: string): string {
   return key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -455,9 +463,12 @@ function onlyExclusions(filters: Record<string, unknown>): boolean {
 }
 
 function rangeValue(raw: string, flag: string): { min?: number; max?: number } {
-  const [minRaw, maxRaw = ""] = raw.includes(":")
-    ? raw.split(":", 2)
-    : [raw, ""];
+  const parts = raw.split(":");
+  // One min:max pair. A third part ("2:10:99", "2::99") was silently
+  // dropped, sometimes with the upper bound.
+  if (parts.length > 2)
+    throw new Error(`${flag} takes one min:max pair, e.g. 2:10, 2: or :10`);
+  const [minRaw = "", maxRaw = ""] = parts;
   const part = (text: string, label: string) => {
     const trimmed = text.trim();
     if (!trimmed) return undefined;
@@ -472,6 +483,8 @@ function rangeValue(raw: string, flag: string): { min?: number; max?: number } {
   const max = part(maxRaw, "max");
   if (min === undefined && max === undefined)
     throw new Error(`${flag} needs min:max, e.g. 2:10, 2: or :10`);
+  if (min !== undefined && max !== undefined && min > max)
+    throw new Error(`${flag} min (${min}) is greater than max (${max})`);
   return {
     ...(min !== undefined ? { min } : {}),
     ...(max !== undefined ? { max } : {}),
@@ -923,17 +936,23 @@ async function addPeopleFile(
   return addRecipients(ctx, recipients, file, reference, allowDuplicates);
 }
 
-function columnSummary(columns: CsvColumn[]): string[] {
+function columnSummary(
+  columns: CsvColumn[],
+  /** Channels switched off with `--map <field>=none`. */
+  off: { email?: boolean; linkedin?: boolean } = {},
+): string[] {
   const names = (role: CsvColumn["role"]) =>
     columns
       .filter((column) => column.role === role)
       .map((column) => column.label);
   const parts: string[] = [];
   const email = names("email");
-  if (email.length) parts.push(`email = ${email.join(", ")}`);
+  if (off.email) parts.push("email off");
+  else if (email.length) parts.push(`email = ${email.join(", ")}`);
   const linkedin = names("linkedin");
-  if (linkedin.length) parts.push(`LinkedIn = ${linkedin.join(", ")}`);
-  if (!email.length && !linkedin.length)
+  if (off.linkedin) parts.push("LinkedIn off");
+  else if (linkedin.length) parts.push(`LinkedIn = ${linkedin.join(", ")}`);
+  if (!email.length && !linkedin.length && !off.email && !off.linkedin)
     parts.push("no email or LinkedIn column");
   const person = [
     ...names("full name"),
@@ -1027,67 +1046,99 @@ async function addList(
     throw new Error(
       `"${campaign.name}" is full (${MAX_CAMPAIGN_PEOPLE} people). Nothing was imported.`,
     );
-  let wanted: number;
+  let limit: ReturnType<typeof parseLimit>;
   try {
-    wanted = Math.min(
-      parseLimit(options.limitRaw, {
-        defaultValue: MAX_CAMPAIGN_PEOPLE,
-        cap: MAX_CAMPAIGN_PEOPLE,
-        command: "campaign add --list",
-      }).effective,
-      room || MAX_CAMPAIGN_PEOPLE,
-    );
+    limit = parseLimit(options.limitRaw, {
+      defaultValue: MAX_CAMPAIGN_PEOPLE,
+      cap: MAX_CAMPAIGN_PEOPLE,
+      command: "campaign add --list",
+    });
   } catch (error) {
     throw new Error(error instanceof Error ? error.message : String(error));
   }
-  const picked: Recipient[] = [];
+  // How many people to add: the --limit, the campaign cap and its room.
+  const wanted = Math.min(limit.effective, room || MAX_CAMPAIGN_PEOPLE);
+  const clamped = options.limitRaw !== undefined && wanted < limit.requested;
+  if (clamped)
+    notice(
+      limit.clamped
+        ? `--limit ${limit.requested} is above the ${MAX_CAMPAIGN_PEOPLE}-person campaign maximum; adding up to ${wanted}.`
+        : `--limit ${limit.requested} is more than "${campaign.name}" has room for; adding up to ${wanted}.`,
+    );
+  const limitInfo = clamped
+    ? {
+        limitClamped: true,
+        limitRequested: limit.requested,
+        limitEffective: wanted,
+      }
+    : {};
+  // Rows are read a page at a time as they're needed. Adding keeps reading
+  // past people who turn out to be duplicates, so a list whose first rows
+  // are already in the campaign still reaches the eligible rows after them.
+  const queue: Recipient[] = [];
   const sample: Array<Record<string, string>> = [];
   let title = "";
   let rowCount = 0;
+  let rowsRead = 0;
   let cursor: string | undefined;
-  do {
-    const page = (await invoke(ctx, "lists.rows", {
-      artifactId,
-      limit: 100,
-      ...(cursor ? { cursor } : {}),
-      ...(options.enrichment ? { enrichment: options.enrichment } : {}),
-    })) as ListRowsPage;
-    title = page.title ?? title;
-    rowCount = page.rowCount ?? rowCount;
-    for (const entry of page.page ?? []) {
-      if (picked.length >= wanted) break;
-      picked.push(listRowRecipient(entry.row, entry.index));
-      if (sample.length < 5) sample.push(listRowSummary(entry.row));
+  let exhausted = false;
+  const readUntil = async (count: number) => {
+    while (
+      queue.length < count &&
+      !exhausted &&
+      rowsRead < MAX_LIST_ROWS_READ
+    ) {
+      const page = (await invoke(ctx, "lists.rows", {
+        artifactId,
+        limit: 100,
+        ...(cursor ? { cursor } : {}),
+        ...(options.enrichment ? { enrichment: options.enrichment } : {}),
+      })) as ListRowsPage;
+      title = page.title ?? title;
+      rowCount = page.rowCount ?? rowCount;
+      for (const entry of page.page ?? []) {
+        rowsRead += 1;
+        queue.push(listRowRecipient(entry.row, entry.index));
+        if (sample.length < 5) sample.push(listRowSummary(entry.row));
+      }
+      exhausted = Boolean(page.isDone || !page.continueCursor);
+      cursor = exhausted ? undefined : (page.continueCursor ?? undefined);
     }
-    cursor =
-      page.isDone || !page.continueCursor || picked.length >= wanted
-        ? undefined
-        : page.continueCursor;
-  } while (cursor);
-  const list = { artifactId, title, rowCount, rows: picked.length };
-  if (!picked.length)
+  };
+  await readUntil(options.preview ? wanted : PEOPLE_BATCH_SIZE);
+  if (!queue.length)
     throw new Error(
       `${title ? `"${title}"` : artifactId} has no rows${options.enrichment ? ` with enrichment "${options.enrichment}"` : ""} to add (${rowCount} saved). See dench lists rows ${artifactId}.`,
     );
-  if (options.preview)
+  if (options.preview) {
+    const previewed = queue.slice(0, wanted);
     return print(
       ctx,
       {
         sequenceId: campaign._id,
         campaignStatus: campaign.status,
-        list,
+        ...limitInfo,
+        list: { artifactId, title, rowCount, rows: previewed.length },
         sample,
       },
-      `${plural(picked.length, "row", "rows")} of "${title}" would be added to "${campaign.name}"; nothing was imported.`,
+      `${plural(previewed.length, "row", "rows")} of "${title}" would be added to "${campaign.name}"; nothing was imported. People already in the campaign are skipped, and later rows take their places.`,
     );
+  }
   const totals: BatchCounts & { cappedAtLimit: number | null } = {
     ...batchCounts({}),
     cappedAtLimit: null,
   };
   const perBatch: Array<Record<string, unknown>> = [];
   let missingInfoSample: unknown;
-  for (let offset = 0; offset < picked.length; offset += PEOPLE_BATCH_SIZE) {
-    const chunk = picked.slice(offset, offset + PEOPLE_BATCH_SIZE);
+  let attempted = 0;
+  const list = () => ({ artifactId, title, rowCount, rows: attempted });
+  while (totals.added < wanted) {
+    const size = Math.min(PEOPLE_BATCH_SIZE, wanted - totals.added);
+    await readUntil(size);
+    const chunk = queue.splice(0, size);
+    if (!chunk.length) break;
+    const offset = attempted;
+    attempted += chunk.length;
     let result: Record<string, unknown>;
     try {
       result = (await invoke(ctx, "campaigns.people.addBatch", {
@@ -1102,7 +1153,8 @@ async function addList(
         sequenceId: campaign._id,
         campaignStatus: campaign.status,
         ...totals,
-        list,
+        ...limitInfo,
+        list: list(),
         batches: perBatch,
         failedBatch: { offset, size: chunk.length },
         error: message,
@@ -1141,10 +1193,11 @@ async function addList(
       campaignStatus: campaign.status,
       ...totals,
       ...(missingInfoSample ? { missingInfoSample } : {}),
+      ...limitInfo,
       batches: perBatch,
-      list,
+      list: list(),
     },
-    `Added ${totals.added} of ${plural(picked.length, "row", "rows")} from "${title}" to "${campaign.name}" (${campaign.status}).`,
+    `Added ${totals.added} of ${plural(attempted, "row", "rows")} from "${title}" to "${campaign.name}" (${campaign.status}).`,
   );
 }
 
@@ -1191,7 +1244,10 @@ async function addCsv(
     hasHeader: result.hasHeader,
     columns,
   };
-  const read = columnSummary(result.columns);
+  const read = columnSummary(result.columns, {
+    email: mapping.email === null,
+    linkedin: mapping.linkedin === null,
+  });
   const mergeColumns = result.columns.filter(
     (column) => column.role === "merge value",
   );
@@ -1205,10 +1261,14 @@ async function addCsv(
     );
   if (result.duplicates > 0)
     notice(
-      `${plural(result.duplicates, "row repeats", "rows repeat")} an earlier person's email or LinkedIn profile URL and ${result.duplicates === 1 ? "was" : "were"} left out.`,
+      `${plural(result.duplicates, "row repeats", "rows repeat")} an earlier person's email or LinkedIn profile URL; anything new on ${result.duplicates === 1 ? "it" : "them"} was added to that person.`,
+    );
+  if (table.raggedRows)
+    notice(
+      `${plural(table.raggedRows, "row has", "rows have")} more cells than the header row, so the columns may not line up; the extra cells became their own merge values. Check ${file} if that looks wrong.`,
     );
   notice(
-    `Read ${file}: ${read.join("; ")}${mergeColumns.length ? `; ${plural(mergeColumns.length, "other column becomes", "other columns become")} merge values (${mergeColumns.map((column) => `{{${column.label}}}`).join(", ")})` : ""}.`,
+    `Read ${file}: ${read.join("; ")}${mergeColumns.length ? `; ${plural(mergeColumns.length, "other column becomes", "other columns become")} merge values (${mergeColumns.map((column) => `{{${column.mergeKey?.replace(/^crm:/, "") ?? column.label}}}`).join(", ")})` : ""}.`,
   );
   if (options.preview)
     return print(
@@ -1399,10 +1459,13 @@ async function draft(ctx: Context) {
     );
   const timezone = assertIanaTimezone(flags.timezone ?? localTimezone());
   schedulePatchFromFlags(flags, { fallbackTimezone: timezone });
+  // The chosen senders go in with the draft, so one that can't be used fails
+  // before anything is created.
   const { sequenceId } = (await invoke(ctx, "campaigns.drafts.create", {
     clientRequestId,
     ...(name ? { name } : {}),
     timezone,
+    ...senderPools,
   })) as { sequenceId: string };
   let campaign = await readCampaign(ctx, sequenceId);
   const schedule = schedulePatchFromFlags(flags, {
@@ -1418,7 +1481,23 @@ async function draft(ctx: Context) {
   const patch = { ...schedule, ...senderPools };
   if (hasScheduleChanges(patch)) {
     if (campaign.status === "draft") {
-      await invoke(ctx, "campaigns.update", { sequenceId, ...patch });
+      try {
+        await invoke(ctx, "campaigns.update", { sequenceId, ...patch });
+      } catch (error) {
+        // The draft exists: say which, and that the same --request-id
+        // returns it, so a retry fixes it rather than creating another.
+        const message = backendErrorText(error);
+        print(ctx, {
+          sequenceId,
+          clientRequestId,
+          status: campaign.status,
+          settingsSaved: false,
+          error: message,
+        });
+        throw new Error(
+          `Created draft "${campaign.name}" [${sequenceId}], but its settings weren't saved: ${message}. Re-run with --request-id ${clientRequestId} and corrected flags to update the same draft, or use dench campaign set ${sequenceId}.`,
+        );
+      }
       campaign = await readCampaign(ctx, sequenceId);
     } else {
       notice(
@@ -1636,6 +1715,13 @@ export async function runCampaignAgentCommand(
     input.leadId = shift(ctx.args, "draft lead id");
   if (verb === "save" && !input.clientRequestId)
     input.clientRequestId = randomUUID();
+  // A save from here is deliberate: like the app's "Save and exit" it gets
+  // a screen, so `builder drafts` lists it and it keeps for two weeks.
+  // (Without one the server treats it as a passing autosave: unlisted,
+  // deleted after a day.)
+  if (verb === "save" && input.screen === undefined)
+    input.screen =
+      input.source === "lookalike" || input.lookalike ? "lookalike" : "target";
   finishArgs(ctx.args, "builder");
   return print(ctx, await invoke(ctx, `campaigns.builder.${verb}`, input));
 }