comfy-qa 1.0.0 → 1.2.1

package/src/commands/setup.ts

@@ -0,0 +1,46 @@
+import * as fs from "fs";
+import * as path from "path";
+
+/** Get the setup prompt text (reusable across setup command and auto-setup) */
+export function getSetupPrompt(): string {
+  const skillPath = path.join(import.meta.dir, "../../skills/comfy-qa-setup/SKILL.md");
+  const skill = fs.readFileSync(skillPath, "utf-8");
+
+  // Strip frontmatter
+  const body = skill.replace(/^---[\s\S]*?---\n*/, "");
+
+  return `${body}
+
+---
+
+## Context: Current Repository
+
+You are running inside a frontend repository. Follow the steps above to:
+
+1. Detect the stack from package.json, lock files, and framework config
+2. Determine the backend dependency and whether to use staging or local
+3. Install Playwright if not present
+4. Create \`playwright.qa.config.ts\`
+5. Create \`.claude/skills/comfy-qa/SKILL.md\` with repo-specific details
+6. Create \`.claude/skills/comfy-qa/REPRODUCE.md\`
+7. Create \`tests/e2e/qa.spec.ts\` with starter smoke tests
+8. Update \`.gitignore\` to include \`tmp/\`
+9. Verify by running the tests
+
+### Updating an existing setup
+
+If QA files already exist, update them instead of overwriting:
+
+- **playwright.qa.config.ts** — check if port or browser config needs updating
+- **SKILL.md** — update if the stack, backend, or key routes changed
+- **qa.spec.ts** — add new tests for new routes/features, keep passing tests
+- **REPRODUCE.md** — update if reproduction workflow changed
+
+Only modify what's out of date. Don't regenerate files that are already correct.
+
+Now read this repo's package.json and begin.`;
+}
+
+export async function commandSetup(_args: string[]): Promise<void> {
+  console.log(getSetupPrompt());
+}

package/src/recorder/narration.ts

