@hasna/testers 0.0.13 → 0.0.14

package/dist/cli/index.js

@@ -2214,6 +2214,24 @@ function scheduleFromRow(row) {
     updatedAt: row.updated_at
   };
 }
+function scanIssueFromRow(row) {
+  return {
+    id: row.id,
+    fingerprint: row.fingerprint,
+    type: row.type,
+    severity: row.severity,
+    pageUrl: row.page_url,
+    message: row.message,
+    detail: row.detail ? JSON.parse(row.detail) : null,
+    status: row.status,
+    occurrenceCount: row.occurrence_count,
+    firstSeenAt: row.first_seen_at,
+    lastSeenAt: row.last_seen_at,
+    resolvedAt: row.resolved_at,
+    todoTaskId: row.todo_task_id,
+    projectId: row.project_id
+  };
+}
 function flowFromRow(row) {
   return {
     id: row.id,
@@ -2531,6 +2549,29 @@ var init_database = __esm(() => {
   `,
     `
   ALTER TABLE runs ADD COLUMN is_baseline INTEGER NOT NULL DEFAULT 0;
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS scan_issues (
+    id TEXT PRIMARY KEY,
+    fingerprint TEXT NOT NULL UNIQUE,
+    type TEXT NOT NULL,
+    severity TEXT NOT NULL DEFAULT 'medium',
+    page_url TEXT NOT NULL,
+    message TEXT NOT NULL,
+    detail TEXT,
+    status TEXT NOT NULL DEFAULT 'open',
+    occurrence_count INTEGER NOT NULL DEFAULT 1,
+    first_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+    resolved_at TEXT,
+    todo_task_id TEXT,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_scan_issues_fingerprint ON scan_issues(fingerprint);
+  CREATE INDEX IF NOT EXISTS idx_scan_issues_status ON scan_issues(status);
+  CREATE INDEX IF NOT EXISTS idx_scan_issues_type ON scan_issues(type);
+  CREATE INDEX IF NOT EXISTS idx_scan_issues_project ON scan_issues(project_id);
   `
   ];
 });
@@ -5743,6 +5784,628 @@ var init_agents = __esm(() => {
   init_database();
 });
 
+// src/lib/scanners/console.ts
+var exports_console = {};
+__export(exports_console, {
+  scanConsoleErrors: () => scanConsoleErrors
+});
+async function scanConsoleErrors(options) {
+  const { url, pages, headed = false, timeoutMs = 15000 } = options;
+  const start = Date.now();
+  const scannedPages = [];
+  const issues = [];
+  const pageUrls = pages?.length ? pages.map((p) => p.startsWith("http") ? p : `${url.replace(/\/$/, "")}${p}`) : [url];
+  const browser = await launchBrowser({ headless: !headed });
+  try {
+    for (const pageUrl of pageUrls) {
+      const page = await getPage(browser, {});
+      const entries = [];
+      page.on("console", (msg) => {
+        if (msg.type() === "error") {
+          entries.push({ type: "console.error", text: msg.text() });
+        }
+      });
+      page.on("pageerror", (err) => {
+        entries.push({ type: "uncaught", text: err.message, location: err.stack?.split(`
+`)[1]?.trim() });
+      });
+      try {
+        await page.goto(pageUrl, { timeout: timeoutMs, waitUntil: "domcontentloaded" });
+        await page.waitForTimeout(1500);
+        scannedPages.push(pageUrl);
+      } catch {
+        entries.push({ type: "navigation", text: `Failed to navigate to ${pageUrl}` });
+        scannedPages.push(pageUrl);
+      } finally {
+        await page.close();
+      }
+      for (const entry of entries) {
+        if (isIgnoredConsoleError(entry.text))
+          continue;
+        const severity = classifyConsoleSeverity(entry.text);
+        issues.push({
+          type: "console_error",
+          severity,
+          pageUrl,
+          message: entry.text.slice(0, 500),
+          detail: {
+            errorType: entry.type,
+            location: entry.location ?? null
+          }
+        });
+      }
+    }
+  } finally {
+    await closeBrowser(browser);
+  }
+  return {
+    url,
+    pages: scannedPages,
+    scannedAt: new Date().toISOString(),
+    durationMs: Date.now() - start,
+    issues
+  };
+}
+function isIgnoredConsoleError(text) {
+  return IGNORED_PATTERNS.some((p) => p.test(text));
+}
+function classifyConsoleSeverity(text) {
+  const lower = text.toLowerCase();
+  if (/uncaught|unhandled|typeerror|referenceerror|cannot read|is not a function|hydrat/i.test(lower))
+    return "critical";
+  if (/error|failed|exception/i.test(lower))
+    return "high";
+  if (/warning|warn|deprecated/i.test(lower))
+    return "medium";
+  return "low";
+}
+var IGNORED_PATTERNS;
+var init_console = __esm(() => {
+  init_browser();
+  IGNORED_PATTERNS = [
+    /Download the React DevTools/i,
+    /\[HMR\]/,
+    /\[vite\]/i,
+    /favicon\.ico/i,
+    /Content Security Policy/i
+  ];
+});
+
+// src/db/scan-issues.ts
+var exports_scan_issues = {};
+__export(exports_scan_issues, {
+  upsertScanIssue: () => upsertScanIssue,
+  setScanIssueTodoTaskId: () => setScanIssueTodoTaskId,
+  resolveScanIssue: () => resolveScanIssue,
+  listScanIssues: () => listScanIssues,
+  getScanIssue: () => getScanIssue,
+  fingerprintIssue: () => fingerprintIssue
+});
+function fingerprintIssue(issue) {
+  let pagePattern = issue.pageUrl;
+  try {
+    pagePattern = new URL(issue.pageUrl).pathname;
+  } catch {}
+  const raw = `${issue.type}::${issue.message.slice(0, 200)}::${pagePattern}`;
+  let hash = 5381;
+  for (let i = 0;i < raw.length; i++) {
+    hash = (hash << 5) + hash ^ raw.charCodeAt(i);
+    hash = hash >>> 0;
+  }
+  return `${issue.type}-${hash.toString(16).padStart(8, "0")}`;
+}
+function upsertScanIssue(issue, projectId) {
+  const db2 = getDatabase();
+  const fingerprint = fingerprintIssue(issue);
+  const timestamp = now();
+  const existing = db2.query("SELECT * FROM scan_issues WHERE fingerprint = ?").get(fingerprint);
+  if (!existing) {
+    const id = uuid();
+    db2.query(`
+      INSERT INTO scan_issues (id, fingerprint, type, severity, page_url, message, detail, status, occurrence_count, first_seen_at, last_seen_at, project_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 'open', 1, ?, ?, ?)
+    `).run(id, fingerprint, issue.type, issue.severity, issue.pageUrl, issue.message, issue.detail ? JSON.stringify(issue.detail) : null, timestamp, timestamp, projectId ?? null);
+    const row = db2.query("SELECT * FROM scan_issues WHERE id = ?").get(id);
+    return { issue: scanIssueFromRow(row), outcome: "new" };
+  }
+  const wasResolved = existing.status === "resolved";
+  const newStatus = wasResolved ? "regressed" : "open";
+  db2.query(`
+    UPDATE scan_issues
+    SET occurrence_count = occurrence_count + 1,
+        last_seen_at = ?,
+        status = ?,
+        resolved_at = CASE WHEN ? = 'regressed' THEN NULL ELSE resolved_at END,
+        severity = ?,
+        page_url = ?,
+        message = ?,
+        detail = ?
+    WHERE fingerprint = ?
+  `).run(timestamp, newStatus, newStatus, issue.severity, issue.pageUrl, issue.message, issue.detail ? JSON.stringify(issue.detail) : existing.detail, fingerprint);
+  const updated = db2.query("SELECT * FROM scan_issues WHERE fingerprint = ?").get(fingerprint);
+  return {
+    issue: scanIssueFromRow(updated),
+    outcome: wasResolved ? "regressed" : "existing"
+  };
+}
+function resolveScanIssue(id) {
+  const db2 = getDatabase();
+  const result = db2.query("UPDATE scan_issues SET status = 'resolved', resolved_at = ? WHERE id = ?").run(now(), id);
+  return result.changes > 0;
+}
+function setScanIssueTodoTaskId(id, todoTaskId) {
+  const db2 = getDatabase();
+  db2.query("UPDATE scan_issues SET todo_task_id = ? WHERE id = ?").run(todoTaskId, id);
+}
+function listScanIssues(opts = {}) {
+  const db2 = getDatabase();
+  const conditions = ["1=1"];
+  const params = [];
+  if (opts.status) {
+    conditions.push("status = ?");
+    params.push(opts.status);
+  }
+  if (opts.type) {
+    conditions.push("type = ?");
+    params.push(opts.type);
+  }
+  if (opts.projectId) {
+    conditions.push("project_id = ?");
+    params.push(opts.projectId);
+  }
+  const limitClause = opts.limit ? ` LIMIT ${opts.limit}` : "";
+  const rows = db2.query(`SELECT * FROM scan_issues WHERE ${conditions.join(" AND ")} ORDER BY last_seen_at DESC${limitClause}`).all(...params);
+  return rows.map(scanIssueFromRow);
+}
+function getScanIssue(id) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM scan_issues WHERE id = ?").get(id);
+  return row ? scanIssueFromRow(row) : null;
+}
+var init_scan_issues = __esm(() => {
+  init_types();
+  init_database();
+});
+
+// src/lib/scanners/network.ts
+var exports_network = {};
+__export(exports_network, {
+  scanNetworkErrors: () => scanNetworkErrors
+});
+async function scanNetworkErrors(options) {
+  const { url, pages, headed = false, timeoutMs = 15000 } = options;
+  const start = Date.now();
+  const scannedPages = [];
+  const issues = [];
+  const pageUrls = pages?.length ? pages.map((p) => p.startsWith("http") ? p : `${url.replace(/\/$/, "")}${p}`) : [url];
+  const browser = await launchBrowser({ headless: !headed });
+  try {
+    for (const pageUrl of pageUrls) {
+      const page = await getPage(browser, {});
+      const entries = [];
+      page.on("response", (resp) => {
+        const reqUrl = resp.url();
+        const status = resp.status();
+        if (shouldIgnoreUrl(reqUrl))
+          return;
+        if (status >= 400) {
+          entries.push({ url: reqUrl, status, method: resp.request().method(), type: resp.request().resourceType(), failed: false });
+        }
+      });
+      page.on("requestfailed", (req) => {
+        const reqUrl = req.url();
+        if (shouldIgnoreUrl(reqUrl))
+          return;
+        entries.push({
+          url: reqUrl,
+          status: 0,
+          method: req.method(),
+          type: req.resourceType(),
+          failed: true,
+          failureText: req.failure()?.errorText
+        });
+      });
+      try {
+        await page.goto(pageUrl, { timeout: timeoutMs, waitUntil: "domcontentloaded" });
+        await page.waitForTimeout(1000);
+        scannedPages.push(pageUrl);
+      } catch {
+        scannedPages.push(pageUrl);
+      } finally {
+        await page.close();
+      }
+      for (const entry of entries) {
+        const severity = classifyNetworkSeverity(entry);
+        const message = entry.failed ? `Request failed: ${entry.method} ${entry.url} \u2014 ${entry.failureText ?? "unknown"}` : `HTTP ${entry.status}: ${entry.method} ${entry.url}`;
+        issues.push({
+          type: "network_error",
+          severity,
+          pageUrl,
+          message: message.slice(0, 500),
+          detail: {
+            requestUrl: entry.url,
+            status: entry.status,
+            method: entry.method,
+            resourceType: entry.type,
+            failureText: entry.failureText ?? null
+          }
+        });
+      }
+    }
+  } finally {
+    await closeBrowser(browser);
+  }
+  return { url, pages: scannedPages, scannedAt: new Date().toISOString(), durationMs: Date.now() - start, issues };
+}
+function shouldIgnoreUrl(reqUrl) {
+  return IGNORE_URL_PATTERNS.some((p) => p.test(reqUrl));
+}
+function classifyNetworkSeverity(entry) {
+  if (entry.failed) {
+    if (entry.failureText?.includes("CORS") || entry.failureText?.includes("blocked"))
+      return "critical";
+    return "high";
+  }
+  if (entry.status >= 500)
+    return "critical";
+  if (entry.status === 401 || entry.status === 403)
+    return "high";
+  if (entry.status >= 400)
+    return "medium";
+  return "low";
+}
+var IGNORE_URL_PATTERNS;
+var init_network = __esm(() => {
+  init_browser();
+  IGNORE_URL_PATTERNS = [
+    /favicon\.ico/i,
+    /\.woff2?$/i,
+    /fonts\.googleapis\.com/i,
+    /analytics\.(google|segment)/i,
+    /hotjar\.com/i,
+    /sentry\.io/i
+  ];
+});
+
+// src/lib/scanners/links.ts
+var exports_links = {};
+__export(exports_links, {
+  scanBrokenLinks: () => scanBrokenLinks
+});
+async function scanBrokenLinks(options) {
+  const { url, maxPages = 30, headed = false, timeoutMs = 12000 } = options;
+  const start = Date.now();
+  const issues = [];
+  const rootOrigin = (() => {
+    try {
+      return new URL(url).origin;
+    } catch {
+      return url;
+    }
+  })();
+  const visited = new Set;
+  const queue = [{ pageUrl: url, sourceUrl: "" }];
+  const browser = await launchBrowser({ headless: !headed });
+  try {
+    while (queue.length > 0 && visited.size < maxPages) {
+      const { pageUrl, sourceUrl } = queue.shift();
+      const normalised = normaliseUrl(pageUrl);
+      if (visited.has(normalised))
+        continue;
+      visited.add(normalised);
+      const page = await getPage(browser, {});
+      let status = 200;
+      let finalUrl = pageUrl;
+      page.on("response", (resp) => {
+        if (resp.url() === pageUrl || resp.url() === normalised) {
+          status = resp.status();
+        }
+      });
+      let hrefs = [];
+      try {
+        const response = await page.goto(pageUrl, { timeout: timeoutMs, waitUntil: "domcontentloaded" });
+        if (response) {
+          status = response.status();
+          finalUrl = response.url();
+        }
+        hrefs = await page.evaluate(() => Array.from(document.querySelectorAll("a[href]")).map((a) => a.href).filter(Boolean));
+      } catch (err) {
+        status = 0;
+      } finally {
+        await page.close();
+      }
+      if (status === 404) {
+        issues.push({
+          type: "broken_link",
+          severity: "high",
+          pageUrl: sourceUrl || url,
+          message: `404 Not Found: ${pageUrl}`,
+          detail: { brokenUrl: pageUrl, sourceUrl, status }
+        });
+      } else if (status === 0) {
+        issues.push({
+          type: "broken_link",
+          severity: "medium",
+          pageUrl: sourceUrl || url,
+          message: `Navigation failed: ${pageUrl}`,
+          detail: { brokenUrl: pageUrl, sourceUrl, status }
+        });
+      }
+      for (const href of hrefs) {
+        try {
+          const linkUrl = new URL(href);
+          if (linkUrl.origin === rootOrigin) {
+            const clean = `${linkUrl.origin}${linkUrl.pathname}`;
+            if (!visited.has(clean)) {
+              queue.push({ pageUrl: clean, sourceUrl: finalUrl });
+            }
+          }
+        } catch {}
+      }
+    }
+  } finally {
+    await closeBrowser(browser);
+  }
+  return {
+    url,
+    pages: Array.from(visited),
+    scannedAt: new Date().toISOString(),
+    durationMs: Date.now() - start,
+    issues
+  };
+}
+function normaliseUrl(rawUrl) {
+  try {
+    const u = new URL(rawUrl);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return rawUrl;
+  }
+}
+var init_links = __esm(() => {
+  init_browser();
+});
+
+// src/lib/scanners/performance.ts
+var exports_performance = {};
+__export(exports_performance, {
+  scanPerformance: () => scanPerformance
+});
+async function scanPerformance(options) {
+  const { url, pages, headed = false, timeoutMs = 20000, thresholds: customThresholds } = options;
+  const thresholds = { ...DEFAULT_THRESHOLDS, ...customThresholds };
+  const start = Date.now();
+  const scannedPages = [];
+  const issues = [];
+  const pageUrls = pages?.length ? pages.map((p) => p.startsWith("http") ? p : `${url.replace(/\/$/, "")}${p}`) : [url];
+  const browser = await launchBrowser({ headless: !headed });
+  try {
+    for (const pageUrl of pageUrls) {
+      const page = await getPage(browser, {});
+      let transferBytes = 0;
+      let requestCount = 0;
+      page.on("response", async (resp) => {
+        requestCount++;
+        try {
+          const headers = resp.headers();
+          const contentLength = parseInt(headers["content-length"] ?? "0", 10);
+          if (!isNaN(contentLength))
+            transferBytes += contentLength;
+        } catch {}
+      });
+      try {
+        await page.goto(pageUrl, { timeout: timeoutMs, waitUntil: "load" });
+        scannedPages.push(pageUrl);
+        const metrics = await page.evaluate((pUrl) => {
+          const nav = performance.getEntriesByType("navigation")[0];
+          const paintEntries = performance.getEntriesByType("paint");
+          const fpEntry = paintEntries.find((e) => e.name === "first-paint");
+          const fcpEntry = paintEntries.find((e) => e.name === "first-contentful-paint");
+          let lcpMs = null;
+          try {
+            const lcpEntries = performance.getEntriesByType("largest-contentful-paint");
+            if (lcpEntries.length > 0) {
+              lcpMs = lcpEntries[lcpEntries.length - 1].startTime;
+            }
+          } catch {}
+          return {
+            pageUrl: pUrl,
+            loadTimeMs: nav ? Math.round(nav.loadEventEnd - nav.startTime) : 0,
+            domContentLoadedMs: nav ? Math.round(nav.domContentLoadedEventEnd - nav.startTime) : 0,
+            firstPaintMs: fpEntry ? Math.round(fpEntry.startTime) : fcpEntry ? Math.round(fcpEntry.startTime) : null,
+            lcpMs,
+            requestCount: 0,
+            transferBytes: 0
+          };
+        }, pageUrl);
+        metrics.requestCount = requestCount;
+        metrics.transferBytes = transferBytes;
+        if (metrics.loadTimeMs > thresholds.loadTimeMs) {
+          issues.push({
+            type: "performance",
+            severity: metrics.loadTimeMs > thresholds.loadTimeMs * 2 ? "critical" : "high",
+            pageUrl,
+            message: `Slow page load: ${metrics.loadTimeMs}ms (threshold: ${thresholds.loadTimeMs}ms)`,
+            detail: { ...metrics }
+          });
+        }
+        if (metrics.domContentLoadedMs > thresholds.domContentLoadedMs) {
+          issues.push({
+            type: "performance",
+            severity: "medium",
+            pageUrl,
+            message: `Slow DOMContentLoaded: ${metrics.domContentLoadedMs}ms (threshold: ${thresholds.domContentLoadedMs}ms)`,
+            detail: { ...metrics }
+          });
+        }
+        if (metrics.lcpMs !== null && metrics.lcpMs > thresholds.lcpMs) {
+          issues.push({
+            type: "performance",
+            severity: metrics.lcpMs > thresholds.lcpMs * 2 ? "critical" : "high",
+            pageUrl,
+            message: `Poor LCP: ${Math.round(metrics.lcpMs)}ms (threshold: ${thresholds.lcpMs}ms)`,
+            detail: { ...metrics }
+          });
+        }
+      } catch (err) {
+        issues.push({
+          type: "performance",
+          severity: "medium",
+          pageUrl,
+          message: `Performance scan failed: ${err instanceof Error ? err.message : String(err)}`,
+          detail: {}
+        });
+      } finally {
+        await page.close();
+      }
+    }
+  } finally {
+    await closeBrowser(browser);
+  }
+  return { url, pages: scannedPages, scannedAt: new Date().toISOString(), durationMs: Date.now() - start, issues };
+}
+var DEFAULT_THRESHOLDS;
+var init_performance = __esm(() => {
+  init_browser();
+  DEFAULT_THRESHOLDS = {
+    loadTimeMs: 5000,
+    domContentLoadedMs: 3000,
+    lcpMs: 2500
+  };
+});
+
+// src/lib/health-scan.ts
+var exports_health_scan = {};
+__export(exports_health_scan, {
+  runHealthScan: () => runHealthScan
+});
+async function runHealthScan(options) {
+  const {
+    url,
+    pages,
+    projectId,
+    headed = false,
+    timeoutMs = 15000,
+    scanners = ["console", "network", "links"],
+    maxPages = 20
+  } = options;
+  const start = Date.now();
+  const results = [];
+  if (scanners.includes("console")) {
+    results.push(await scanConsoleErrors({ url, pages, headed, timeoutMs }));
+  }
+  if (scanners.includes("network")) {
+    results.push(await scanNetworkErrors({ url, pages, headed, timeoutMs }));
+  }
+  if (scanners.includes("links")) {
+    results.push(await scanBrokenLinks({ url, maxPages, headed, timeoutMs }));
+  }
+  if (scanners.includes("performance")) {
+    results.push(await scanPerformance({ url, pages, headed, timeoutMs }));
+  }
+  const allIssues = results.flatMap((r) => r.issues);
+  let newCount = 0;
+  let regressedCount = 0;
+  let existingCount = 0;
+  const newAndRegressed = [];
+  for (const issue of allIssues) {
+    const { issue: persisted, outcome } = upsertScanIssue(issue, projectId);
+    if (outcome === "new") {
+      newCount++;
+      newAndRegressed.push({ issue, persistedId: persisted.id });
+    } else if (outcome === "regressed") {
+      regressedCount++;
+      newAndRegressed.push({ issue, persistedId: persisted.id });
+    } else
+      existingCount++;
+  }
+  await createTodoTasksForIssues(newAndRegressed, url, projectId);
+  await notifyHealthScan(url, { new: newCount, regressed: regressedCount, existing: existingCount, total: allIssues.length });
+  return {
+    url,
+    scannedAt: new Date().toISOString(),
+    durationMs: Date.now() - start,
+    totalIssues: allIssues.length,
+    newIssues: newCount,
+    regressedIssues: regressedCount,
+    existingIssues: existingCount,
+    results
+  };
+}
+async function createTodoTasksForIssues(items, url, _projectId) {
+  const todosProjectId = process.env["TESTERS_TODOS_PROJECT_ID"];
+  if (!todosProjectId || items.length === 0)
+    return;
+  let db2 = null;
+  try {
+    db2 = connectToTodos();
+  } catch {
+    return;
+  }
+  try {
+    for (const { issue, persistedId } of items) {
+      const title = `BUG: [scan] ${issue.type.replace(/_/g, " ")}: ${issue.message.slice(0, 80)}`;
+      const id = crypto.randomUUID();
+      const now2 = new Date().toISOString();
+      const description = [
+        `Health scan detected a ${issue.type.replace(/_/g, " ")} issue.`,
+        ``,
+        `**URL:** ${url}`,
+        `**Page:** ${issue.pageUrl}`,
+        `**Severity:** ${issue.severity}`,
+        `**Message:** ${issue.message}`,
+        issue.detail ? `**Detail:**
+\`\`\`json
+${JSON.stringify(issue.detail, null, 2)}
+\`\`\`` : null
+      ].filter(Boolean).join(`
+`);
+      try {
+        db2.query(`
+          INSERT INTO tasks (id, short_id, title, description, status, priority, tags, project_id, version, created_at, updated_at)
+          VALUES (?, ?, ?, ?, 'pending', ?, ?, ?, 1, ?, ?)
+        `).run(id, `SCAN-${id.slice(0, 6)}`, title, description, issue.severity, JSON.stringify(["bug", "scan", issue.type, "auto-created"]), todosProjectId, now2, now2);
+        setScanIssueTodoTaskId(persistedId, id);
+      } catch {}
+    }
+  } finally {
+    db2.close();
+  }
+}
+async function notifyHealthScan(url, counts) {
+  const baseUrl = process.env["TESTERS_CONVERSATIONS_URL"];
+  const space = process.env["TESTERS_CONVERSATIONS_SPACE"];
+  if (!baseUrl || !space)
+    return;
+  if (counts.new === 0 && counts.regressed === 0)
+    return;
+  const icon = counts.new + counts.regressed > 0 ? "\uD83D\uDEA8" : "\u2705";
+  const message = [
+    `${icon} **Health scan** \u2014 ${url}`,
+    ``,
+    `**New issues:** ${counts.new}`,
+    `**Regressed:** ${counts.regressed}`,
+    `**Known (skipped):** ${counts.existing}`,
+    `**Total found:** ${counts.total}`
+  ].join(`
+`);
+  try {
+    await fetch(`${baseUrl.replace(/\/$/, "")}/api/spaces/${encodeURIComponent(space)}/messages`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content: message, from: "testers-health-scan" })
+    });
+  } catch {}
+}
+var init_health_scan = __esm(() => {
+  init_console();
+  init_network();
+  init_links();
+  init_performance();
+  init_scan_issues();
+  init_todos_connector();
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -5764,7 +6427,7 @@ import chalk6 from "chalk";
 // package.json
 var package_default = {
   name: "@hasna/testers",
-  version: "0.0.13",
+  version: "0.0.14",
   description: "AI-powered QA testing CLI \u2014 spawns cheap AI agents to test web apps with headless browsers",
   type: "module",
   main: "dist/index.js",
@@ -9431,6 +10094,165 @@ agentCmd.command("list").description("List all registered agents").action(() =>
     process.exit(1);
   }
 });
+var scanCmd = program2.command("scan").description("Scan a running app for runtime issues");
+var SCAN_COMMON_OPTIONS = (cmd) => cmd.option("--project <id>", "Project ID for issue tracking").option("--headed", "Run browser in headed mode", false).option("--timeout <ms>", "Navigation timeout per page in ms", "15000").option("--json", "Output results as JSON", false);
+SCAN_COMMON_OPTIONS(scanCmd.command("console <url>").description("Collect JS/React console errors and uncaught exceptions").option("-p, --page <path>", "Page path to visit (repeatable)", (v, acc) => {
+  acc.push(v);
+  return acc;
+}, [])).action(async (url, opts) => {
+  try {
+    const { scanConsoleErrors: scanConsoleErrors2 } = await Promise.resolve().then(() => (init_console(), exports_console));
+    const { upsertScanIssue: upsertScanIssue2 } = await Promise.resolve().then(() => (init_scan_issues(), exports_scan_issues));
+    const result = await scanConsoleErrors2({ url, pages: opts.page, headed: opts.headed, timeoutMs: parseInt(opts.timeout) });
+    result.issues.forEach((i) => upsertScanIssue2(i, opts.project));
+    printScanResult(result, opts.json);
+  } catch (e) {
+    logError(chalk6.red(e instanceof Error ? e.message : String(e)));
+    process.exit(1);
+  }
+});
+SCAN_COMMON_OPTIONS(scanCmd.command("network <url>").description("Detect failed API calls, 5xx, 404s, CORS errors").option("-p, --page <path>", "Page path to visit (repeatable)", (v, acc) => {
+  acc.push(v);
+  return acc;
+}, [])).action(async (url, opts) => {
+  try {
+    const { scanNetworkErrors: scanNetworkErrors2 } = await Promise.resolve().then(() => (init_network(), exports_network));
+    const { upsertScanIssue: upsertScanIssue2 } = await Promise.resolve().then(() => (init_scan_issues(), exports_scan_issues));
+    const result = await scanNetworkErrors2({ url, pages: opts.page, headed: opts.headed, timeoutMs: parseInt(opts.timeout) });
+    result.issues.forEach((i) => upsertScanIssue2(i, opts.project));
+    printScanResult(result, opts.json);
+  } catch (e) {
+    logError(chalk6.red(e instanceof Error ? e.message : String(e)));
+    process.exit(1);
+  }
+});
+SCAN_COMMON_OPTIONS(scanCmd.command("links <url>").description("Crawl app and find broken links / 404s").option("--max-pages <n>", "Max pages to crawl", "30")).action(async (url, opts) => {
+  try {
+    const { scanBrokenLinks: scanBrokenLinks2 } = await Promise.resolve().then(() => (init_links(), exports_links));
+    const { upsertScanIssue: upsertScanIssue2 } = await Promise.resolve().then(() => (init_scan_issues(), exports_scan_issues));
+    const result = await scanBrokenLinks2({ url, maxPages: parseInt(opts.maxPages), headed: opts.headed, timeoutMs: parseInt(opts.timeout) });
+    result.issues.forEach((i) => upsertScanIssue2(i, opts.project));
+    printScanResult(result, opts.json);
+  } catch (e) {
+    logError(chalk6.red(e instanceof Error ? e.message : String(e)));
+    process.exit(1);
+  }
+});
+SCAN_COMMON_OPTIONS(scanCmd.command("perf <url>").description("Measure page load time, LCP, DOMContentLoaded").option("-p, --page <path>", "Page path to visit (repeatable)", (v, acc) => {
+  acc.push(v);
+  return acc;
+}, []).option("--lcp-threshold <ms>", "LCP threshold in ms (default 2500)", "2500").option("--load-threshold <ms>", "Load time threshold in ms (default 5000)", "5000")).action(async (url, opts) => {
+  try {
+    const { scanPerformance: scanPerformance2 } = await Promise.resolve().then(() => (init_performance(), exports_performance));
+    const { upsertScanIssue: upsertScanIssue2 } = await Promise.resolve().then(() => (init_scan_issues(), exports_scan_issues));
+    const result = await scanPerformance2({
+      url,
+      pages: opts.page,
+      headed: opts.headed,
+      timeoutMs: parseInt(opts.timeout),
+      thresholds: { lcpMs: parseInt(opts.lcpThreshold), loadTimeMs: parseInt(opts.loadThreshold) }
+    });
+    result.issues.forEach((i) => upsertScanIssue2(i, opts.project));
+    printScanResult(result, opts.json);
+  } catch (e) {
+    logError(chalk6.red(e instanceof Error ? e.message : String(e)));
+    process.exit(1);
+  }
+});
+SCAN_COMMON_OPTIONS(scanCmd.command("all <url>").description("Run all scanners: console, network, links, performance").option("-p, --page <path>", "Page path to visit (repeatable)", (v, acc) => {
+  acc.push(v);
+  return acc;
+}, []).option("--max-pages <n>", "Max pages for link crawl", "20").option("--skip <scanner>", "Skip a scanner: console|network|links|perf (repeatable)", (v, acc) => {
+  acc.push(v);
+  return acc;
+}, [])).action(async (url, opts) => {
+  try {
+    const { runHealthScan: runHealthScan2 } = await Promise.resolve().then(() => (init_health_scan(), exports_health_scan));
+    const skip = new Set(opts.skip);
+    const scanners = ["console", "network", "links", "performance"].filter((s) => !skip.has(s) && !skip.has(s === "performance" ? "perf" : s));
+    log(chalk6.bold(`  Health scan: ${url}`));
+    log(chalk6.dim(`  Scanners: ${scanners.join(", ")}`));
+    log("");
+    const summary = await runHealthScan2({
+      url,
+      pages: opts.page,
+      projectId: opts.project,
+      scanners,
+      maxPages: parseInt(opts.maxPages),
+      headed: opts.headed,
+      timeoutMs: parseInt(opts.timeout)
+    });
+    if (opts.json) {
+      log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    log(chalk6.bold("  Results"));
+    log(chalk6.dim(`  ${"\u2500".repeat(50)}`));
+    log(`  Total issues:    ${chalk6.bold(String(summary.totalIssues))}`);
+    log(`  New issues:      ${summary.newIssues > 0 ? chalk6.red(String(summary.newIssues)) : chalk6.green("0")}`);
+    log(`  Regressed:       ${summary.regressedIssues > 0 ? chalk6.yellow(String(summary.regressedIssues)) : chalk6.green("0")}`);
+    log(`  Known (skipped): ${chalk6.dim(String(summary.existingIssues))}`);
+    log(`  Duration:        ${(summary.durationMs / 1000).toFixed(1)}s`);
+    log("");
+    for (const result of summary.results) {
+      if (result.issues.length > 0)
+        printScanResult(result, false);
+    }
+    if (summary.newIssues + summary.regressedIssues > 0)
+      process.exit(1);
+  } catch (e) {
+    logError(chalk6.red(e instanceof Error ? e.message : String(e)));
+    process.exit(1);
+  }
+});
+scanCmd.command("issues").description("List tracked scan issues").option("--status <status>", "Filter by status: open|resolved|regressed").option("--type <type>", "Filter by type: console_error|network_error|broken_link|performance").option("--project <id>", "Filter by project ID").option("--limit <n>", "Max results", "50").action((opts) => {
+  try {
+    const { listScanIssues: listScanIssues2 } = (init_scan_issues(), __toCommonJS(exports_scan_issues));
+    const issues = listScanIssues2({ status: opts.status, type: opts.type, projectId: opts.project, limit: parseInt(opts.limit) });
+    if (issues.length === 0) {
+      log(chalk6.dim("No scan issues found."));
+      return;
+    }
+    for (const i of issues) {
+      const statusColor = i.status === "open" ? chalk6.red : i.status === "regressed" ? chalk6.yellow : chalk6.green;
+      log(`  ${statusColor(i.status.padEnd(10))} ${chalk6.cyan(i.type.padEnd(16))} ${chalk6.bold(i.severity.padEnd(8))} ${i.message.slice(0, 60)} ${chalk6.dim(i.pageUrl)}`);
+    }
+  } catch (e) {
+    logError(chalk6.red(e instanceof Error ? e.message : String(e)));
+    process.exit(1);
+  }
+});
+scanCmd.command("resolve <id>").description("Mark a scan issue as resolved").action((id) => {
+  try {
+    const { resolveScanIssue: resolveScanIssue2 } = (init_scan_issues(), __toCommonJS(exports_scan_issues));
+    const ok = resolveScanIssue2(id);
+    if (!ok) {
+      logError(chalk6.red(`Scan issue not found: ${id}`));
+      process.exit(1);
+    }
+    log(chalk6.green(`Resolved scan issue: ${id}`));
+  } catch (e) {
+    logError(chalk6.red(e instanceof Error ? e.message : String(e)));
+    process.exit(1);
+  }
+});
+function printScanResult(result, asJson) {
+  if (asJson) {
+    log(JSON.stringify(result, null, 2));
+    return;
+  }
+  log(chalk6.bold(`  ${result.url}`) + chalk6.dim(` \u2014 ${result.pages.length} page(s) scanned in ${(result.durationMs / 1000).toFixed(1)}s`));
+  if (result.issues.length === 0) {
+    log(chalk6.green("  \u2713 No issues found"));
+  } else {
+    for (const issue of result.issues) {
+      const sev = issue.severity === "critical" ? chalk6.bgRed.white(` ${issue.severity} `) : issue.severity === "high" ? chalk6.red(issue.severity) : issue.severity === "medium" ? chalk6.yellow(issue.severity) : chalk6.dim(issue.severity);
+      log(`  ${sev}  ${issue.message.slice(0, 80)}`);
+      log(chalk6.dim(`          ${issue.pageUrl}`));
+    }
+  }
+  log("");
+}
 program2.command("doctor").description("Check system setup and configuration").action(async () => {
   let allPassed = true;
   const hasApiKey = Boolean(process.env["ANTHROPIC_API_KEY"]);