@sudobility/testomniac_runner 0.0.128

package/src/auth/form-identifier.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect } from "vitest";
+import { identifyFormType } from "./form-identifier";
+import type { FormInfo } from "@sudobility/testomniac_types";
+
+describe("form-identifier", () => {
+  it("identifies login form by field pattern", () => {
+    const form: FormInfo = {
+      selector: "form",
+      action: "/login",
+      method: "POST",
+      fieldCount: 2,
+      fields: [
+        {
+          selector: "#email",
+          name: "email",
+          type: "email",
+          label: "Email",
+          required: true,
+        },
+        {
+          selector: "#pass",
+          name: "password",
+          type: "password",
+          label: "Password",
+          required: true,
+        },
+      ],
+      submitSelector: 'button[type="submit"]',
+    };
+    expect(identifyFormType(form, "https://example.com/login")).toBe("login");
+  });
+
+  it("identifies signup form by field pattern", () => {
+    const form: FormInfo = {
+      selector: "form",
+      action: "/register",
+      method: "POST",
+      fieldCount: 4,
+      fields: [
+        {
+          selector: "#name",
+          name: "name",
+          type: "text",
+          label: "Name",
+          required: true,
+        },
+        {
+          selector: "#email",
+          name: "email",
+          type: "email",
+          label: "Email",
+          required: true,
+        },
+        {
+          selector: "#pass",
+          name: "password",
+          type: "password",
+          label: "Password",
+          required: true,
+        },
+        {
+          selector: "#confirm",
+          name: "confirm",
+          type: "password",
+          label: "Confirm Password",
+          required: true,
+        },
+      ],
+      submitSelector: 'button[type="submit"]',
+    };
+    expect(identifyFormType(form, "https://example.com/register")).toBe(
+      "signup"
+    );
+  });
+
+  it("identifies login form by URL", () => {
+    const form: FormInfo = {
+      selector: "form",
+      action: "",
+      method: "POST",
+      fieldCount: 2,
+      fields: [
+        {
+          selector: "#user",
+          name: "user",
+          type: "text",
+          label: "User",
+          required: true,
+        },
+        {
+          selector: "#pass",
+          name: "pass",
+          type: "password",
+          label: "Pass",
+          required: true,
+        },
+      ],
+      submitSelector: "button",
+    };
+    expect(identifyFormType(form, "https://example.com/signin")).toBe("login");
+  });
+
+  it("identifies other forms", () => {
+    const form: FormInfo = {
+      selector: "form",
+      action: "/contact",
+      method: "POST",
+      fieldCount: 3,
+      fields: [
+        {
+          selector: "#name",
+          name: "name",
+          type: "text",
+          label: "Name",
+          required: true,
+        },
+        {
+          selector: "#email",
+          name: "email",
+          type: "email",
+          label: "Email",
+          required: true,
+        },
+        {
+          selector: "#msg",
+          name: "message",
+          type: "textarea",
+          label: "Message",
+          required: true,
+        },
+      ],
+      submitSelector: "button",
+    };
+    expect(identifyFormType(form, "https://example.com/contact")).toBe("other");
+  });
+});

package/src/auth/form-identifier.ts

@@ -0,0 +1,54 @@
+import {
+  AUTH_URL_PATTERNS,
+  SIGNUP_URL_PATTERNS,
+} from "@sudobility/testomniac_runner_service";
+import type { FormInfo } from "@sudobility/testomniac_types";
+
+export type FormType = "login" | "signup" | "other";
+
+export function identifyFormType(form: FormInfo, pageUrl: string): FormType {
+  const url = pageUrl.toLowerCase();
+  const fields = form.fields;
+
+  const isLoginUrl = AUTH_URL_PATTERNS.some(p => url.includes(p));
+  const isSignupUrl = SIGNUP_URL_PATTERNS.some(p => url.includes(p));
+
+  const hasPassword = fields.some(f => f.type === "password");
+  const hasEmail = fields.some(
+    f =>
+      f.type === "email" ||
+      f.name === "email" ||
+      f.label.toLowerCase().includes("email")
+  );
+  const hasUsername = fields.some(
+    f => f.name === "username" || f.label.toLowerCase().includes("username")
+  );
+  const hasName = fields.some(f => {
+    const n = (f.name + " " + f.label).toLowerCase();
+    return (
+      n.includes("name") && !n.includes("username") && !n.includes("email")
+    );
+  });
+  const hasMessage = fields.some(f => {
+    const n = (f.name + " " + f.label).toLowerCase();
+    return n.includes("message") || n.includes("subject");
+  });
+  const hasConfirmPassword =
+    fields.filter(f => f.type === "password").length >= 2;
+
+  if (hasMessage) return "other";
+  if (!hasPassword) return "other";
+
+  if (hasPassword && (hasEmail || hasUsername)) {
+    if (hasConfirmPassword || hasName || isSignupUrl) return "signup";
+    if (isLoginUrl) return "login";
+    if (fields.length <= 2) return "login";
+    if (hasName) return "signup";
+    return "login";
+  }
+
+  if (isSignupUrl) return "signup";
+  if (isLoginUrl) return "login";
+
+  return "other";
+}

