@dench.com/cli 2.5.2 → 2.7.0

package/crm.ts

@@ -16,7 +16,7 @@
  *
  * The full surface mirrors the plan's "dench-cli CRM surface" section:
  *   crm objects   list / get / create / update / delete / rename
- *   crm views     list / get / entries
+ *   crm views     list / get / entries / create / update / delete
  *   crm fields    list / create / update / delete / reorder
  *   crm entries   list / get / create / create-many / update / update-many / delete / bulk-delete
  *   crm cells     get / set / set-many / append
@@ -562,6 +562,12 @@ const api = {
     update: makeFunctionReference<"mutation">("functions/crm/objects:update"),
     rename: makeFunctionReference<"mutation">("functions/crm/objects:rename"),
     remove: makeFunctionReference<"mutation">("functions/crm/objects:remove"),
+    saveView: makeFunctionReference<"mutation">(
+      "functions/crm/objects:saveView",
+    ),
+    deleteView: makeFunctionReference<"mutation">(
+      "functions/crm/objects:deleteView",
+    ),
   },
   fields: {
     list: makeFunctionReference<"query">("functions/crm/fields:list"),
@@ -968,6 +974,216 @@ function summarizeSavedView(view: SavedViewForCli): Record<string, unknown> {
   };
 }
 
