@dench.com/cli 2.1.5 → 2.2.1

package/crm.ts

@@ -509,6 +509,23 @@ const api = {
   members: {
     list: makeFunctionReference<"query">("functions/crm/members:list"),
   },
+  automations: {
+    list: makeFunctionReference<"query">("functions/crm/automations:list"),
+    setEnabled: makeFunctionReference<"mutation">(
+      "functions/crm/automations:setEnabled",
+    ),
+  },
+  templates: {
+    listAvailable: makeFunctionReference<"query">(
+      "functions/crm/templates:listAvailable",
+    ),
+    install: makeFunctionReference<"mutation">(
+      "functions/crm/templates:install",
+    ),
+    removeSampleData: makeFunctionReference<"mutation">(
+      "functions/crm/templates:removeSampleData",
+    ),
+  },
 };
 
 export async function runCrmCommand(opts: {
@@ -573,6 +590,10 @@ export async function runCrmCommand(opts: {
       return await runDocsCommand(ctx);
     case "actions":
       return await runActionsCommand(ctx);
+    case "automations":
+      return await runAutomationsCommand(ctx);
+    case "templates":
+      return await runTemplatesCommand(ctx);
     case "members":
       // Alias for `dench members` so the AI agent finds the roster
       // surface from inside the `dench crm` namespace it's primed
@@ -584,6 +605,81 @@ export async function runCrmCommand(opts: {
   }
 }
 
+/**
+ * `dench crm automations …` — deterministic CRM rules (installed by
+ * templates, e.g. "qualified prospect → opportunity"). These fire inside
+ * entry writes automatically; this surface is for visibility and the
+ * enable/disable kill switch. There is no create verb here — rules are
+ * installed by `crm templates install` (or programmatically).
+ */
+async function runAutomationsCommand(ctx: CrmCliContext): Promise<void> {
+  const verb = ctx.args.shift();
+  switch (verb) {
+    case "list": {
+      assertNoUnknownFlags(ctx.args, "crm automations list");
+      out(ctx, await callQuery(ctx, api.automations.list, {}));
+      return;
+    }
+    case "enable":
+    case "disable": {
+      const automationId = shift(ctx.args, "automation id");
+      assertNoUnknownFlags(ctx.args, `crm automations ${verb}`);
+      out(
+        ctx,
+        await callMutation(ctx, api.automations.setEnabled, {
+          automationId,
+          enabled: verb === "enable",
+        }),
+      );
+      return;
+    }
+    default:
+      throw new CrmCliError(
+        `Unknown automations verb: ${verb ?? "(none)"}. Use list | enable <id> | disable <id>.`,
+      );
+  }
+}
+
+/**
+ * `dench crm templates …` — one-click CRM setups (objects + fields +
+ * kanban statuses + pinned views + automations + sample rows tagged
+ * "Sample"). Installs are idempotent and compose across templates.
+ */
+async function runTemplatesCommand(ctx: CrmCliContext): Promise<void> {
+  const verb = ctx.args.shift();
+  switch (verb) {
+    case "list": {
+      assertNoUnknownFlags(ctx.args, "crm templates list");
+      out(ctx, await callQuery(ctx, api.templates.listAvailable, {}));
+      return;
+    }
+    case "install": {
+      const templateId = shift(ctx.args, "template id");
+      assertNoUnknownFlags(ctx.args, "crm templates install");
+      out(
+        ctx,
+        await callMutation(ctx, api.templates.install, { templateId }),
+      );
+      return;
+    }
+    case "remove-sample-data": {
+      const templateId = shift(ctx.args, "template id");
+      assertNoUnknownFlags(ctx.args, "crm templates remove-sample-data");
+      out(
+        ctx,
+        await callMutation(ctx, api.templates.removeSampleData, {
+          templateId,
+        }),
+      );
+      return;
+    }
+    default:
+      throw new CrmCliError(
+        `Unknown templates verb: ${verb ?? "(none)"}. Use list | install <id> | remove-sample-data <id>.`,
+      );
+  }
+}
+
 async function runCrmMembersCommand(ctx: CrmCliContext): Promise<void> {
   const { runMembersCommand } = await import("./members");
   // Re-prepend `--json` so the members dispatcher's own `hasFlag`
@@ -634,6 +730,11 @@ async function runObjectsCommand(ctx: CrmCliContext): Promise<void> {
       const description = getFlag(ctx.args, "--description");
       const defaultView = getFlag(ctx.args, "--default-view") as any;
       const icon = getFlag(ctx.args, "--icon");
+      // Cosmetic relabels (UI only; canonical `name` is unchanged, so
+      // protected objects like `people` can be shown as e.g. "Clients").
+      // Pass an empty string to clear back to the default label.
+      const displayName = getFlag(ctx.args, "--display-name");
+      const displayNameSingular = getFlag(ctx.args, "--display-name-singular");
       assertNoUnknownFlags(ctx.args, "crm objects update");
       out(
         ctx,
@@ -642,6 +743,8 @@ async function runObjectsCommand(ctx: CrmCliContext): Promise<void> {
           description,
           defaultView,
           icon,
+          displayName,
+          displayNameSingular,
         }),
       );
       return;
@@ -2618,7 +2721,9 @@ Objects (CRM tables):
   dench crm objects list [--json]
   dench crm objects get <name>
   dench crm objects create <name> [--description ...] [--default-view kanban] [--icon ...]
-  dench crm objects update <name> [--default-view ...] [--icon ...]
+  dench crm objects update <name> [--default-view ...] [--icon ...] [--display-name "Clients"] [--display-name-singular "Client"]
+      --display-name relabels the UI only; the canonical <name> stays the
+      command/API identifier (works on protected objects too).
   dench crm objects rename <from> <to>
   dench crm objects delete <name>
 
@@ -2743,10 +2848,32 @@ Docs:
   dench crm docs create <path> [--title ...] [--icon ...] [--link-entry <id>]
   dench crm docs link <path> --object <name> --entry <id>
 
+Templates (one-click CRM setups: objects + automations + sample rows):
+  dench crm templates list [--json]
+      Catalog with per-org installed flags. Installs are idempotent and
+      compose (e.g. sales + fundraising share the company Type enum).
+  dench crm templates install <templateId>
+  dench crm templates remove-sample-data <templateId>
+      Deletes only the template's sample rows (tagged "Sample"); schema,
+      views, and automations stay.
+
+Automations (deterministic rules, fire inside entry writes):
+  dench crm automations list [--json]
+      e.g. "prospect Status -> Qualified creates an opportunity". Writes
+      that trigger one return an automationEffects array describing what
+      was created/updated — expected behavior, not an error.
+  dench crm automations enable <automationId>
+  dench crm automations disable <automationId>
+
 Actions:
   dench crm actions list <entryId>
   dench crm actions run <actionId> --field-id <id> --entry-id <id>
 
+Object names: commands take the canonical object name (singular lowercase,
+e.g. people, company, prospect). Display labels shown in the UI (a template
+may relabel people as "Clients") and plural forms also resolve when
+unambiguous, but prefer canonical names from 'crm objects list'.
+
 Global flags:
   --json    Output raw JSON instead of pretty-printed text.
 `);

package/dench.ts

@@ -296,9 +296,34 @@ function throwIfCliError(value: unknown) {
   }
 }
 
+/**
+ * Production Convex deployments mask `error.message` ("[Request ID: …]
+ * Server Error") but forward `ConvexError.data` verbatim. Prefer the data
+ * payload so agents see the actionable message instead of the mask.
+ */
+function convexErrorData(error: unknown): string | undefined {
+  if (!error || typeof error !== "object" || !("data" in error)) {
+    return undefined;
+  }
+  const data = (error as { data?: unknown }).data;
+  if (typeof data === "string" && data.trim()) return data;
+  if (data && typeof data === "object") {
+    const message = (data as { message?: unknown }).message;
+    if (typeof message === "string" && message.trim()) return message;
+    try {
+      return JSON.stringify(data);
+    } catch {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
 function normalizeCliError(error: unknown): CliError {
   if (error instanceof CliError) return error;
-  const message = error instanceof Error ? error.message : String(error);
+  const message =
+    convexErrorData(error) ??
+    (error instanceof Error ? error.message : String(error));
   if (message.includes("Invalid dev agent key")) {
     return new CliError("Invalid dev agent key", {
       code: "invalid_dev_agent_key",
@@ -486,10 +511,6 @@ Cloud browser (Browserbase, runs entirely in Dench Cloud):
   dench browser stop
   Help: dench browser help
 
-LinkedIn outreach (Browserbase, verified before CRM update):
-  dench linkedin connect <profileUrl> [--entry people:<entryId>] [--json]
-  Help: dench linkedin help
-
 Managed email campaigns (Dench Emailing Service):
   dench email identity verify --from founder@example.com [--json]
   dench email template create --name "Intro" --subject "Hi {{firstName}}" --html-file body.html [--json]
@@ -3713,18 +3734,6 @@ async function main() {
     return;
   }
 
-  if (
-    command === "linkedin" &&
-    (!subcommand || subcommand === "help" || hasFlag("--help"))
-  ) {
-    const { runLinkedInCommand } = await import("./linkedin");
-    await runLinkedInCommand({
-      args: subcommand ? [subcommand] : ["help"],
-      runtime: { host: "", bearerToken: "" },
-    });
-    return;
-  }
-
   if (
     command === "email" &&
     (!subcommand || subcommand === "help" || hasFlag("--help"))
@@ -4043,24 +4052,6 @@ async function main() {
     return;
   }
 
-  if (command === "linkedin") {
-    const subArgs = args.slice(args.indexOf("linkedin") + 1);
-    const { runLinkedInCommand } = await import("./linkedin");
-    const runtime = await getRuntime();
-    const authedRuntime = requireAuthenticatedRuntime(
-      runtime,
-      "dench linkedin",
-    );
-    await runLinkedInCommand({
-      args: subArgs,
-      runtime: {
-        host: authedRuntime.host,
-        bearerToken: authedRuntime.sessionToken,
-      },
-    });
-    return;
-  }
-
   if (command === "chat") {
     const subArgs = args.slice(args.indexOf("chat") + 1);
     const sub = subArgs[0];

package/email.ts

@@ -189,12 +189,19 @@ export function emailHelp() {
 
 Usage:
   dench email identity verify --from founder@example.com [--json]
-  dench email identity verify --domain example.com --from founder@example.com [--json]
+  dench email identity verify --domain example.com [--from founder@example.com] [--json]
+  dench email identity list [--domain example.com] [--json]
+  dench email identity dns --identity <identityId|domain|email> [--json]
   dench email identity status --identity founder@example.com [--json]
   dench email identity status --identity-id <identityId> [--json]
+  dench email identity disable --identity <identityId|email|domain> [--json]
+  dench email identity restore --identity <identityId|email|domain> [--json]
+  dench email send --from founder@example.com --to "Ada <ada@x.com>,bob@y.com" --subject "Hi" (--html-file body.html | --text "...") [--cc ...] [--bcc ...] [--from-name "Ada"] [--reply-to support@x.com] [--reply-message-id <messageId|rfc-id>] [--json]
+  dench email message status --message <messageId> [--json]
+  dench email message list [--limit 25] [--json]
   dench email template create --name "Intro" --subject "Hi {{firstName}}" --html-file body.html [--text-file body.txt] [--json]
   dench email template preview --template <id> --data '{"firstName":"Ada"}' [--json]
-  dench email campaign create --name "Q2 outreach" --identity <id> --template <id> [--json]
+  dench email campaign create --name "Q2 outreach" --identity <identityId|fromEmail> --template <id> [--json]
   dench email campaign recipients add --campaign <id> --file recipients.jsonl [--json]
   dench email campaign preview --campaign <id> [--sample 5] [--json]
   dench email campaign submit --campaign <id> [--json]
@@ -212,6 +219,14 @@ export async function runEmailCommand(ctx: EmailCliContext): Promise<void> {
     await runIdentity(ctx);
     return;
   }
+  if (group === "send") {
+    await runSend(ctx);
+    return;
+  }
+  if (group === "message") {
+    await runMessage(ctx);
+    return;
+  }
   if (group === "template") {
     await runTemplate(ctx);
     return;
@@ -223,11 +238,193 @@ export async function runEmailCommand(ctx: EmailCliContext): Promise<void> {
   throw new EmailCliError(`Unknown dench email subcommand: ${group}`);
 }
 
+/**
+ * Parse a comma-separated address list where each entry is either a bare
+ * email or `Name <email>`.
+ */
+function parseAddressList(
+  value: string | undefined,
+): Array<{ email: string; name?: string }> {
+  if (!value?.trim()) return [];
+  return value
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => {
+      const match = entry.match(/^(.*)<([^<>\s]+@[^<>\s]+)>$/);
+      if (match) {
+        const name = match[1].trim().replace(/^"|"$/g, "").trim();
+        return { email: match[2].trim(), name: name || undefined };
+      }
+      return { email: entry };
+    });
+}
+
+async function runSend(ctx: EmailCliContext) {
+  const from = requiredFlag(ctx.args, "--from");
+  const to = parseAddressList(requiredFlag(ctx.args, "--to"));
+  if (to.length === 0) {
+    throw new EmailCliError(
+      'No valid --to recipients. Use --to "Ada <ada@x.com>,bob@y.com"',
+    );
+  }
+  const cc = parseAddressList(getFlag(ctx.args, "--cc"));
+  const bcc = parseAddressList(getFlag(ctx.args, "--bcc"));
+  const htmlBody = await readTextFlag(ctx.args, "--html", "--html-file");
+  const textBody = await readTextFlag(ctx.args, "--text", "--text-file");
+  if (!htmlBody && !textBody) {
+    throw new EmailCliError(
+      "Provide a body: --html/--html-file and/or --text/--text-file",
+    );
+  }
+  const payload = (await callAction(
+    ctx,
+    "functions/emailCampaignsNode:sendEmail",
+    {
+      fromEmail: from,
+      fromName: getFlag(ctx.args, "--from-name"),
+      to,
+      cc: cc.length > 0 ? cc : undefined,
+      bcc: bcc.length > 0 ? bcc : undefined,
+      replyToEmail: getFlag(ctx.args, "--reply-to"),
+      subject: requiredFlag(ctx.args, "--subject"),
+      htmlBody,
+      textBody,
+      replyToMessageId: getFlag(ctx.args, "--reply-message-id"),
+      configurationSetName: getFlag(ctx.args, "--configuration-set"),
+    },
+  )) as JsonRecord;
+  out(
+    ctx,
+    payload,
+    `Sent to ${to.length + cc.length + bcc.length} recipient(s). Message: ${payload.messageId}\nCheck opens: dench email message status --message ${payload.messageId}`,
+  );
+}
+
+async function runMessage(ctx: EmailCliContext) {
+  const sub = ctx.args.shift();
+  if (sub === "status") {
+    const messageId = requiredFlag(ctx.args, "--message");
+    const payload = (await callQuery(
+      ctx,
+      "functions/emailCampaigns:getMessage",
+      { messageId },
+    )) as JsonRecord;
+    out(ctx, payload, JSON.stringify(payload, null, 2));
+    return;
+  }
+  if (sub === "list") {
+    const limitRaw = getFlag(ctx.args, "--limit");
+    const status = getFlag(ctx.args, "--status");
+    const payload = (await callQuery(
+      ctx,
+      "functions/emailCampaigns:listMessages",
+      {
+        limit: limitRaw ? Number(limitRaw) : undefined,
+        status,
+      },
+    )) as JsonRecord[];
+    const text =
+      payload.length === 0
+        ? "No raw messages sent yet. Use `dench email send`."
+        : payload
+            .map(
+              (message) =>
+                `${message.messageId}  ${message.status}  from=${message.fromEmail}  subject=${JSON.stringify(message.subject)}  opens=${message.openCount}  clicks=${message.clickCount}`,
+            )
+            .join("\n");
+    out(ctx, { ok: true, messages: payload }, text);
+    return;
+  }
+  throw new EmailCliError("Usage: dench email message status|list");
+}
+
+type DnsRecord = {
+  type: string;
+  name: string;
+  value: string;
+  purpose: string;
+};
+
+function buildDnsRecords(domain: string, dkimTokens: string[]): DnsRecord[] {
+  return [
+    ...dkimTokens.map((token) => ({
+      type: "CNAME",
+      name: `${token}._domainkey.${domain}`,
+      value: `${token}.dkim.amazonses.com`,
+      purpose: "DKIM (required for domain verification)",
+    })),
+    {
+      type: "TXT",
+      name: domain,
+      value: "v=spf1 include:amazonses.com ~all",
+      purpose: "SPF (recommended)",
+    },
+    {
+      type: "TXT",
+      name: `_dmarc.${domain}`,
+      value: `v=DMARC1; p=none; rua=mailto:postmaster@${domain}`,
+      purpose: "DMARC (recommended)",
+    },
+  ];
+}
+
+function asDnsRecords(value: unknown): DnsRecord[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (record): record is DnsRecord =>
+      Boolean(record) &&
+      typeof record === "object" &&
+      typeof (record as DnsRecord).type === "string" &&
+      typeof (record as DnsRecord).name === "string" &&
+      typeof (record as DnsRecord).value === "string",
+  );
+}
+
+function formatDnsRecords(records: DnsRecord[]): string {
+  if (records.length === 0) return "";
+  const lines = ["DNS records to add:"];
+  for (const record of records) {
+    lines.push(`  ${record.type}  ${record.name}`);
+    lines.push(`        value: ${record.value}`);
+    if (record.purpose) lines.push(`        (${record.purpose})`);
+  }
+  return lines.join("\n");
+}
+
+async function listIdentitiesQuery(
+  ctx: EmailCliContext,
+  domain?: string,
+): Promise<JsonRecord[]> {
+  const payload = await callQuery(
+    ctx,
+    "functions/emailCampaigns:listIdentities",
+    domain ? { domain } : {},
+  );
+  return Array.isArray(payload) ? (payload as JsonRecord[]) : [];
+}
+
 async function runIdentity(ctx: EmailCliContext) {
   const sub = ctx.args.shift();
   if (sub === "verify") {
-    const domain = getFlag(ctx.args, "--domain");
-    const from = requiredFlag(ctx.args, "--from");
+    const domain = getFlag(ctx.args, "--domain")?.trim().toLowerCase();
+    let from = getFlag(ctx.args, "--from")?.trim();
+    if (!from) {
+      if (!domain) throw new EmailCliError("Missing required --from");
+      // Domain-only verify: reuse the sender mailbox already registered
+      // on this domain so the user doesn't have to repeat --from.
+      const existing = await listIdentitiesQuery(ctx, domain);
+      const preferred =
+        existing.find(
+          (identity) => identity.denchVerificationStatus === "verified",
+        ) ?? existing[0];
+      if (!preferred || typeof preferred.fromEmail !== "string") {
+        throw new EmailCliError(
+          `No sender registered on ${domain} yet. Pass --from <mailbox@${domain}> to register one.`,
+        );
+      }
+      from = preferred.fromEmail;
+    }
     const type = domain ? "domain" : "email";
     const identity = domain ?? from;
     const configurationSetName = getFlag(ctx.args, "--configuration-set");
@@ -243,16 +440,123 @@ async function runIdentity(ctx: EmailCliContext) {
         configurationSetName,
       },
     );
-    const verification = await callAction(
+    const verification = (await callAction(
       ctx,
       "functions/emailCampaignsNode:beginSenderVerification",
       { identityId: (created as JsonRecord).identityId },
-    );
-    out(
-      ctx,
-      { ok: true, created, verification },
+    )) as JsonRecord;
+    const dnsRecords = asDnsRecords(verification.dnsRecords);
+    const text = [
       `Verification started for ${identity}`,
-    );
+      typeof verification.message === "string" ? verification.message : "",
+      formatDnsRecords(dnsRecords),
+    ]
+      .filter(Boolean)
+      .join("\n");
+    out(ctx, { ok: true, created, verification }, text);
+    return;
+  }
+  if (sub === "list") {
+    const domain = getFlag(ctx.args, "--domain")?.trim().toLowerCase();
+    const identities = await listIdentitiesQuery(ctx, domain);
+    const text =
+      identities.length === 0
+        ? "No sending identities yet. Run `dench email identity verify --from you@example.com`."
+        : identities
+            .map(
+              (identity) =>
+                `${identity.identityId}  ${identity.fromEmail}  type=${identity.type}` +
+                `${identity.domain ? ` domain=${identity.domain}` : ""}` +
+                `  delivery=${identity.deliveryVerificationStatus}  workspace=${identity.denchVerificationStatus}` +
+                `${identity.disabled ? "  DISABLED" : ""}`,
+            )
+            .join("\n");
+    out(ctx, { ok: true, identities }, text);
+    return;
+  }
+  if (sub === "disable" || sub === "restore") {
+    const identity = requiredFlag(ctx.args, "--identity");
+    const payload = (await callMutation(
+      ctx,
+      sub === "disable"
+        ? "functions/emailCampaigns:disableIdentity"
+        : "functions/emailCampaigns:restoreIdentity",
+      { identity },
+    )) as JsonRecord;
+    const rows = (
+      Array.isArray(payload.disabled)
+        ? payload.disabled
+        : Array.isArray(payload.restored)
+          ? payload.restored
+          : []
+    ) as JsonRecord[];
+    const verb = sub === "disable" ? "Disabled" : "Restored";
+    const text =
+      rows.length === 0
+        ? `${verb} 0 identities.`
+        : `${verb} ${rows.length} sender(s):\n${rows
+            .map((row) => `  ${row.fromEmail} (${row.identityId})`)
+            .join("\n")}`;
+    out(ctx, payload, text);
+    return;
+  }
+  if (sub === "dns") {
+    const identity = requiredFlag(ctx.args, "--identity");
+    if (!identity.includes("@") && !identity.includes(".")) {
+      // Identity id: the refresh action returns formatted dnsRecords.
+      const payload = (await callAction(
+        ctx,
+        "functions/emailCampaignsNode:refreshIdentityStatus",
+        { identityId: identity },
+      )) as JsonRecord;
+      const records = asDnsRecords(payload.dnsRecords);
+      const text =
+        records.length > 0
+          ? formatDnsRecords(records)
+          : payload.domainVerified === true
+            ? `Domain ${payload.domain} is verified — no DNS records pending.`
+            : "No DNS records available yet. Run `dench email identity verify --domain <domain>` first.";
+      out(ctx, { ok: true, ...payload }, text);
+      return;
+    }
+    const domain = identity.includes("@")
+      ? identity.slice(identity.lastIndexOf("@") + 1).toLowerCase()
+      : identity.toLowerCase();
+    const status = (await callGateway(
+      ctx,
+      "GET",
+      `/v1/email/identities/${encodeURIComponent(domain)}/status`,
+    )) as JsonRecord;
+    const dkim =
+      status.dkimAttributes && typeof status.dkimAttributes === "object"
+        ? (status.dkimAttributes as JsonRecord)
+        : {};
+    const tokens = Array.isArray(dkim.Tokens)
+      ? dkim.Tokens.filter(
+          (token): token is string => typeof token === "string",
+        )
+      : [];
+    const records = buildDnsRecords(domain, tokens);
+    const verified = status.verifiedForSendingStatus === true;
+    const payload: JsonRecord = {
+      ok: true,
+      domain,
+      domainVerified: verified,
+      dnsRecords: records,
+    };
+    if (
+      !verified &&
+      status.verificationInfo &&
+      typeof status.verificationInfo === "object"
+    ) {
+      payload.verificationInfo = status.verificationInfo;
+    }
+    const text = verified
+      ? `Domain ${domain} is verified — DNS records below are already in place.\n${formatDnsRecords(records)}`
+      : tokens.length > 0
+        ? formatDnsRecords(records)
+        : `Domain ${domain} has no verification records yet. Run \`dench email identity verify --domain ${domain}\` first.`;
+    out(ctx, payload, text);
     return;
   }
   if (sub === "status") {
@@ -273,16 +577,27 @@ async function runIdentity(ctx: EmailCliContext) {
       `/v1/email/identities/${encodeURIComponent(identity)}/status`,
     );
     const status = payload as JsonRecord;
-    const shaped = {
+    const shaped: JsonRecord = {
       ok: status.ok === true,
       identity: status.identity,
       deliveryVerified: status.verifiedForSendingStatus === true,
       deliveryVerificationStatus: status.verificationStatus,
     };
+    // Pending domains: surface when the provider last polled DNS and
+    // why it failed, so callers know whether to fix records or wait.
+    if (
+      status.verifiedForSendingStatus !== true &&
+      status.verificationInfo &&
+      typeof status.verificationInfo === "object"
+    ) {
+      shaped.verificationInfo = status.verificationInfo;
+    }
     out(ctx, shaped, JSON.stringify(shaped, null, 2));
     return;
   }
-  throw new EmailCliError("Usage: dench email identity verify|status");
+  throw new EmailCliError(
+    "Usage: dench email identity verify|list|dns|status|disable|restore",
+  );
 }
 
 async function runTemplate(ctx: EmailCliContext) {