package/src/auth/login-executor.ts

@@ -0,0 +1,112 @@
+import type { Page } from "puppeteer-core";
+import pino from "pino";
+import type { Credentials, FormInfo } from "@sudobility/testomniac_types";
+
+const logger = pino({ name: "login-executor" });
+
+export async function executeLogin(
+  page: Page,
+  form: FormInfo,
+  credentials: Credentials
+): Promise<boolean> {
+  logger.info({ url: page.url() }, "executing login");
+
+  const emailField = form.fields.find(
+    f =>
+      f.type === "email" ||
+      f.name === "email" ||
+      f.label.toLowerCase().includes("email") ||
+      f.name === "username" ||
+      f.label.toLowerCase().includes("username")
+  );
+  if (emailField) {
+    const value = credentials.email || credentials.username || "";
+    const el = await page.waitForSelector(emailField.selector, {
+      timeout: 5000,
+    });
+    if (el) {
+      await el.click({ clickCount: 3 });
+      await el.type(value);
+    }
+  }
+
+  const passwordField = form.fields.find(f => f.type === "password");
+  if (passwordField) {
+    const el = await page.waitForSelector(passwordField.selector, {
+      timeout: 5000,
+    });
+    if (el) {
+      await el.click({ clickCount: 3 });
+      await el.type(credentials.password);
+    }
+  }
+
+  if (form.submitSelector) {
+    const btn = await page.waitForSelector(form.submitSelector, {
+      timeout: 5000,
+    });
+    if (btn) await btn.click();
+  } else {
+    await page.keyboard.press("Enter");
+  }
+
+  try {
+    await page.waitForNavigation({
+      waitUntil: "networkidle0",
+      timeout: 10_000,
+    });
+  } catch (err) {
+    logger.debug({ err }, "navigation timeout after login submit — may be SPA");
+  }
+
+  if (credentials.twoFactorCode) {
+    const tfaSelectors = [
+      'input[name*="code"]',
+      'input[name*="otp"]',
+      'input[name*="2fa"]',
+      'input[name*="verification"]',
+      'input[name*="authenticator"]',
+      'input[placeholder*="code"]',
+      'input[placeholder*="verification"]',
+    ];
+    for (const sel of tfaSelectors) {
+      try {
+        const el = await page.waitForSelector(sel, {
+          timeout: 3000,
+          visible: true,
+        });
+        if (el) {
+          await el.type(credentials.twoFactorCode);
+          await page.keyboard.press("Enter");
+          try {
+            await page.waitForNavigation({
+              waitUntil: "networkidle0",
+              timeout: 10_000,
+            });
+          } catch (err) {
+            logger.debug({ err }, "navigation timeout during 2FA submission");
+          }
+          break;
+        }
+      } catch (err) {
+        logger.debug({ err, selector: sel }, "2FA field selector not found");
+        continue;
+      }
+    }
+  }
+
+  const currentUrl = page.url().toLowerCase();
+  const stillOnLogin = ["/login", "/signin", "/sign-in", "/auth"].some(p =>
+    currentUrl.includes(p)
+  );
+  if (stillOnLogin) {
+    logger.warn(
+      { url: currentUrl },
+      "login may have failed — still on auth page"
+    );
+    return false;
+  }
+
+  logger.info({ url: page.url() }, "login succeeded");
+  return true;
+}