+const VIEW_TYPES = [
+  "table",
+  "kanban",
+  "calendar",
+  "timeline",
+  "gallery",
+  "list",
+] as const;
+
+type SortRuleForCli = { field: string; direction: "asc" | "desc" };
+
+/**
+ * Parse `--sort` for views. Accepts either the canonical JSON array
+ * (`[{"field":"Score","direction":"desc"}]`) or the compact syntax the
+ * rest of the CRM CLI uses (`-Score,Name` — leading `-` means desc).
+ */
+function parseViewSortFlag(
+  raw: string | undefined,
+): SortRuleForCli[] | undefined {
+  if (raw === undefined) return undefined;
+  const trimmed = raw.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.startsWith("[")) {
+    const parsed = parseJson(trimmed);
+    if (!Array.isArray(parsed)) {
+      throw new CrmCliError("--sort must be a JSON array of sort rules");
+    }
+    return parsed.map((rule, index) => {
+      if (
+        !isJsonRecord(rule) ||
+        typeof rule.field !== "string" ||
+        !rule.field ||
+        (rule.direction !== "asc" && rule.direction !== "desc")
+      ) {
+        throw new CrmCliError(
+          `--sort rule ${index + 1} must look like {"field":"Score","direction":"desc"}`,
+        );
+      }
+      return { field: rule.field, direction: rule.direction };
+    });
+  }
+  return trimmed
+    .split(",")
+    .map((token) => token.trim())
+    .filter(Boolean)
+    .map((token) =>
+      token.startsWith("-")
+        ? { field: token.slice(1), direction: "desc" as const }
+        : { field: token, direction: "asc" as const },
+    );
+}
+
+/**
+ * Turn the `--where '{"Status":"Hot"}'` equality-map sugar into a real
+ * FilterGroup. The operator per rule is chosen from the object's field
+ * schema (enum → is / is_any_of, boolean → is_true / is_false, number
+ * → eq, date → on, relation → has_any, everything else → equals) so
+ * the saved view round-trips through the savedViewValidator.
+ */
+async function buildFiltersFromWhere(
+  ctx: CrmCliContext,
+  objectName: string,
+  where: JsonRecord,
+): Promise<JsonRecord> {
+  const fields = (await callQuery(ctx, api.fields.list, { objectName })) as
+    | Array<{ name?: unknown; type?: unknown }>
+    | null
+    | undefined;
+  const knownFields = Array.isArray(fields)
+    ? fields.filter(
+        (field): field is { name: string; type?: string } =>
+          typeof field?.name === "string",
+      )
+    : [];
+  const rules = Object.entries(where).map(([rawName, value], index) => {
+    const field =
+      knownFields.find((candidate) => candidate.name === rawName) ??
+      knownFields.find(
+        (candidate) => candidate.name.toLowerCase() === rawName.toLowerCase(),
+      );
+    if (!field && knownFields.length > 0) {
+      const suggestion = suggestKnownField(
+        rawName,
+        knownFields.map((candidate) => candidate.name),
+      );
+      throw new CrmCliError(
+        `Unknown field "${rawName}" on ${objectName}` +
+          `${suggestion ? ` (did you mean "${suggestion}"?)` : ""}. ` +
+          `Valid fields: ${knownFields.map((candidate) => candidate.name).join(", ")}`,
+      );
+    }
+    const fieldName = field?.name ?? rawName;
+    const type = field?.type;
+    const id = `w${index + 1}`;
+    if (type === "boolean") {
+      const isFalsy =
+        !value ||
+        value === "false" ||
+        value === "0" ||
+        value === "no" ||
+        value === "off";
+      return {
+        id,
+        field: fieldName,
+        operator: isFalsy ? "is_false" : "is_true",
+      };
+    }
+    if (type === "enum") {
+      return Array.isArray(value)
+        ? {
+            id,
+            field: fieldName,
+            operator: "is_any_of",
+            value: value.map(String),
+          }
+        : { id, field: fieldName, operator: "is", value: String(value) };
+    }
+    if (type === "number") {
+      return { id, field: fieldName, operator: "eq", value: Number(value) };
+    }
+    if (type === "date") {
+      return { id, field: fieldName, operator: "on", value: String(value) };
+    }
+    if (type === "relation") {
+      return {
+        id,
+        field: fieldName,
+        operator: "has_any",
+        value: Array.isArray(value) ? value.map(String) : [String(value)],
+      };
+    }
+    return { id, field: fieldName, operator: "equals", value: String(value) };
+  });
+  return { id: "where", conjunction: "and", rules };
+}
+
+/**
+ * Shared flag parsing for `crm views create` / `crm views update`.
+ * Returns only the keys the caller actually passed so `update` can
+ * merge over the existing view without clobbering untouched keys.
+ */
+async function collectViewFlags(
+  ctx: CrmCliContext,
+  objectName: string,
+  command: string,
+): Promise<JsonRecord> {
+  const filtersRaw = getFlag(ctx.args, "--filters");
+  const whereRaw = getFlag(ctx.args, "--where");
+  const sortRaw = getFlag(ctx.args, "--sort");
+  const columnsRaw = getFlag(ctx.args, "--columns");
+  const typeRaw = getFlag(ctx.args, "--type");
+  const settingsRaw = getFlag(ctx.args, "--settings");
+  const pinnedRaw = getFlag(ctx.args, "--pinned-entry-ids");
+
+  if (filtersRaw !== undefined && whereRaw !== undefined) {
+    throw new CrmCliError(
+      `${command} accepts either --filters (full FilterGroup JSON) or --where (equality map), not both`,
+    );
+  }
+
+  const patch: JsonRecord = {};
+  if (filtersRaw !== undefined) {
+    const filters = parseJson(filtersRaw);
+    if (
+      !isJsonRecord(filters) ||
+      typeof filters.conjunction !== "string" ||
+      !Array.isArray(filters.rules)
+    ) {
+      throw new CrmCliError(
+        '--filters must be a FilterGroup JSON object: {"id":"g1","conjunction":"and","rules":[{"id":"r1","field":"Status","operator":"is","value":"Hot"}]}',
+      );
+    }
+    if (typeof filters.id !== "string" || !filters.id) filters.id = "g1";
+    patch.filters = filters;
+  }
+  if (whereRaw !== undefined) {
+    const where = requireNonEmptyJsonRecord(parseJson(whereRaw), "--where");
+    patch.filters = await buildFiltersFromWhere(ctx, objectName, where);
+  }
+  const sort = parseViewSortFlag(sortRaw);
+  if (sort !== undefined) patch.sort = sort;
+  if (columnsRaw !== undefined) {
+    patch.columns = columnsRaw
+      .split(",")
+      .map((column) => column.trim())
+      .filter(Boolean);
+  }
+  if (typeRaw !== undefined) {
+    if (!(VIEW_TYPES as readonly string[]).includes(typeRaw)) {
+      throw new CrmCliError(
+        `--type must be one of: ${VIEW_TYPES.join(", ")} (got "${typeRaw}")`,
+      );
+    }
+    patch.view_type = typeRaw;
+  }
+  if (settingsRaw !== undefined) {
+    patch.settings = requireNonEmptyJsonRecord(
+      parseJson(settingsRaw),
+      "--settings",
+    );
+  }
+  if (pinnedRaw !== undefined) {
+    patch.pinnedEntryIds = pinnedRaw
+      .split(",")
+      .map((id) => id.trim())
+      .filter(Boolean);
+  }
+  return patch;
+}
+
 async function runViewsCommand(ctx: CrmCliContext): Promise<void> {
   const verb = ctx.args.shift();
   switch (verb) {
@@ -1071,6 +1287,82 @@ async function runViewsCommand(ctx: CrmCliContext): Promise<void> {
       });
       return;
     }
