@commandgarden/cli 1.4.1 → 2.0.0

package/node_modules/@commandgarden/daemon/connectors/ado-git-commits.eval.js

@@ -0,0 +1,143 @@
+// Runs in page context via js_evaluate step.
+// Fetches ADO Git commits (via Pushes API, all branches) and completed PRs
+// using the browser's ADO session cookies — no PAT or MSAL token required.
+//
+// Strategy: navigate to dev.azure.com to trigger SSO, then call the ADO REST
+// API with session cookies (credentials:'include'). The Pushes API captures
+// work across ALL branches (unlike the Commits API which only searches the
+// default branch).
+//
+// Template variables interpolated before execution:
+//   ${{ args.org }}
+//   ${{ args.project }}
+//   ${{ args.repo }}
+//   ${{ args.fromDate }}
+//   ${{ args.toDate }}
+//   ${{ args.author | default("") }}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+// ── Read args ─────────────────────────────────────────────────────────
+const org = '${{ args.org }}'.trim();
+const project = '${{ args.project }}'.trim();
+const repo = '${{ args.repo }}'.trim();
+const fromDate = '${{ args.fromDate }}'.trim();
+const toDate = '${{ args.toDate }}'.trim();
+const authorFilter = '${{ args.author | default("") }}'.trim().toLowerCase();
+
+if (!org || !project || !repo || !fromDate || !toDate) {
+  throw new Error('Missing required args: org, project, repo, fromDate, toDate');
+}
+
+// ── Wait for ADO to finish SSO/redirect (up to 30s) ──────────────────
+// ADO uses httpOnly session cookies — no MSAL tokens in sessionStorage.
+// We just need the browser to be logged in; session cookies are sent
+// automatically with same-origin fetch (credentials: 'include').
+const __deadline = Date.now() + 30000;
+while (Date.now() < __deadline) {
+  if (location.hostname === 'dev.azure.com') break;
+  await sleep(1000);
+}
+if (location.hostname !== 'dev.azure.com') {
+  throw new Error('Not signed in to Azure DevOps — log in at dev.azure.com and retry');
+}
+
+// ADO REST API: dev.azure.com/{org}/{project}/_apis/...
+const apiBase = `https://dev.azure.com/${org}/${project}/_apis`;
+// Use session cookies for auth (same-origin, no Bearer token needed)
+const authHeaders = { Accept: 'application/json' };
+
+// ── Step 1: List pushes in the date range ─────────────────────────────
+const listUrl =
+  `${apiBase}/git/repositories/${repo}/pushes` +
+  `?searchCriteria.fromDate=${fromDate}T00:00:00Z` +
+  `&searchCriteria.toDate=${toDate}T23:59:59Z` +
+  `&api-version=7.1`;
+
+const listResp = await fetch(listUrl, { headers: authHeaders, credentials: 'include' });
+if (!listResp.ok) throw new Error(`Pushes list HTTP ${listResp.status}: ${await listResp.text()}`);
+const listBody = await listResp.json();
+let pushes = listBody.value || [];
+
+// Filter by author if provided (case-insensitive substring match on
+// pushedBy.uniqueName or pushedBy.displayName)
+if (authorFilter) {
+  pushes = pushes.filter(p => {
+    const un = (p.pushedBy?.uniqueName || '').toLowerCase();
+    const dn = (p.pushedBy?.displayName || '').toLowerCase();
+    return un.includes(authorFilter) || dn.includes(authorFilter);
+  });
+}
+
+// ── Step 2: Fetch each push's commits ─────────────────────────────────
+const seen = new Set();
+const commits = [];
+
+for (const push of pushes) {
+  const detailUrl = `${apiBase}/git/repositories/${repo}/pushes/${push.pushId}?api-version=7.1`;
+  try {
+    const detailResp = await fetch(detailUrl, { headers: authHeaders, credentials: 'include' });
+    if (!detailResp.ok) continue;
+    const detail = await detailResp.json();
+    for (const c of (detail.commits || [])) {
+      // Deduplicate: same commit can appear in multiple pushes (e.g. after merge)
+      if (seen.has(c.commitId)) continue;
+      seen.add(c.commitId);
+      commits.push(c);
+    }
+  } catch (_) { /* skip failed push detail fetches */ }
+}
+
+// ── Step 3: Fetch completed PRs in the date range ─────────────────────
+const prUrl =
+  `${apiBase}/git/repositories/${repo}/pullrequests` +
+  `?searchCriteria.status=completed` +
+  `&api-version=7.1`;
+
+let prRows = [];
+try {
+  const prResp = await fetch(prUrl, { headers: authHeaders, credentials: 'include' });
+  if (prResp.ok) {
+    const prBody = await prResp.json();
+    const prs = (prBody.value || []).filter(pr => {
+      if (!pr.closedDate) return false;
+      return pr.closedDate >= `${fromDate}T00:00:00Z` && pr.closedDate <= `${toDate}T23:59:59Z`;
+    });
+    // Optionally filter PRs by author
+    const filtered = authorFilter
+      ? prs.filter(pr => {
+          const un = (pr.createdBy?.uniqueName || '').toLowerCase();
+          return un.includes(authorFilter);
+        })
+      : prs;
+    prRows = filtered.map(pr => ({
+      commitId: '',
+      authorName: pr.createdBy?.displayName || '',
+      authorEmail: pr.createdBy?.uniqueName || '',
+      date: (pr.closedDate || '').slice(0, 10),
+      message: `PR #${pr.pullRequestId}: ${pr.title || '(no title)'}`,
+      filesAdded: 0,
+      filesEdited: 0,
+      filesDeleted: 0,
+      isPR: 'true',
+      prId: pr.pullRequestId,
+    }));
+  }
+} catch (_) { /* PRs are supplemental — don't fail on error */ }
+
+// ── Build output rows ─────────────────────────────────────────────────
+const commitRows = commits.map(c => ({
+  commitId: c.commitId || '',
+  authorName: c.author?.name || '',
+  authorEmail: c.author?.email || '',
+  date: (c.author?.date || '').slice(0, 10),
+  message: (c.comment || '').split('\n')[0].slice(0, 200),
+  filesAdded: c.changeCounts?.Add || 0,
+  filesEdited: c.changeCounts?.Edit || 0,
+  filesDeleted: c.changeCounts?.Delete || 0,
+  isPR: 'false',
+  prId: 0,
+}));
+
+const rows = [...commitRows, ...prRows];
+return rows;