@@ -0,0 +1,176 @@
+/**
+ * TTS narration generator using Gemini.
+ * Generates per-segment WAV files, concatenates them into a single track,
+ * and returns durations for narration-driven recording timing.
+ *
+ * Inspired by snomiao/playwright-multi-tab — see docs/making-the-demo-video.md
+ */
+import { $ } from "bun";
+import * as fs from "fs";
+import * as path from "path";
+
+const GEMINI_TTS_MODEL = "gemini-2.5-flash-preview-tts";
+const GEMINI_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
+
+export interface NarrationSegment {
+  id: string;
+  text: string;
+}
+
+export interface NarrationResult {
+  /** Per-segment durations in ms, keyed by segment id */
+  durations: Map<string, number>;
+  /** Concatenated WAV path (all segments joined in order) */
+  trackPath: string;
+  /** Per-segment WAV files in order */
+  segmentPaths: string[];
+  /** Meta JSON path with text + duration for subtitle generation */
+  metaPath: string;
+  /** Total duration in ms */
+  totalDurationMs: number;
+}
+
+/** Wrap raw PCM in a WAV header */
+function pcmToWav(pcm: Buffer, rate = 24000, channels = 1, bits = 16): Buffer {
+  const dataLen = pcm.length;
+  const byteRate = rate * channels * (bits / 8);
+  const blockAlign = channels * (bits / 8);
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + dataLen, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);    // PCM chunk size
+  header.writeUInt16LE(1, 20);     // PCM format
+  header.writeUInt16LE(channels, 22);
+  header.writeUInt32LE(rate, 24);
+  header.writeUInt32LE(byteRate, 28);
+  header.writeUInt16LE(blockAlign, 32);
+  header.writeUInt16LE(bits, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(dataLen, 40);
+  return Buffer.concat([header, pcm]);
+}
+
+/** Get WAV duration in ms by reading the header */
+function getWavDurationMs(wavPath: string): number {
+  const buf = fs.readFileSync(wavPath);
+  const sampleRate = buf.readUInt32LE(24);
+  const channels = buf.readUInt16LE(22);
+  const bits = buf.readUInt16LE(34);
+  const dataLen = buf.readUInt32LE(40);
+  return Math.round((dataLen / (sampleRate * channels * (bits / 8))) * 1000);
+}
+
+/** Call Gemini TTS for one text segment */
+async function geminiTTS(text: string, apiKey: string): Promise<Buffer> {
+  const url = `${GEMINI_API_BASE}/models/${GEMINI_TTS_MODEL}:generateContent?key=${apiKey}`;
+  const body = {
+    contents: [{ parts: [{ text }] }],
+    generationConfig: {
+      responseModalities: ["AUDIO"],
+      speechConfig: {
+        voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } },
+      },
+    },
+  };
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+  if (!resp.ok) {
+    throw new Error(`Gemini TTS failed: ${resp.status} ${await resp.text()}`);
+  }
+
+  const data: any = await resp.json();
+  const b64 = data.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+  if (!b64) throw new Error(`Gemini TTS returned no audio: ${JSON.stringify(data).slice(0, 200)}`);
+  return Buffer.from(b64, "base64");
+}
+
+/**
+ * Generate narration WAVs for all segments, concatenate, and return durations.
+ * Uses GEMINI_API_KEY from env. If unavailable, returns empty result (recorder will skip narration).
+ */
+export async function generateNarration(
+  segments: NarrationSegment[],
+  outputDir: string
+): Promise<NarrationResult | null> {
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    console.log(`  [narration] GEMINI_API_KEY not set — skipping narration`);
+    return null;
+  }
+  if (segments.length === 0) return null;
+
+  const narrationDir = path.join(outputDir, "narration");
+  fs.mkdirSync(narrationDir, { recursive: true });
+
+  console.log(`  [narration] Generating ${segments.length} TTS segments via Gemini…`);
+
+  const segmentPaths: string[] = [];
+  const durations = new Map<string, number>();
+  const meta: { id: string; text: string; durationMs: number }[] = [];
+
+  // Generate sequentially to avoid rate limiting
+  for (const seg of segments) {
+    const segPath = path.join(narrationDir, `${seg.id}.wav`);
+    if (fs.existsSync(segPath)) {
+      // Reuse cached segment
+      const dur = getWavDurationMs(segPath);
+      segmentPaths.push(segPath);
+      durations.set(seg.id, dur);
+      meta.push({ id: seg.id, text: seg.text, durationMs: dur });
+      continue;
+    }
+
+    // Retry up to 2 times on failure (Gemini sometimes returns OTHER finishReason)
+    let pcm: Buffer | null = null;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        pcm = await geminiTTS(seg.text, apiKey);
+        break;
+      } catch (err) {
+        if (attempt === 2) {
+          console.log(`  [narration] Skipped ${seg.id}: ${String(err).slice(0, 80)}`);
+        }
+      }
+    }
+    if (!pcm) continue; // Skip this segment but keep going
+
+    const wav = pcmToWav(pcm);
+    fs.writeFileSync(segPath, wav);
+    const dur = getWavDurationMs(segPath);
+    segmentPaths.push(segPath);
+    durations.set(seg.id, dur);
+    meta.push({ id: seg.id, text: seg.text, durationMs: dur });
+    console.log(`  [narration] ${seg.id}: ${dur}ms — "${seg.text.slice(0, 50)}..."`);
+  }
+
+  if (segmentPaths.length === 0) {
+    console.log(`  [narration] No segments generated — disabling narration`);
+    return null;
+  }
+
+  // Concatenate all WAVs into one track
+  const trackPath = path.join(narrationDir, "narration_track.wav");
+  const listPath = path.join(narrationDir, "concat-list.txt");
+  fs.writeFileSync(
+    listPath,
+    segmentPaths.map((p) => `file '${path.resolve(p)}'`).join("\n")
+  );
+  await $`ffmpeg -y -f concat -safe 0 -i ${listPath} -c copy ${trackPath}`.quiet();
+
+  const totalDurationMs = meta.reduce((sum, m) => sum + m.durationMs, 0);
+
+  // Save meta for subtitle generation
+  const metaPath = path.join(narrationDir, "meta.json");
+  fs.writeFileSync(metaPath, JSON.stringify({ segments: meta, totalDurationMs }, null, 2));
+
+  console.log(`  [narration] Track: ${trackPath} (${(totalDurationMs / 1000).toFixed(1)}s)`);
+
+  return { durations, trackPath, segmentPaths, metaPath, totalDurationMs };
+}

