camunda-cli 0.2.0

package/src/commands/diagnose.js

@@ -0,0 +1,257 @@
+import { Client } from '../client.js';
+import { requireConfig } from '../config.js';
+import { unwrapError, explain, condenseStacktrace } from '../errors.js';
+import * as out from '../output.js';
+
+// One command for "this instance is broken, why".
+//
+// It reads more than the obvious /incident, because several real failure shapes are
+// invisible there:
+//   * A step that fails inside the caller's transaction rolls the transaction back, so no
+//     incident and no job survive; the only record is the historic job log, or nothing at
+//     all if the failure happened synchronously in an API call.
+//   * An incident carries both activityId (where the job hangs) and failedActivityId
+//     (where the error actually came from). Reporting only the first points at the wrong
+//     element, which is exactly what you do not want while hunting a bug.
+export async function diagnoseCommand(id, options) {
+  const client = new Client(requireConfig());
+
+  const [historic, tree, incidents, jobs, jobLog, histIncidents, tasks, externalLog] = await Promise.all([
+    client.historyProcessInstance(id),
+    client.activityInstanceTree(id).catch(() => null),
+    client.incidents({ processInstanceId: id }).catch(() => []),
+    client.jobs({ processInstanceId: id }).catch(() => []),
+    client.historyJobLog({ processInstanceId: id, failureLog: true, sortBy: 'timestamp', sortOrder: 'desc', maxResults: 10 }).catch(() => []),
+    client.historyIncidents({ processInstanceId: id, sortBy: 'createTime', sortOrder: 'desc', maxResults: 10 }).catch(() => []),
+    client.tasks({ processInstanceId: id }).catch(() => []),
+    client.historyExternalTaskLog({ processInstanceId: id, failureLog: true, maxResults: 5 }).catch(() => []),
+  ]);
+
+  if (out.isJsonMode()) {
+    return out.json({ instance: historic, activityTree: tree, incidents, jobs, jobLog, historicIncidents: histIncidents, tasks, externalTaskLog: externalLog });
+  }
+
+  out.heading(`Instance ${id}`);
+  out.kv([
+    ['definition', `${historic.processDefinitionKey} v${historic.processDefinitionVersion}`],
+    ['state', out.stateLabel(historic.state)],
+    ['started', out.formatDateTime(historic.startTime)],
+    ['ended', historic.endTime ? out.formatDateTime(historic.endTime) : '-'],
+    ['tenant', historic.tenantId ?? '-'],
+  ]);
+
+  const waiting = tree ? flatten(tree).filter((n) => n.activityType !== 'processDefinition') : [];
+  if (waiting.length > 0) {
+    out.line('\nStopped at');
+    out.table(null, waiting.map((n) => [`  ${n.activityId}`, n.activityType, n.activityName ?? '']));
+  }
+
+  const problems = [];
+
+  for (const inc of incidents) {
+    problems.push({
+      source: 'open incident',
+      when: inc.incidentTimestamp,
+      activity: inc.failedActivityId || inc.activityId,
+      attachedAt: inc.activityId,
+      message: inc.incidentMessage,
+      jobId: inc.configuration,
+    });
+  }
+
+  for (const job of jobs.filter((j) => j.exceptionMessage)) {
+    if (incidents.some((i) => i.configuration === job.id)) continue;
+    problems.push({
+      source: `job (retries left ${job.retries})`,
+      when: job.createTime,
+      activity: job.failedActivityId,
+      message: job.exceptionMessage,
+      jobId: job.id,
+    });
+  }
+
+  // Only surface the historic log when nothing live explains the failure, otherwise the
+  // same error is reported three times over.
+  if (problems.length === 0) {
+    for (const entry of jobLog) {
+      problems.push({
+        source: 'historic job failure',
+        when: entry.timestamp,
+        activity: entry.failedActivityId || entry.activityId,
+        attachedAt: entry.activityId,
+        message: entry.jobExceptionMessage,
+        historicJobLogId: entry.id,
+      });
+    }
+    for (const inc of histIncidents.filter((i) => i.endTime)) {
+      problems.push({
+        source: `resolved incident (${out.formatDateTime(inc.endTime)})`,
+        when: inc.createTime,
+        activity: inc.failedActivityId || inc.activityId,
+        message: inc.incidentMessage,
+      });
+    }
+  }
+
+  for (const entry of externalLog) {
+    problems.push({ source: 'external task failure', when: entry.timestamp, activity: entry.activityId, message: entry.errorMessage });
+  }
+
+  if (problems.length === 0) {
+    if (historic.state === 'ACTIVE') {
+      out.line('\nNothing is failing. This instance is simply waiting.');
+      if (tasks.length > 0) {
+        out.table(null, tasks.map((t) => [`  task ${t.id}`, out.truncate(t.name, 34), t.assignee ?? 'unassigned']));
+        out.note(`\nMove it along with: camunda complete <taskId> --var name=value`);
+      }
+    } else {
+      out.line(`\nNothing is failing; the instance finished as ${historic.state}.`);
+      if (historic.state === 'EXTERNALLY_TERMINATED') {
+        out.note(`It was force-terminated${historic.deleteReason ? `: ${historic.deleteReason}` : ''}, not completed normally.`);
+      }
+    }
+    return;
+  }
+
+  out.line('');
+  out.problem(`${problems.length} problem(s)`);
+  for (const p of problems) {
+    out.line(`\n  ${p.source} at ${out.formatDateTime(p.when)}`);
+    if (p.activity) out.line(`  failing element: ${p.activity}`);
+    if (p.attachedAt && p.attachedAt !== p.activity) {
+      out.line(`  job attached to:  ${p.attachedAt}  (the async marker sits here, the error came from the element above)`);
+    }
+
+    const unwrapped = unwrapError(p.message);
+    out.line(`  ${unwrapped.message}`);
+
+    for (const layer of unwrapped.layers) {
+      const text = typeof layer.value === 'string' ? layer.value : JSON.stringify(layer.value, null, 2);
+      out.note(`  ${layer.label}:`);
+      for (const l of text.split('\n')) out.note(`    ${l}`);
+    }
+
+    const hint = explain(p.message);
+    if (hint) {
+      out.line('');
+      for (const l of out.wrap(hint, 92)) out.line(`  ${l}`);
+    }
+
+    if (options.stacktrace && (p.jobId || p.historicJobLogId)) {
+      try {
+        const trace = p.jobId ? await client.jobStacktrace(p.jobId) : await client.historyJobLogStacktrace(p.historicJobLogId);
+        const { header, frames, omitted } = condenseStacktrace(trace);
+        out.line('');
+        for (const h of header.slice(0, 3)) out.note(`  ${h}`);
+        for (const f of frames) out.note(`    ${f}`);
+        if (omitted > 0) out.note(`    ... ${omitted} engine-internal frame(s) hidden`);
+      } catch {
+        /* the job may already be gone */
+      }
+    }
+  }
+
+  if (!options.stacktrace) out.note('\nAdd --stacktrace for the Java frames behind these.');
+  process.exitCode = 1;
+}
+
+// The activity-instance tree nests scopes (a subprocess holds its children); flattening
+// it gives the plain list of places a token is currently sitting.
+function flatten(node, acc = []) {
+  acc.push(node);
+  for (const c of node.childActivityInstances ?? []) flatten(c, acc);
+  for (const t of node.childTransitionInstances ?? []) acc.push({ ...t, activityType: 'transition' });
+  return acc;
+}
+
+export async function incidentsCommand(options) {
+  const client = new Client(requireConfig());
+  const query = { maxResults: options.limit ?? 50 };
+  if (options.instance) query.processInstanceId = options.instance;
+  if (options.key) query.processDefinitionKeyIn = options.key;
+  if (options.tenant) query.tenantIdIn = options.tenant;
+
+  const rows = options.history
+    ? await client.historyIncidents({ ...query, sortBy: 'createTime', sortOrder: 'desc' })
+    : await client.incidents(query);
+
+  if (out.isJsonMode()) return out.json(rows);
+  if (rows.length === 0) return out.note(options.history ? 'No incidents recorded.' : 'No open incidents.');
+
+  out.table(
+    ['INSTANCE', 'FAILING ELEMENT', 'TYPE', 'SINCE', 'MESSAGE'],
+    rows.map((i) => [
+      i.processInstanceId,
+      i.failedActivityId || i.activityId || '-',
+      i.incidentType,
+      out.formatDateTime(i.incidentTimestamp || i.createTime),
+      out.truncate(unwrapError(i.incidentMessage).message, 60),
+    ])
+  );
+  out.note(`\n${rows.length} incident(s). Detail: camunda diagnose <instanceId>`);
+}
+
+export async function jobsCommand(options) {
+  const client = new Client(requireConfig());
+  const query = { maxResults: options.limit ?? 50 };
+  if (options.instance) query.processInstanceId = options.instance;
+  if (options.key) query.processDefinitionKey = options.key;
+  if (options.failed) query.withException = true;
+
+  const jobs = await client.jobs(query);
+  if (out.isJsonMode()) return out.json(jobs);
+  if (jobs.length === 0) return out.note('No jobs match.');
+
+  out.table(
+    ['ID', 'INSTANCE', 'ELEMENT', 'RETRIES', 'DUE', 'ERROR'],
+    jobs.map((j) => [
+      j.id,
+      j.processInstanceId,
+      j.failedActivityId || '-',
+      String(j.retries),
+      out.formatDateTime(j.dueDate),
+      out.truncate(unwrapError(j.exceptionMessage || '').message, 50),
+    ])
+  );
+}
+
+export async function stacktraceCommand(jobId, options) {
+  const client = new Client(requireConfig());
+  const trace = await client.jobStacktrace(jobId);
+  if (options.full) return console.log(trace);
+  const { header, frames, omitted } = condenseStacktrace(trace, { keep: 20 });
+  for (const h of header) out.line(h);
+  for (const f of frames) out.note(`  ${f}`);
+  if (omitted > 0) out.note(`  ... ${omitted} engine-internal frame(s) hidden, use --full for everything`);
+}
+
+// The execution trace. Ordering matters here: several activities routinely share a
+// millisecond, so ties are broken by following the sequence flows rather than trusting
+// the timestamp alone.
+export async function traceCommand(id, options) {
+  const client = new Client(requireConfig());
+  const activities = await client.historyActivityInstances({
+    processInstanceId: id,
+    maxResults: options.limit ?? 200,
+    sortBy: 'startTime',
+    sortOrder: 'asc',
+  });
+
+  if (out.isJsonMode()) return out.json(activities);
+  if (activities.length === 0) return out.note('No activity recorded for this instance.');
+
+  const rows = activities.map((a) => [
+    out.formatDateTime(a.startTime),
+    a.activityType,
+    a.activityId,
+    out.truncate(a.activityName ?? '', 32),
+    out.formatDuration(a.durationInMillis),
+    a.canceled ? 'canceled' : a.endTime ? '' : 'running',
+  ]);
+  out.table(['TIME', 'TYPE', 'ID', 'NAME', 'TOOK', ''], rows);
+
+  const running = activities.filter((a) => !a.endTime);
+  if (running.length > 0) {
+    out.note(`\nStill open: ${running.map((a) => a.activityId).join(', ')}`);
+  }
+}