package/node_modules/@commandgarden/daemon/connectors/ado-git-commits.yaml

@@ -0,0 +1,70 @@
+site: ado
+name: git-commits
+version: "1.0"
+description: "Azure DevOps Git commits and PRs across all branches for a date range"
+access: read
+
+domains:
+  - "dev.azure.com"
+capabilities:
+  - navigate
+  - js_evaluate
+
+args:
+  - name: org
+    type: string
+    required: true
+    help: "ADO organization name (e.g. 'daimler-mic')"
+  - name: project
+    type: string
+    required: true
+    help: "ADO project name (e.g. 'mic-dns')"
+  - name: repo
+    type: string
+    required: true
+    help: "Repository name (e.g. 'mic-dns-api')"
+  - name: fromDate
+    type: string
+    required: true
+    help: "Start date in YYYY-MM-DD format"
+    pattern: "^\\d{4}-\\d{2}-\\d{2}$"
+  - name: toDate
+    type: string
+    required: true
+    help: "End date in YYYY-MM-DD format"
+    pattern: "^\\d{4}-\\d{2}-\\d{2}$"
+  - name: author
+    type: string
+    required: false
+    help: "Filter by pusher name or email (case-insensitive substring match)"
+
+columns:
+  - name: commitId
+    type: string
+  - name: authorName
+    type: string
+  - name: authorEmail
+    type: string
+  - name: date
+    type: string
+  - name: message
+    type: string
+  - name: filesAdded
+    type: number
+  - name: filesEdited
+    type: number
+  - name: filesDeleted
+    type: number
+  - name: isPR
+    type: string
+  - name: prId
+    type: number
+
+pipeline:
+  - step: navigate
+    url: "https://dev.azure.com/${{ args.org }}"
+  - step: wait
+    selector: "body"
+    timeout: 30000
+  - step: js_evaluate
+    file: ado-git-commits.eval.js

package/node_modules/@commandgarden/daemon/connectors/gcs-kb-content.yaml

