@dench.com/cli 3.5.6-staging.344 → 3.6.0-staging.356

package/lib/campaign-timeline.ts

@@ -0,0 +1,189 @@
+export type TimelineRun = {
+  _id: string;
+  stepId: string;
+  stepIndex: number;
+  type: string;
+  status: string;
+  scheduledAt?: number;
+  startedAt?: number;
+  waitUntil?: number;
+  retryAt?: number;
+  completedAt?: number;
+  emailMessageId?: string;
+  lastError?: string;
+  result?: unknown;
+};
+
+export type TimelineEmail = {
+  _id: string;
+  subject?: string;
+  textBody?: string;
+  status?: string;
+  sentAt?: number;
+  firstOpenedAt?: number;
+  firstClickedAt?: number;
+  lastError?: string;
+};
+
+export type TimelineLinkedin = {
+  outreachStepRunId?: string;
+  direction?: string;
+  text?: string;
+  sentAt?: number;
+  deliveredAt?: number;
+  readAt?: number;
+};
+
+export type TimelineResult = {
+  enrollment: {
+    _id: string;
+    displayName?: string;
+    status: string;
+    lastError?: string;
+    repliedAt?: number;
+    linkedinProfileUrl?: string;
+    personalization?: unknown;
+  };
+  steps: Array<{
+    _id: string;
+    type: string;
+    order: number;
+    waitHours?: number;
+  }>;
+  runs: TimelineRun[];
+  emailMessages: TimelineEmail[];
+  linkedinMessages: TimelineLinkedin[];
+};
+
+export type TimelineStep = {
+  step: number;
+  stepId: string;
+  type: string;
+  status: string;
+  outcome: string;
+  at: number | null;
+  detail: string[];
+  subject?: string;
+  text?: string;
+  error?: string;
+};
+
+const SKIP_REASONS: Record<string, string> = {
+  missing_email_identity: "Skipped: no email address",
+  missing_linkedin_identity: "Skipped: no LinkedIn profile",
+  not_connected_on_linkedin: "Skipped: not connected on LinkedIn",
+  already_connected_on_linkedin: "Skipped: already connected on LinkedIn",
+  already_connected: "Skipped: already connected",
+  not_connected: "Skipped: not connected on LinkedIn",
+  linkedin_connection_timeout:
+    "Skipped: they did not accept the request in time",
+  recipient_invited_sender: "Skipped: they had already sent you a request",
+  provider_outcome_unresolved: "Skipped: we could not confirm it went out",
+  unsubscribe: "Skipped: they unsubscribed",
+  bounce: "Skipped: their address bounced",
+};
+
+const RUN_STATUS: Record<string, string> = {
+  queued: "Queued",
+  running: "Sending",
+  waiting: "Waiting",
+  retry: "Will retry",
+  sent: "Done",
+  skipped: "Skipped",
+  failed: "Failed",
+  unknown: "Needs a look",
+};
+
+const EMAIL_STATUS: Record<string, string> = {
+  queued: "sending",
+  bounced: "bounced",
+  complained: "marked as spam",
+  failed: "could not send",
+};
+
+function skipReason(result: unknown): string {
+  const reason =
+    result && typeof result === "object"
+      ? (result as { reason?: unknown }).reason
+      : undefined;
+  return (typeof reason === "string" && SKIP_REASONS[reason]) || "Skipped";
+}
+
+function outcomeOf(run: TimelineRun): string {
+  if (run.status === "skipped") return skipReason(run.result);
+  if (run.status === "sent") {
+    if (run.type === "wait") return "Waited";
+    if (run.type === "linkedin_visit") return "Visited";
+    return "Sent";
+  }
+  return RUN_STATUS[run.status] ?? run.status;
+}
+
+export function timelineSteps(result: TimelineResult): TimelineStep[] {
+  const steps = new Map(result.steps.map((step) => [String(step._id), step]));
+  const emails = new Map(
+    result.emailMessages.map((message) => [String(message._id), message]),
+  );
+  const linkedin = new Map(
+    result.linkedinMessages.map((message) => [
+      String(message.outreachStepRunId ?? ""),
+      message,
+    ]),
+  );
+  return [...result.runs]
+    .sort((a, b) => a.stepIndex - b.stepIndex)
+    .map((run) => {
+      const step = steps.get(String(run.stepId));
+      const email = run.emailMessageId
+        ? emails.get(String(run.emailMessageId))
+        : undefined;
+      const message = linkedin.get(String(run._id));
+      const detail: string[] = [];
+      if (email) {
+        if (email.firstClickedAt) detail.push("clicked");
+        else if (email.firstOpenedAt) detail.push("opened");
+        else if (email.status && EMAIL_STATUS[email.status])
+          detail.push(EMAIL_STATUS[email.status]);
+      } else if (message) {
+        if (message.readAt) detail.push("read");
+        else if (message.deliveredAt) detail.push("delivered");
+      }
+      const text = (email?.textBody ?? message?.text)?.trim();
+      const problem =
+        run.status === "sent" || run.status === "skipped"
+          ? undefined
+          : (run.lastError ?? email?.lastError)?.trim();
+      return {
+        step: (step?.order ?? run.stepIndex) + 1,
+        stepId: String(run.stepId),
+        type: run.type,
+        status: run.status,
+        outcome: outcomeOf(run),
+        at:
+          run.completedAt ??
+          run.retryAt ??
+          run.waitUntil ??
+          run.startedAt ??
+          run.scheduledAt ??
+          null,
+        detail,
+        ...(email?.subject ? { subject: email.subject } : {}),
+        ...(text ? { text } : {}),
+        ...(problem ? { error: problem } : {}),
+      };
+    });
+}
+
+export function personAddress(enrollment: TimelineResult["enrollment"]) {
+  const snapshot =
+    enrollment.personalization && typeof enrollment.personalization === "object"
+      ? (enrollment.personalization as Record<string, unknown>)
+      : {};
+  const email = typeof snapshot.email === "string" ? snapshot.email : undefined;
+  return {
+    ...(email ? { email } : {}),
+    ...(enrollment.linkedinProfileUrl
+      ? { linkedinProfileUrl: enrollment.linkedinProfileUrl }
+      : {}),
+  };
+}

package/lib/cli-version.ts

@@ -0,0 +1,14 @@
+import { readFile } from "node:fs/promises";
+
+export async function cliVersion(): Promise<string> {
+  try {
+    const packageJson = JSON.parse(
+      await readFile(new URL("../package.json", import.meta.url), "utf8"),
+    ) as { version?: unknown };
+    return typeof packageJson.version === "string"
+      ? packageJson.version
+      : "unknown";
+  } catch {
+    return "unknown";
+  }
+}