package/src/commands/instances.js

@@ -0,0 +1,205 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { Client, parseVariableFlags, resolveDefinition } from '../client.js';
+import { requireConfig } from '../config.js';
+import * as out from '../output.js';
+
+export async function instancesCommand(options) {
+  const client = new Client(requireConfig());
+
+  if (options.history) {
+    const query = { maxResults: options.limit ?? 30, sortBy: 'startTime', sortOrder: 'desc' };
+    if (options.key) query.processDefinitionKey = options.key;
+    if (options.tenant) query.tenantIdIn = options.tenant;
+    if (options.businessKey) query.processInstanceBusinessKey = options.businessKey;
+    if (options.state) query[options.state] = true;
+
+    const rows = await client.historyProcessInstances(query);
+    if (out.isJsonMode()) return out.json(rows);
+    if (rows.length === 0) return out.note('No instances match.');
+    out.table(
+      ['ID', 'DEFINITION', 'STARTED', 'DURATION', 'STATE'],
+      rows.map((i) => [
+        i.id,
+        out.truncate(i.processDefinitionKey, 34),
+        out.formatDateTime(i.startTime),
+        out.formatDuration(i.durationInMillis),
+        out.stateLabel(i.state),
+      ])
+    );
+    return out.note(`\n${rows.length} instance(s), history`);
+  }
+
+  const query = { maxResults: options.limit ?? 50 };
+  if (options.key) query.processDefinitionKey = options.key;
+  if (options.businessKey) query.businessKey = options.businessKey;
+  if (options.tenant) query.tenantIdIn = options.tenant;
+  if (options.withIncident) query.withIncident = true;
+
+  const instances = await client.processInstances(query);
+  if (out.isJsonMode()) return out.json(instances);
+  if (instances.length === 0) return out.note('No running instances match.');
+
+  out.table(
+    ['ID', 'DEFINITION', 'BUSINESS KEY', 'TENANT'],
+    instances.map((i) => [i.id, i.definitionId.split(':')[0], i.businessKey ?? '-', i.tenantId ?? '-'])
+  );
+  out.note(`\n${instances.length} running instance(s)`);
+}
+
+// Shows where the instance is now rather than only what it is. The activity-instance
+// tree is the live token position; history alone cannot tell you that.
+export async function instanceCommand(id, options) {
+  const client = new Client(requireConfig());
+
+  const [historic, variables, tree, incidents, tasks] = await Promise.all([
+    client.historyProcessInstance(id),
+    client.historyVariableInstances({ processInstanceId: id, maxResults: 200 }),
+    client.activityInstanceTree(id).catch(() => null),
+    client.incidents({ processInstanceId: id }).catch(() => []),
+    client.tasks({ processInstanceId: id }).catch(() => []),
+  ]);
+
+  if (out.isJsonMode()) return out.json({ instance: historic, variables, activityTree: tree, incidents, tasks });
+
+  out.heading(`Instance ${historic.id}`);
+  out.kv([
+    ['definition', `${historic.processDefinitionKey} v${historic.processDefinitionVersion}`],
+    ['state', out.stateLabel(historic.state)],
+    ['business key', historic.businessKey ?? '-'],
+    ['tenant', historic.tenantId ?? '-'],
+    ['started', out.formatDateTime(historic.startTime)],
+    ['ended', historic.endTime ? out.formatDateTime(historic.endTime) : '-'],
+    ['duration', out.formatDuration(historic.durationInMillis)],
+    ['started by', historic.startUserId ?? '-'],
+    ['delete reason', historic.deleteReason ?? ''],
+  ]);
+
+  const waiting = tree ? flattenTree(tree).filter((n) => n.activityType !== 'processDefinition') : [];
+  if (waiting.length > 0) {
+    out.line('\nCurrently at');
+    out.table(
+      null,
+      waiting.map((n) => [`  ${n.activityId}`, n.activityType, n.activityName ?? '', (n.incidentIds ?? []).length ? 'has incident' : ''])
+    );
+  } else if (historic.state === 'ACTIVE') {
+    out.note('\nActive but not sitting at any activity (it may be between transitions).');
+  }
+
+  if (tasks.length > 0) {
+    out.line('\nOpen tasks');
+    out.table(null, tasks.map((t) => [`  ${t.id}`, out.truncate(t.name, 34), t.assignee ?? 'unassigned']));
+  }
+
+  if (incidents.length > 0) {
+    out.line('');
+    out.problem(`${incidents.length} open incident(s). Run: camunda diagnose ${id}`);
+  }
+
+  if (variables.length > 0) {
+    out.line('\nVariables');
+    out.table(
+      null,
+      variables.map((v) => [`  ${v.name}`, v.type, out.truncate(JSON.stringify(v.value), 70)])
+    );
+  } else {
+    out.note('\nNo variables set on this instance.');
+  }
+}
+
+export async function startCommand(keyOrId, options) {
+  const client = new Client(requireConfig());
+  const def = await resolveDefinition(client, keyOrId, options);
+  const variables = parseVariableFlags(options.var);
+
+  const result = await client.startByDefinitionId(def.id, {
+    businessKey: options.businessKey,
+    variables,
+  });
+
+  // A start returning 200 only means the engine accepted it. Anything marked async runs
+  // after the response, so a failure there shows up as a job or incident a moment later
+  // rather than in this reply.
+  let trouble = { incidents: [], jobs: [] };
+  if (!options.noWait) {
+    await new Promise((r) => setTimeout(r, options.wait ?? 1200));
+    const [incidents, jobs] = await Promise.all([
+      client.incidents({ processInstanceId: result.id }).catch(() => []),
+      client.jobs({ processInstanceId: result.id, withException: true }).catch(() => []),
+    ]);
+    trouble = { incidents, jobs };
+  }
+
+  if (out.isJsonMode()) return out.json({ ...result, ...trouble });
+
+  out.line(`Started ${def.key} v${def.version} as instance ${result.id}`);
+  if (result.businessKey) out.note(`business key ${result.businessKey}`);
+
+  if (trouble.incidents.length > 0 || trouble.jobs.length > 0) {
+    const msg = trouble.incidents[0]?.incidentMessage || trouble.jobs[0]?.exceptionMessage;
+    out.problem(`\nIt already failed after starting: ${msg}`);
+    out.note(`Run: camunda diagnose ${result.id}`);
+    process.exitCode = 1;
+  }
+}
+
+export async function cancelCommand(id, options) {
+  const client = new Client(requireConfig());
+
+  if (!options.yes) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    const answer = await rl.question(
+      `Force-terminating ${id} cannot be undone (it ends as EXTERNALLY_TERMINATED, not COMPLETED).\nType the instance id to confirm: `
+    );
+    rl.close();
+    if (answer.trim() !== id) return out.note('Aborted, the id did not match.');
+  }
+
+  await client.deleteProcessInstance(id, { reason: options.reason });
+  out.line(`Instance ${id} terminated.`);
+}
+
+export async function varsCommand(id, options) {
+  const client = new Client(requireConfig());
+
+  if (options.history) {
+    const details = await client.historyDetails({
+      processInstanceId: id,
+      type: 'variableUpdate',
+      maxResults: options.limit ?? 200,
+      sortBy: 'time',
+      sortOrder: 'asc',
+    });
+    if (out.isJsonMode()) return out.json(details);
+    if (details.length === 0) {
+      out.note('No variable updates recorded. This needs the engine history level at FULL.');
+      return;
+    }
+    out.table(
+      ['TIME', 'VARIABLE', 'TYPE', 'REV', 'VALUE'],
+      details.map((d) => [
+        out.formatDateTime(d.time),
+        d.variableName,
+        d.variableType,
+        String(d.revision ?? ''),
+        out.truncate(JSON.stringify(d.value), 50),
+      ])
+    );
+    return;
+  }
+
+  const variables = await client.historyVariableInstances({ processInstanceId: id, maxResults: 500 });
+  if (out.isJsonMode()) return out.json(variables);
+  if (variables.length === 0) return out.note('No variables on this instance.');
+  out.table(
+    ['NAME', 'TYPE', 'VALUE'],
+    variables.map((v) => [v.name, v.type, out.truncate(JSON.stringify(v.value), 80)])
+  );
+}
+
+function flattenTree(node, acc = []) {
+  acc.push(node);
+  for (const c of node.childActivityInstances ?? []) flattenTree(c, acc);
+  for (const t of node.childTransitionInstances ?? []) acc.push({ ...t, activityType: 'transition' });
+  return acc;
+}

