@autobest-ui/agent 1.0.0

package/plugins/autobest-delivery/mcp-server/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@autobest/delivery-mcp-server",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "lint": "node --check ../scripts/setup.mjs && node --check ../scripts/start-mcp.mjs && node --check ../scripts/export-delivery-report.mjs && node --check src/paths.mjs && node --check src/report.mjs && node --check src/runner.mjs && node --check src/server.mjs && node --check tests/fixture-server.mjs && node --check tests/report.test.mjs && node --check tests/runner.test.mjs && node --check tests/mcp-smoke.test.mjs && node --check tests/fixtures/basic.feature.mjs",
+    "test": "node --test --test-concurrency=1 tests/*.test.mjs",
+    "verify": "npm run lint && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "@playwright/test": "1.62.1",
+    "exceljs": "4.4.0",
+    "zod": "4.4.3"
+  },
+  "overrides": {
+    "uuid": "11.1.1"
+  }
+}

package/plugins/autobest-delivery/mcp-server/src/paths.mjs

@@ -0,0 +1,43 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export class PathPolicyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'PathPolicyError';
+  }
+}
+
+function isInside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+export async function resolveWorkspacePaths({ workspaceRoot, scenarioPath, outputDir }) {
+  const root = await fs.realpath(path.resolve(workspaceRoot));
+  const scenario = await fs.realpath(path.resolve(root, scenarioPath));
+  const output = path.resolve(root, outputDir);
+
+  if (!isInside(root, scenario)) {
+    throw new PathPolicyError('scenarioPath 必须位于 workspaceRoot 内');
+  }
+  if (!isInside(root, output)) {
+    throw new PathPolicyError('outputDir 必须位于 workspaceRoot 内');
+  }
+
+  await fs.mkdir(output, { recursive: true });
+  const realOutput = await fs.realpath(output);
+  if (!isInside(root, realOutput)) {
+    throw new PathPolicyError('outputDir 解析后的路径位于 workspaceRoot 外');
+  }
+
+  return { root, scenario, output: realOutput };
+}
+
+export function resolveArtifactPath(outputDir, relativePath) {
+  const target = path.resolve(outputDir, relativePath);
+  if (!isInside(outputDir, target)) {
+    throw new PathPolicyError('产物路径必须位于 outputDir 内');
+  }
+  return target;
+}

package/plugins/autobest-delivery/mcp-server/src/report.mjs