@@ -0,0 +1,58 @@
+site: gcs
+name: kb-content
+version: "2.0"
+description: "Retrieve a single GCS Knowledge Base page as Markdown"
+access: read
+
+domains:
+  - "pages.i.mercedes-benz.com"
+capabilities:
+  - navigate
+  - dom_read
+
+args:
+  - name: path
+    type: string
+    required: true
+    help: "Page path from the kb-pages index, e.g. /gcs/KB/docs/general-security/edr/"
+    pattern: "^/gcs/KB/[a-zA-Z0-9_./-]+$"
+
+columns:
+  - name: title
+    type: string
+  - name: path
+    type: string
+  - name: author
+    type: string
+  - name: lastUpdated
+    type: string
+  - name: content
+    type: string
+
+pipeline:
+  - step: navigate
+    url: "https://pages.i.mercedes-benz.com${{ args.path }}"
+  - step: wait
+    selector: "article"
+    timeout: 30000
+  - step: extract
+    selector: "article"
+    fields:
+      title: "h1"
+      authorPill: "span.inline-flex"
+  - step: extract_html
+    selector: "article"
+    as: rawHtml
+  - step: transform
+    type: html_to_markdown
+    input: rawHtml
+    as: content
+  - step: transform
+    type: split_metadata
+    input: authorPill
+    as: meta
+    options:
+      delimiter: "|"
+      fields:
+        - author
+        - lastUpdated

package/node_modules/@commandgarden/daemon/connectors/gcs-kb-pages.yaml

@@ -0,0 +1,47 @@
+site: gcs
+name: kb-pages
+version: "2.0"
+description: "Page index of the GCS Knowledge Base — titles, URLs, sections, and hierarchy"
+access: read
+
+domains:
+  - "pages.i.mercedes-benz.com"
+capabilities:
+  - navigate
+  - dom_read
+  - dom_write
+
+columns:
+  - name: title
+    type: string
+  - name: url
+    type: string
+  - name: section
+    type: string
+  - name: path
+    type: string
+  - name: depth
+    type: number
+
+pipeline:
+  - step: navigate
+    url: "https://pages.i.mercedes-benz.com/gcs/KB/docs/main/"
+  - step: wait
+    selector: "aside"
+    timeout: 30000
+  - step: click_all
+    selector: "aside button[aria-expanded='false']"
+    pause: 200
+    maxRounds: 10
+    settle: 300
+  - step: extract_tree
+    root: "aside > *:nth-child(2)"
+    group:
+      match: "div:has(> button), section:has(> button)"
+      title: ":scope > button"
+      children: ":scope > div"
+    leaf:
+      match: "a[href^='/gcs/KB/']"
+      fields:
+        title: textContent
+        url: href

package/node_modules/@commandgarden/daemon/connectors/jira-my-tickets.eval.js