+    case "create": {
+      const objectName = shift(ctx.args, "object name");
+      // View name is positional, but `--name` is accepted too because
+      // that's the flag agents reach for first.
+      const nameFlag = getFlag(ctx.args, "--name");
+      const viewName =
+        nameFlag ??
+        (ctx.args[0] && !ctx.args[0].startsWith("--")
+          ? shift(ctx.args, "view name")
+          : undefined);
+      if (!viewName?.trim()) {
+        throw new CrmCliError(
+          'crm views create requires a view name: dench crm views create <object> "<view name>" [--where …]',
+        );
+      }
+      const replace = hasFlag(ctx.args, "--replace");
+      const setActive = hasFlag(ctx.args, "--set-active");
+      const patch = await collectViewFlags(ctx, objectName, "crm views create");
+      assertNoUnknownFlags(ctx.args, "crm views create");
+      out(
+        ctx,
+        await callMutation(ctx, api.objects.saveView, {
+          objectName,
+          view: { name: viewName.trim(), ...patch },
+          replaceExisting: replace,
+          setActive,
+        }),
+      );
+      return;
+    }
+    case "update": {
+      const objectName = shift(ctx.args, "object name");
+      const viewName = shift(ctx.args, "view name");
+      const setActive = hasFlag(ctx.args, "--set-active");
+      const patch = await collectViewFlags(ctx, objectName, "crm views update");
+      assertNoUnknownFlags(ctx.args, "crm views update");
+      if (Object.keys(patch).length === 0 && !setActive) {
+        throw new CrmCliError(
+          "crm views update needs at least one change: --filters/--where, --sort, --columns, --type, --settings, --pinned-entry-ids, or --set-active",
+        );
+      }
+      // Merge over the existing view so untouched keys survive. The
+      // existing (exact-cased) name is reused, which also makes a
+      // case-insensitive <view name> argument update the right view.
+      const object = await callQuery(ctx, api.objects.get, {
+        name: objectName,
+      });
+      const existing = resolveSavedView(
+        objectName,
+        savedViewsFromObject(objectName, object),
+        viewName,
+      );
+      out(
+        ctx,
+        await callMutation(ctx, api.objects.saveView, {
+          objectName,
+          view: { ...existing, ...patch, name: readViewName(existing) },
+          replaceExisting: true,
+          setActive,
+        }),
+      );
+      return;
+    }
+    case "delete": {
+      const objectName = shift(ctx.args, "object name");
+      const viewName = shift(ctx.args, "view name");
+      assertNoUnknownFlags(ctx.args, "crm views delete");
+      out(
+        ctx,
+        await callMutation(ctx, api.objects.deleteView, {
+          objectName,
+          viewName,
+        }),
+      );
+      return;
+    }
     default:
       throw new CrmCliError(`Unknown crm views verb: ${verb ?? "<none>"}`);
   }
@@ -3000,6 +3292,20 @@ Views (saved CRM subsets):
   dench crm views list <object> [--json]
   dench crm views get <object> <view-name> [--json]
   dench crm views entries <object> <view-name> [--limit N] [--page N] [--with-meta] [--json]
+  dench crm views create <object> <view-name> [--where '{"Status":"Hot"}']
+      [--filters '<FilterGroup JSON>'] [--sort '-Score' | --sort '[{"field":"Score","direction":"desc"}]']
+      [--columns Name,Email] [--type table|kanban|calendar|timeline|gallery|list]
+      [--settings '{"kanbanField":"Status"}'] [--pinned-entry-ids id1,id2]
+      [--replace] [--set-active] [--json]
+      --where is equality-map sugar (operators picked from the field
+      schema); --filters takes a full FilterGroup for AND/OR logic.
+      Fails on a name collision unless --replace is passed.
+  dench crm views update <object> <view-name> [same flags as create] [--set-active]
+      Merges the provided flags over the existing view definition;
+      untouched keys survive.
+  dench crm views delete <object> <view-name>
+      Idempotent; also clears the active-view pointer if it referenced
+      the deleted view.
 
 Fields (columns):
   dench crm fields list <object> [--json]

