npm - @sudobility/testomniac_runner - Versions diffs - 0.0.128 - Mend

@sudobility/testomniac_runner 0.0.128

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

package/.dockerignore +75 -0
package/.env.example +67 -0
package/.github/workflows/ci-cd.yml +30 -0
package/.prettierignore +62 -0
package/.prettierrc +11 -0
package/.vscode/settings.json +29 -0
package/CLAUDE.md +170 -0
package/Dockerfile +76 -0
package/README.md +22 -0
package/bun.lock +707 -0
package/docs/superpowers/specs/2026-04-20-smarter-scanner-navigation-design.md +121 -0
package/eslint.config.js +80 -0
package/package.json +55 -0
package/plans/DATA.md +703 -0
package/plans/POLLING.md +569 -0
package/plans/RUNNER.md +288 -0
package/src/adapters/PuppeteerAdapter.ts +394 -0
package/src/auth/credential-manager.ts +17 -0
package/src/auth/form-identifier.test.ts +136 -0
package/src/auth/form-identifier.ts +54 -0
package/src/auth/login-executor.ts +112 -0
package/src/auth/password-detector.test.ts +61 -0
package/src/auth/password-detector.ts +119 -0
package/src/auth/signic-registrar.ts +186 -0
package/src/browser/chromium.ts +35 -0
package/src/config/index.test.ts +23 -0
package/src/config/index.ts +35 -0
package/src/email/deep-link.test.ts +17 -0
package/src/email/deep-link.ts +23 -0
package/src/email/sender.ts +35 -0
package/src/email/templates.ts +34 -0
package/src/index.test.ts +17 -0
package/src/index.ts +110 -0
package/src/orchestrator.ts +220 -0
package/src/plugins/content/ai-checks.ts +115 -0
package/src/plugins/content/checks.test.ts +49 -0
package/src/plugins/content/checks.ts +141 -0
package/src/plugins/content/index.ts +73 -0
package/src/plugins/registry.test.ts +49 -0
package/src/plugins/registry.ts +21 -0
package/src/plugins/security/header-checks.ts +56 -0
package/src/plugins/security/html-checks.ts +93 -0
package/src/plugins/security/index.ts +58 -0
package/src/plugins/security/network-checks.test.ts +74 -0
package/src/plugins/security/network-checks.ts +136 -0
package/src/plugins/seo/checks.test.ts +70 -0
package/src/plugins/seo/checks.ts +173 -0
package/src/plugins/seo/index.ts +85 -0
package/src/plugins/types.ts +43 -0
package/src/plugins/ui-consistency/comparator.test.ts +108 -0
package/src/plugins/ui-consistency/comparator.ts +58 -0
package/src/plugins/ui-consistency/index.ts +36 -0
package/src/plugins/ui-consistency/style-extractor.ts +79 -0
package/src/runner/executor.test.ts +37 -0
package/src/runner/executor.ts +167 -0
package/src/runner/reporter.ts +19 -0
package/src/runner/worker-pool.ts +106 -0
package/src/runner-manager.ts +163 -0
package/src/scanner/email-checker.ts +106 -0
package/tsconfig.json +21 -0

package/src/plugins/seo/checks.test.ts ADDED Viewed

