@hasna/testers 0.0.22 → 0.0.23

package/dist/cli/index.js

@@ -27115,7 +27115,7 @@ import chalk6 from "chalk";
 // package.json
 var package_default = {
   name: "@hasna/testers",
-  version: "0.0.22",
+  version: "0.0.23",
   description: "AI-powered QA testing CLI \u2014 spawns cheap AI agents to test web apps with headless browsers",
   type: "module",
   main: "dist/index.js",

package/dist/lib/crawl-and-generate.d.ts

@@ -0,0 +1,43 @@
+/**
+ * crawl_and_generate — zero-config test generation for any web app.
+ *
+ * Given any URL:
+ * 1. Crawls the app with a headless browser to discover pages
+ * 2. Visits each page, captures a screenshot + simplified HTML
+ * 3. Sends both to Claude with a prompt to write test scenarios
+ * 4. Creates the scenarios in the DB under the given project
+ *
+ * Works for any web app — no manual setup required.
+ */
+export interface CrawlAndGenerateOptions {
+    url: string;
+    projectId?: string;
+    maxPages?: number;
+    scenariosPerPage?: number;
+    model?: string;
+    apiKey?: string;
+    headed?: boolean;
+    skipPaths?: string[];
+    tags?: string[];
+}
+export interface GeneratedPage {
+    path: string;
+    title: string;
+    scenariosCreated: number;
+    scenarios: Array<{
+        id: string;
+        shortId: string;
+        name: string;
+    }>;
+}
+export interface CrawlAndGenerateResult {
+    projectId: string | null;
+    url: string;
+    pagesDiscovered: number;
+    pagesGenerated: number;
+    totalScenariosCreated: number;
+    pages: GeneratedPage[];
+    skipped: string[];
+}
+export declare function crawlAndGenerate(options: CrawlAndGenerateOptions): Promise<CrawlAndGenerateResult>;
+//# sourceMappingURL=crawl-and-generate.d.ts.map

package/dist/lib/crawl-and-generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crawl-and-generate.d.ts","sourceRoot":"","sources":["../../src/lib/crawl-and-generate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAUH,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjE;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAwJD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAuGxG"}

package/dist/mcp/index.js

@@ -17792,6 +17792,232 @@ var init_army_runner = __esm(() => {
   init_config2();
 });
 
+// src/lib/crawl-and-generate.ts
+var exports_crawl_and_generate = {};
+__export(exports_crawl_and_generate, {
+  crawlAndGenerate: () => crawlAndGenerate
+});
+function shouldSkip(href, rootOrigin, skipPaths) {
+  try {
+    const u = new URL(href);
+    if (u.origin !== rootOrigin)
+      return true;
+    const path = u.pathname;
+    const allSkip = [...DEFAULT_SKIP_PATTERNS, ...skipPaths];
+    return allSkip.some((p) => path.startsWith(p) || path.includes(p));
+  } catch {
+    return true;
+  }
+}
+function normaliseUrl2(href) {
+  try {
+    const u = new URL(href);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return href;
+  }
+}
+async function getPageContext(browser, pageUrl, timeoutMs) {
+  const page = await getPage(browser, {});
+  try {
+    await page.goto(pageUrl, { timeout: timeoutMs, waitUntil: "domcontentloaded" });
+    await page.waitForTimeout(800).catch(() => {});
+    const [title, html, links, screenshot] = await Promise.all([
+      page.title().catch(() => ""),
+      page.evaluate(() => {
+        const body = document.body;
+        if (!body)
+          return "";
+        const clone = body.cloneNode(true);
+        clone.querySelectorAll("script,style,svg,noscript,iframe").forEach((el) => el.remove());
+        return clone.innerText?.slice(0, 3000) ?? clone.textContent?.slice(0, 3000) ?? "";
+      }).catch(() => ""),
+      page.evaluate((origin) => Array.from(document.querySelectorAll("a[href]")).map((a) => a.href).filter((h) => {
+        try {
+          return new URL(h).origin === origin;
+        } catch {
+          return false;
+        }
+      }), new URL(pageUrl).origin).catch(() => []),
+      page.screenshot({ fullPage: false }).catch(() => null)
+    ]);
+    return { title, path: new URL(pageUrl).pathname, html, screenshot, links };
+  } finally {
+    await page.close().catch(() => {});
+  }
+}
+async function generateScenariosForPage(client, model, pageContext, baseUrl, count) {
+  const Anthropic4 = (await import("@anthropic-ai/sdk")).default;
+  const anthropicClient = client;
+  const pageDesc = [
+    `URL: ${baseUrl.replace(/\/$/, "")}${pageContext.path}`,
+    `Title: ${pageContext.title || pageContext.path}`,
+    pageContext.html ? `
+Page content (text):
+${pageContext.html.slice(0, 2000)}` : ""
+  ].filter(Boolean).join(`
+`);
+  const prompt = `You are a QA engineer. Analyze this web page and write ${count} practical test scenarios.
+
+${pageDesc}
+
+Return ONLY a JSON array (no markdown, no explanation). Each scenario:
+{
+  "name": "short action-oriented name (e.g. 'User can log in with valid credentials')",
+  "description": "what this test verifies",
+  "steps": ["step 1", "step 2", "step 3"],
+  "tags": ["tag1"],
+  "priority": "low|medium|high|critical"
+}
+
+Rules:
+- Focus on user flows, not implementation details
+- Steps should be plain English instructions the browser agent can follow
+- Vary priorities: 1 critical/high per page for the main flow, rest medium/low
+- Keep steps concise (max 8 per scenario)
+- Tags should reflect the page area (e.g. "auth", "dashboard", "settings", "checkout")`;
+  const contentParts = [
+    ...pageContext.screenshot ? [{
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: "image/png",
+        data: pageContext.screenshot.toString("base64")
+      }
+    }] : [],
+    { type: "text", text: prompt }
+  ];
+  const messages = [{ role: "user", content: contentParts }];
+  try {
+    const response = await anthropicClient.messages.create({
+      model,
+      max_tokens: 2048,
+      messages
+    });
+    const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    const match = text.match(/\[[\s\S]*\]/);
+    if (!match)
+      return [];
+    const parsed = JSON.parse(match[0]);
+    return parsed.map((s) => ({
+      name: s.name ?? "Untitled scenario",
+      description: s.description ?? "",
+      steps: s.steps ?? [],
+      tags: s.tags ?? [],
+      priority: s.priority ?? "medium"
+    }));
+  } catch {
+    return [];
+  }
+}
+async function crawlAndGenerate(options) {
+  const {
+    url,
+    projectId,
+    maxPages = 20,
+    scenariosPerPage = 3,
+    headed = false,
+    skipPaths = [],
+    tags: extraTags = []
+  } = options;
+  const config = loadConfig();
+  const model = resolveModel2(options.model ?? config.defaultModel ?? "thorough");
+  const client = createClient(options.apiKey ?? config.anthropicApiKey);
+  const rootOrigin = new URL(url).origin;
+  const visited = new Set;
+  const queue = [url];
+  const pageContexts = [];
+  const skipped = [];
+  const browser = await launchBrowser({ headless: !headed });
+  try {
+    while (queue.length > 0 && visited.size < maxPages) {
+      const pageUrl = queue.shift();
+      const norm = normaliseUrl2(pageUrl);
+      if (visited.has(norm))
+        continue;
+      if (shouldSkip(pageUrl, rootOrigin, skipPaths)) {
+        skipped.push(pageUrl);
+        continue;
+      }
+      visited.add(norm);
+      try {
+        const ctx = await getPageContext(browser, pageUrl, 15000);
+        pageContexts.push(ctx);
+        for (const link of ctx.links) {
+          const normLink = normaliseUrl2(link);
+          if (!visited.has(normLink) && !shouldSkip(link, rootOrigin, skipPaths)) {
+            queue.push(link);
+          }
+        }
+      } catch {
+        skipped.push(pageUrl);
+      }
+    }
+  } finally {
+    await closeBrowser(browser).catch(() => {});
+  }
+  const pages = [];
+  let totalCreated = 0;
+  for (const ctx of pageContexts) {
+    const generated = await generateScenariosForPage(client, model, ctx, url, scenariosPerPage);
+    const createdScenarios = [];
+    for (const s of generated) {
+      try {
+        const priority = ["low", "medium", "high", "critical"].includes(s.priority) ? s.priority : "medium";
+        const scenario = createScenario({
+          name: s.name,
+          description: s.description,
+          steps: s.steps,
+          tags: [...s.tags ?? [], ...extraTags, "generated"],
+          priority,
+          targetPath: ctx.path,
+          projectId
+        });
+        createdScenarios.push({ id: scenario.id, shortId: scenario.shortId, name: scenario.name });
+        totalCreated++;
+      } catch {}
+    }
+    if (createdScenarios.length > 0) {
+      pages.push({
+        path: ctx.path,
+        title: ctx.title,
+        scenariosCreated: createdScenarios.length,
+        scenarios: createdScenarios
+      });
+    }
+  }
+  return {
+    projectId: projectId ?? null,
+    url,
+    pagesDiscovered: pageContexts.length,
+    pagesGenerated: pages.length,
+    totalScenariosCreated: totalCreated,
+    pages,
+    skipped
+  };
+}
+var DEFAULT_SKIP_PATTERNS;
+var init_crawl_and_generate = __esm(() => {
+  init_browser();
+  init_scenarios();
+  init_ai_client();
+  init_config2();
+  init_ai_client();
+  DEFAULT_SKIP_PATTERNS = [
+    "/logout",
+    "/sign-out",
+    "/signout",
+    "/static/",
+    "/assets/",
+    "/_next/",
+    "/__/",
+    "/favicon",
+    "/robots.txt",
+    "/sitemap",
+    "#"
+  ];
+});
+
 // src/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -24399,6 +24625,107 @@ server.tool("run_with_army", "Dispatch scenarios across multiple concurrent work
     return errorResponse(e);
   }
 });