package/src/auth/password-detector.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "vitest";
+import {
+  detectPasswordRequirements,
+  generatePasswordTestInteractions,
+} from "./password-detector";
+
+describe("password-detector", () => {
+  it("detects minimum length", () => {
+    const reqs = detectPasswordRequirements(
+      "Password must be at least 8 characters"
+    );
+    expect(reqs.minLength).toBe(8);
+  });
+
+  it("detects uppercase requirement", () => {
+    const reqs = detectPasswordRequirements("Must contain an uppercase letter");
+    expect(reqs.requiresUppercase).toBe(true);
+  });
+
+  it("detects multiple requirements", () => {
+    const text =
+      "Password must be at least 10 characters, contain uppercase, lowercase, a number, and a special character. No spaces allowed.";
+    const reqs = detectPasswordRequirements(text);
+    expect(reqs.minLength).toBe(10);
+    expect(reqs.requiresUppercase).toBe(true);
+    expect(reqs.requiresLowercase).toBe(true);
+    expect(reqs.requiresNumber).toBe(true);
+    expect(reqs.requiresSpecial).toBe(true);
+    expect(reqs.noSpaces).toBe(true);
+  });
+
+  it("returns defaults when no requirements detected", () => {
+    const reqs = detectPasswordRequirements("Create your account");
+    expect(reqs.minLength).toBeUndefined();
+    expect(reqs.requiresUppercase).toBe(false);
+  });
+
+  it("generates fail cases before pass case", () => {
+    const reqs = detectPasswordRequirements(
+      "At least 8 characters, must include uppercase and a number"
+    );
+    const cases = generatePasswordTestInteractions(reqs);
+    const failCases = cases.filter(c => c.shouldFail);
+    const passCases = cases.filter(c => !c.shouldFail);
+    expect(failCases.length).toBeGreaterThanOrEqual(2);
+    expect(passCases.length).toBe(1);
+    const firstPassIndex = cases.findIndex(c => !c.shouldFail);
+    const lastFailIndex =
+      cases.length - 1 - [...cases].reverse().findIndex(c => c.shouldFail);
+    expect(firstPassIndex).toBeGreaterThan(lastFailIndex);
+  });
+
+  it("generates too-short password", () => {
+    const reqs = detectPasswordRequirements("At least 8 characters");
+    const cases = generatePasswordTestInteractions(reqs);
+    const tooShort = cases.find(c => c.description.includes("too short"));
+    expect(tooShort).toBeDefined();
+    expect(tooShort!.password.length).toBeLessThan(8);
+    expect(tooShort!.shouldFail).toBe(true);
+  });
+});

package/src/auth/password-detector.ts