@@ -0,0 +1,115 @@
+// Runs in page context via js_evaluate step.
+// Fetches Jira Cloud tickets assigned to the user using the browser's
+// authenticated session (Atlassian cookies — no API token required).
+//
+// Uses Jira REST API v3 with JQL queries to find:
+// - Resolved tickets within the date range
+// - Currently in-progress tickets
+// - Blockers: in-progress items not updated in 3+ days
+//
+// Template variables interpolated before execution:
+//   ${{ args.fromDate }}
+//   ${{ args.toDate }}
+//   ${{ args.assignee | default("") }}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+const JIRA_BASE = 'https://mercedes-benz.atlassian.net';
+const API = `${JIRA_BASE}/rest/api/3`;
+
+const fromDate = '${{ args.fromDate }}'.trim();
+const toDate = '${{ args.toDate }}'.trim();
+const assigneeArg = '${{ args.assignee | default("") }}'.trim();
+
+if (!fromDate || !toDate) {
+  throw new Error('Missing required args: fromDate, toDate');
+}
+
+// Use currentUser() if no assignee provided — Jira JQL function that
+// resolves to the logged-in user without knowing their username.
+const assignee = assigneeArg || 'currentUser()';
+// JQL uses currentUser() as a function (no quotes), but a literal
+// username needs quotes. Detect which format to use.
+const assigneeJql = assignee === 'currentUser()' ? 'currentUser()' : `"${assignee}"`;
+
+// ── Wait for Jira to finish SSO/redirect (up to 30s) ──────────────────
+const __deadline = Date.now() + 30000;
+while (Date.now() < __deadline) {
+  if (location.hostname === 'mercedes-benz.atlassian.net') break;
+  await sleep(1000);
+}
+if (location.hostname !== 'mercedes-benz.atlassian.net') {
+  throw new Error('Not signed in to Jira — log in at mercedes-benz.atlassian.net and retry');
+}
+
+// ── Helper: run a JQL search and return issues ────────────────────────
+// Uses the browser's session cookies for auth (same-origin fetch).
+async function jqlSearch(jql, maxResults = 100) {
+  // Jira Cloud deprecated /rest/api/3/search (HTTP 410) — must use /rest/api/3/search/jql
+  const url = `${API}/search/jql?jql=${encodeURIComponent(jql)}&maxResults=${maxResults}&fields=summary,status,issuetype,resolutiondate,updated`;
+  const resp = await fetch(url, {
+    headers: { Accept: 'application/json' },
+    credentials: 'include',      // send Atlassian session cookies
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => '');
+    throw new Error(`Jira search failed (HTTP ${resp.status}): ${text.slice(0, 200)}`);
+  }
+  const body = await resp.json();
+  return body.issues || [];
+}
+
+// ── Run two JQL queries ───────────────────────────────────────────────
+
+// Resolved: tickets resolved/closed within the date range
+const resolvedJql = `assignee = ${assigneeJql} AND status changed TO ("Done", "Closed", "Resolved") DURING ("${fromDate}", "${toDate}") ORDER BY resolutiondate DESC`;
+
+// In-progress: currently active tickets assigned to the user
+const inProgressJql = `assignee = ${assigneeJql} AND status IN ("In Progress", "In Review", "To Do", "Open") ORDER BY updated ASC`;
+
+const [resolvedIssues, inProgressIssues] = await Promise.all([
+  jqlSearch(resolvedJql),
+  jqlSearch(inProgressJql),
+]);
+
+// ── Build output rows ─────────────────────────────────────────────────
+const now = Date.now();
+const rows = [];
+
+for (const issue of resolvedIssues) {
+  const f = issue.fields || {};
+  rows.push({
+    key: issue.key,
+    summary: f.summary || '(no title)',
+    status: f.status?.name || '',
+    type: f.issuetype?.name || '',
+    resolvedDate: (f.resolutiondate || '').slice(0, 10),
+    updatedDate: (f.updated || '').slice(0, 10),
+    staleDays: 0,
+    category: 'resolved',
+  });
+}
+
+for (const issue of inProgressIssues) {
+  const f = issue.fields || {};
+  const updated = f.updated;
+  // Calculate staleDays: days since the ticket was last updated
+  const staleDays = updated
+    ? Math.floor((now - new Date(updated).getTime()) / 86400000)
+    : 0;
+  // Tickets not updated in 3+ days are flagged as blockers
+  const category = staleDays >= 3 ? 'blocker' : 'inProgress';
+
+  rows.push({
+    key: issue.key,
+    summary: f.summary || '(no title)',
+    status: f.status?.name || '',
+    type: f.issuetype?.name || '',
+    resolvedDate: '',
+    updatedDate: (updated || '').slice(0, 10),
+    staleDays,
+    category,
+  });
+}
+
+return rows;

package/node_modules/@commandgarden/daemon/connectors/jira-my-tickets.yaml

@@ -0,0 +1,54 @@
+site: jira
+name: my-tickets
+version: "2.0"
+description: "Jira Cloud tickets assigned to the user — resolved, in-progress, and blockers"
+access: read
+
+domains:
+  - "mercedes-benz.atlassian.net"
+capabilities:
+  - navigate
+  - js_evaluate
+
+args:
+  - name: fromDate
+    type: string
+    required: true
+    help: "Start date in YYYY-MM-DD format"
+    pattern: "^\\d{4}-\\d{2}-\\d{2}$"
+  - name: toDate
+    type: string
+    required: true
+    help: "End date in YYYY-MM-DD format"
+    pattern: "^\\d{4}-\\d{2}-\\d{2}$"
+  - name: assignee
+    type: string
+    required: false
+    help: "Override assignee (Jira username or 'currentUser()'). Default: currentUser()"
+
+columns:
+  - name: key
+    type: string
+  - name: summary
+    type: string
+  - name: status
+    type: string
+  - name: type
+    type: string
+  - name: resolvedDate
+    type: string
+  - name: updatedDate
+    type: string
+  - name: staleDays
+    type: number
+  - name: category
+    type: string
+
+pipeline:
+  - step: navigate
+    url: "https://mercedes-benz.atlassian.net/"
+  - step: wait
+    selector: "body"
+    timeout: 30000
+  - step: js_evaluate
+    file: jira-my-tickets.eval.js