package/src/recorder/post-mix.ts

@@ -0,0 +1,81 @@
+/**
+ * Post-mix narration audio onto the recorded video and burn subtitles.
+ * Uses ffmpeg adelay filter for sync — single offset = (demo_start - ffmpeg_start) ms.
+ *
+ * Inspired by snomiao/playwright-multi-tab — see docs/making-the-demo-video.md
+ */
+import { $ } from "bun";
+import * as fs from "fs";
+import * as path from "path";
+
+interface Meta {
+  segments: { id: string; text: string; durationMs: number }[];
+  totalDurationMs: number;
+}
+
+/** Format ms as SRT timestamp HH:MM:SS,mmm */
+function srtTime(ms: number): string {
+  const h = Math.floor(ms / 3600000);
+  const m = Math.floor((ms % 3600000) / 60000);
+  const s = Math.floor((ms % 60000) / 1000);
+  const msr = ms % 1000;
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")},${String(msr).padStart(3, "0")}`;
+}
+
+/** Generate SRT subtitle file from meta + initial offset */
+function generateSrt(meta: Meta, offsetMs: number, outPath: string): void {
+  const lines: string[] = [];
+  let cursor = offsetMs;
+  meta.segments.forEach((seg, i) => {
+    const start = cursor;
+    const end = cursor + seg.durationMs;
+    lines.push(String(i + 1));
+    lines.push(`${srtTime(start)} --> ${srtTime(end)}`);
+    lines.push(seg.text);
+    lines.push("");
+    cursor = end;
+  });
+  fs.writeFileSync(outPath, lines.join("\n"));
+}
+
+/**
+ * Mix audio + subtitles onto video.
+ * @param videoPath path to silent recorded video (webm/mp4)
+ * @param trackPath narration_track.wav from generateNarration
+ * @param metaPath meta.json from generateNarration
+ * @param offsetMs delay to apply to audio (when narration starts in video timeline)
+ * @param outPath output video path
+ */
+export async function postMix(
+  videoPath: string,
+  trackPath: string,
+  metaPath: string,
+  offsetMs: number,
+  outPath: string
+): Promise<void> {
+  const meta: Meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+
+  // Step 1: overlay audio with adelay
+  const tmpDir = path.dirname(outPath);
+  const audioMixed = path.join(tmpDir, "_audio-mixed.mp4");
+  const adelay = `${offsetMs}|${offsetMs}`;
+
+  console.log(`  [post-mix] Overlaying audio (adelay=${offsetMs}ms)…`);
+  await $`ffmpeg -y -i ${videoPath} -i ${trackPath} -filter_complex ${`[1:a]adelay=${adelay}[aout]`} -map 0:v -map [aout] -c:v libx264 -preset fast -pix_fmt yuv420p -c:a aac -shortest ${audioMixed}`.quiet();
+
+  // Step 2: generate SRT
+  const srtPath = path.join(tmpDir, "narration.srt");
+  generateSrt(meta, offsetMs, srtPath);
+  console.log(`  [post-mix] Subtitles → ${srtPath}`);
+
+  // Step 3: burn subtitles
+  console.log(`  [post-mix] Burning subtitles…`);
+  // Escape path for ffmpeg subtitle filter
+  const escSrt = srtPath.replace(/\\/g, "/").replace(/:/g, "\\:");
+  await $`ffmpeg -y -i ${audioMixed} -vf ${`subtitles=${escSrt}:force_style='FontSize=18,Alignment=2,OutlineColour=&H80000000,BorderStyle=4,MarginV=30'`} -c:a copy ${outPath}`.quiet();
+
+  // Cleanup intermediate
+  try { fs.unlinkSync(audioMixed); } catch {}
+
+  console.log(`  [post-mix] Final video → ${outPath}`);
+}

package/src/report/e2e-test.ts