@@ -0,0 +1,605 @@
+import { createHash } from 'node:crypto';
+import { access, mkdir, readFile, readdir, rename, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import ExcelJS from 'exceljs';
+
+const pluginRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const defaultTemplatePath = path.join(pluginRoot, 'assets', 'delivery-report-template.xlsx');
+const expectedHeaders = ['页面/模块', '自测点', '自测方式', '通过', '截图1', '截图2'];
+
+function isInside(parent, child) {
+  const relative = path.relative(parent, child);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(filePath, label) {
+  try {
+    return JSON.parse(await readFile(filePath, 'utf8'));
+  } catch (error) {
+    throw new Error(`${label} 无法读取或不是有效 JSON：${filePath} (${error.message})`);
+  }
+}
+
+async function findWorkspaceRoot(startPath) {
+  let current = path.resolve(startPath);
+  while (true) {
+    if (await fileExists(path.join(current, '.git'))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new Error(`无法从功能目录定位 Git 工作区：${startPath}`);
+    }
+    current = parent;
+  }
+}
+
+function resolveEvidencePath(rawPath, { featureDir, workspaceRoot }) {
+  if (!rawPath || typeof rawPath !== 'string') {
+    return null;
+  }
+  const resolved = path.isAbsolute(rawPath)
+    ? path.resolve(rawPath)
+    : path.resolve(workspaceRoot, rawPath);
+  if (!isInside(featureDir, resolved)) {
+    throw new Error(`证据路径越出功能目录：${rawPath}`);
+  }
+  return resolved;
+}
+
+function parseSpecStories(specText) {
+  const section = specText.match(/(?:^|\n)## 用户故事\s*\n([\s\S]*?)(?=\n## |$)/);
+  if (!section) {
+    throw new Error('spec.md 缺少“用户故事”章节，无法生成自测点');
+  }
+  const stories = [];
+  const lines = section[1].split(/\r?\n/);
+  let current = null;
+  for (const line of lines) {
+    const match = line.match(/^\s*(\d+)\.\s+(.+?)\s*$/);
+    if (match) {
+      current = {
+        number: Number(match[1]),
+        id: `story-${String(match[1]).padStart(2, '0')}`,
+        text: match[2]
+      };
+      stories.push(current);
+    } else if (current && line.trim()) {
+      current.text += ` ${line.trim()}`;
+    }
+  }
+  if (stories.length === 0) {
+    throw new Error('spec.md 的“用户故事”章节没有编号功能点');
+  }
+  return stories;
+}
+
+async function findLatestRunnerResult(featureDir) {
+  const runsDir = path.join(featureDir, 'e2e', 'runs');
+  let entries;
+  try {
+    entries = await readdir(runsDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const candidates = entries
+    .filter(entry => entry.isDirectory() && /^iteration-\d+$/.test(entry.name))
+    .map(entry => ({
+      iteration: Number(entry.name.slice('iteration-'.length)),
+      filePath: path.join(runsDir, entry.name, 'runner-result.json')
+    }))
+    .sort((left, right) => right.iteration - left.iteration);
+  for (const candidate of candidates) {
+    if (await fileExists(candidate.filePath)) {
+      return candidate.filePath;
+    }
+  }
+  return null;
+}
+
+async function selectRunnerResult(checker, context) {
+  if (checker.runnerResult) {
+    const declared = resolveEvidencePath(checker.runnerResult, context);
+    if (await fileExists(declared)) {
+      return declared;
+    }
+  }
+  return findLatestRunnerResult(context.featureDir);
+}
+
+function mergeChecks(checker, runner) {
+  const merged = new Map();
+  for (const check of runner.checks || []) {
+    if (check && check.id) {
+      merged.set(check.id, check);
+    }
+  }
+  for (const check of checker.checks || []) {
+    if (check && check.id) {
+      merged.set(check.id, { ...(merged.get(check.id) || {}), ...check });
+    }
+  }
+  return merged;
+}
+
+function statusFor(check) {
+  if (check?.isPass === true) {
+    return '通过';
+  }
+  if (check?.isPass === false) {
+    return '不通过';
+  }
+  return 'Blocked';
+}
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function hasMetadataGrouping(stories, checks) {
+  return stories.every(story => {
+    const check = checks.get(story.id);
+    return ['reportModule', 'reportGroup', 'reportTitle', 'reportMethod']
+      .every(field => nonEmptyString(check?.[field]));
+  });
+}
+
+function buildMetadataGroups(stories, checks) {
+  const groups = new Map();
+  for (const story of stories) {
+    const check = checks.get(story.id);
+    const groupId = nonEmptyString(check.reportGroup);
+    let group = groups.get(groupId);
+    if (!group) {
+      group = {
+        id: groupId,
+        explicitGroup: groupId,
+        module: nonEmptyString(check.reportModule),
+        title: nonEmptyString(check.reportTitle),
+        method: nonEmptyString(check.reportMethod),
+        items: [],
+      };
+      groups.set(groupId, group);
+    } else if (
+      group.module !== nonEmptyString(check.reportModule) ||
+      group.title !== nonEmptyString(check.reportTitle) ||
+      group.method !== nonEmptyString(check.reportMethod)
+    ) {
+      throw new Error(`reportGroup ${groupId} 的 module、title 或 method 不一致`);
+    }
+    group.items.push({ story, check });
+  }
+  return [...groups.values()].map(group => ({
+    ...group,
+    status: worstStatus(group.items.map(item => statusFor(item.check)))
+  }));
+}
+
+function worstStatus(statuses) {
+  const priority = { '通过': 1, '不通过': 2, Blocked: 3 };
+  return statuses.reduce(
+    (worst, status) => priority[status] > priority[worst] ? status : worst,
+    '通过'
+  );
+}
+
+function emptyStatusCounts() {
+  return { '通过': 0, '不通过': 0, Blocked: 0 };
+}
+
+function reportMethodFor(group) {
+  const exceptions = group.items.filter(({ check }) => statusFor(check) !== '通过');
+  if (exceptions.length === 0) {
+    return group.method;
+  }
+  const exceptionLines = exceptions.map(({ story, check }) => {
+    if (!check) {
+      return `未执行：${story.text}`;
+    }
+    const expectation = check.expect || check.specSnippet || story.text;
+    const actual = check.actual ? `；实际：${check.actual}` : '';
+    return `${expectation}${actual}`;
+  });
+  return [
+    group.method,
+    `异常 ${exceptions.length} 项：`,
+    ...exceptionLines,
+  ].join('\n');
+}
+
+function buildCaptureRecords(runner) {
+  const mappings = runner.metadata?.visualMappings || [];
+  const mappingByCapture = new Map(mappings.map(mapping => [mapping.capture, mapping]));
+  return (runner.captures || []).map(rawPath => {
+    const basename = path.basename(rawPath);
+    const mapping = mappingByCapture.get(basename) || {};
+    const lower = basename.toLowerCase();
+    return {
+      rawPath,
+      basename,
+      mapping,
+      device: candidateDevice(mapping.reportDevice) ||
+        (lower.includes('mobile') ? 'mobile' : lower.includes('desktop') ? 'desktop' : null),
+      scene: mapping.scene || basename.replace(/\.(png|jpe?g)$/i, '')
+    };
+  });
+}
+
+function candidateDevice(value) {
+  return value === 'desktop' || value === 'mobile' ? value : null;
+}
+
+function chooseGroupCapture(records, group, device) {
+  const manifestCapture = group[`${device}Capture`];
+  if (manifestCapture) {
+    const candidates = records.filter(candidate =>
+      candidate.rawPath === manifestCapture || candidate.basename === manifestCapture
+    );
+    if (candidates.length !== 1) {
+      throw new Error(`功能组 ${group.id} 的 ${device}Capture 无法唯一匹配：${manifestCapture}`);
+    }
+    return candidates[0];
+  }
+  let best = null;
+  let bestScore = -1;
+  for (const candidate of records) {
+    if (candidate.device !== device) {
+      continue;
+    }
+    const mappingGroup = typeof candidate.mapping.reportGroup === 'string'
+      ? candidate.mapping.reportGroup.trim()
+      : '';
+    const groupMatches = Boolean(group.explicitGroup && mappingGroup === group.explicitGroup);
+    if (!groupMatches) {
+      continue;
+    }
+    const score = 20;
+    if (score > bestScore) {
+      best = candidate;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+function sha256Text(value) {
+  return createHash('sha256').update(value).digest('hex');
+}
+
+function validateManifestSource(manifest, { specText, checker, runner }) {
+  const expected = {
+    specSha256: sha256Text(specText),
+    iteration: runner.iteration ?? checker.iteration ?? null,
+    scenarioSha256: runner.scenarioSha256 ?? checker.scenarioSha256 ?? null
+  };
+  if (!manifest?.source || manifest.source.specSha256 !== expected.specSha256) {
+    throw new Error('语义分组清单与当前 spec.md 不一致');
+  }
+  if (manifest.source.iteration !== expected.iteration) {
+    throw new Error('语义分组清单与当前 Runner iteration 不一致');
+  }
+  if (manifest.source.scenarioSha256 !== expected.scenarioSha256) {
+    throw new Error('语义分组清单与当前冻结场景 SHA-256 不一致');
+  }
+}
+
+function buildManifestGroups(manifest, stories, checks, sourceContext) {
+  if (manifest?.version !== 1 || !Array.isArray(manifest.groups) || manifest.groups.length === 0) {
+    throw new Error('语义分组清单必须使用 version 1 并包含非空 groups');
+  }
+  validateManifestSource(manifest, sourceContext);
+  const storyById = new Map(stories.map(story => [story.id, story]));
+  const assigned = new Set();
+  const groupIds = new Set();
+  const groups = manifest.groups.map(group => {
+    const id = nonEmptyString(group?.id);
+    const module = nonEmptyString(group?.module);
+    const title = nonEmptyString(group?.title);
+    const method = nonEmptyString(group?.method);
+    if (!id || !/^[a-z0-9][a-z0-9._-]*$/.test(id) || !module || !title || !method) {
+      throw new Error('语义分组必须包含合法 id、module、title 和 method');
+    }
+    if (groupIds.has(id)) {
+      throw new Error(`语义分组 ID 重复：${id}`);
+    }
+    groupIds.add(id);
+    if (!Array.isArray(group.storyIds) || group.storyIds.length === 0) {
+      throw new Error(`语义分组 ${id} 必须包含非空 storyIds`);
+    }
+    const items = group.storyIds.map(storyId => {
+      const story = storyById.get(storyId);
+      if (!story) {
+        throw new Error(`语义分组 ${id} 引用了未知 story：${storyId}`);
+      }
+      if (assigned.has(storyId)) {
+        throw new Error(`story 被重复分组：${storyId}`);
+      }
+      assigned.add(storyId);
+      return { story, check: checks.get(storyId) };
+    });
+    for (const field of ['desktopCapture', 'mobileCapture']) {
+      if (group[field] !== undefined && !nonEmptyString(group[field])) {
+        throw new Error(`语义分组 ${id} 的 ${field} 必须是非空字符串`);
+      }
+    }
+    return {
+      id,
+      explicitGroup: null,
+      module,
+      title,
+      method,
+      items,
+      desktopCapture: nonEmptyString(group.desktopCapture),
+      mobileCapture: nonEmptyString(group.mobileCapture),
+      status: worstStatus(items.map(item => statusFor(item.check)))
+    };
+  });
+  const missing = stories.filter(story => !assigned.has(story.id)).map(story => story.id);
+  if (missing.length > 0) {
+    throw new Error(`语义分组未覆盖全部 story：${missing.join('、')}`);
+  }
+  return groups;
+}
+
+async function resolveReportGroups({ stories, checks, specText, checker, runner, context, groupingPath }) {
+  if (!groupingPath && hasMetadataGrouping(stories, checks)) {
+    return { groups: buildMetadataGroups(stories, checks), source: 'metadata', groupingPath: null };
+  }
+  let resolvedGroupingPath = groupingPath
+    ? resolveEvidencePath(groupingPath, context)
+    : path.join(context.featureDir, 'report', 'report-groups.json');
+  if (!(await fileExists(resolvedGroupingPath))) {
+    throw new Error(
+      `旧证据缺少语义分组清单：${resolvedGroupingPath}；不得按 scene 猜测组件或功能`
+    );
+  }
+  const manifest = await readJson(resolvedGroupingPath, '语义分组清单');
+  return {
+    groups: buildManifestGroups(manifest, stories, checks, { specText, checker, runner }),
+    source: 'manifest',
+    groupingPath: resolvedGroupingPath
+  };
+}
+
+function pngDimensions(buffer) {
+  const signature = '89504e470d0a1a0a';
+  if (buffer.length >= 24 && buffer.subarray(0, 8).toString('hex') === signature) {
+    return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+  }
+  return null;
+}
+
+function jpegDimensions(buffer) {
+  if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) {
+    return null;
+  }
+  let offset = 2;
+  while (offset + 9 < buffer.length) {
+    if (buffer[offset] !== 0xff) {
+      offset += 1;
+      continue;
+    }
+    const marker = buffer[offset + 1];
+    const length = buffer.readUInt16BE(offset + 2);
+    if ([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker)) {
+      return { width: buffer.readUInt16BE(offset + 7), height: buffer.readUInt16BE(offset + 5) };
+    }
+    if (length < 2) {
+      break;
+    }
+    offset += length + 2;
+  }
+  return null;
+}
+
+async function addScreenshot(workbook, worksheet, rowNumber, columnNumber, capture, context, imageCache) {
+  if (!capture) {
+    return { placed: false, added: false };
+  }
+  const imagePath = resolveEvidencePath(capture.rawPath, context);
+  if (!(await fileExists(imagePath))) {
+    return { placed: false, added: false };
+  }
+  const extension = path.extname(imagePath).toLowerCase();
+  if (!['.png', '.jpg', '.jpeg'].includes(extension)) {
+    return { placed: false, added: false };
+  }
+  let image = imageCache.get(imagePath);
+  let added = false;
+  if (!image) {
+    const buffer = await readFile(imagePath);
+    const dimensions = pngDimensions(buffer) || jpegDimensions(buffer);
+    if (!dimensions || dimensions.width <= 0 || dimensions.height <= 0) {
+      return { placed: false, added: false };
+    }
+    image = {
+      imageId: workbook.addImage({
+        buffer,
+        extension: extension === '.png' ? 'png' : 'jpeg'
+      }),
+      dimensions
+    };
+    imageCache.set(imagePath, image);
+    added = true;
+  }
+  const maxWidth = 220;
+  const maxHeight = 150;
+  const scale = Math.min(
+    maxWidth / image.dimensions.width,
+    maxHeight / image.dimensions.height,
+    1
+  );
+  const width = Math.max(1, Math.round(image.dimensions.width * scale));
+  const height = Math.max(1, Math.round(image.dimensions.height * scale));
+  worksheet.addImage(image.imageId, {
+    tl: { col: columnNumber - 1 + 0.08, row: rowNumber - 1 + 0.08 },
+    ext: { width, height },
+    editAs: 'oneCell'
+  });
+  worksheet.getRow(rowNumber).height = Math.max(worksheet.getRow(rowNumber).height || 0, height * 0.75 + 10);
+  return { placed: true, added };
+}
+
+function styleDataRow(row, status) {
+  const border = {
+    top: { style: 'thin', color: { argb: 'FFD9D9D9' } },
+    left: { style: 'thin', color: { argb: 'FFD9D9D9' } },
+    bottom: { style: 'thin', color: { argb: 'FFD9D9D9' } },
+    right: { style: 'thin', color: { argb: 'FFD9D9D9' } }
+  };
+  row.eachCell({ includeEmpty: true }, cell => {
+    cell.alignment = { vertical: 'middle', wrapText: true };
+    cell.border = border;
+  });
+  const statusCell = row.getCell(4);
+  statusCell.alignment = { horizontal: 'center', vertical: 'middle' };
+  const fills = {
+    '通过': 'FFE2F0D9',
+    '不通过': 'FFF4CCCC',
+    Blocked: 'FFFFE599'
+  };
+  statusCell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: fills[status] } };
+}
+
+async function validateTemplate(workbook) {
+  const worksheet = workbook.worksheets[0];
+  if (!worksheet) {
+    throw new Error('Excel 模板没有工作表');
+  }
+  const actual = expectedHeaders.map((_, index) => String(worksheet.getCell(1, index + 1).value || '').trim());
+  if (actual.some((header, index) => header !== expectedHeaders[index])) {
+    throw new Error(`Excel 模板表头不匹配，期望：${expectedHeaders.join('、')}`);
+  }
+  return worksheet;
+}
+
+function configureWorksheet(worksheet) {
+  worksheet.views = [{ state: 'frozen', ySplit: 1 }];
+  worksheet.autoFilter = { from: 'A1', to: 'F1' };
+}
+
+export async function exportDeliveryReport(options) {
+  const featureDir = path.resolve(options.featureDir);
+  const workspaceRoot = path.resolve(options.workspaceRoot || await findWorkspaceRoot(featureDir));
+  if (!isInside(workspaceRoot, featureDir)) {
+    throw new Error(`功能目录不在工作区内：${featureDir}`);
+  }
+  const outputPath = path.resolve(options.outputPath || path.join(featureDir, 'delivery-report.xlsx'));
+  if (!isInside(featureDir, outputPath)) {
+    throw new Error(`报告输出路径必须位于功能目录内：${outputPath}`);
+  }
+  const context = { featureDir, workspaceRoot };
+  const specPath = path.join(featureDir, 'spec.md');
+  const checkerPath = path.join(featureDir, 'checker', 'checker-result.json');
+  if (!(await fileExists(specPath))) {
+    throw new Error(`缺少 spec.md：${specPath}`);
+  }
+  if (!(await fileExists(checkerPath))) {
+    throw new Error(`缺少 Checker 结果：${checkerPath}`);
+  }
+  const specText = await readFile(specPath, 'utf8');
+  const stories = parseSpecStories(specText);
+  const checker = await readJson(checkerPath, 'Checker 结果');
+  const runnerPath = await selectRunnerResult(checker, context);
+  if (!runnerPath) {
+    throw new Error(`缺少 Runner 结果：${path.join(featureDir, 'e2e', 'runs')}`);
+  }
+  const runner = await readJson(runnerPath, 'Runner 结果');
+  const checks = mergeChecks(checker, runner);
+  const captures = buildCaptureRecords(runner);
+  const grouping = await resolveReportGroups({
+    stories,
+    checks,
+    specText,
+    checker,
+    runner,
+    context,
+    groupingPath: options.groupingPath
+  });
+  const groups = grouping.groups;
+
+  const workbook = new ExcelJS.Workbook();
+  await workbook.xlsx.readFile(options.templatePath || defaultTemplatePath);
+  const worksheet = await validateTemplate(workbook);
+  for (const extraWorksheet of workbook.worksheets.slice(1)) {
+    workbook.removeWorksheet(extraWorksheet.id);
+  }
+  worksheet.name = '自测报告';
+  if (worksheet.rowCount > 1) {
+    worksheet.spliceRows(2, worksheet.rowCount - 1);
+  }
+  configureWorksheet(worksheet);
+
+  let embeddedScreenshots = 0;
+  let screenshotPlacements = 0;
+  const imageCache = new Map();
+  const counts = emptyStatusCounts();
+  for (const group of groups) {
+    counts[group.status] += 1;
+    const row = worksheet.addRow([
+      group.module,
+      group.title,
+      reportMethodFor(group),
+      group.status,
+      '',
+      ''
+    ]);
+    row.height = 54;
+    styleDataRow(row, group.status);
+    const desktop = chooseGroupCapture(captures, group, 'desktop');
+    const mobile = chooseGroupCapture(captures, group, 'mobile');
+    for (const [columnNumber, capture] of [[5, desktop], [6, mobile]]) {
+      const imageResult = await addScreenshot(
+        workbook,
+        worksheet,
+        row.number,
+        columnNumber,
+        capture,
+        context,
+        imageCache
+      );
+      if (imageResult.placed) {
+        screenshotPlacements += 1;
+      }
+      if (imageResult.added) {
+        embeddedScreenshots += 1;
+      }
+    }
+  }
+
+  await mkdir(path.dirname(outputPath), { recursive: true });
+  const temporaryPath = path.join(
+    path.dirname(outputPath),
+    `.${path.basename(outputPath)}.${process.pid}.${Date.now()}.tmp`
+  );
+  try {
+    await workbook.xlsx.writeFile(temporaryPath);
+    await rename(temporaryPath, outputPath);
+  } finally {
+    await rm(temporaryPath, { force: true });
+  }
+
+  return {
+    outputPath,
+    iteration: runner.iteration ?? checker.iteration ?? null,
+    checkerStatus: checker.status,
+    runnerStatus: runner.status,
+    rows: groups.length,
+    statuses: counts,
+    embeddedScreenshots,
+    screenshotPlacements,
+    groupingSource: grouping.source,
+    groupingPath: grouping.groupingPath
+  };
+}