+server.tool("crawl_and_generate", "Crawl any web app from a URL and auto-generate test scenarios for each page discovered. Zero config \u2014 works for any app. Uses AI (Claude) to analyze each page and write practical test scenarios.", {
+  url: exports_external.string().describe("Root URL to crawl (e.g. https://app.example.com)"),
+  projectId: exports_external.string().optional().describe("Project ID to attach generated scenarios to"),
+  maxPages: exports_external.number().int().min(1).max(50).optional().default(20).describe("Max pages to crawl (default 20)"),
+  scenariosPerPage: exports_external.number().int().min(1).max(10).optional().default(3).describe("Scenarios to generate per page (default 3)"),
+  model: exports_external.string().optional().describe(MODEL_DESC),
+  skipPaths: exports_external.array(exports_external.string()).optional().describe("URL paths to skip (e.g. ['/logout', '/admin'])"),
+  tags: exports_external.array(exports_external.string()).optional().describe("Extra tags to add to all generated scenarios"),
+  headed: exports_external.boolean().optional().describe("Run browser in headed mode")
+}, async ({ url, projectId, maxPages, scenariosPerPage, model, skipPaths, tags, headed }) => {
+  try {
+    const { crawlAndGenerate: crawlAndGenerate2 } = await Promise.resolve().then(() => (init_crawl_and_generate(), exports_crawl_and_generate));
+    const result = await crawlAndGenerate2({
+      url,
+      projectId,
+      maxPages: maxPages ?? 20,
+      scenariosPerPage: scenariosPerPage ?? 3,
+      model,
+      skipPaths,
+      tags,
+      headed
+    });
+    return json(result);
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("create_environment", "Register a named environment (e.g. staging, production, local) with its base URL. Use env name in run_scenarios instead of hardcoding URLs.", {
+  name: exports_external.string().describe("Environment name (e.g. staging, production, local)"),
+  url: exports_external.string().describe("Base URL for this environment (e.g. https://staging.example.com)"),
+  projectId: exports_external.string().optional().describe("Scope to a specific project"),
+  isDefault: exports_external.boolean().optional().describe("Set as default environment for this project"),
+  variables: exports_external.record(exports_external.string()).optional().describe("Environment variables (e.g. { API_KEY: 'test-key' })")
+}, async ({ name, url, projectId, isDefault, variables }) => {
+  try {
+    const { createEnvironment: createEnvironment2 } = await Promise.resolve().then(() => (init_environments(), exports_environments));
+    const env2 = createEnvironment2({ name, url, projectId, isDefault, variables });
+    return json(env2);
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("list_environments", "List registered environments with their URLs", {
+  projectId: exports_external.string().optional().describe("Filter by project ID")
+}, async ({ projectId }) => {
+  try {
+    const { listEnvironments: listEnvironments2 } = await Promise.resolve().then(() => (init_environments(), exports_environments));
+    const envs = listEnvironments2(projectId);
+    return json({ items: envs, total: envs.length });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("delete_environment", "Delete a named environment", { name: exports_external.string().describe("Environment name to delete") }, async ({ name }) => {
+  try {
+    const { deleteEnvironment: deleteEnvironment2 } = await Promise.resolve().then(() => (init_environments(), exports_environments));
+    const deleted = deleteEnvironment2(name);
+    if (!deleted)
+      return errorResponse(notFoundErr(name, "Environment"));
+    return json({ deleted: true, name });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("set_default_environment", "Set an environment as the default \u2014 run_scenarios will use it when no url/env is specified", { name: exports_external.string().describe("Environment name to set as default") }, async ({ name }) => {
+  try {
+    const { setDefaultEnvironment: setDefaultEnvironment2, getEnvironment: getEnvironment2 } = await Promise.resolve().then(() => (init_environments(), exports_environments));
+    setDefaultEnvironment2(name);
+    return json({ default: true, name, env: getEnvironment2(name) });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
+server.tool("list_scenarios_by_page", "Group scenarios by page (targetPath). Shows which pages have test coverage and which don't. Useful for spotting gaps.", {
+  projectId: exports_external.string().optional().describe("Filter by project ID")
+}, async ({ projectId }) => {
+  try {
+    const scenarios = listScenarios({ projectId });
+    const byPage = {};
+    const noPath = [];
+    for (const s of scenarios) {
+      if (s.targetPath) {
+        if (!byPage[s.targetPath])
+          byPage[s.targetPath] = [];
+        byPage[s.targetPath].push({ id: s.id, shortId: s.shortId, name: s.name, priority: s.priority, tags: s.tags });
+      } else {
+        noPath.push({ id: s.id, shortId: s.shortId, name: s.name });
+      }
+    }
+    const pages = Object.entries(byPage).sort(([a], [b]) => a.localeCompare(b)).map(([path, items]) => ({ path, scenarioCount: items.length, scenarios: items }));
+    return json({
+      pages,
+      totalPages: pages.length,
+      totalScenarios: scenarios.length,
+      scenariosWithNoPage: noPath.length,
+      noPageScenarios: noPath
+    });
+  } catch (e) {
+    return errorResponse(e);
+  }
+});
 registerCloudTools(server, "testers");
 async function main() {
   const transport = new StdioServerTransport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/testers",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "AI-powered QA testing CLI — spawns cheap AI agents to test web apps with headless browsers",
   "type": "module",
   "main": "dist/index.js",