@@ -0,0 +1,119 @@
+export interface PasswordRequirements {
+  minLength?: number;
+  requiresUppercase: boolean;
+  requiresLowercase: boolean;
+  requiresNumber: boolean;
+  requiresSpecial: boolean;
+  noSpaces: boolean;
+}
+
+export interface PasswordTestInteraction {
+  password: string;
+  description: string;
+  shouldFail: boolean;
+}
+
+export function detectPasswordRequirements(
+  visibleText: string
+): PasswordRequirements {
+  const lower = visibleText.toLowerCase();
+  const reqs: PasswordRequirements = {
+    requiresUppercase: false,
+    requiresLowercase: false,
+    requiresNumber: false,
+    requiresSpecial: false,
+    noSpaces: false,
+  };
+
+  const lengthMatch =
+    lower.match(/(?:at least|minimum|min\.?)\s*(\d+)\s*character/i) ||
+    lower.match(/(\d+)\+?\s*character/i);
+  if (lengthMatch) {
+    reqs.minLength = parseInt(lengthMatch[1]);
+  }
+
+  if (/uppercase|capital letter/i.test(lower)) reqs.requiresUppercase = true;
+  if (/lowercase/i.test(lower)) reqs.requiresLowercase = true;
+  if (
+    /number|digit|\d/i.test(lower) &&
+    /must|require|contain|include/i.test(lower)
+  )
+    reqs.requiresNumber = true;
+  if (
+    /special character|symbol|[!@#$%^&*]/i.test(lower) &&
+    /must|require|contain|include/i.test(lower)
+  )
+    reqs.requiresSpecial = true;
+  if (/no\s*spaces/i.test(lower)) reqs.noSpaces = true;
+
+  return reqs;
+}
+
+export function generatePasswordTestInteractions(
+  reqs: PasswordRequirements
+): PasswordTestInteraction[] {
+  const cases: PasswordTestInteraction[] = [];
+  const goodLength = Math.max(reqs.minLength || 8, 8);
+
+  let validPassword = "Aa1!";
+  while (validPassword.length < goodLength) {
+    validPassword += "xY2@".charAt(validPassword.length % 4);
+  }
+
+  if (reqs.minLength) {
+    const tooShort = validPassword.slice(0, reqs.minLength - 1);
+    cases.push({
+      password: tooShort,
+      description: `too short (${tooShort.length} chars, need ${reqs.minLength})`,
+      shouldFail: true,
+    });
+  }
+
+  if (reqs.requiresUppercase) {
+    cases.push({
+      password: validPassword.toLowerCase(),
+      description: "no uppercase letter",
+      shouldFail: true,
+    });
+  }
+
+  if (reqs.requiresLowercase) {
+    cases.push({
+      password: validPassword.toUpperCase(),
+      description: "no lowercase letter",
+      shouldFail: true,
+    });
+  }
+
+  if (reqs.requiresNumber) {
+    cases.push({
+      password: validPassword.replace(/\d/g, "a"),
+      description: "no number",
+      shouldFail: true,
+    });
+  }
+
+  if (reqs.requiresSpecial) {
+    cases.push({
+      password: validPassword.replace(/[^a-zA-Z0-9]/g, "a"),
+      description: "no special character",
+      shouldFail: true,
+    });
+  }
+
+  if (reqs.noSpaces) {
+    cases.push({
+      password: validPassword.slice(0, 4) + " " + validPassword.slice(4),
+      description: "contains space",
+      shouldFail: true,
+    });
+  }
+
+  cases.push({
+    password: validPassword,
+    description: "valid password satisfying all requirements",
+    shouldFail: false,
+  });
+
+  return cases;
+}

package/src/auth/signic-registrar.ts

@@ -0,0 +1,186 @@
+import { SignicClient } from "@sudobility/signic_sdk";
+import { randomBytes } from "node:crypto";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { keccak_256 } from "@noble/hashes/sha3";
+import type { Page } from "puppeteer-core";
+import pino from "pino";
+import type { FormInfo, Credentials } from "@sudobility/testomniac_types";
+import { loadConfig } from "../config/index";
+
+const logger = pino({ name: "signic-registrar" });
+
+function generatePrivateKey(): Uint8Array {
+  return randomBytes(32);
+}
+
+function privateKeyToAddress(privateKey: Uint8Array): string {
+  const publicKey = secp256k1.getPublicKey(privateKey, false).slice(1);
+  const hash = keccak_256(publicKey);
+  return `0x${Buffer.from(hash.slice(-20)).toString("hex")}`;
+}
+
+function signEthMessage(
+  message: string,
+  privateKey: Uint8Array
+): { address: string; signature: string } {
+  const prefix = `\x19Ethereum Signed Message:\n${message.length}`;
+  const hash = keccak_256(
+    Buffer.concat([Buffer.from(prefix), Buffer.from(message)])
+  );
+  const sig = secp256k1.sign(hash, privateKey);
+  const r = sig.r.toString(16).padStart(64, "0");
+  const s = sig.s.toString(16).padStart(64, "0");
+  const v = (sig.recovery! + 27).toString(16).padStart(2, "0");
+  return {
+    address: privateKeyToAddress(privateKey),
+    signature: `0x${r}${s}${v}`,
+  };
+}
+
+function generatePassword(): string {
+  return `TestPass!${randomBytes(4).toString("hex")}`;
+}
+
+export async function autoRegister(
+  page: Page,
+  signupForm: FormInfo
+): Promise<Credentials | null> {
+  const config = loadConfig();
+  const privateKey = generatePrivateKey();
+  const walletAddress = privateKeyToAddress(privateKey);
+
+  const client = new SignicClient({
+    indexerUrl: config.signicIndexerUrl,
+    wildduckUrl: config.signicWildduckUrl,
+    signMessage: async (message: string) => signEthMessage(message, privateKey),
+  });
+
+  const email = client.getEmailAddress();
+  const password = generatePassword();
+
+  logger.info({ email }, "auto-registering with Signic email");
+
+  await client.connect(walletAddress);
+
+  for (const field of signupForm.fields) {
+    const label = (field.name + " " + field.label).toLowerCase();
+    let value = "";
+
+    if (field.type === "email" || label.includes("email")) {
+      value = email;
+    } else if (field.type === "password") {
+      value = password;
+    } else if (label.includes("name") && !label.includes("username")) {
+      value = "Test User";
+    } else if (label.includes("username")) {
+      value = `testuser_${randomBytes(3).toString("hex")}`;
+    } else {
+      continue;
+    }
+
+    try {
+      const el = await page.waitForSelector(field.selector, { timeout: 5000 });
+      if (el) {
+        await el.click({ clickCount: 3 });
+        await el.type(value);
+      }
+    } catch (err) {
+      logger.warn(
+        { err, selector: field.selector },
+        "could not fill signup field"
+      );
+    }
+  }
+
+  if (signupForm.submitSelector) {
+    const btn = await page.waitForSelector(signupForm.submitSelector, {
+      timeout: 5000,
+    });
+    if (btn) await btn.click();
+  } else {
+    await page.keyboard.press("Enter");
+  }
+
+  try {
+    await page.waitForNavigation({
+      waitUntil: "networkidle0",
+      timeout: 10_000,
+    });
+  } catch (err) {
+    logger.debug({ err }, "navigation timeout after signup form submission");
+  }
+
+  logger.info("polling Signic inbox for verification email");
+  let verified = false;
+  for (let attempt = 0; attempt < 30; attempt++) {
+    await new Promise(r => setTimeout(r, 2000));
+    const { emails } = await client.getUnreadEmails(5);
+    if (emails.length === 0) continue;
+
+    const latestEmail = await client.getEmail(emails[0].id);
+    const body = latestEmail.text || latestEmail.html?.join("") || "";
+
+    const otpMatch = body.match(/\b(\d{4,8})\b/);
+    if (otpMatch) {
+      const otp = otpMatch[1];
+      logger.info({ otp }, "found OTP in verification email");
+      const otpSelectors = [
+        'input[name*="code"]',
+        'input[name*="otp"]',
+        'input[name*="verification"]',
+        'input[placeholder*="code"]',
+        'input[type="number"]',
+      ];
+      for (const sel of otpSelectors) {
+        try {
+          const el = await page.waitForSelector(sel, {
+            timeout: 3000,
+            visible: true,
+          });
+          if (el) {
+            await el.type(otp);
+            await page.keyboard.press("Enter");
+            try {
+              await page.waitForNavigation({
+                waitUntil: "networkidle0",
+                timeout: 10_000,
+              });
+            } catch (err) {
+              logger.debug(
+                { err },
+                "navigation timeout during OTP verification"
+              );
+            }
+            verified = true;
+            break;
+          }
+        } catch (err) {
+          logger.debug({ err, selector: sel }, "OTP field selector not found");
+          continue;
+        }
+      }
+      if (verified) break;
+    }
+
+    const linkMatch =
+      body.match(/https?:\/\/[^\s"'<>]+verify[^\s"'<>]*/i) ||
+      body.match(/https?:\/\/[^\s"'<>]+confirm[^\s"'<>]*/i);
+    if (linkMatch) {
+      logger.info({ link: linkMatch[0] }, "found verification link");
+      await page.goto(linkMatch[0], {
+        waitUntil: "networkidle0",
+        timeout: 15_000,
+      });
+      verified = true;
+      break;
+    }
+  }
+
+  if (!verified) {
+    logger.warn("could not verify account — no OTP or link found");
+    return null;
+  }
+
+  logger.info({ email }, "auto-registration complete");
+  return { email, password };
+}

package/src/browser/chromium.ts

@@ -0,0 +1,35 @@
+import puppeteer, { type Browser, type Page } from "puppeteer-core";
+import type { Config } from "../config/index";
+import type { Screen } from "@sudobility/testomniac_types";
+
+export class ChromiumManager {
+  private browser: Browser | null = null;
+
+  constructor(private config: Config) {}
+
+  async launch(): Promise<Browser> {
+    this.browser = await puppeteer.launch({
+      executablePath: this.config.chromiumPath,
+      userDataDir: this.config.userDataDir,
+      headless: true,
+      args: ["--no-sandbox", "--disable-setuid-sandbox"],
+    });
+    return this.browser;
+  }
+
+  async newPage(screen?: Screen): Promise<Page> {
+    if (!this.browser) throw new Error("Browser not launched");
+    const page = await this.browser.newPage();
+    if (screen) {
+      await page.setViewport({ width: screen.width, height: screen.height });
+    }
+    return page;
+  }
+
+  async close(): Promise<void> {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+    }
+  }
+}