@dench.com/cli 0.4.8 → 0.4.9

package/members.ts

@@ -0,0 +1,192 @@
+/**
+ * `dench members <subcommand>` — workspace member roster for CRM
+ * `user`-type fields (and anyone else who needs to look up who is in
+ * the org from the command line).
+ *
+ * Why this exists:
+ *
+ * CRM `user`-typed cells store a Convex `users` doc id. The UI
+ * resolves that id to a real avatar + name against the org's member
+ * roster, which the browser SPA fetches via
+ * `api.functions.organizations.listMembers`. That query is wired to
+ * `getAuthUserId(ctx)` (Convex Auth cookies), so it's invisible to
+ * the dench-cli running in a sandbox under `DENCH_API_KEY` or a
+ * `dch_agent_*` session token from `dench login`.
+ *
+ * Before this command existed, the AI agent had no way to discover
+ * userIds and would write display names as strings into user-typed
+ * cells, which the UI then rendered as unlinked badges. This module
+ * pairs with the new `crm/members.list` Convex query (which
+ * authenticates via `requireCrmAccess` and accepts every CLI bearer)
+ * to give the AI a way to look up `{ userId, name, email, role }` for
+ * every member of the org and assign cells correctly.
+ *
+ * Surfaces:
+ *   dench members list          (top-level, this module)
+ *   dench crm members list      (alias dispatched from cli/crm.ts so the
+ *                                command is also discoverable from
+ *                                inside the `dench crm` namespace, which
+ *                                is what the seed skill points the AI
+ *                                at most of the time)
+ *
+ * Both surfaces share this implementation so the CLI auth + payload
+ * shape stays in lockstep.
+ */
+import { ConvexHttpClient } from "convex/browser";
+import { makeFunctionReference } from "convex/server";
+import { CliArgError, hasFlag } from "./lib/cli-args";
+
+class MembersCliError extends Error {}
+
+type MembersCliContext = {
+  convex: ConvexHttpClient;
+  args: string[];
+  jsonOutput: boolean;
+  /**
+   * Bearer forwarded with every Convex call so the server-side
+   * `requireCrmAccess` helper can resolve the caller's organization
+   * without a Convex Auth cookie. Two accepted formats:
+   *   • `dch_agent_*` agent session token minted by `dench login`.
+   *   • Unified Dench API key (`dench_pk_*`, `dench_live_*`, etc.)
+   *     baked into sandbox envVars as `DENCH_API_KEY`.
+   */
+  sessionToken?: string;
+};
+
+type MemberRow = {
+  userId: string;
+  name: string | null;
+  email: string | null;
+  image: string | null;
+  role: "ADMIN" | "MEMBER";
+  joinedAt: number;
+};
+
+type ListMembersResult = {
+  members: MemberRow[];
+  organizationId: string;
+  organizationSlug: string | null;
+  organizationName: string;
+};
+
+const api = {
+  members: {
+    list: makeFunctionReference<"query">("functions/crm/members:list"),
+  },
+};
+
+export async function runMembersCommand(opts: {
+  convex: ConvexHttpClient;
+  args: string[];
+  sessionToken?: string;
+}): Promise<void> {
+  const args = [...opts.args];
+  const jsonOutput = hasFlag(args, "--json");
+  const ctx: MembersCliContext = {
+    convex: opts.convex,
+    args,
+    jsonOutput,
+    sessionToken: opts.sessionToken,
+  };
+  const subcommand = args.shift();
+  if (!subcommand || subcommand === "help" || subcommand === "--help") {
+    membersHelp();
+    return;
+  }
+  switch (subcommand) {
+    case "list":
+      return await runListMembers(ctx);
+    default:
+      throw new MembersCliError(
+        `Unknown members subcommand: ${subcommand}. Run \`dench members help\`.`,
+      );
+  }
+}
+
+async function runListMembers(ctx: MembersCliContext): Promise<void> {
+  if (ctx.args.some((arg) => arg.startsWith("--"))) {
+    // No subflags supported beyond --json (which hasFlag already drained).
+    // Surface a typo with a useful hint so the AI doesn't silently get a
+    // full list when it asked for a filter that doesn't exist.
+    throw new MembersCliError(
+      `Unknown flag: ${ctx.args.find((arg) => arg.startsWith("--"))}. \`dench members list\` only accepts --json.`,
+    );
+  }
+  const result = (await callQuery(ctx, api.members.list, {})) as
+    | ListMembersResult
+    | null
+    | undefined;
+  if (ctx.jsonOutput) {
+    console.log(JSON.stringify(result ?? { members: [] }, null, 2));
+    return;
+  }
+  const members = result?.members ?? [];
+  if (members.length === 0) {
+    console.log("(no members)");
+    return;
+  }
+  // Plain table for human consumption — userIds are first column so the
+  // operator can copy/paste directly into a `dench crm cells set ...
+  // --field Owner --value <userId>` follow-up.
+  const headers = ["userId", "role", "name", "email"];
+  const rows = members.map((m) => [
+    m.userId,
+    m.role,
+    m.name ?? "",
+    m.email ?? "",
+  ]);
+  const widths = headers.map((header, idx) =>
+    Math.max(header.length, ...rows.map((row) => row[idx].length)),
+  );
+  const formatRow = (row: string[]) =>
+    row.map((cell, idx) => cell.padEnd(widths[idx])).join("  ");
+  console.log(formatRow(headers));
+  console.log(widths.map((w) => "-".repeat(w)).join("  "));
+  for (const row of rows) {
+    console.log(formatRow(row));
+  }
+}
+
+async function callQuery(
+  ctx: MembersCliContext,
+  fn: Parameters<ConvexHttpClient["query"]>[0],
+  args: Record<string, unknown> = {},
+): Promise<unknown> {
+  try {
+    return await ctx.convex.query(fn, {
+      ...args,
+      ...(ctx.sessionToken ? { sessionToken: ctx.sessionToken } : {}),
+    } as never);
+  } catch (error) {
+    if (error instanceof CliArgError) throw new MembersCliError(error.message);
+    throw error;
+  }
+}
+
+function membersHelp(): void {
+  console.log(`Usage: dench members <subcommand>
+
+Workspace members for the active organization. Use these userIds when
+assigning CRM \`user\`-type cells (e.g. \`Owner\`, \`Assignee\`) so the
+UI shows a real linked avatar instead of an unlinked literal string.
+
+Subcommands:
+  dench members list [--json]
+      List every member of the current org as \`userId / role / name / email\`.
+      Pass --json for a machine-readable shape that includes
+      organizationId / organizationSlug / organizationName.
+
+Alias:
+  dench crm members list [--json]
+      Same surface, dispatched from inside the \`dench crm\` namespace
+      since the canonical use case is assigning CRM \`user\` fields.
+
+After picking a userId:
+  dench crm cells set task --entry <entryId> --field Owner --value <userId>
+  dench crm entries create task --data '{"Name":"Ship CRM","Owner":"<userId>"}'
+
+The server best-effort-resolves a name / email passed to a \`user\`
+field when the match against the roster is unique, but the explicit
+lookup via \`dench members list\` is the correct pattern.
+`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dench.com/cli",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "description": "Dench agent workspace CLI.",
   "type": "module",
   "bin": {
@@ -24,11 +24,13 @@
     "chat.ts",
     "chat-spawn.ts",
     "crm.ts",
+    "members.ts",
     "cron.ts",
     "search.ts",
     "image.ts",
     "tools.ts",
     "agentKind.ts",
+    "agent-config.ts",
     "host.ts",
     "openUrl.ts",
     "session.ts",