@dench.com/cli 2.1.1 → 2.1.3

package/crm.ts

@@ -16,6 +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 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
@@ -330,6 +331,29 @@ async function callMutation(
   }
 }
 
+async function suppressForwardedConvexLogs<T>(
+  fn: () => Promise<T>,
+): Promise<T> {
+  const originalLog = console.log;
+  const originalInfo = console.info;
+  const shouldSuppress = (args: unknown[]) =>
+    typeof args[0] === "string" && args[0].startsWith("[CONVEX ");
+  console.log = (...args: Parameters<typeof console.log>) => {
+    if (shouldSuppress(args)) return;
+    originalLog(...args);
+  };
+  console.info = (...args: Parameters<typeof console.info>) => {
+    if (shouldSuppress(args)) return;
+    originalInfo(...args);
+  };
+  try {
+    return await fn();
+  } finally {
+    console.log = originalLog;
+    console.info = originalInfo;
+  }
+}
+
 function out(ctx: CrmCliContext, value: unknown): void {
   if (ctx.jsonOutput) {
     console.log(JSON.stringify(value, null, 2));
@@ -410,6 +434,9 @@ const api = {
   objects: {
     list: makeFunctionReference<"query">("functions/crm/objects:list"),
     get: makeFunctionReference<"query">("functions/crm/objects:get"),
+    materializeView: makeFunctionReference<"query">(
+      "functions/crm/objects:materializeView",
+    ),
     create: makeFunctionReference<"mutation">("functions/crm/objects:create"),
     update: makeFunctionReference<"mutation">("functions/crm/objects:update"),
     rename: makeFunctionReference<"mutation">("functions/crm/objects:rename"),
@@ -507,6 +534,8 @@ export async function runCrmCommand(opts: {
   switch (subcommand) {
     case "objects":
       return await runObjectsCommand(ctx);
+    case "views":
+      return await runViewsCommand(ctx);
     case "fields":
       return await runFieldsCommand(ctx);
     case "entries":
@@ -636,6 +665,181 @@ async function runObjectsCommand(ctx: CrmCliContext): Promise<void> {
   }
 }
 
+type SavedViewForCli = Record<string, unknown> & {
+  name?: unknown;
+  pinnedEntryIds?: unknown;
+  filters?: unknown;
+  sort?: unknown;
+};
+
+type CrmObjectWithViews = {
+  name?: string;
+  savedViews?: SavedViewForCli[];
+};
+
+function savedViewsFromObject(
+  objectName: string,
+  object: unknown,
+): SavedViewForCli[] {
+  if (!object || typeof object !== "object") {
+    throw new CrmCliError(`CRM object "${objectName}" not found`);
+  }
+  const savedViews = (object as CrmObjectWithViews).savedViews;
+  return Array.isArray(savedViews) ? savedViews : [];
+}
+
+function readViewName(view: SavedViewForCli): string | null {
+  return typeof view.name === "string" && view.name.trim()
+    ? view.name.trim()
+    : null;
+}
+
+function resolveSavedView(
+  objectName: string,
+  views: SavedViewForCli[],
+  requestedName: string,
+): SavedViewForCli {
+  const trimmed = requestedName.trim();
+  const exact = views.find((view) => readViewName(view) === trimmed);
+  if (exact) return exact;
+
+  const lower = trimmed.toLowerCase();
+  const insensitiveMatches = views.filter(
+    (view) => readViewName(view)?.toLowerCase() === lower,
+  );
+  if (insensitiveMatches.length === 1) return insensitiveMatches[0];
+  if (insensitiveMatches.length > 1) {
+    throw new CrmCliError(
+      `Multiple views named like "${requestedName}" exist on ${objectName}; use the exact case-sensitive name.`,
+    );
+  }
+
+  const available = views.map(readViewName).filter(Boolean).join(", ");
+  throw new CrmCliError(
+    `View "${requestedName}" not found on ${objectName}${
+      available ? `. Available views: ${available}` : ". No saved views exist."
+    }`,
+  );
+}
+
+function summarizeSavedView(view: SavedViewForCli): Record<string, unknown> {
+  const pinned = Array.isArray(view.pinnedEntryIds)
+    ? view.pinnedEntryIds
+    : undefined;
+  return {
+    ...view,
+    pinnedCount: pinned?.length ?? 0,
+  };
+}
+
+async function runViewsCommand(ctx: CrmCliContext): Promise<void> {
+  const verb = ctx.args.shift();
+  switch (verb) {
+    case "list": {
+      const objectName = shift(ctx.args, "object name");
+      assertNoUnknownFlags(ctx.args, "crm views list");
+      const object = await callQuery(ctx, api.objects.get, {
+        name: objectName,
+      });
+      const views = savedViewsFromObject(objectName, object).map(
+        summarizeSavedView,
+      );
+      out(ctx, views);
+      return;
+    }
+    case "get": {
+      const objectName = shift(ctx.args, "object name");
+      const viewName = shift(ctx.args, "view name");
+      assertNoUnknownFlags(ctx.args, "crm views get");
+      const object = await callQuery(ctx, api.objects.get, {
+        name: objectName,
+      });
+      const view = resolveSavedView(
+        objectName,
+        savedViewsFromObject(objectName, object),
+        viewName,
+      );
+      out(ctx, summarizeSavedView(view));
+      return;
+    }
+    case "entries": {
+      const objectName = shift(ctx.args, "object name");
+      const viewName = shift(ctx.args, "view name");
+      const page = Number.parseInt(getFlag(ctx.args, "--page") ?? "1", 10);
+      const pageSize = Number.parseInt(
+        getFlagWithAliases(ctx.args, "--page-size", ["--limit"]) ?? "100",
+        10,
+      );
+      const withMeta = hasFlag(ctx.args, "--with-meta");
+      assertNoUnknownFlags(ctx.args, "crm views entries");
+      if (!Number.isFinite(page) || page < 1) {
+        throw new CrmCliError(`--page must be a positive integer, got ${page}`);
+      }
+      if (!Number.isFinite(pageSize) || pageSize < 1) {
+        throw new CrmCliError(
+          `--page-size/--limit must be a positive integer, got ${pageSize}`,
+        );
+      }
+
+      const object = await callQuery(ctx, api.objects.get, {
+        name: objectName,
+      });
+      const view = resolveSavedView(
+        objectName,
+        savedViewsFromObject(objectName, object),
+        viewName,
+      );
+      const pinnedEntryIds = Array.isArray(view.pinnedEntryIds)
+        ? view.pinnedEntryIds.filter(
+            (id): id is string => typeof id === "string" && id.length > 0,
+          )
+        : undefined;
+      const materialized = (await suppressForwardedConvexLogs(() =>
+        callQuery(ctx, api.objects.materializeView, {
+          objectName,
+          page,
+          pageSize,
+          filters: view.filters,
+          sort: Array.isArray(view.sort) ? view.sort : undefined,
+          pinnedEntryIds,
+          includeReverseRelations: false,
+        }),
+      )) as {
+        entries?: unknown[];
+        totalCount?: number;
+        page?: number;
+        pageSize?: number;
+        truncated?: boolean;
+      } | null;
+
+      if (!materialized) {
+        throw new CrmCliError(`CRM object "${objectName}" not found`);
+      }
+      const entries = Array.isArray(materialized.entries)
+        ? materialized.entries
+        : [];
+      if (!withMeta) {
+        out(ctx, entries);
+        return;
+      }
+      out(ctx, {
+        objectName,
+        viewName: readViewName(view) ?? viewName,
+        view: summarizeSavedView(view),
+        totalCount: materialized.totalCount ?? entries.length,
+        returnedCount: entries.length,
+        page: materialized.page ?? page,
+        pageSize: materialized.pageSize ?? pageSize,
+        truncated: materialized.truncated ?? false,
+        entries,
+      });
+      return;
+    }
+    default:
+      throw new CrmCliError(`Unknown crm views verb: ${verb ?? "<none>"}`);
+  }
+}
+
 async function runFieldsCommand(ctx: CrmCliContext): Promise<void> {
   const verb = ctx.args.shift();
   switch (verb) {
@@ -2418,6 +2622,11 @@ Objects (CRM tables):
   dench crm objects rename <from> <to>
   dench crm objects delete <name>
 
+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]
+
 Fields (columns):
   dench crm fields list <object> [--json]
   dench crm fields create <object> <name> --type text|email|phone|url|number|boolean|date|enum|relation|user|tags|action|file|richtext \\

package/dench.ts

@@ -27,6 +27,7 @@ import {
   resolveHostFromArgs,
   STAGING_HOST,
 } from "./host";
+import { resolveOrganizationBySelector } from "./lib/organizationSelector";
 import { formatApprovalOpenMessage, openUrl } from "./openUrl";
 import {
   explicitSessionKeyInput,
@@ -94,6 +95,10 @@ type ConfigFile = {
   sessions?: Record<string, StoredSession>;
 };
 
+function createCliConvexClient(convexUrl: string): ConvexHttpClient {
+  return new ConvexHttpClient(convexUrl, { logger: false });
+}
+
 type WorkspaceOverview = {
   agents: Array<{ _id: string } & JsonRecord>;
   projects: JsonRecord[];
@@ -223,6 +228,7 @@ const BOOLEAN_FLAGS = new Set([
   "--compact",
   "--dev",
   "--follow",
+  "--full-page",
   "--help",
   "--mine",
   "--self",
@@ -470,6 +476,29 @@ Live web search (Exa via the Dench Gateway, auths with the active \`dench signin
   dench search answer "<query>" [--json]
   Help: dench search help
 
+Cloud browser (Browserbase, runs entirely in Dench Cloud):
+  dench browser open [url] [--json]
+  dench browser inspect [--json]
+  dench browser navigate <url>
+  dench browser click --selector <css> | --text "Button text"
+  dench browser fill --label "Email" --value "me@example.com"
+  dench browser screenshot [--output page.jpg] [--full-page]
+  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]
+  dench email campaign create --name "Q2 outreach" --identity <id> --template <id> [--json]
+  dench email campaign recipients add --campaign <id> --file recipients.jsonl [--json]
+  dench email campaign submit --campaign <id> [--json]
+  dench email campaign status --campaign <id> [--json]
+  Help: dench email help
+
 Image generation / editing (via the Dench Gateway):
   dench image generate "<prompt>" [--size 1024x1024] [--quality auto|low|medium|high] [--format png|jpeg|webp] [--save-path /workspace/path/file.png] [--output <local file>] [--no-write] [--json]
   dench image edit "<prompt>" --input <path> [--input <path> ...] [--mask <path>] [--size ...] [--quality ...] [--format ...] [--save-path ...] [--output ...] [--json]
@@ -499,6 +528,7 @@ Spawn a new chat-turn workflow (same as the web UI):
 File sync:
   dench fs status [--json] [--workspace /workspace] [--no-hash] [--drift-limit N]
   dench fs sync --initial --org-id <orgId> [--workspace /workspace]
+  dench fs pull <path> [<path>...] [--wait] [--timeout-ms N] [--json]
   dench fs stream-open <path>
   dench fs stream-append <token> <chunk>
   dench fs stream-close <token>
@@ -531,8 +561,6 @@ Self-updating agent harness:
   dench user show | edit                        USER.md (per-member)
   dench tools show | edit                       TOOLS.md notes section
   dench mem show | append "<text>" | set        MEMORY.md aggregate
-  dench heartbeat status | enable | disable
-                  | interval <30m|1h|…> | instructions
   dench bootstrap status | complete | reopen | template
   dench model default <id|clear>
   dench model thread <threadId> <id|clear>
@@ -1585,7 +1613,7 @@ async function signin() {
   const explicitKey = explicitSessionKeyInput({ args: filteredArgs });
   const host = resolveHostFromArgs(filteredArgs, undefined);
   const convexUrl = await discoverConvexUrl(host);
-  const client = new ConvexHttpClient(convexUrl);
+  const client = createCliConvexClient(convexUrl);
 
   const sessionToken = `dch_agent_${randomUrlSafe(32)}`;
   const sessionTokenHash = await sha256Hex(sessionToken);
@@ -1970,11 +1998,9 @@ async function resolveOrgChoiceForOtp(input: {
   orgSelector: string | null;
 }): Promise<{ organizationId?: string; newOrganizationName?: string }> {
   if (input.orgSelector) {
-    const match = input.organizations.find(
-      (org) =>
-        org.id === input.orgSelector ||
-        org.slug === input.orgSelector ||
-        org.name === input.orgSelector,
+    const match = resolveOrganizationBySelector(
+      input.organizations,
+      input.orgSelector,
     );
     if (!match) {
       throw new CliError(
@@ -2325,7 +2351,7 @@ async function getRuntime() {
       return {
         mode: "session" as const,
         host: resolveApiHost(host),
-        client: new ConvexHttpClient(stored.session.convexUrl),
+        client: createCliConvexClient(stored.session.convexUrl),
         sessionToken: stored.session.sessionToken,
         organization: stored.session.organization,
       };
@@ -2340,48 +2366,55 @@ async function getRuntime() {
       });
     }
 
-    // Sandbox session-mode path: workflow minting provisions a real
-    // dch_agent_* token at sandbox-create time. Prefer it over apiKey so
-    // agentWorkspace.* commands (Composio tools) work inside sandboxes.
-    const sandboxAgentToken = process.env.DENCH_AGENT_SESSION_TOKEN?.trim();
     const sandboxConvexUrl = resolveApiKeyConvexUrl();
-    if (sandboxAgentToken && sandboxConvexUrl) {
-      const orgId = process.env.DENCH_ORG_ID?.trim();
-      const orgSlug = process.env.DENCH_ORG_SLUG?.trim();
+    const orgId = process.env.DENCH_ORG_ID?.trim();
+    const orgSlug = process.env.DENCH_ORG_SLUG?.trim();
+    const sandboxOrganization =
+      orgId && orgSlug
+        ? { id: orgId, name: orgSlug, slug: orgSlug }
+        : undefined;
+
+    // Sandbox / automation path. PREFER the unified Dench API key over the
+    // `dch_agent_*` agent-session token.
+    //
+    // Both are baked into sandbox envVars (src/lib/secrets/sandbox-tokens.ts)
+    // and the server's `requireCrmAccess` / `requireCliWorkspaceAccess`
+    // accept EITHER for the full CRM + files + integration surface. But the
+    // agent-session token EXPIRES (SANDBOX_AGENT_SESSION_TTL_MS, 7d) while
+    // the API key is org-secret-keyed with no TTL. The old order tried the
+    // agent token first and — critically — `getRuntime` keys the session
+    // branch purely on the token being PRESENT, never on validity, so an
+    // expired token in a long-lived / reused sandbox would be used blindly
+    // and the server would reject it, even though a perfectly valid API key
+    // sat right next to it. The server itself documents the API key as the
+    // "preferred path for dench-cli and any automation outside the browser"
+    // and the agent token as legacy back-compat that "new sandboxes do not
+    // need". So prefer the key; it removes the expired-token failure mode
+    // entirely for unattended cron/heartbeat runs.
+    const apiKey = process.env.DENCH_API_KEY?.trim();
+    if (apiKey && sandboxConvexUrl) {
       const apiHost = resolveApiHost(host);
       return {
-        mode: "session" as const,
+        mode: "apiKey" as const,
         host: apiHost,
-        client: new ConvexHttpClient(sandboxConvexUrl),
-        sessionToken: sandboxAgentToken,
-        organization:
-          orgId && orgSlug
-            ? { id: orgId, name: orgSlug, slug: orgSlug }
-            : undefined,
+        client: createCliConvexClient(sandboxConvexUrl),
+        sessionToken: apiKey,
+        organization: sandboxOrganization,
       };
     }
 
-    // Sandbox / automation path: the unified Dench API key + Convex URL
-    // baked into sandbox envVars (see
-    // src/lib/secrets/sandbox-tokens.ts) is enough to drive every
-    // command that goes through `requireCrmAccess` server-side. We only
-    // fall into this branch when no stored session is present, so
-    // explicit `dench signin` setups keep their existing behavior.
-    const apiKey = process.env.DENCH_API_KEY?.trim();
-    const convexUrl = resolveApiKeyConvexUrl();
-    if (apiKey && convexUrl) {
-      const orgId = process.env.DENCH_ORG_ID?.trim();
-      const orgSlug = process.env.DENCH_ORG_SLUG?.trim();
+    // Fallback: no API key present (older sandbox images / custom setups) —
+    // use the agent-session token. Still subject to expiry, but it's the
+    // only credential available in this branch.
+    const sandboxAgentToken = process.env.DENCH_AGENT_SESSION_TOKEN?.trim();
+    if (sandboxAgentToken && sandboxConvexUrl) {
       const apiHost = resolveApiHost(host);
       return {
-        mode: "apiKey" as const,
+        mode: "session" as const,
         host: apiHost,
-        client: new ConvexHttpClient(convexUrl),
-        sessionToken: apiKey,
-        organization:
-          orgId && orgSlug
-            ? { id: orgId, name: orgSlug, slug: orgSlug }
-            : undefined,
+        client: createCliConvexClient(sandboxConvexUrl),
+        sessionToken: sandboxAgentToken,
+        organization: sandboxOrganization,
       };
     }
 
@@ -2394,7 +2427,7 @@ async function getRuntime() {
 
   return {
     mode: "dev" as const,
-    client: new ConvexHttpClient(readEnv("NEXT_PUBLIC_CONVEX_URL")),
+    client: createCliConvexClient(readEnv("NEXT_PUBLIC_CONVEX_URL")),
     workspaceArgs: {
       devKey: readEnv("DENCH_DEV_AGENT_KEY"),
       workspaceSlug: readEnv("DENCH_WORKSPACE"),
@@ -2933,7 +2966,7 @@ async function listArtifacts(runtime: Runtime, limit?: number) {
 }
 
 async function listSuggestedWork(runtime: Runtime) {
-  if (runtime.mode === "session") {
+  if (runtime.mode === "session" || runtime.mode === "apiKey") {
     const context = await buildContext(runtime);
     return asRecordArray(asRecord(context)?.suggestedWork);
   }
@@ -3616,6 +3649,44 @@ async function main() {
     return;
   }
 
+  if (
+    command === "browser" &&
+    (!subcommand || subcommand === "help" || hasFlag("--help"))
+  ) {
+    const { runBrowserCommand } = await import("./browser");
+    await runBrowserCommand({
+      args: subcommand ? [subcommand] : ["help"],
+      runtime: { host: "", bearerToken: "" },
+    });
+    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"))
+  ) {
+    const { runEmailCommand } = await import("./email");
+    await runEmailCommand({
+      // biome-ignore lint/suspicious/noExplicitAny: harmless help-only stub
+      convex: {} as any,
+      args: subcommand ? [subcommand] : ["help"],
+      jsonOutput: json,
+    });
+    return;
+  }
+
   if (
     command === "billing" &&
     (!subcommand || subcommand === "help" || hasFlag("--help"))
@@ -3847,6 +3918,31 @@ async function main() {
     return;
   }
 
+  if (command === "email") {
+    const subArgs = args.slice(args.indexOf("email") + 1);
+    const { runEmailCommand } = await import("./email");
+    const runtime = await getRuntime();
+    const authedRuntime = requireAuthenticatedRuntime(runtime, "dench email");
+    let gatewayAuth:
+      | Awaited<ReturnType<typeof resolveGatewayCommandAuth>>
+      | undefined;
+    try {
+      gatewayAuth = await resolveGatewayCommandAuth(runtime, "dench email");
+    } catch {
+      gatewayAuth = undefined;
+    }
+    await runEmailCommand({
+      convex: authedRuntime.client,
+      args: subArgs.filter((arg) => arg !== "--json"),
+      jsonOutput: json,
+      sessionToken: authedRuntime.sessionToken,
+      bearerToken: gatewayAuth?.bearerToken ?? authedRuntime.sessionToken,
+      gatewayBaseUrl: gatewayAuth?.gatewayBaseUrl,
+      gatewayHeaders: gatewayAuth?.gatewayHeaders,
+    });
+    return;
+  }
+
   if (command === "apps") {
     const runtime = await getRuntime();
     const gatewayAuth = await resolveGatewayCommandAuth(runtime, "dench apps");
@@ -3880,6 +3976,39 @@ async function main() {
     return;
   }
 
+  if (command === "browser") {
+    const subArgs = args.slice(args.indexOf("browser") + 1);
+    const { runBrowserCommand } = await import("./browser");
+    const runtime = await getRuntime();
+    const authedRuntime = requireAuthenticatedRuntime(runtime, "dench browser");
+    await runBrowserCommand({
+      args: subArgs,
+      runtime: {
+        host: authedRuntime.host,
+        bearerToken: authedRuntime.sessionToken,
+      },
+    });
+    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];
@@ -4010,7 +4139,7 @@ async function main() {
   // ── OpenClaw-parity self-update CLI surface ──────────────────────────
   //
   // Dispatch all `dench identity / organisation / user / tools / mem /
-  // heartbeat / bootstrap / model / daily` traffic through the shared
+  // bootstrap / model / daily` traffic through the shared
   // agent-config CLI module. Each command requires the same auth shape
   // as `dench cron` (Bearer DENCH_API_KEY or `dench signin` session
   // token) so server-side `requireCronAccess` accepts both.
@@ -4020,7 +4149,6 @@ async function main() {
     "user",
     "tools",
     "mem",
-    "heartbeat",
     "bootstrap",
     "model",
     "daily",
@@ -4068,10 +4196,6 @@ async function main() {
       await mod.runMemoryAggregateCommand(ctxBase);
       return;
     }
-    if (command === "heartbeat") {
-      await mod.runHeartbeatCommand(ctxBase);
-      return;
-    }
     if (command === "bootstrap") {
       await mod.runBootstrapCommand(ctxBase);
       return;