package/cron.ts

@@ -18,11 +18,9 @@
  * both formats; we just pass whichever bearer the parent runtime
  * resolved through `sessionToken`.
  *
- * Convex calls go direct via `ConvexHttpClient` (same pattern as
- * `cli/crm.ts`); `run-now` is the one operation that goes through
- * the REST API hop (`POST /api/cron/jobs/<id>/run-now`) because it
- * needs to start a Vercel Workflow which can only be done from a
- * Next.js route.
+ * Convex calls generally go direct via `ConvexHttpClient` (same pattern as
+ * `cli/crm.ts`). Run-now and delete go through REST: run-now starts a Vercel
+ * Workflow, while delete coordinates upstream app-event cleanup.
  *
  * Subcommands:
  *   list                                 List all cron jobs in the org.
@@ -166,6 +164,28 @@ async function getJson(
   return json;
 }
 
+async function deleteJson(
+  url: string,
+  headers: Record<string, string>,
+): Promise<unknown> {
+  const response = await fetch(url, { method: "DELETE", headers });
+  const text = await response.text();
+  let json: unknown;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch {
+    json = { raw: text };
+  }
+  if (!response.ok) {
+    const detail =
+      json && typeof json === "object" && "error" in json
+        ? String((json as Record<string, unknown>).error)
+        : JSON.stringify(json);
+    throw new CronCliError(`${url} failed (${response.status}): ${detail}`);
+  }
+  return json;
+}
+
 async function callQuery(
   ctx: CronCliContext,
   fn: Parameters<ConvexHttpClient["query"]>[0],
@@ -339,9 +359,6 @@ const createCronTriggerRef = makeFunctionReference<"mutation">(
 const updateCronTriggerRef = makeFunctionReference<"mutation">(
   "functions/triggers:updateCronTrigger",
 );
-const deleteCronTriggerRef = makeFunctionReference<"mutation">(
-  "functions/triggers:deleteCronTrigger",
-);
 const setCronEnabledRef = makeFunctionReference<"mutation">(
   "functions/triggers:setCronEnabled",
 );
@@ -709,7 +726,10 @@ async function runUpdate(ctx: CronCliContext): Promise<void> {
 
 async function runDelete(ctx: CronCliContext): Promise<void> {
   const jobId = shift(ctx.args, "job id");
-  const result = await callMutation(ctx, deleteCronTriggerRef, { jobId });
+  const result = await deleteJson(
+    `${getApiBase()}/api/cron/jobs/${encodeURIComponent(jobId)}`,
+    apiKeyHeaders(ctx.sessionToken ?? ""),
+  );
   out(ctx, result);
 }
 

package/email.ts

@@ -196,6 +196,9 @@ Usage:
   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 identity delete --identity <identityId|email|domain> [--json]
+  dench email identity forward --identity <identityId|email> --to inbox@you.com [--json]   # forward this sender's sequence replies
+  dench email identity forward --identity <identityId|email> --off [--json]                # turn forwarding off
   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]
@@ -499,19 +502,22 @@ async function runIdentity(ctx: EmailCliContext) {
                 `${identity.identityId}  ${identity.fromEmail}  type=${identity.type}` +
                 `${identity.domain ? ` domain=${identity.domain}` : ""}` +
                 `  delivery=${identity.deliveryVerificationStatus}  workspace=${identity.denchVerificationStatus}` +
+                `${identity.forwardRepliesTo ? `  forward=${identity.forwardRepliesTo}` : ""}` +
                 `${identity.disabled ? "  DISABLED" : ""}`,
             )
             .join("\n");
     out(ctx, { ok: true, identities }, text);
     return;
   }
-  if (sub === "disable" || sub === "restore") {
+  if (sub === "disable" || sub === "restore" || sub === "delete") {
     const identity = requiredFlag(ctx.args, "--identity");
     const payload = (await callMutation(
       ctx,
       sub === "disable"
         ? "functions/emailCampaigns:disableIdentity"
-        : "functions/emailCampaigns:restoreIdentity",
+        : sub === "restore"
+          ? "functions/emailCampaigns:restoreIdentity"
+          : "functions/emailCampaigns:deleteIdentity",
       { identity },
     )) as JsonRecord;
     const rows = (
@@ -519,18 +525,57 @@ async function runIdentity(ctx: EmailCliContext) {
         ? payload.disabled
         : Array.isArray(payload.restored)
           ? payload.restored
-          : []
+          : Array.isArray(payload.deleted)
+            ? payload.deleted
+            : []
     ) as JsonRecord[];
-    const verb = sub === "disable" ? "Disabled" : "Restored";
+    const verb =
+      sub === "disable"
+        ? "Disabled"
+        : sub === "restore"
+          ? "Restored"
+          : "Deleted";
+    const suffix =
+      sub === "delete" && rows.length > 0
+        ? "\nDeleted senders must be re-verified before they can send again."
+        : "";
     const text =
       rows.length === 0
         ? `${verb} 0 identities.`
         : `${verb} ${rows.length} sender(s):\n${rows
             .map((row) => `  ${row.fromEmail} (${row.identityId})`)
-            .join("\n")}`;
+            .join("\n")}${suffix}`;
     out(ctx, payload, text);
     return;
   }
+  if (sub === "forward") {
+    // Configure where a sender's managed sequence replies are forwarded.
+    // `--to <email>` turns it on (composed from the verified sender, Reply-To =
+    // the prospect); `--off` clears it. Replies are always still captured
+    // in-app regardless — forwarding is an extra copy to a chosen inbox.
+    const identity = requiredFlag(ctx.args, "--identity");
+    const off = hasFlag(ctx.args, "--off");
+    const to = off ? "" : (getFlag(ctx.args, "--to")?.trim() ?? "");
+    if (!off && !to) {
+      throw new Error(
+        "Provide --to <email> to forward this sender's replies, or --off to turn forwarding off.",
+      );
+    }
+    const payload = (await callMutation(
+      ctx,
+      "functions/emailCampaigns:setSenderReplyForward",
+      { identity, forwardRepliesTo: to },
+    )) as JsonRecord;
+    const forwardTo =
+      typeof payload.forwardRepliesTo === "string"
+        ? payload.forwardRepliesTo
+        : null;
+    const text = forwardTo
+      ? `Replies to ${identity}'s sequences will be forwarded to ${forwardTo}.`
+      : `Reply forwarding turned off for ${identity}.`;
+    out(ctx, { ok: true, ...payload }, text);
+    return;
+  }
   if (sub === "dns") {
     const identity = requiredFlag(ctx.args, "--identity");
     if (!identity.includes("@") && !identity.includes(".")) {
@@ -627,7 +672,7 @@ async function runIdentity(ctx: EmailCliContext) {
     return;
   }
   throw new EmailCliError(
-    "Usage: dench email identity verify|list|dns|status|disable|restore",
+    "Usage: dench email identity verify|list|dns|status|disable|restore|delete",
   );
 }
 

package/lib/api-schemas.ts

@@ -440,6 +440,51 @@ const chatSpawnResponse = z.object({
 
 // -- crm ---------------------------------------------------------------------
 
+const savedViewSortRule = z.object({
+  field: z.string().describe("Field name to sort by."),
+  direction: z.enum(["asc", "desc"]),
+});
+
+/**
+ * SavedView definition as stored in `crmObjects.savedViews` and
+ * validated by `convex/lib/savedView.ts`. `filters` is a FilterGroup:
+ * `{id, conjunction: "and"|"or", rules: [{id, field, operator,
+ * value?}]}` with one level of nested groups allowed.
+ */
+const savedViewDefinition = z
+  .object({
+    name: z
+      .string()
+      .min(1)
+      .max(100)
+      .describe("View name (upsert key; shows in the view dropdown)."),
+    view_type: viewKind.optional(),
+    filters: z
+      .record(z.string(), z.unknown())
+      .optional()
+      .describe(
+        'FilterGroup, e.g. {"id":"g1","conjunction":"and","rules":[{"id":"r1","field":"Status","operator":"is","value":"Hot"}]}.',
+      ),
+    sort: z.array(savedViewSortRule).optional(),
+    columns: z
+      .array(z.string())
+      .optional()
+      .describe("Visible-column ordering. Omit to keep the default set."),
+    settings: z
+      .record(z.string(), z.unknown())
+      .optional()
+      .describe(
+        "View-type settings (kanbanField, calendarDateField, timelineStartField, …).",
+      ),
+    pinnedEntryIds: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "Pinned-list mode: show EXACTLY these entry ids (mutually exclusive with filters).",
+      ),
+  })
+  .passthrough();
+
 const crmObjectDoc = z
   .object({
     _id: z.string(),
@@ -1338,6 +1383,46 @@ export const requestSchemas: Record<string, ZodTypeAny> = {
   }),
   "crm.objects.delete": z.object({ name: z.string() }),
 
+  // CRM saved views
+  "crm.views.list": z.object({ objectName: z.string() }),
+  "crm.views.get": z.object({
+    objectName: z.string(),
+    viewName: z.string(),
+  }),
+  "crm.views.entries": z.object({
+    objectName: z.string(),
+    viewName: z.string(),
+    page: z.number().int().min(1).optional(),
+    pageSize: z.number().int().min(1).optional(),
+  }),
+  "crm.views.create": z.object({
+    objectName: z.string(),
+    view: savedViewDefinition,
+    replaceExisting: z
+      .boolean()
+      .optional()
+      .describe("Overwrite an existing view with the same name."),
+    setActive: z
+      .boolean()
+      .optional()
+      .describe("Also switch the object's active view to this one."),
+  }),
+  "crm.views.update": z.object({
+    objectName: z.string(),
+    viewName: z.string().describe("Name of the view to replace (path)."),
+    view: savedViewDefinition
+      .partial()
+      .optional()
+      .describe(
+        "Full replacement definition; the path viewName is used as the name.",
+      ),
+    setActive: z.boolean().optional(),
+  }),
+  "crm.views.delete": z.object({
+    objectName: z.string(),
+    viewName: z.string(),
+  }),
+
   // CRM fields
   "crm.fields.list": z.object({ objectName: z.string() }),
   "crm.fields.create": z.object({
@@ -1701,6 +1786,13 @@ export const requestSchemas: Record<string, ZodTypeAny> = {
   "email.identity.restore": z.object({
     identity: z.string().describe("Identity id, sender email, or domain."),
   }),
+  "email.identity.delete": z.object({
+    identity: z
+      .string()
+      .describe(
+        "Identity id, sender email, or domain (deletes every sender on the domain). Permanent: re-adding requires re-verification.",
+      ),
+  }),
   "email.send": z.object({
     fromEmail: z.string().describe("Verified sender mailbox."),
     fromName: z.string().optional().describe("Display name override."),
@@ -2078,6 +2170,34 @@ export const responseSchemas: Record<string, ZodTypeAny> = {
   "crm.objects.rename": okResponse,
   "crm.objects.delete": okResponse,
 
+  // CRM saved views
+  "crm.views.list": z.object({
+    objectName: z.string(),
+    activeView: z.string().nullable(),
+    views: z.array(z.record(z.string(), z.unknown())),
+  }),
+  "crm.views.get": z.record(z.string(), z.unknown()),
+  "crm.views.create": z.object({
+    ok: z.boolean(),
+    objectName: z.string(),
+    viewName: z.string(),
+    replaced: z.boolean(),
+    activeView: z.string().nullable(),
+  }),
+  "crm.views.update": z.object({
+    ok: z.boolean(),
+    objectName: z.string(),
+    viewName: z.string(),
+    replaced: z.boolean(),
+    activeView: z.string().nullable(),
+  }),
+  "crm.views.delete": z.object({
+    ok: z.boolean(),
+    objectName: z.string(),
+    viewName: z.string(),
+    removed: z.boolean(),
+  }),
+
   // CRM fields
   "crm.fields.list": z.array(crmFieldDoc),
   "crm.fields.create": z.object({ id: z.string() }),
@@ -2411,6 +2531,10 @@ export const responseSchemas: Record<string, ZodTypeAny> = {
     ok: z.boolean(),
     restored: z.array(identitySummaryShape),
   }),
+  "email.identity.delete": z.object({
+    ok: z.boolean(),
+    deleted: z.array(identitySummaryShape),
+  }),
   "email.send": z.object({
     ok: z.boolean(),
     messageId: z
@@ -2583,6 +2707,27 @@ export type ConvexExtras = {
 export const convexExtras: Record<string, ConvexExtras> = {
   "cron.enable": { fixedArgs: { enabled: true } },
   "cron.disable": { fixedArgs: { enabled: false } },
+  // PATCH /crm/objects/{objectName}/views/{viewName} — the path's
+  // viewName is the upsert key: fold it into `view.name` and force
+  // replaceExisting so the mutation overwrites instead of erroring on
+  // the (guaranteed) name collision.
+  "crm.views.update": {
+    transformArgs: (input) => {
+      const { viewName, view, ...rest } = input as {
+        viewName?: unknown;
+        view?: unknown;
+      } & Record<string, unknown>;
+      const baseView =
+        view && typeof view === "object" && !Array.isArray(view)
+          ? (view as Record<string, unknown>)
+          : {};
+      return {
+        ...rest,
+        view: { ...baseView, name: String(viewName ?? baseView.name ?? "") },
+        replaceExisting: true,
+      };
+    },
+  },
   "crm.entries.updateMany": {
     transformArgs: (input) => {
       const updates = Array.isArray(input.updates) ? input.updates : [];
@@ -2629,6 +2774,25 @@ export const requestExamples: Record<string, unknown> = {
     enumColors: ["#94a3b8", "#3b82f6", "#22c55e", "#ef4444"],
     indexed: true,
   },
+  "crm.views.create": {
+    view: {
+      name: "Hot leads",
+      view_type: "table",
+      filters: {
+        id: "g1",
+        conjunction: "and",
+        rules: [{ id: "r1", field: "Status", operator: "is", value: "Hot" }],
+      },
+      sort: [{ field: "created_at", direction: "desc" }],
+    },
+    setActive: true,
+  },
+  "crm.views.update": {
+    view: {
+      sort: [{ field: "Score", direction: "desc" }],
+      columns: ["Name", "Email", "Status", "Score"],
+    },
+  },
   "crm.fields.enum.color": { color: "#22c55e" },
   "crm.fields.enum.add": { value: "Nurturing", color: "#eab308", position: 2 },
   "crm.entries.create": {
@@ -3048,6 +3212,42 @@ export const responseExamples: Record<string, unknown> = {
   "crm.objects.update": { ok: true },
   "crm.objects.rename": { ok: true },
   "crm.objects.delete": { ok: true },
+  "crm.views.list": {
+    objectName: "lead",
+    activeView: "Hot leads",
+    views: [
+      {
+        name: "Hot leads",
+        view_type: "table",
+        filters: {
+          id: "g1",
+          conjunction: "and",
+          rules: [{ id: "r1", field: "Status", operator: "is", value: "Hot" }],
+        },
+        sort: [{ field: "created_at", direction: "desc" }],
+      },
+    ],
+  },
+  "crm.views.create": {
+    ok: true,
+    objectName: "lead",
+    viewName: "Hot leads",
+    replaced: false,
+    activeView: "Hot leads",
+  },
+  "crm.views.update": {
+    ok: true,
+    objectName: "lead",
+    viewName: "Hot leads",
+    replaced: true,
+    activeView: null,
+  },
+  "crm.views.delete": {
+    ok: true,
+    objectName: "lead",
+    viewName: "Hot leads",
+    removed: true,
+  },
   "crm.fields.list": [
     {
       _id: "fld_status01",
@@ -3431,6 +3631,16 @@ export const responseExamples: Record<string, unknown> = {
       },
     ],
   },
+  "email.identity.delete": {
+    ok: true,
+    deleted: [
+      {
+        identityId: "esi_abc123",
+        fromEmail: "founder@example.com",
+        disabled: false,
+      },
+    ],
+  },
   "email.send": {
     ok: true,
     messageId: "emsg_abc123",

package/lib/command-registry.ts

@@ -29,6 +29,7 @@ export type CustomOperation = {
     | "commandsList"
     | "chatSpawn"
     | "chatFollow"
+    | "cronDelete"
     | "cronRunNow"
     | "billingTopup"
     | "upgrade"
@@ -583,6 +584,75 @@ const rawApiOperations = [
     backend: convex("mutation", "functions/crm/objects:remove"),
   }),
 
+  op({
+    id: "crm.views.list",
+    group: "crm",
+    summary: "List the saved views on a CRM object (plus the active view).",
+    cli: "dench crm views list",
+    method: "GET",
+    path: "/crm/objects/{objectName}/views",
+    requestSchema: noBody,
+    responseSchema: anyResponse,
+    backend: convex("query", "functions/crm/objects:listViews"),
+  }),
+  op({
+    id: "crm.views.get",
+    group: "crm",
+    summary: "Get one saved view's definition by name.",
+    cli: "dench crm views get",
+    method: "GET",
+    path: "/crm/objects/{objectName}/views/{viewName}",
+    requestSchema: noBody,
+    responseSchema: anyResponse,
+    backend: convex("query", "functions/crm/objects:getView"),
+  }),
+  op({
+    id: "crm.views.entries",
+    group: "crm",
+    summary:
+      "Materialize a saved view's rows (applies its filters/sort/pins), paginated.",
+    cli: "dench crm views entries",
+    method: "GET",
+    path: "/crm/objects/{objectName}/views/{viewName}/entries",
+    requestSchema: noBody,
+    responseSchema: anyResponse,
+    backend: convex("query", "functions/crm/objects:materializeView"),
+  }),
+  op({
+    id: "crm.views.create",
+    group: "crm",
+    summary:
+      "Create a saved view (named filters/sort/columns combo) on a CRM object.",
+    cli: "dench crm views create",
+    method: "POST",
+    path: "/crm/objects/{objectName}/views",
+    requestSchema: anyObject,
+    responseSchema: anyResponse,
+    backend: convex("mutation", "functions/crm/objects:saveView"),
+  }),
+  op({
+    id: "crm.views.update",
+    group: "crm",
+    summary: "Replace a saved view's definition (upsert by name).",
+    cli: "dench crm views update",
+    method: "PATCH",
+    path: "/crm/objects/{objectName}/views/{viewName}",
+    requestSchema: anyObject,
+    responseSchema: anyResponse,
+    backend: convex("mutation", "functions/crm/objects:saveView"),
+  }),
+  op({
+    id: "crm.views.delete",
+    group: "crm",
+    summary: "Delete a saved view by name (idempotent).",
+    cli: "dench crm views delete",
+    method: "DELETE",
+    path: "/crm/objects/{objectName}/views/{viewName}",
+    requestSchema: anyObject,
+    responseSchema: anyResponse,
+    backend: convex("mutation", "functions/crm/objects:deleteView"),
+  }),
+
   op({
     id: "crm.fields.list",
     group: "crm",
@@ -1366,6 +1436,18 @@ const rawApiOperations = [
     responseSchema: anyResponse,
     backend: convex("mutation", "functions/emailCampaigns:restoreIdentity"),
   }),
+  op({
+    id: "email.identity.delete",
+    group: "email",
+    summary:
+      "Permanently delete a sender (or every sender on a domain) from the workspace; re-adding it requires verification from scratch.",
+    cli: "dench email identity delete",
+    method: "DELETE",
+    path: "/email/sending-identities/{identity}",
+    requestSchema: anyObject,
+    responseSchema: anyResponse,
+    backend: convex("mutation", "functions/emailCampaigns:deleteIdentity"),
+  }),
   op({
     id: "email.send",
     group: "email",
@@ -1814,7 +1896,7 @@ const rawApiOperations = [
     path: "/routines/{jobId}",
     requestSchema: anyObject,
     responseSchema: anyResponse,
-    backend: convex("mutation", "functions/triggers:deleteCronTrigger"),
+    backend: custom("cronDelete", "bearer"),
   }),
   op({
     id: "cron.enable",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dench.com/cli",
-  "version": "2.5.2",
+  "version": "2.7.0",
   "description": "Dench agent workspace CLI. v2 unifies auth behind `dench signin`; the legacy `dench login` / `dench onboard` / `dench setup` / `dench what-can-i-do` / `dench register` commands now error with a redirect.",
   "type": "module",
   "bin": {