@dench.com/cli 2.8.7-staging.189 → 2.8.8-staging.192

package/crm-comments.ts

@@ -0,0 +1,303 @@
+/**
+ * `dench crm comments …`, `dench crm watch …`, `dench crm tasks …`
+ *
+ * Thin dispatchers over the Convex functions the entry panel itself uses
+ * (`functions/crm/comments`, `functions/crm/tasks`), so the CLI, the
+ * `/api/v1` surface, and the UI share one contract. Kept out of `crm.ts`
+ * only for file size.
+ */
+
+import { readFile } from "node:fs/promises";
+import { makeFunctionReference } from "convex/server";
+import {
+  assertNoUnknownFlags,
+  type CrmCliContext,
+  CrmCliError,
+  callMutation,
+  callQuery,
+  out,
+  shift,
+} from "./crm";
+import { getFlag, hasFlag } from "./lib/cli-args";
+
+const api = {
+  comments: {
+    listForEntry: makeFunctionReference<"query">(
+      "functions/crm/comments:listForEntry",
+    ),
+    listReplies: makeFunctionReference<"query">(
+      "functions/crm/comments:listReplies",
+    ),
+    get: makeFunctionReference<"query">("functions/crm/comments:get"),
+    create: makeFunctionReference<"mutation">("functions/crm/comments:create"),
+    edit: makeFunctionReference<"mutation">("functions/crm/comments:edit"),
+    remove: makeFunctionReference<"mutation">("functions/crm/comments:remove"),
+    toggleReaction: makeFunctionReference<"mutation">(
+      "functions/crm/comments:toggleReaction",
+    ),
+    getWatchState: makeFunctionReference<"query">(
+      "functions/crm/comments:getWatchState",
+    ),
+    setWatching: makeFunctionReference<"mutation">(
+      "functions/crm/comments:setWatching",
+    ),
+  },
+  tasks: {
+    listMyOpenTasks: makeFunctionReference<"query">(
+      "functions/crm/tasks:listMyOpenTasks",
+    ),
+    listEntryTasks: makeFunctionReference<"query">(
+      "functions/crm/tasks:listEntryTasks",
+    ),
+    createEntryTask: makeFunctionReference<"mutation">(
+      "functions/crm/tasks:createEntryTask",
+    ),
+    completeTask: makeFunctionReference<"mutation">(
+      "functions/crm/tasks:completeTask",
+    ),
+    reopenTask: makeFunctionReference<"mutation">(
+      "functions/crm/tasks:reopenTask",
+    ),
+  },
+};
+
+const DENCH_MENTION = "[@Dench](/?member=dench)";
+
+function paginationFlags(
+  args: string[],
+  defaultLimit: number,
+): { numItems: number; cursor: string | null } {
+  const rawLimit = getFlag(args, "--limit");
+  const limit =
+    rawLimit === undefined ? defaultLimit : Number.parseInt(rawLimit, 10);
+  if (!Number.isFinite(limit) || limit < 1) {
+    throw new CrmCliError("--limit must be a positive integer");
+  }
+  return {
+    numItems: Math.min(limit, 100),
+    cursor: getFlag(args, "--cursor") ?? null,
+  };
+}
+
+/** `--body`, `--body-file`, or piped stdin — in that order. */
+async function readBody(args: string[]): Promise<string> {
+  const inline = getFlag(args, "--body");
+  if (inline !== undefined) return inline;
+  const file = getFlag(args, "--body-file");
+  if (file) return await readFile(file, "utf8");
+  if (!process.stdin.isTTY) {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const text = Buffer.concat(chunks).toString("utf8");
+    if (text.trim()) return text;
+  }
+  throw new CrmCliError(
+    'A comment body is required: pass --body "…", --body-file <path>, or pipe markdown on stdin.',
+  );
+}
+
+/** Repeated `--mention <userId>` flags. */
+function collectMentions(args: string[]): string[] {
+  const ids: string[] = [];
+  for (;;) {
+    const value = getFlag(args, "--mention");
+    if (value === undefined) break;
+    if (value.trim()) ids.push(value.trim());
+  }
+  return ids;
+}
+
+export async function runCommentsCommand(ctx: CrmCliContext): Promise<void> {
+  const verb = ctx.args.shift();
+  switch (verb) {
+    case "list": {
+      const objectName = shift(ctx.args, "object name");
+      const entryId = shift(ctx.args, "entry id");
+      const paginationOpts = paginationFlags(ctx.args, 20);
+      const rawReplies = getFlag(ctx.args, "--replies");
+      const previewReplies =
+        rawReplies === undefined ? undefined : Number.parseInt(rawReplies, 10);
+      assertNoUnknownFlags(ctx.args, "crm comments list");
+      out(
+        ctx,
+        await callQuery(ctx, api.comments.listForEntry, {
+          objectName,
+          entryId,
+          paginationOpts,
+          ...(previewReplies !== undefined && Number.isFinite(previewReplies)
+            ? { previewReplies }
+            : {}),
+        }),
+      );
+      return;
+    }
+    case "replies": {
+      const rootCommentId = shift(ctx.args, "comment id");
+      const paginationOpts = paginationFlags(ctx.args, 50);
+      assertNoUnknownFlags(ctx.args, "crm comments replies");
+      out(
+        ctx,
+        await callQuery(ctx, api.comments.listReplies, {
+          rootCommentId,
+          paginationOpts,
+        }),
+      );
+      return;
+    }
+    case "get": {
+      const commentId = shift(ctx.args, "comment id");
+      assertNoUnknownFlags(ctx.args, "crm comments get");
+      out(ctx, await callQuery(ctx, api.comments.get, { commentId }));
+      return;
+    }
+    case "create": {
+      const objectName = shift(ctx.args, "object name");
+      const entryId = shift(ctx.args, "entry id");
+      let body = await readBody(ctx.args);
+      const parentCommentId = getFlag(ctx.args, "--reply-to");
+      const mentionUserIds = collectMentions(ctx.args);
+      const mentionDench = hasFlag(ctx.args, "--dench");
+      assertNoUnknownFlags(ctx.args, "crm comments create");
+      if (mentionDench && !body.includes("/?member=dench")) {
+        body = `${DENCH_MENTION} ${body}`;
+      }
+      out(
+        ctx,
+        await callMutation(ctx, api.comments.create, {
+          objectName,
+          entryId,
+          body,
+          ...(parentCommentId ? { parentCommentId } : {}),
+          ...(mentionUserIds.length > 0 ? { mentionUserIds } : {}),
+          ...(mentionDench ? { mentionDench: true } : {}),
+          ...(ctx.runId ? { runId: ctx.runId } : {}),
+        }),
+      );
+      return;
+    }
+    case "update": {
+      const commentId = shift(ctx.args, "comment id");
+      const body = await readBody(ctx.args);
+      assertNoUnknownFlags(ctx.args, "crm comments update");
+      out(ctx, await callMutation(ctx, api.comments.edit, { commentId, body }));
+      return;
+    }
+    case "delete": {
+      const commentId = shift(ctx.args, "comment id");
+      assertNoUnknownFlags(ctx.args, "crm comments delete");
+      out(ctx, await callMutation(ctx, api.comments.remove, { commentId }));
+      return;
+    }
+    case "react": {
+      const commentId = shift(ctx.args, "comment id");
+      const emoji = shift(ctx.args, "emoji");
+      assertNoUnknownFlags(ctx.args, "crm comments react");
+      out(
+        ctx,
+        await callMutation(ctx, api.comments.toggleReaction, {
+          commentId,
+          emoji,
+        }),
+      );
+      return;
+    }
+    default:
+      throw new CrmCliError(
+        `Unknown comments verb: ${verb ?? "(none)"}. Use list | replies | get | create | update | delete | react.`,
+      );
+  }
+}
+
+export async function runWatchCommand(ctx: CrmCliContext): Promise<void> {
+  if (ctx.args[0] === "status") {
+    ctx.args.shift();
+    const objectName = shift(ctx.args, "object name");
+    const entryId = shift(ctx.args, "entry id");
+    assertNoUnknownFlags(ctx.args, "crm watch status");
+    void objectName;
+    out(ctx, await callQuery(ctx, api.comments.getWatchState, { entryId }));
+    return;
+  }
+  const objectName = shift(ctx.args, "object name");
+  const entryId = shift(ctx.args, "entry id");
+  const off = hasFlag(ctx.args, "--off");
+  assertNoUnknownFlags(ctx.args, "crm watch");
+  void objectName;
+  out(
+    ctx,
+    await callMutation(ctx, api.comments.setWatching, {
+      entryId,
+      watching: !off,
+    }),
+  );
+}
+
+export async function runTasksCommand(ctx: CrmCliContext): Promise<void> {
+  const verb = ctx.args.shift();
+  switch (verb) {
+    case "mine": {
+      const rawLimit = getFlag(ctx.args, "--limit");
+      assertNoUnknownFlags(ctx.args, "crm tasks mine");
+      out(
+        ctx,
+        await callQuery(ctx, api.tasks.listMyOpenTasks, {
+          ...(rawLimit ? { limit: Number.parseInt(rawLimit, 10) } : {}),
+        }),
+      );
+      return;
+    }
+    case "list": {
+      const objectName = shift(ctx.args, "object name");
+      const entryId = shift(ctx.args, "entry id");
+      assertNoUnknownFlags(ctx.args, "crm tasks list");
+      out(
+        ctx,
+        await callQuery(ctx, api.tasks.listEntryTasks, { objectName, entryId }),
+      );
+      return;
+    }
+    case "create": {
+      const objectName = shift(ctx.args, "object name");
+      const entryId = shift(ctx.args, "entry id");
+      const name = getFlag(ctx.args, "--name");
+      const assigneeUserId = getFlag(ctx.args, "--assignee");
+      const dueDateKey = getFlag(ctx.args, "--due");
+      assertNoUnknownFlags(ctx.args, "crm tasks create");
+      if (!name?.trim()) throw new CrmCliError("--name is required");
+      if (dueDateKey && !/^\d{4}-\d{2}-\d{2}$/.test(dueDateKey)) {
+        throw new CrmCliError("--due must be YYYY-MM-DD");
+      }
+      out(
+        ctx,
+        await callMutation(ctx, api.tasks.createEntryTask, {
+          objectName,
+          entryId,
+          name: name.trim(),
+          ...(assigneeUserId ? { assigneeUserId } : {}),
+          ...(dueDateKey ? { dueDateKey } : {}),
+        }),
+      );
+      return;
+    }
+    case "complete":
+    case "reopen": {
+      const entryId = shift(ctx.args, "task entry id");
+      assertNoUnknownFlags(ctx.args, `crm tasks ${verb}`);
+      out(
+        ctx,
+        await callMutation(
+          ctx,
+          verb === "complete" ? api.tasks.completeTask : api.tasks.reopenTask,
+          { entryId },
+        ),
+      );
+      return;
+    }
+    default:
+      throw new CrmCliError(
+        `Unknown tasks verb: ${verb ?? "(none)"}. Use mine | list | create | complete | reopen.`,
+      );
+  }
+}