@@ -0,0 +1,70 @@
+import { describe, it, expect } from "vitest";
+import {
+  checkTitle,
+  checkMetaDescription,
+  checkH1,
+  checkImgAlt,
+  checkViewportMeta,
+} from "./checks";
+const PAGE_URL = "https://example.com";
+describe("SEO checks", () => {
+  it("flags missing title", () => {
+    const html = "<html><head></head><body></body></html>";
+    const issue = checkTitle(html, PAGE_URL);
+    expect(issue).not.toBeNull();
+    expect(issue!.type).toBe("seo-missing-title");
+  });
+  it("passes valid title", () => {
+    const html = "<html><head><title>My Page</title></head></html>";
+    const issue = checkTitle(html, PAGE_URL);
+    expect(issue).toBeNull();
+  });
+  it("flags title too long", () => {
+    const longTitle = "A".repeat(61);
+    const html = `<html><head><title>${longTitle}</title></head></html>`;
+    const issue = checkTitle(html, PAGE_URL);
+    expect(issue).not.toBeNull();
+    expect(issue!.type).toBe("seo-title-too-long");
+  });
+  it("flags missing meta description", () => {
+    const html = "<html><head></head><body></body></html>";
+    const issue = checkMetaDescription(html, PAGE_URL);
+    expect(issue).not.toBeNull();
+    expect(issue!.type).toBe("seo-missing-meta-description");
+  });
+  it("flags missing h1", () => {
+    const html = "<html><body><h2>Hello</h2></body></html>";
+    const issue = checkH1(html, PAGE_URL);
+    expect(issue).not.toBeNull();
+    expect(issue!.type).toBe("seo-missing-h1");
+  });
+  it("flags multiple h1 tags", () => {
+    const html = "<html><body><h1>First</h1><h1>Second</h1></body></html>";
+    const issue = checkH1(html, PAGE_URL);
+    expect(issue).not.toBeNull();
+    expect(issue!.type).toBe("seo-multiple-h1");
+  });
+  it("flags img without alt attribute", () => {
+    const html =
+      '<html><body><img src="photo.jpg"><img src="logo.png" alt="Logo"></body></html>';
+    const issues = checkImgAlt(html, PAGE_URL);
+    expect(issues).toHaveLength(1);
+    expect(issues[0].type).toBe("seo-img-missing-alt");
+    expect(issues[0].details?.src).toBe("photo.jpg");
+  });
+  it("flags missing viewport meta tag", () => {
+    const html = "<html><head></head><body></body></html>";
+    const issue = checkViewportMeta(html, PAGE_URL);
+    expect(issue).not.toBeNull();
+    expect(issue!.type).toBe("seo-missing-viewport");
+  });
+});

package/src/plugins/seo/checks.ts ADDED Viewed