package/node_modules/@commandgarden/daemon/connectors/outlook-my-meetings.eval.js

@@ -0,0 +1,186 @@
+// Runs in page context via js_evaluate step.
+// Captures the user's calendar events by intercepting OWA's own data fetches.
+//
+// Strategy: patch fetch() and XMLHttpRequest to capture responses containing
+// calendar event data. OWA loads calendar events automatically when the
+// calendar page opens — we just wait and read what it fetched.
+//
+// This avoids all auth issues (no tokens, no CANARY, no cross-origin) because
+// we're reading data OWA already fetched for itself.
+//
+// Template variables interpolated before execution:
+//   ${{ args.date }}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+function pad2(n) { return String(n).padStart(2, '0'); }
+
+const DATE_RE = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+const date = '${{ args.date }}'.trim();
+if (!DATE_RE.test(date)) throw new Error(`Invalid date "${date}" — use YYYY-MM-DD`);
+
+// ── Wait for OWA to finish SSO/redirect (up to 30s) ──────────────────
+const __deadline = Date.now() + 30000;
+while (Date.now() < __deadline) {
+  if (location.hostname.includes('outlook') && !(/login\.|\/oauth2\/|signin|sso/i.test(location.href))) break;
+  await sleep(1000);
+}
+if (/login\.|\/oauth2\/|signin|sso/i.test(location.href)) {
+  throw new Error('Not signed in to Outlook — log in and retry');
+}
+
+// ── Install interceptors to capture calendar event data ───────────────
+// OWA uses both fetch() and XMLHttpRequest for API calls. We patch both
+// to capture any response containing calendar events (Items, calendarView,
+// getSchedule, FindItem).
+if (!window.__calEvents) {
+  window.__calEvents = [];
+
+  // Patch fetch
+  const origFetch = window.fetch;
+  window.fetch = function () {
+    const args = arguments;
+    return origFetch.apply(this, args).then(r => {
+      try {
+        r.clone().text().then(t => {
+          // Capture responses that look like calendar event data
+          if (t.includes('"Subject"') && (t.includes('"Start"') || t.includes('"StartTime"'))) {
+            try {
+              const parsed = JSON.parse(t);
+              extractEvents(parsed);
+            } catch (_) {}
+          }
+          // Also capture getSchedule GraphQL responses (fallback)
+          if (t.includes('getSchedule') && t.includes('scheduleItems')) {
+            try {
+              const parsed = JSON.parse(t);
+              extractScheduleItems(parsed);
+            } catch (_) {}
+          }
+        }).catch(() => {});
+      } catch (_) {}
+      return r;
+    });
+  };
+
+  // Patch XMLHttpRequest (OWA uses this for some API calls)
+  const origXHROpen = XMLHttpRequest.prototype.open;
+  const origXHRSend = XMLHttpRequest.prototype.send;
+  XMLHttpRequest.prototype.open = function () {
+    this.__url = arguments[1] || '';
+    return origXHROpen.apply(this, arguments);
+  };
+  XMLHttpRequest.prototype.send = function () {
+    this.addEventListener('load', function () {
+      try {
+        const t = this.responseText || '';
+        if (t.includes('"Subject"') && (t.includes('"Start"') || t.includes('"StartTime"'))) {
+          try { extractEvents(JSON.parse(t)); } catch (_) {}
+        }
+      } catch (_) {}
+    });
+    return origXHRSend.apply(this, arguments);
+  };
+}
+
+/** Extract calendar events from OWA API response shapes. */
+function extractEvents(data) {
+  // OWA returns events in various shapes; try common patterns
+  const items = data.value || data.Items || data.items || [];
+  const arr = Array.isArray(data) ? data : (Array.isArray(items) ? items : []);
+  for (const item of arr) {
+    if (item && (item.Subject || item.subject) && (item.Start || item.start)) {
+      window.__calEvents.push(item);
+    }
+  }
+}
+
+/** Extract events from getSchedule GraphQL responses (fallback path). */
+function extractScheduleItems(data) {
+  const nodes = Array.isArray(data) ? data : [data];
+  for (const node of nodes) {
+    const schedules = node?.data?.getSchedule?.schedules;
+    if (!Array.isArray(schedules)) continue;
+    for (const s of schedules) {
+      for (const it of (s.scheduleItems || [])) {
+        if (it && it.startTime && it.endTime) {
+          // Convert getSchedule format to calendarView-like format
+          window.__calEvents.push({
+            subject: it.subject || '(meeting)',
+            start: it.startTime,
+            end: it.endTime,
+            showAs: it.status || 'Busy',
+            responseStatus: { response: 'Accepted' },
+            isAllDayEvent: false,
+            isCancelled: false,
+            _fromSchedule: true,
+          });
+        }
+      }
+    }
+  }
+}
+
+// ── Wait for OWA to load calendar data (up to 20s) ───────────────────
+for (let i = 0; i < 20; i++) {
+  await sleep(1000);
+  if (window.__calEvents.length > 0) break;
+}
+
+// Deduplicate events by start+end time
+const seen = new Set();
+const uniqueEvents = [];
+for (const ev of window.__calEvents) {
+  const startStr = ev.Start?.DateTime || ev.start?.dateTime || ev.start?.DateTime || '';
+  const endStr = ev.End?.DateTime || ev.end?.dateTime || ev.end?.DateTime || '';
+  const key = startStr + '|' + endStr;
+  if (seen.has(key)) continue;
+  seen.add(key);
+  uniqueEvents.push(ev);
+}
+
+// Clear captured events for next run
+window.__calEvents = [];
+
+// ── Filter to the target date and map to output rows ──────────────────
+const rows = [];
+for (const ev of uniqueEvents) {
+  // Normalize field names (OWA mixes PascalCase and camelCase)
+  const subject = ev.Subject || ev.subject || '(meeting)';
+  const startRaw = ev.Start?.DateTime || ev.start?.dateTime || ev.start?.DateTime || '';
+  const endRaw = ev.End?.DateTime || ev.end?.dateTime || ev.end?.DateTime || '';
+  const showAs = (ev.ShowAs || ev.showAs || 'busy');
+  const isCancelled = ev.IsCancelled || ev.isCancelled || false;
+  const isAllDay = ev.IsAllDayEvent || ev.isAllDayEvent || false;
+  const responseType = ev.ResponseStatus?.Response || ev.responseStatus?.response || '';
+
+  if (isCancelled || isAllDay) continue;
+
+  // Filter by response status if available (accepted/organizer only)
+  // If responseStatus is missing (e.g. from getSchedule), include the event
+  if (responseType && responseType !== 'Organizer' && responseType !== 'Accepted') continue;
+
+  // Only show busy/tentative items (skip free blocks from getSchedule)
+  const showAsLower = String(showAs).toLowerCase();
+  if (showAsLower === 'free') continue;
+
+  const startDt = new Date(startRaw.endsWith('Z') ? startRaw : startRaw + 'Z');
+  const endDt = new Date(endRaw.endsWith('Z') ? endRaw : endRaw + 'Z');
+  const evDate = `${startDt.getFullYear()}-${pad2(startDt.getMonth() + 1)}-${pad2(startDt.getDate())}`;
+
+  // Filter to the target date
+  if (evDate !== date) continue;
+
+  const durationMin = Math.round((endDt.getTime() - startDt.getTime()) / 60000);
+  if (durationMin < 5 || durationMin > 480) continue;
+
+  rows.push({
+    date: evDate,
+    subject: subject,
+    start: `${pad2(startDt.getHours())}:${pad2(startDt.getMinutes())}`,
+    end: `${pad2(endDt.getHours())}:${pad2(endDt.getMinutes())}`,
+    durationMin,
+    state: showAsLower,
+  });
+}
+
+return rows;