package/crm.ts

@@ -29,6 +29,11 @@
  */
 import type { ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
+import {
+  runCommentsCommand,
+  runTasksCommand,
+  runWatchCommand,
+} from "./crm-comments";
 import {
   assertNoUnknownFlags as assertNoUnknownFlagsRaw,
   CliArgError,
@@ -65,7 +70,7 @@ type JsonRecord = Record<string, unknown>;
 
 const CRM_BATCH_CHUNK_SIZE = 200;
 
-type CrmCliContext = {
+export type CrmCliContext = {
   convex: ConvexHttpClient;
   args: string[];
   jsonOutput: boolean;
@@ -196,7 +201,7 @@ function withCrmEntryDeepLinks(
 
 // Adapt the shared helpers to throw CrmCliError so existing call sites
 // don't need to change their try/catch shape.
-class CrmCliError extends Error {}
+export class CrmCliError extends Error {}
 
 function userFacingConvexErrorMessage(error: unknown): string | null {
   if (!error || typeof error !== "object") return null;
@@ -224,7 +229,7 @@ function normalizeRpcError(error: unknown): Error {
   );
 }
 
-function shift(args: string[], expected: string): string {
+export function shift(args: string[], expected: string): string {
   try {
     return shiftRaw(args, expected);
   } catch (error) {
@@ -307,7 +312,10 @@ function parseJson(value: string | undefined): unknown {
   }
 }
 
-function assertNoUnknownFlags(args: readonly string[], command: string): void {
+export function assertNoUnknownFlags(
+  args: readonly string[],
+  command: string,
+): void {
   try {
     assertNoUnknownFlagsRaw(args, command);
   } catch (error) {
@@ -652,7 +660,7 @@ async function assertKnownDataKeys(
   );
 }
 
-async function callQuery(
+export async function callQuery(
   ctx: CrmCliContext,
   fn: Parameters<ConvexHttpClient["query"]>[0],
   args: Record<string, unknown> = {},
@@ -667,7 +675,7 @@ async function callQuery(
   }
 }
 
-async function callMutation(
+export async function callMutation(
   ctx: CrmCliContext,
   fn: Parameters<ConvexHttpClient["mutation"]>[0],
   args: Record<string, unknown> = {},
@@ -720,7 +728,7 @@ async function suppressForwardedConvexLogs<T>(
   }
 }
 
-function out(ctx: CrmCliContext, value: unknown): void {
+export function out(ctx: CrmCliContext, value: unknown): void {
   if (ctx.jsonOutput) {
     console.log(JSON.stringify(value, null, 2));
     return;
@@ -983,6 +991,12 @@ export async function runCrmCommand(opts: {
       return await runEntriesCommand(ctx);
     case "history":
       return await runHistoryCommand(ctx);
+    case "comments":
+      return await runCommentsCommand(ctx);
+    case "watch":
+      return await runWatchCommand(ctx);
+    case "tasks":
+      return await runTasksCommand(ctx);
     case "cells":
       return await runCellsCommand(ctx);
     case "query":
@@ -1045,6 +1059,9 @@ const CRM_SUBCOMMANDS = [
   "fields",
   "entries",
   "history",
+  "comments",
+  "watch",
+  "tasks",
   "cells",
   "query",
   "sql",
@@ -4256,6 +4273,28 @@ Entries (rows):
   dench crm entries list <object> [--limit N] [--with-meta] [--json]
   dench crm entries get <object> <entryId>
   dench crm history <object> <entryId> [--include-system] [--limit N] [--cursor CURSOR] [--json]
+
+Comments (the record's Activity feed):
+  dench crm comments list <object> <entryId> [--limit N] [--cursor CURSOR] [--replies N] [--json]
+  dench crm comments replies <commentId> [--limit N] [--cursor CURSOR]
+  dench crm comments get <commentId>
+  dench crm comments create <object> <entryId> --body "markdown" [--body-file f.md] [--reply-to <commentId>] [--mention <userId>]... [--dench]
+      Mention a member inline as [@Name](/?member=<userId>); --dench appends
+      [@Dench](/?member=dench) so the agent replies in the thread. Returns
+      { id, denchRunId? } immediately — poll 'comments list' for the reply.
+  dench crm comments update <commentId> --body "markdown"
+  dench crm comments delete <commentId>
+  dench crm comments react <commentId> <emoji>          (toggles)
+  dench crm watch <object> <entryId> [--off]            (follow / unfollow activity)
+  dench crm watch status <object> <entryId>
+
+Tasks (shortcuts over the protected 'task' object):
+  dench crm tasks mine [--limit N]
+  dench crm tasks list <object> <entryId>
+  dench crm tasks create <object> <entryId> --name "…" [--assignee <userId>] [--due YYYY-MM-DD]
+  dench crm tasks complete <taskEntryId>
+  dench crm tasks reopen <taskEntryId>
+
   dench crm entries create <object> --data '{"Field":"Value",...}'    (alias: --fields) [--allow-unknown] [--idempotency-key <key>]
       --idempotency-key upserts on (object, key): a retried create returns
       the existing row with alreadyExisted: true instead of duplicating it.

package/dench.ts

@@ -517,9 +517,18 @@ CRM (Daytona-native rewrite):
   dench crm docs <list|create|link>
   dench crm actions <list|run> ...
   dench crm batch --file ops.jsonl
+  dench crm comments <list|get|replies|create|update|delete|react> ...   (record Activity feed; --dench summons the agent)
+  dench crm watch <object> <entryId> [--off]                             (follow a record's activity)
+  dench crm tasks <mine|list|create|complete|reopen> ...
   Batch write helpers: entries create-many/update-many, cells set-many
   Help: dench crm help
 
+Notifications (the bell's inbox):
+  dench notifications list [--filter inbox|unread|archived|all] [--limit N] [--json]
+  dench notifications count | read <id> [--unread] | read-all | archive <id>
+  dench notifications prefs [--set emailEnabled=false] [--set <kind>.email=false]
+  Help: dench notifications help
+
 Workspace members (for CRM \`user\`-type fields):
   dench members list [--json]                  (top-level alias)
   dench crm members list [--json]              (canonical CRM-scoped name)
@@ -4569,6 +4578,41 @@ async function main() {
     return;
   }
 
+  if (command === "notifications") {
+    // The bell's inbox from the terminal. Same auth shape as `dench crm`:
+    // agent sessions read their owner's inbox; org API keys are refused
+    // server-side because there is no person behind them.
+    const subArgs = stripRuntimeFlags(
+      args.slice(args.indexOf("notifications") + 1),
+    );
+    const sub = subArgs[0];
+    const { runNotificationsCommand } = await import("./notifications");
+    if (!sub || sub === "help" || sub === "--help") {
+      // biome-ignore lint/suspicious/noExplicitAny: harmless help-only stub
+      await runNotificationsCommand({ convex: {} as any, args: subArgs });
+      return;
+    }
+    const runtime = await getRuntime();
+    if (runtime.mode === "dev") {
+      await runNotificationsCommand({
+        convex: runtime.client,
+        args: subArgs,
+        sessionToken: encodeDevCrmSessionToken(runtime.workspaceArgs),
+      });
+      return;
+    }
+    const authedRuntime = requireAuthenticatedRuntime(
+      runtime,
+      "dench notifications",
+    );
+    await runNotificationsCommand({
+      convex: authedRuntime.client,
+      args: subArgs,
+      sessionToken: authedRuntime.sessionToken,
+    });
+    return;
+  }
+
   if (command === "fs") {
     await runFsCommand();
     return;