@@ -0,0 +1,173 @@
+import type { PluginIssue } from "../types";
+export function checkTitle(html: string, pageUrl: string): PluginIssue | null {
+  const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  if (!match || !match[1].trim()) {
+    return {
+      type: "seo-missing-title",
+      severity: "warning",
+      description: "Page is missing a <title> tag",
+      pageUrl,
+    };
+  }
+  const title = match[1].trim();
+  if (title.length > 60) {
+    return {
+      type: "seo-title-too-long",
+      severity: "info",
+      description: `Title is too long (${title.length} chars, recommended max 60)`,
+      pageUrl,
+      details: { title, length: title.length },
+    };
+  }
+  return null;
+}
+export function checkMetaDescription(
+  html: string,
+  pageUrl: string
+): PluginIssue | null {
+  const match = html.match(
+    /<meta\s+[^>]*name=["']description["'][^>]*content=["']([^"']*)["'][^>]*\/?>/i
+  );
+  const match2 = html.match(
+    /<meta\s+[^>]*content=["']([^"']*)["'][^>]*name=["']description["'][^>]*\/?>/i
+  );
+  const content = match?.[1] ?? match2?.[1];
+  if (content === undefined) {
+    return {
+      type: "seo-missing-meta-description",
+      severity: "warning",
+      description: "Page is missing a meta description",
+      pageUrl,
+    };
+  }
+  if (content.length > 160) {
+    return {
+      type: "seo-meta-description-too-long",
+      severity: "info",
+      description: `Meta description is too long (${content.length} chars, recommended max 160)`,
+      pageUrl,
+      details: { length: content.length },
+    };
+  }
+  return null;
+}
+export function checkH1(html: string, pageUrl: string): PluginIssue | null {
+  const h1Matches = html.match(/<h1[\s>]/gi);
+  if (!h1Matches || h1Matches.length === 0) {
+    return {
+      type: "seo-missing-h1",
+      severity: "warning",
+      description: "Page is missing an <h1> tag",
+      pageUrl,
+    };
+  }
+  if (h1Matches.length > 1) {
+    return {
+      type: "seo-multiple-h1",
+      severity: "warning",
+      description: `Page has ${h1Matches.length} <h1> tags (recommended: 1)`,
+      pageUrl,
+      details: { count: h1Matches.length },
+    };
+  }
+  return null;
+}
+export function checkImgAlt(html: string, pageUrl: string): PluginIssue[] {
+  const issues: PluginIssue[] = [];
+  const imgRegex = /<img\s[^>]*>/gi;
+  let imgMatch = imgRegex.exec(html);
+  while (imgMatch !== null) {
+    const imgTag = imgMatch[0];
+    const hasAlt = /\balt\s*=\s*["'][^"']*["']/i.test(imgTag);
+    if (!hasAlt) {
+      const srcMatch = imgTag.match(/\bsrc\s*=\s*["']([^"']*)["']/i);
+      issues.push({
+        type: "seo-img-missing-alt",
+        severity: "warning",
+        description: "Image is missing alt attribute",
+        pageUrl,
+        details: { src: srcMatch?.[1] ?? "unknown" },
+      });
+    }
+    imgMatch = imgRegex.exec(html);
+  }
+  return issues;
+}
+export function checkCanonical(
+  html: string,
+  pageUrl: string
+): PluginIssue | null {
+  const hasCanonical = /<link\s[^>]*rel=["']canonical["'][^>]*>/i.test(html);
+  if (!hasCanonical) {
+    return {
+      type: "seo-missing-canonical",
+      severity: "info",
+      description: "Page is missing a canonical link",
+      pageUrl,
+    };
+  }
+  return null;
+}
+export function checkViewportMeta(
+  html: string,
+  pageUrl: string
+): PluginIssue | null {
+  const hasViewport = /<meta\s[^>]*name=["']viewport["'][^>]*>/i.test(html);
+  if (!hasViewport) {
+    return {
+      type: "seo-missing-viewport",
+      severity: "warning",
+      description: "Page is missing a viewport meta tag",
+      pageUrl,
+    };
+  }
+  return null;
+}
+export function checkOpenGraph(html: string, pageUrl: string): PluginIssue[] {
+  const issues: PluginIssue[] = [];
+  const ogTags = ["og:title", "og:description", "og:image"];
+  for (const tag of ogTags) {
+    const regex = new RegExp(
+      `<meta\\s[^>]*property=["']${tag}["'][^>]*/?>`,
+      "i"
+    );
+    if (!regex.test(html)) {
+      issues.push({
+        type: `seo-missing-${tag.replace(":", "-")}`,
+        severity: "info",
+        description: `Page is missing Open Graph ${tag} meta tag`,
+        pageUrl,
+      });
+    }
+  }
+  return issues;
+}
+export function checkStructuredData(
+  html: string,
+  pageUrl: string
+): PluginIssue | null {
+  const hasJsonLd =
+    /<script\s[^>]*type=["']application\/ld\+json["'][^>]*>/i.test(html);
+  if (!hasJsonLd) {
+    return {
+      type: "seo-missing-structured-data",
+      severity: "info",
+      description: "Page is missing JSON-LD structured data",
+      pageUrl,
+    };
+  }
+  return null;
+}

package/src/plugins/seo/index.ts ADDED Viewed

@@ -0,0 +1,85 @@
+import type { Plugin, PluginContext, PluginIssue } from "../types";
+import { registerPlugin } from "../registry";
+import {
+  checkTitle,
+  checkMetaDescription,
+  checkH1,
+  checkImgAlt,
+  checkCanonical,
+  checkViewportMeta,
+  checkOpenGraph,
+  checkStructuredData,
+} from "./checks";
+export const seoPlugin: Plugin = {
+  name: "seo",
+  description:
+    "Checks pages for SEO best practices including titles, meta descriptions, headings, images, and structured data",
+  async analyze(context: PluginContext): Promise<{
+    issues: PluginIssue[];
+    metadata?: Record<string, unknown>;
+  }> {
+    const issues: PluginIssue[] = [];
+    const titles: Map<string, string[]> = new Map();
+    for (const pageState of context.pageStates) {
+      const { html, url } = pageState;
+      // Title check + collect for duplicate detection
+      const titleIssue = checkTitle(html, url);
+      if (titleIssue) {
+        issues.push(titleIssue);
+      } else {
+        const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+        if (titleMatch) {
+          const title = titleMatch[1].trim();
+          const urls = titles.get(title) ?? [];
+          urls.push(url);
+          titles.set(title, urls);
+        }
+      }
+      const metaIssue = checkMetaDescription(html, url);
+      if (metaIssue) issues.push(metaIssue);
+      const h1Issue = checkH1(html, url);
+      if (h1Issue) issues.push(h1Issue);
+      const imgIssues = checkImgAlt(html, url);
+      issues.push(...imgIssues);
+      const canonicalIssue = checkCanonical(html, url);
+      if (canonicalIssue) issues.push(canonicalIssue);
+      const viewportIssue = checkViewportMeta(html, url);
+      if (viewportIssue) issues.push(viewportIssue);
+      const ogIssues = checkOpenGraph(html, url);
+      issues.push(...ogIssues);
+      const structuredDataIssue = checkStructuredData(html, url);
+      if (structuredDataIssue) issues.push(structuredDataIssue);
+    }
+    // Duplicate title detection across pages
+    for (const [title, urls] of titles.entries()) {
+      if (urls.length > 1) {
+        issues.push({
+          type: "seo-duplicate-title",
+          severity: "warning",
+          description: `Duplicate title "${title}" found on ${urls.length} pages`,
+          pageUrl: urls[0],
+          details: { title, urls },
+        });
+      }
+    }
+    return {
+      issues,
+      metadata: { pagesAnalyzed: context.pageStates.length },
+    };
+  },
+};
+registerPlugin(seoPlugin);

package/src/plugins/types.ts ADDED Viewed

@@ -0,0 +1,43 @@
+import type { Page } from "puppeteer-core";
+import type { OpenAI } from "openai";
+import type { NetworkLogEntry, FormInfo } from "@sudobility/testomniac_types";
+export interface PluginContext {
+  runnerId: number;
+  runId: number;
+  baseUrl: string;
+  pages: { id: number; url: string }[];
+  pageStates: {
+    id: number;
+    pageId: number;
+    html: string;
+    text: string;
+    url: string;
+    headers: Record<string, string>;
+  }[];
+  networkLogs: NetworkLogEntry[];
+  forms: FormInfo[];
+  openai?: OpenAI;
+  browser: Page;
+}
+export interface PluginIssue {
+  type: string;
+  severity: "error" | "warning" | "info";
+  description: string;
+  pageUrl: string;
+  pageId?: number;
+  pageStateId?: number;
+  details?: Record<string, unknown>;
+}
+export interface PluginResult {
+  issues: PluginIssue[];
+  metadata?: Record<string, unknown>;
+}
+export interface Plugin {
+  name: string;
+  description: string;
+  analyze(context: PluginContext): Promise<PluginResult>;
+}

package/src/plugins/ui-consistency/comparator.test.ts ADDED Viewed

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+import { findStyleDeviations } from "./comparator";
+describe("UI consistency comparator", () => {
+  it("detects font inconsistency across pages", () => {
+    const styles = [
+      {
+        pageUrl: "/home",
+        category: "headings",
+        tag: "h1",
+        styles: {
+          fontFamily: "Arial",
+          fontSize: "32px",
+          fontWeight: "700",
+          color: "#000",
+        },
+      },
+      {
+        pageUrl: "/about",
+        category: "headings",
+        tag: "h1",
+        styles: {
+          fontFamily: "Arial",
+          fontSize: "32px",
+          fontWeight: "700",
+          color: "#000",
+        },
+      },
+      {
+        pageUrl: "/contact",
+        category: "headings",
+        tag: "h1",
+        styles: {
+          fontFamily: "Helvetica",
+          fontSize: "28px",
+          fontWeight: "700",
+          color: "#000",
+        },
+      },
+    ];
+    const deviations = findStyleDeviations(styles);
+    expect(deviations.length).toBeGreaterThan(0);
+    expect(deviations[0].pageUrl).toBe("/contact");
+    expect(deviations[0].details!.property).toBeDefined();
+  });
+  it("reports no deviations when consistent", () => {
+    const styles = [
+      {
+        pageUrl: "/home",
+        category: "buttons",
+        tag: "button",
+        styles: { backgroundColor: "#2563EB", fontSize: "14px" },
+      },
+      {
+        pageUrl: "/about",
+        category: "buttons",
+        tag: "button",
+        styles: { backgroundColor: "#2563EB", fontSize: "14px" },
+      },
+    ];
+    const deviations = findStyleDeviations(styles);
+    expect(deviations).toHaveLength(0);
+  });
+  it("detects button color inconsistency", () => {
+    const styles = [
+      {
+        pageUrl: "/home",
+        category: "buttons",
+        tag: "button",
+        styles: {
+          backgroundColor: "#2563EB",
+          fontSize: "14px",
+          borderRadius: "4px",
+          padding: "8px 16px",
+        },
+      },
+      {
+        pageUrl: "/about",
+        category: "buttons",
+        tag: "button",
+        styles: {
+          backgroundColor: "#2563EB",
+          fontSize: "14px",
+          borderRadius: "4px",
+          padding: "8px 16px",
+        },
+      },
+      {
+        pageUrl: "/checkout",
+        category: "buttons",
+        tag: "button",
+        styles: {
+          backgroundColor: "#FF0000",
+          fontSize: "14px",
+          borderRadius: "4px",
+          padding: "8px 16px",
+        },
+      },
+    ];
+    const deviations = findStyleDeviations(styles);
+    expect(deviations.length).toBeGreaterThan(0);
+    expect(
+      deviations.some(d => d.details!.property === "backgroundColor")
+    ).toBe(true);
+  });
+});

package/src/plugins/ui-consistency/comparator.ts ADDED Viewed

@@ -0,0 +1,58 @@
+import type { PluginIssue } from "../types";
+import type { ExtractedStyle } from "./style-extractor";
+export function findStyleDeviations(
+  allStyles: ExtractedStyle[]
+): PluginIssue[] {
+  const issues: PluginIssue[] = [];
+  const groups = new Map<string, ExtractedStyle[]>();
+  for (const s of allStyles) {
+    const key = `${s.category}:${s.tag}`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key)!.push(s);
+  }
+  for (const [key, entries] of groups) {
+    if (entries.length < 2) continue;
+    const propNames = Object.keys(entries[0].styles);
+    for (const prop of propNames) {
+      const valueCounts = new Map<string, string[]>();
+      for (const entry of entries) {
+        const val = entry.styles[prop] || "";
+        if (!valueCounts.has(val)) valueCounts.set(val, []);
+        valueCounts.get(val)!.push(entry.pageUrl);
+      }
+      if (valueCounts.size <= 1) continue;
+      let majorityValue = "";
+      let majorityCount = 0;
+      for (const [val, pages] of valueCounts) {
+        if (pages.length > majorityCount) {
+          majorityCount = pages.length;
+          majorityValue = val;
+        }
+      }
+      for (const [val, pages] of valueCounts) {
+        if (val === majorityValue) continue;
+        for (const pageUrl of pages) {
+          const [category, tag] = key.split(":");
+          issues.push({
+            type: `ui_inconsistent_${category}`,
+            severity: "warning",
+            description: `${tag} on ${pageUrl} uses ${prop}: ${val}, but ${majorityCount}/${entries.length} pages use ${majorityValue}`,
+            pageUrl,
+            details: {
+              property: prop,
+              actual: val,
+              expected: majorityValue,
+              category,
+              tag,
+            },
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}

package/src/plugins/ui-consistency/index.ts ADDED Viewed

@@ -0,0 +1,36 @@
+import type { Plugin, PluginContext, PluginResult } from "../types";
+import { registerPlugin } from "../registry";
+import { extractStyles, type ExtractedStyle } from "./style-extractor";
+import { findStyleDeviations } from "./comparator";
+const uiConsistencyPlugin: Plugin = {
+  name: "ui-consistency",
+  description:
+    "Detects visual style inconsistencies across pages (fonts, colors, spacing)",
+  async analyze(context: PluginContext): Promise<PluginResult> {
+    const allStyles: ExtractedStyle[] = [];
+    for (const pageState of context.pageStates) {
+      await context.browser.goto(pageState.url, {
+        waitUntil: "domcontentloaded",
+      });
+      const styles = await extractStyles(context.browser, pageState.url);
+      allStyles.push(...styles);
+    }
+    const issues = findStyleDeviations(allStyles);
+    return {
+      issues,
+      metadata: {
+        totalElementsChecked: allStyles.length,
+        pagesAnalyzed: context.pageStates.length,
+      },
+    };
+  },
+};
+registerPlugin(uiConsistencyPlugin);
+export { uiConsistencyPlugin };

package/src/plugins/ui-consistency/style-extractor.ts ADDED Viewed

@@ -0,0 +1,79 @@
+import type { Page } from "puppeteer-core";
+export interface ExtractedStyle {
+  pageUrl: string;
+  category: string;
+  tag: string;
+  styles: Record<string, string>;
+}
+const STYLE_TARGETS: Record<string, { selectors: string[]; props: string[] }> =
+  {
+    headings: {
+      selectors: ["h1", "h2", "h3"],
+      props: ["fontFamily", "fontSize", "fontWeight", "color", "lineHeight"],
+    },
+    bodyText: {
+      selectors: ["p", "li"],
+      props: ["fontFamily", "fontSize", "color", "lineHeight"],
+    },
+    buttons: {
+      selectors: ["button", '[role="button"]', 'input[type="submit"]'],
+      props: [
+        "fontFamily",
+        "fontSize",
+        "fontWeight",
+        "color",
+        "backgroundColor",
+        "borderRadius",
+        "padding",
+        "height",
+      ],
+    },
+    links: {
+      selectors: ["a"],
+      props: ["fontFamily", "fontSize", "color", "textDecoration"],
+    },
+    inputs: {
+      selectors: ['input[type="text"]', 'input[type="email"]', "textarea"],
+      props: [
+        "fontFamily",
+        "fontSize",
+        "borderColor",
+        "borderRadius",
+        "padding",
+        "height",
+      ],
+    },
+  };
+export async function extractStyles(
+  page: Page,
+  pageUrl: string
+): Promise<ExtractedStyle[]> {
+  const results: ExtractedStyle[] = [];
+  for (const [category, config] of Object.entries(STYLE_TARGETS)) {
+    for (const selector of config.selectors) {
+      const styles = await page.evaluate(
+        (sel: string, props: string[]) => {
+          const el = document.querySelector(sel);
+          if (!el) return null;
+          const computed = window.getComputedStyle(el);
+          const result: Record<string, string> = {};
+          for (const prop of props) {
+            result[prop] = computed.getPropertyValue(
+              prop.replace(/([A-Z])/g, "-$1").toLowerCase()
+            );
+          }
+          return result;
+        },
+        selector,
+        config.props
+      );
+      if (styles) {
+        results.push({ pageUrl, category, tag: selector, styles });
+      }
+    }
+  }
+  return results;
+}

package/src/runner/executor.test.ts ADDED Viewed

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { mapActionToPuppeteer } from "./executor";
+describe("executor", () => {
+  it("maps navigate action", () => {
+    const mapped = mapActionToPuppeteer({
+      action: "navigate",
+      url: "https://example.com",
+    });
+    expect(mapped.method).toBe("goto");
+    expect(mapped.args).toEqual([
+      "https://example.com",
+      { waitUntil: "networkidle0" },
+    ]);
+  });
+  it("maps click action", () => {
+    const mapped = mapActionToPuppeteer({ action: "click", selector: "#btn" });
+    expect(mapped.method).toBe("click");
+    expect(mapped.selector).toBe("#btn");
+  });
+  it("maps assertVisible action", () => {
+    const mapped = mapActionToPuppeteer({
+      action: "assertVisible",
+      selector: ".header",
+    });
+    expect(mapped.method).toBe("waitForSelector");
+    expect(mapped.selector).toBe(".header");
+    expect(mapped.args).toEqual([".header", { visible: true, timeout: 5000 }]);
+  });
+  it("maps step as noop", () => {
+    const mapped = mapActionToPuppeteer({ action: "step", label: "Step 1" });
+    expect(mapped.method).toBe("noop");
+  });
+});