package/src/commands/ops.js

@@ -0,0 +1,127 @@
+import { Client } from '../client.js';
+import { requireConfig } from '../config.js';
+import { unwrapError } from '../errors.js';
+import * as out from '../output.js';
+
+// Repair operations. A job that ran out of retries stays put until its retry count is
+// raised, which is how you re-run a step after fixing the addon behind it without
+// starting the whole instance over.
+export async function retryCommand(jobId, options) {
+  const client = new Client(requireConfig());
+  const retries = options.retries ?? 1;
+  await client.setJobRetries(jobId, retries);
+  out.line(`Job ${jobId} set to ${retries} retry/retries.`);
+
+  if (options.now) {
+    try {
+      await client.executeJob(jobId);
+      out.line('Executed immediately, it succeeded.');
+    } catch (err) {
+      const unwrapped = unwrapError(err.body?.message || err.message);
+      out.problem(`Ran it now and it failed again: ${unwrapped.message}`);
+      process.exitCode = 1;
+    }
+  } else {
+    out.note('The job runner will pick it up shortly. Use --now to run it immediately instead.');
+  }
+}
+
+// Runs a pending job at once rather than waiting for the scheduler. Useful for testing a
+// step marked async without sitting through the poll interval.
+export async function runJobCommand(jobId) {
+  const client = new Client(requireConfig());
+  try {
+    await client.executeJob(jobId);
+    out.line(`Job ${jobId} executed.`);
+  } catch (err) {
+    const unwrapped = unwrapError(err.body?.message || err.message);
+    out.problem(`Job ${jobId} failed: ${unwrapped.message}`);
+    process.exitCode = 1;
+  }
+}
+
+export async function setVarCommand(instanceId, assignment, options) {
+  const client = new Client(requireConfig());
+  const eq = assignment.indexOf('=');
+  if (eq === -1) throw new Error('Expected name=value.');
+  const name = assignment.slice(0, eq);
+  const raw = assignment.slice(eq + 1);
+  const type = options.type ?? 'String';
+
+  let value = raw;
+  if (type === 'Integer' || type === 'Long') value = parseInt(raw, 10);
+  else if (type === 'Double') value = parseFloat(raw);
+  else if (type === 'Boolean') value = raw === 'true';
+  else if (type === 'Json') value = JSON.parse(raw);
+
+  await client.setProcessInstanceVariable(instanceId, name, { value, type });
+  out.line(`Set ${name} (${type}) on instance ${instanceId}.`);
+}
+
+export async function messageCommand(name, options) {
+  const client = new Client(requireConfig());
+  const body = { messageName: name, resultEnabled: true };
+  if (options.instance) body.processInstanceId = options.instance;
+  if (options.businessKey) body.businessKey = options.businessKey;
+  if (options.all) body.all = true;
+
+  const result = await client.correlateMessage(body);
+  if (out.isJsonMode()) return out.json(result);
+
+  if (!result || result.length === 0) {
+    out.warn(`Message "${name}" correlated with nothing. No instance is waiting for it.`);
+    process.exitCode = 1;
+    return;
+  }
+  for (const r of result) {
+    out.line(`Correlated with ${r.resultType === 'ProcessDefinition' ? 'new instance' : 'instance'} ${r.processInstance?.id ?? r.execution?.processInstanceId}`);
+  }
+}
+
+export async function subscriptionsCommand(options) {
+  const client = new Client(requireConfig());
+  const query = { maxResults: options.limit ?? 50 };
+  if (options.instance) query.processInstanceId = options.instance;
+  if (options.type) query.eventType = options.type;
+
+  const subs = await client.eventSubscriptions(query);
+  if (out.isJsonMode()) return out.json(subs);
+  if (subs.length === 0) return out.note('Nothing is waiting on a message or signal.');
+
+  out.table(
+    ['TYPE', 'NAME', 'ELEMENT', 'INSTANCE', 'SINCE'],
+    subs.map((s) => [s.eventType, s.eventName ?? '-', s.activityId ?? '-', s.processInstanceId ?? '-', out.formatDateTime(s.createdDate)])
+  );
+}
+
+export async function usersCommand(options) {
+  const client = new Client(requireConfig());
+  const query = { maxResults: options.limit ?? 50 };
+  if (options.search) query.idLike = `%${options.search}%`;
+  const users = await client.users(query);
+  if (out.isJsonMode()) return out.json(users);
+  if (users.length === 0) return out.note('No users found.');
+  out.table(
+    ['ID', 'FIRST', 'LAST', 'EMAIL'],
+    users.map((u) => [u.id, u.firstName ?? '', u.lastName ?? '', u.email ?? ''])
+  );
+}
+
+export async function groupsCommand(options) {
+  const client = new Client(requireConfig());
+  const groups = await client.groups({ maxResults: options.limit ?? 50 });
+  if (out.isJsonMode()) return out.json(groups);
+  if (groups.length === 0) return out.note('No groups found.');
+  out.table(['ID', 'NAME', 'TYPE'], groups.map((g) => [g.id, g.name ?? '', g.type ?? '']));
+}
+
+export async function tenantsCommand(options) {
+  const client = new Client(requireConfig());
+  const query = { maxResults: options.limit ?? 200 };
+  if (options.search) query.nameLike = `%${options.search}%`;
+  const tenants = await client.tenants(query);
+  if (out.isJsonMode()) return out.json(tenants);
+  if (tenants.length === 0) return out.note('No tenants found.');
+  out.table(['ID', 'NAME'], tenants.map((t) => [t.id, t.name ?? '']));
+  out.note(`\n${tenants.length} tenant(s)`);
+}