@@ -0,0 +1,132 @@
+import type { ResearchResult, TestScenario } from "../agent/research";
+import type { PRInfo, IssueInfo } from "../utils/github";
+
+/** Generate a Playwright E2E test file from research results */
+export function generateE2ETest(
+  target: PRInfo | IssueInfo,
+  targetType: "pr" | "issue",
+  research: ResearchResult,
+  comfyUrl = "http://localhost:8188"
+): string {
+  const num = target.number;
+  const title = target.title.replace(/'/g, "\\'");
+
+  const scenarioBlocks = research.testScenarios
+    .map((s, i) => generateScenarioTest(s, i, comfyUrl))
+    .join("\n\n");
+
+  return `// Auto-generated E2E test for ${targetType.toUpperCase()} #${num}
+// ${title}
+// ${target.url}
+//
+// Generated by comfy-qa — run with: bunx playwright test ${targetType}-${num}.e2e.ts
+
+import { test, expect, type Page } from "@playwright/test";
+
+const COMFY_URL = process.env.COMFY_URL ?? "${comfyUrl}";
+
+test.describe("${targetType.toUpperCase()} #${num}: ${title}", () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto(COMFY_URL, { waitUntil: "networkidle", timeout: 30000 });
+    // Wait for ComfyUI to fully initialize
+    await page.waitForTimeout(2000);
+  });
+
+${scenarioBlocks}
+});
+`;
+}
+
+function generateScenarioTest(
+  scenario: TestScenario,
+  index: number,
+  comfyUrl: string
+): string {
+  const stepsComment = scenario.steps
+    .map((s, i) => `    // Step ${i + 1}: ${s}`)
+    .join("\n");
+
+  const preconditionsComment = scenario.preconditions
+    .map((p) => `    // Precondition: ${p}`)
+    .join("\n");
+
+  return `  test("Scenario ${index + 1}: ${scenario.name.replace(/"/g, '\\"')}", async ({ page }) => {
+    // ${scenario.description}
+    //
+    // Preconditions:
+${preconditionsComment}
+    //
+    // Steps:
+${stepsComment}
+    //
+    // Expected: ${scenario.expectedOutcome}
+    // Playwright hint: ${scenario.playwrightHint}
+
+    // --- AUTO-GENERATED SKELETON ---
+    // This test provides the structure; the AI agent fills in
+    // real selectors and assertions at runtime.
+
+${generateStepCode(scenario)}
+
+    // Verify expected outcome
+    // TODO: Add assertion for: ${scenario.expectedOutcome}
+  });`;
+}
+
+function generateStepCode(scenario: TestScenario): string {
+  return scenario.steps
+    .map((step, i) => {
+      const lowered = step.toLowerCase();
+
+      // Try to generate meaningful Playwright code from step descriptions
+      if (lowered.includes("click") && lowered.includes("queue")) {
+        return `    // Step ${i + 1}: ${step}
+    const queueBtn = page.locator('button:has-text("Queue"), [data-testid="queue-button"]').first();
+    if (await queueBtn.isVisible()) await queueBtn.click();`;
+      }
+
+      if (lowered.includes("wait") && (lowered.includes("preview") || lowered.includes("image"))) {
+        return `    // Step ${i + 1}: ${step}
+    await page.waitForTimeout(3000); // Wait for preview to appear`;
+      }
+
+      if (lowered.includes("switch") && lowered.includes("tab")) {
+        return `    // Step ${i + 1}: ${step}
+    const newTab = await page.context().newPage();
+    await newTab.goto("about:blank");
+    await newTab.waitForTimeout(3000);
+    await newTab.close();
+    await page.bringToFront();`;
+      }
+
+      if (lowered.includes("visibility") || lowered.includes("hidden")) {
+        return `    // Step ${i + 1}: ${step}
+    await page.evaluate(() => {
+      Object.defineProperty(document, "hidden", { value: true, writable: true });
+      document.dispatchEvent(new Event("visibilitychange"));
+    });
+    await page.waitForTimeout(2000);
+    await page.evaluate(() => {
+      Object.defineProperty(document, "hidden", { value: false, writable: true });
+      document.dispatchEvent(new Event("visibilitychange"));
+    });`;
+      }
+
+      if (lowered.includes("assert") || lowered.includes("verify") || lowered.includes("check")) {
+        return `    // Step ${i + 1}: ${step}
+    // TODO: Add specific assertion here
+    await page.waitForTimeout(1000);`;
+      }
+
+      if (lowered.includes("scroll")) {
+        return `    // Step ${i + 1}: ${step}
+    await page.mouse.wheel(0, 300);
+    await page.waitForTimeout(500);`;
+      }
+
+      // Generic fallback
+      return `    // Step ${i + 1}: ${step}
+    await page.waitForTimeout(1000);`;
+    })
+    .join("\n\n");
+}

package/src/report/generate.ts

@@ -0,0 +1,271 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { ResearchResult, QAChecklistItem } from "../agent/research";
+import type { PRInfo, IssueInfo } from "../utils/github";
+
+export interface ReportContext {
+  target: PRInfo | IssueInfo;
+  targetType: "pr" | "issue";
+  research: ResearchResult;
+  outputDir: string;
+  screenshots: string[];
+  videoPath?: string;
+  runAt: Date;
+}
+
+function isPR(t: PRInfo | IssueInfo): t is PRInfo {
+  return "headRefName" in t;
+}
+
+function severityBadge(s: string): string {
+  const map: Record<string, string> = {
+    critical: "🔴 CRITICAL",
+    high: "🟠 HIGH",
+    medium: "🟡 MEDIUM",
+    low: "🟢 LOW",
+  };
+  return map[s] ?? s.toUpperCase();
+}
+
+function statusIcon(s: string): string {
+  const map: Record<string, string> = {
+    pending: "⬜",
+    pass: "✅",
+    fail: "❌",
+    blocked: "⛔",
+  };
+  return map[s] ?? "⬜";
+}
+
+function priorityBadge(p: string): string {
+  const map: Record<string, string> = {
+    P0: "🔥 P0",
+    P1: "⚡ P1",
+    P2: "📋 P2",
+  };
+  return map[p] ?? p;
+}
+
+export function generateMarkdownReport(ctx: ReportContext): string {
+  const { target, targetType, research, screenshots, videoPath, runAt } = ctx;
+  const num = target.number;
+  const url = target.url;
+  const title = target.title;
+
+  const checklistTable = research.qaChecklist
+    .map(
+      (item) =>
+        `| ${statusIcon(item.status)} | ${priorityBadge(item.priority)} | ${item.id} | ${item.category} | ${item.description} |`
+    )
+    .join("\n");
+
+  const scenarioBlocks = research.testScenarios
+    .map(
+      (s, i) => `
+### Scenario ${i + 1}: ${s.name}
+
+> ${s.description}
+
+**Preconditions:**
+${s.preconditions.map((p) => `- ${p}`).join("\n")}
+
+**Steps:**
+${s.steps.map((step, j) => `${j + 1}. ${step}`).join("\n")}
+
+**Expected Outcome:** ${s.expectedOutcome}
+
+**Playwright Hint:** \`${s.playwrightHint}\`
+`
+    )
+    .join("\n---\n");
+
+  const checklistDetails = research.qaChecklist
+    .map(
+      (item) => `
+#### ${item.id} — ${item.description}
+
+- **Category:** ${item.category}
+- **Priority:** ${priorityBadge(item.priority)}
+- **Status:** ${statusIcon(item.status)} ${item.status}
+
+**Steps:**
+${item.steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}
+
+**Expected Result:** ${item.expectedResult}
+`
+    )
+    .join("\n---\n");
+
+  const screenshotSection =
+    screenshots.length > 0
+      ? `
+## Screenshots
+
+${screenshots
+  .map((s) => {
+    const rel = path.basename(s);
+    return `### ${rel}\n![${rel}](screenshots/${rel})\n`;
+  })
+  .join("\n")}`
+      : "";
+
+  const videoSection = videoPath
+    ? `
+## Video Recording
+
+[Watch QA Session Video](${path.basename(videoPath)})
+
+> Recorded with Comfy-QA Agent HUD overlay showing step-by-step operations.
+`
+    : `
+## Video Recording
+
+> ⚠️ Video recording requires a running ComfyUI instance. Start ComfyUI and re-run with \`--record\`.
+`;
+
+  return `# QA Report: ${targetType.toUpperCase()} #${num}
+
+> **${title}**
+> ${url}
+
+---
+
+## Executive Summary
+
+${research.summary}
+
+| Field | Value |
+|-------|-------|
+| Type | ${research.bugType} |
+| Severity | ${severityBadge(research.severity)} |
+| Affected Area | ${research.affectedArea} |
+| Generated At | ${runAt.toISOString()} |
+| Target | [${targetType.toUpperCase()} #${num}](${url}) |
+
+---
+
+## Bug Analysis
+
+### Actual Behavior (The Bug)
+${research.actualBehavior}
+
+### Expected Behavior
+${research.expectedBehavior}
+
+### Root Cause
+${research.rootCauseSummary}
+
+---
+
+## Reproduction Steps
+
+${research.reproductionSteps.map((s, i) => `${i + 1}. ${s}`).join("\n")}
+
+---
+
+## QA Checklist
+
+| Status | Priority | ID | Category | Description |
+|--------|----------|----|----------|-------------|
+${checklistTable}
+
+### Checklist Details
+
+${checklistDetails}
+
+---
+
+## Test Scenarios
+
+${scenarioBlocks}
+
+---
+
+## Risk Assessment
+
+${research.risks.map((r) => `- ⚠️ ${r}`).join("\n")}
+
+${research.relatedFiles.length > 0 ? `
+## Related Files
+
+${research.relatedFiles.map((f) => `- \`${f}\``).join("\n")}
+` : ""}
+
+${videoSection}
+
+${screenshotSection}
+
+---
+
+*Generated by [Comfy-QA](https://github.com/snomiao/Comfy-QA) · ${runAt.toISOString()}*
+`;
+}
+
+export function generateQASheet(ctx: ReportContext): string {
+  const { target, targetType, research } = ctx;
+
+  const rows = research.qaChecklist
+    .map(
+      (item) =>
+        `| ${item.id} | ${item.description} | ${item.priority} | ${item.category} | ${item.status} | ${item.expectedResult} |`
+    )
+    .join("\n");
+
+  return `# QA Test Sheet — ${targetType.toUpperCase()} #${target.number}
+
+## ${target.title}
+
+**Severity:** ${severityBadge(research.severity)}
+**Area:** ${research.affectedArea}
+**Tester:** _____________
+**Date:** ${ctx.runAt.toISOString().split("T")[0]}
+
+---
+
+## Test Cases
+
+| ID | Description | Priority | Category | Result | Expected Result |
+|----|-------------|----------|----------|--------|-----------------|
+${rows}
+
+---
+
+## Notes
+
+_________________________________
+_________________________________
+_________________________________
+
+## Sign-off
+
+- [ ] All P0 items passed
+- [ ] All P1 items passed or accepted with known issues
+- [ ] Video evidence recorded
+- [ ] Report filed
+
+**QA Engineer:** _________________  **Date:** _________________
+`;
+}
+
+export function saveReport(ctx: ReportContext): {
+  reportPath: string;
+  qaSheetPath: string;
+  jsonPath: string;
+} {
+  const { outputDir, target, targetType } = ctx;
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const reportPath = path.join(outputDir, "report.md");
+  const qaSheetPath = path.join(outputDir, "qa-sheet.md");
+  const jsonPath = path.join(outputDir, "research.json");
+
+  fs.writeFileSync(reportPath, generateMarkdownReport(ctx));
+  fs.writeFileSync(qaSheetPath, generateQASheet(ctx));
+  fs.writeFileSync(jsonPath, JSON.stringify({ target, research: ctx.research, runAt: ctx.runAt }, null, 2));
+
+  console.log(`  [report] ${reportPath}`);
+  console.log(`  [qa-sheet] ${qaSheetPath}`);
+  console.log(`  [json] ${jsonPath}`);
+
+  return { reportPath, qaSheetPath, jsonPath };
+}