@dench.com/cli 2.8.1-staging.110 → 2.8.2-staging.112

package/crm.ts

@@ -3093,6 +3093,13 @@ async function resolveEnrichmentTarget(
  * Email (no first/last name reached the gateway, so the validator
  * rejected the request before any lookup ran).
  */
+const CONTACT_REQUIRED_FIELDS = new Set([
+  "email",
+  "work_email",
+  "personal_email",
+  "phone",
+]);
+
 async function callEnrichmentGatewayForEntry(args: {
   target: EnrichmentTarget;
   entry: CrmEntryForEnrichment;
@@ -3118,7 +3125,11 @@ async function callEnrichmentGatewayForEntry(args: {
   // Contact cells stay on /person/contact. A LinkedIn URL for a profile
   // field (name, title, headline) uses /person so the gateway waterfall
   // can fill graph data without a contact job.
-  const isContactField = Boolean(target.column.enrichFields?.length);
+  const isContactField =
+    Boolean(target.column.enrichFields?.length) ||
+    target.column.requiredFields.some((field) =>
+      CONTACT_REQUIRED_FIELDS.has(field),
+    );
   if (!isContactField && personBody.linkedinUrl) {
     return aviatoEnrichPerson(
       {

package/dench.ts

@@ -44,7 +44,11 @@ import {
   withCurrentSessionSelection,
   withSavedSession,
 } from "./session";
-import { fetchConnectedAppsSummary, runToolCommand } from "./tools";
+import {
+  fetchConnectedAppsSummary,
+  fetchUnipileConnections,
+  runToolCommand,
+} from "./tools";
 
 type JsonRecord = Record<string, unknown>;
 
@@ -2879,11 +2883,14 @@ async function connectedAppsContext(runtime: Runtime) {
       ...unipileQueryAuth(runtime),
     });
   } catch (error) {
+    const unipile = await fetchUnipileConnections(unipileQueryAuth(runtime));
     return {
       available: false,
       reason: errorMessage(error),
-      count: 0,
-      connections: [],
+      count: unipile.connections.length,
+      connections: unipile.connections,
+      unipileAvailable: unipile.available,
+      ...(unipile.error ? { unipileError: unipile.error } : {}),
     };
   }
 }
@@ -4979,6 +4986,7 @@ async function main() {
       args.slice(args.indexOf("artifacts") + 1),
     );
     if (
+      runtime.mode === "dev" ||
       runtime.mode === "session" ||
       runtime.mode === "apiKey"
     ) {
@@ -4987,7 +4995,10 @@ async function main() {
         convex: runtime.client,
         args: artifactArgs,
         jsonOutput: json,
-        sessionToken: runtime.sessionToken,
+        sessionToken:
+          runtime.mode === "dev"
+            ? encodeDevCrmSessionToken(runtime.workspaceArgs)
+            : runtime.sessionToken,
       });
       if (handled) return;
     }

package/leads.ts

@@ -0,0 +1,585 @@
+/**
+ * `dench leads find`, `dench jobs find`, and workspace artifact
+ * list/show/import. Find writes a durable table artifact; import is the
+ * same path as the chat card.
+ */
+import type { ConvexHttpClient } from "convex/browser";
+import { makeFunctionReference } from "convex/server";
+import {
+  assertNoUnknownFlags as assertNoUnknownFlagsRaw,
+  CliArgError,
+  getFlag,
+  hasFlag,
+  shift as shiftRaw,
+} from "./lib/cli-args";
+import {
+  EnrichmentGatewayError,
+  type EnrichmentGatewayOptions,
+  searchCompanies,
+  searchJobs,
+  searchPeople,
+} from "./lib/enrichment-gateway";
+
+class FindCliError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "FindCliError";
+  }
+}
+
+type FindCliContext = {
+  convex: ConvexHttpClient;
+  args: string[];
+  jsonOutput: boolean;
+  sessionToken?: string;
+  enrichmentGateway?: Pick<EnrichmentGatewayOptions, "apiKey" | "baseUrl">;
+};
+
+const api = {
+  saveFind: makeFunctionReference<"action">(
+    "functions/workspaceArtifacts:saveFind",
+  ),
+  list: makeFunctionReference<"query">("functions/workspaceArtifacts:list"),
+  get: makeFunctionReference<"query">("functions/workspaceArtifacts:get"),
+  importArtifact: makeFunctionReference<"action">(
+    "functions/workspaceArtifacts:importArtifact",
+  ),
+};
+
+function shift(args: string[], expected: string): string {
+  try {
+    return shiftRaw(args, expected);
+  } catch (error) {
+    if (error instanceof CliArgError) throw new FindCliError(error.message);
+    throw error;
+  }
+}
+
+function assertNoUnknownFlags(args: readonly string[], command: string): void {
+  try {
+    assertNoUnknownFlagsRaw(args, command);
+  } catch (error) {
+    if (error instanceof CliArgError) throw new FindCliError(error.message);
+    throw error;
+  }
+}
+
+function parseLeadsFindFlags(args: string[]): {
+  titles?: string[];
+  locations?: string[];
+  seniorities?: string[];
+  industries?: string[];
+  functions?: string[];
+  companyDomain?: string;
+  keywords?: string;
+  limit?: number;
+  pageToken?: string;
+} {
+  const titles = csvFlag(args, "--titles");
+  const locations = csvFlag(args, "--locations");
+  const seniorities = csvFlag(args, "--seniorities");
+  const industries = csvFlag(args, "--industries");
+  const functions = csvFlag(args, "--functions");
+  const companyDomain = getFlag(args, "--company-domain");
+  const keywords = getFlag(args, "--keywords");
+  const limit = parseLimit(args);
+  const pageToken = getFlag(args, "--page-token");
+  assertNoUnknownFlags(args, "leads find");
+  if (
+    !titles &&
+    !locations &&
+    !companyDomain &&
+    !keywords &&
+    !industries &&
+    !seniorities
+  ) {
+    throw new FindCliError(
+      "dench leads find requires at least one of --titles, --locations, --company-domain, --keywords, --industries, --seniorities",
+    );
+  }
+  return {
+    titles,
+    locations,
+    seniorities,
+    industries,
+    functions,
+    companyDomain,
+    keywords,
+    limit,
+    pageToken,
+  };
+}
+
+export function assertLeadsFindArgs(args: string[]): void {
+  const copy = [...args];
+  hasFlag(copy, "--json");
+  const verb = copy[0];
+  if (verb !== "find") return;
+  parseLeadsFindFlags(copy.slice(1));
+}
+
+function csvFlag(args: string[], name: string): string[] | undefined {
+  const raw = getFlag(args, name);
+  if (!raw) return undefined;
+  return raw
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+function parseLimit(args: string[]): number | undefined {
+  const raw = getFlag(args, "--limit");
+  if (!raw) return undefined;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new FindCliError("--limit must be a positive integer");
+  }
+  return Math.min(parsed, 5000);
+}
+
+function out(ctx: FindCliContext, value: unknown): void {
+  console.log(JSON.stringify(value, null, ctx.jsonOutput ? 2 : 0));
+}
+
+async function callQuery(
+  ctx: FindCliContext,
+  fn: Parameters<ConvexHttpClient["query"]>[0],
+  args: Record<string, unknown> = {},
+): Promise<unknown> {
+  return await ctx.convex.query(fn, {
+    ...args,
+    ...(ctx.sessionToken ? { sessionToken: ctx.sessionToken } : {}),
+  } as never);
+}
+
+async function callAction(
+  ctx: FindCliContext,
+  fn: Parameters<ConvexHttpClient["action"]>[0],
+  args: Record<string, unknown> = {},
+): Promise<unknown> {
+  return await ctx.convex.action(fn, {
+    ...args,
+    ...(ctx.sessionToken ? { sessionToken: ctx.sessionToken } : {}),
+  } as never);
+}
+
+function asArray(value: unknown): unknown[] {
+  return Array.isArray(value) ? value : [];
+}
+
+function findTitle(
+  kind: "people" | "companies" | "jobs",
+  parts: string[],
+): string {
+  const first = parts.find((part) => part.length > 0);
+  if (kind === "people") return first ? `People: ${first}` : "People search";
+  if (kind === "companies") {
+    return first ? `Companies: ${first}` : "Company search";
+  }
+  return first ? `Jobs: ${first}` : "Job search";
+}
+
+async function persist(
+  ctx: FindCliContext,
+  args: {
+    createdFrom: "find_people" | "find_companies" | "find_jobs";
+    title: string;
+    filters: Record<string, unknown>;
+    people?: unknown[];
+    companies?: unknown[];
+    jobs?: unknown[];
+  },
+): Promise<unknown> {
+  return await callAction(ctx, api.saveFind, args);
+}
+
+export function leadsHelp(): void {
+  console.log(`Dench leads
+
+Usage:
+  dench leads find --titles "VP Sales" --locations "San Francisco" [--company-domain acme.com] [--limit 500] [--page-token <token>] [--json]
+  dench leads find --keywords "fintech" [--industries SaaS] [--seniorities director,vp] [--json]
+
+Finds people through Dench search and writes a workspace artifact.
+Import with \`dench artifacts import <id> --to lead\`.
+`);
+}
+
+export function companiesHelp(): void {
+  console.log(`Dench companies
+
+Usage:
+  dench companies find --name "Acme" [--domain acme.com] [--keywords fintech] [--industries SaaS] [--locations "San Francisco"] [--linkedin https://linkedin.com/company/acme] [--limit 500] [--page-token <token>] [--json]
+
+Finds companies through Dench search and writes a workspace artifact.
+Import with \`dench artifacts import <id> --to lead\`.
+`);
+}
+
+export function jobsHelp(): void {
+  console.log(`Dench jobs
+
+Usage:
+  dench jobs find --titles "Account Executive" --locations "San Francisco" [--company-domain acme.com] [--keywords remote] [--limit 500] [--page-token <token>] [--json]
+
+Finds job postings through Dench search and writes a workspace artifact.
+Import with \`dench artifacts import <id> --to job_posting\`.
+`);
+}
+
+export function workspaceArtifactsHelp(): void {
+  console.log(`Dench artifacts
+
+Usage:
+  dench artifacts [--limit 25] [--json]
+  dench artifacts list [--limit 25] [--json]
+  dench artifacts show <id> [--json]
+  dench artifacts import <id> --to lead|company|job_posting [--view "Q3 outbound"] [--pin] [--json]
+
+\`list\` / \`show\` / \`import\` operate on find results (lead lists and job
+searches). Bare \`dench artifacts\` still lists agent suggested-work artifacts.
+`);
+}
+
+export function assertJobsFindArgs(args: string[]): void {
+  const copy = [...args];
+  hasFlag(copy, "--json");
+  if (copy[0] !== "find") return;
+  if (
+    !copy.includes("--titles") &&
+    !copy.includes("--locations") &&
+    !copy.includes("--company-domain") &&
+    !copy.includes("--company") &&
+    !copy.includes("--keywords")
+  ) {
+    throw new FindCliError(
+      "dench jobs find requires at least one of --titles, --locations, --company-domain, --company, --keywords",
+    );
+  }
+}
+
+export function assertCompaniesFindArgs(args: string[]): void {
+  const copy = [...args];
+  hasFlag(copy, "--json");
+  if (copy[0] !== "find") return;
+  if (
+    !copy.includes("--domain") &&
+    !copy.includes("--name") &&
+    !copy.includes("--keywords") &&
+    !copy.includes("--industries") &&
+    !copy.includes("--locations") &&
+    !copy.includes("--linkedin") &&
+    !copy.includes("--headcount")
+  ) {
+    throw new FindCliError(
+      "dench companies find requires at least one of --name, --domain, --keywords, --industries, --locations, --linkedin, --headcount",
+    );
+  }
+}
+
+export async function runLeadsCommand(opts: {
+  convex: ConvexHttpClient;
+  args: string[];
+  jsonOutput?: boolean;
+  sessionToken?: string;
+  enrichmentGateway?: Pick<EnrichmentGatewayOptions, "apiKey" | "baseUrl">;
+}): Promise<void> {
+  const args = [...opts.args];
+  const jsonFromArgs = hasFlag(args, "--json");
+  const ctx: FindCliContext = {
+    convex: opts.convex,
+    args,
+    jsonOutput: opts.jsonOutput === true || jsonFromArgs,
+    sessionToken: opts.sessionToken,
+    enrichmentGateway: opts.enrichmentGateway,
+  };
+  const verb = args.shift();
+  if (!verb || verb === "help" || verb === "--help") {
+    leadsHelp();
+    return;
+  }
+  if (verb !== "find") {
+    throw new FindCliError(`Unknown leads verb: ${verb}`);
+  }
+  const {
+    titles,
+    locations,
+    seniorities,
+    industries,
+    functions,
+    companyDomain,
+    keywords,
+    limit,
+    pageToken,
+  } = parseLeadsFindFlags(args);
+  try {
+    const result = await searchPeople(
+      {
+        personTitles: titles,
+        personLocations: locations,
+        personSeniorities: seniorities,
+        personFunctions: functions,
+        organizationDomains: companyDomain ? [companyDomain] : undefined,
+        organizationIndustries: industries,
+        keywords,
+        limit,
+        pageToken,
+      },
+      ctx.enrichmentGateway,
+    );
+    const people = asArray(result.people);
+    const artifact = await persist(ctx, {
+      createdFrom: "find_people",
+      title: findTitle("people", [
+        titles?.[0] ?? "",
+        keywords ?? "",
+        companyDomain ?? "",
+      ]),
+      filters: {
+        titles,
+        locations,
+        seniorities,
+        industries,
+        companyDomain,
+        keywords,
+        limit,
+      },
+      people,
+    });
+    // metadata carries total / nextPageToken — pass the token back via
+    // --page-token to continue where this page stopped.
+    out(ctx, {
+      ...(artifact as Record<string, unknown>),
+      metadata: result.metadata,
+    });
+  } catch (error) {
+    throw new FindCliError(
+      error instanceof EnrichmentGatewayError || error instanceof Error
+        ? error.message
+        : String(error),
+    );
+  }
+}
+
+export async function runJobsCommand(opts: {
+  convex: ConvexHttpClient;
+  args: string[];
+  jsonOutput?: boolean;
+  sessionToken?: string;
+  enrichmentGateway?: Pick<EnrichmentGatewayOptions, "apiKey" | "baseUrl">;
+}): Promise<void> {
+  const args = [...opts.args];
+  const jsonFromArgs = hasFlag(args, "--json");
+  const ctx: FindCliContext = {
+    convex: opts.convex,
+    args,
+    jsonOutput: opts.jsonOutput === true || jsonFromArgs,
+    sessionToken: opts.sessionToken,
+    enrichmentGateway: opts.enrichmentGateway,
+  };
+  const verb = args.shift();
+  if (!verb || verb === "help" || verb === "--help") {
+    jobsHelp();
+    return;
+  }
+  if (verb !== "find") {
+    throw new FindCliError(`Unknown jobs verb: ${verb}`);
+  }
+  const titles = csvFlag(args, "--titles");
+  const locations = csvFlag(args, "--locations");
+  const companyDomain = getFlag(args, "--company-domain");
+  const companyName = getFlag(args, "--company");
+  const keywords = getFlag(args, "--keywords");
+  const postedAfter = getFlag(args, "--posted-after");
+  const limit = parseLimit(args);
+  const pageToken = getFlag(args, "--page-token");
+  assertNoUnknownFlags(args, "jobs find");
+  if (!titles && !locations && !companyDomain && !companyName && !keywords) {
+    throw new FindCliError(
+      "dench jobs find requires at least one of --titles, --locations, --company-domain, --company, --keywords",
+    );
+  }
+  try {
+    const result = await searchJobs(
+      {
+        titles,
+        locations,
+        companyDomain,
+        companyName,
+        keywords,
+        postedAfter,
+        limit,
+        pageToken,
+      },
+      ctx.enrichmentGateway,
+    );
+    const jobs = asArray(result.jobs);
+    const artifact = await persist(ctx, {
+      createdFrom: "find_jobs",
+      title: findTitle("jobs", [titles?.[0] ?? "", companyName ?? "", keywords ?? ""]),
+      filters: {
+        titles,
+        locations,
+        companyDomain,
+        companyName,
+        keywords,
+        postedAfter,
+        limit,
+      },
+      jobs,
+    });
+    out(ctx, {
+      ...(artifact as Record<string, unknown>),
+      metadata: result.metadata,
+    });
+  } catch (error) {
+    throw new FindCliError(
+      error instanceof EnrichmentGatewayError || error instanceof Error
+        ? error.message
+        : String(error),
+    );
+  }
+}
+
+export async function runCompaniesCommand(opts: {
+  convex: ConvexHttpClient;
+  args: string[];
+  jsonOutput?: boolean;
+  sessionToken?: string;
+  enrichmentGateway?: Pick<EnrichmentGatewayOptions, "apiKey" | "baseUrl">;
+}): Promise<void> {
+  const args = [...opts.args];
+  const jsonFromArgs = hasFlag(args, "--json");
+  const ctx: FindCliContext = {
+    convex: opts.convex,
+    args,
+    jsonOutput: opts.jsonOutput === true || jsonFromArgs,
+    sessionToken: opts.sessionToken,
+    enrichmentGateway: opts.enrichmentGateway,
+  };
+  const verb = args.shift();
+  if (!verb || verb === "help" || verb === "--help") {
+    companiesHelp();
+    return;
+  }
+  if (verb !== "find") {
+    throw new FindCliError(`Unknown companies verb: ${verb}`);
+  }
+  const domain = getFlag(args, "--domain");
+  const name = getFlag(args, "--name");
+  const keywords = getFlag(args, "--keywords");
+  const industries = csvFlag(args, "--industries");
+  const locations = csvFlag(args, "--locations");
+  const linkedinUrl = getFlag(args, "--linkedin");
+  const headcountRanges = csvFlag(args, "--headcount");
+  const limit = parseLimit(args);
+  const pageToken = getFlag(args, "--page-token");
+  assertNoUnknownFlags(args, "companies find");
+  if (
+    !domain &&
+    !name &&
+    !keywords &&
+    !industries &&
+    !locations &&
+    !linkedinUrl &&
+    !headcountRanges
+  ) {
+    throw new FindCliError(
+      "dench companies find requires at least one of --name, --domain, --keywords, --industries, --locations, --linkedin, --headcount",
+    );
+  }
+  try {
+    const result = await searchCompanies(
+      {
+        domain,
+        name,
+        keywords,
+        industries,
+        locations,
+        linkedinUrl,
+        headcountRanges,
+        limit,
+        pageToken,
+      },
+      ctx.enrichmentGateway,
+    );
+    const artifact = await persist(ctx, {
+      createdFrom: "find_companies",
+      title: findTitle("companies", [name ?? "", domain ?? "", keywords ?? ""]),
+      filters: {
+        domain,
+        name,
+        keywords,
+        industries,
+        locations,
+        linkedinUrl,
+        headcountRanges,
+        limit,
+      },
+      companies: asArray(result.companies),
+    });
+    out(ctx, {
+      ...(artifact as Record<string, unknown>),
+      metadata: result.metadata,
+    });
+  } catch (error) {
+    throw new FindCliError(
+      error instanceof EnrichmentGatewayError || error instanceof Error
+        ? error.message
+        : String(error),
+    );
+  }
+}
+
+export async function runWorkspaceArtifactsCommand(opts: {
+  convex: ConvexHttpClient;
+  args: string[];
+  jsonOutput?: boolean;
+  sessionToken?: string;
+}): Promise<boolean> {
+  const args = [...opts.args];
+  const verb = args[0];
+  if (verb !== "list" && verb !== "show" && verb !== "import") {
+    return false;
+  }
+  args.shift();
+  const ctx: FindCliContext = {
+    convex: opts.convex,
+    args,
+    jsonOutput: opts.jsonOutput === true || hasFlag(args, "--json"),
+    sessionToken: opts.sessionToken,
+  };
+  if (verb === "list") {
+    const limitRaw = getFlag(args, "--limit");
+    const limit = limitRaw ? Number(limitRaw) : 25;
+    assertNoUnknownFlags(args, "artifacts list");
+    out(ctx, await callQuery(ctx, api.list, { limit }));
+    return true;
+  }
+  if (verb === "show") {
+    const artifactId = shift(args, "artifact id");
+    assertNoUnknownFlags(args, "artifacts show");
+    out(ctx, await callQuery(ctx, api.get, { artifactId }));
+    return true;
+  }
+  const artifactId = shift(args, "artifact id");
+  const to = getFlag(args, "--to");
+  if (to !== "lead" && to !== "job_posting" && to !== "company") {
+    throw new FindCliError(
+      "dench artifacts import <id> --to lead|company|job_posting [--view ...] [--pin]",
+    );
+  }
+  const viewName = getFlag(args, "--view");
+  const pin = hasFlag(args, "--pin");
+  assertNoUnknownFlags(args, "artifacts import");
+  out(
+    ctx,
+    await callAction(ctx, api.importArtifact, {
+      artifactId,
+      to,
+      viewName,
+      pin,
+    }),
+  );
+  return true;
+}

package/lib/crm-enrichment.ts

@@ -91,6 +91,22 @@ export const PEOPLE_ENRICHMENT_COLUMNS: readonly EnrichmentColumnDef[] = [
     extractionFallbacks: ["email"],
     enrichFields: ["work_emails"],
   },
+  {
+    label: "Work Email",
+    key: "person.work_email",
+    fieldType: "email",
+    apolloPath: "person.work_email",
+    requiredFields: ["work_email"],
+    enrichFields: ["work_emails"],
+  },
+  {
+    label: "Personal Email",
+    key: "person.personal_email",
+    fieldType: "email",
+    apolloPath: "person.personal_email",
+    requiredFields: ["personal_email"],
+    enrichFields: ["personal_emails"],
+  },
   {
     label: "Headline",
     key: "person.headline",
@@ -336,7 +352,14 @@ export function getRequiredFieldsForApolloPath(
   const column = getEnrichmentColumns(category).find(
     (candidate) => candidate.apolloPath === apolloPath,
   );
-  return column?.requiredFields ?? [];
+  if (column) return column.requiredFields;
+  if (category !== "people") return [];
+  if (apolloPath.includes("personal_email")) return ["personal_email"];
+  if (apolloPath.includes("phone")) return ["phone"];
+  if (apolloPath.includes("work_email") || /(^|\.)email$/.test(apolloPath)) {
+    return ["work_email"];
+  }
+  return [];
 }
 
 export function buildEnrichmentMeta(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dench.com/cli",
-  "version": "2.8.1-staging.110",
+  "version": "2.8.2-staging.112",
   "description": "Dench agent workspace CLI.",
   "type": "module",
   "bin": {
@@ -32,6 +32,7 @@
     "search.ts",
     "web.ts",
     "image.ts",
+    "leads.ts",
     "tools.ts",
     "apps.ts",
     "agentKind.ts",

package/tools.ts

@@ -169,7 +169,9 @@ function withoutShadowedComposioTools(
  * whole command over that would take `dench integrations` from "missing the
  * calendar" to "broken", which is strictly worse.
  */
-async function fetchUnipileConnections(ctx: UnipileAuthContext): Promise<{
+export async function fetchUnipileConnections(
+  ctx: UnipileAuthContext,
+): Promise<{
   available: boolean;
   connections: CompactConnection[];
   error?: string;
@@ -257,12 +259,9 @@ async function runStatusSubcommand(ctx: ToolCliContext): Promise<void> {
   const filterToolkit = ctx.args[0]?.startsWith("--") ? undefined : ctx.args[0];
   if (filterToolkit) ctx.args.shift();
 
-  const [connectionsPayload, unipile] = await Promise.all([
-    callGateway(ctx, "GET", "/v1/composio/connections"),
-    fetchUnipileConnections(ctx),
-  ]);
+  const connectionsSummary = await fetchConnectedAppsSummary(ctx);
   let toolkitsPayload: unknown = null;
-  if (filterToolkit) {
+  if (filterToolkit && connectionsSummary.available) {
     const search = encodeURIComponent(filterToolkit);
     toolkitsPayload = await callGateway(
       ctx,
@@ -271,10 +270,7 @@ async function runStatusSubcommand(ctx: ToolCliContext): Promise<void> {
     );
   }
 
-  const allConnections = [
-    ...extractConnections(connectionsPayload).map(compactConnection),
-    ...unipile.connections,
-  ];
+  const allConnections = connectionsSummary.connections;
   // Filtering after the merge is what makes `dench tool status gmail` answer
   // with the Unipile mailbox instead of nothing.
   const filteredConnections = filterToolkit
@@ -285,12 +281,16 @@ async function runStatusSubcommand(ctx: ToolCliContext): Promise<void> {
 
   const summary = {
     ok: true,
-    available: true,
+    available: connectionsSummary.available,
     toolkit: filterToolkit ?? null,
     count: filteredConnections.length,
     connections: filteredConnections,
-    unipileAvailable: unipile.available,
-    ...(unipile.error ? { unipileError: unipile.error } : {}),
+    unipileAvailable: connectionsSummary.unipileAvailable,
+    ...(connectionsSummary.unipileError
+      ? { unipileError: connectionsSummary.unipileError }
+      : {}),
+    ...(connectionsSummary.error ? { error: connectionsSummary.error } : {}),
+    ...(connectionsSummary.reason ? { reason: connectionsSummary.reason } : {}),
     ...(toolkitsPayload
       ? { toolkit_info: extractToolkits(toolkitsPayload) }
       : {}),