qazen-cli 0.1.2 → 0.1.3

package/dist/commands/record.js

@@ -86,9 +86,45 @@ export async function recordCommand(options) {
         console.error(chalk.red(err instanceof Error ? err.message : String(err)));
         process.exit(1);
     }
-    console.log(chalk.green(`\n  ✓ Session captured`));
-    console.log(chalk.gray(`  Cookies: ${result.cookieCount} (including HttpOnly)`));
-    console.log(chalk.gray(`  Domain:  ${result.domain}`));
+    const targetHostname = (() => {
+        try {
+            return new URL(targetUrl).hostname.replace(/^www\./i, "").toLowerCase();
+        }
+        catch {
+            return "";
+        }
+    })();
+    const ss = result.storageState;
+    const cookies = ss.cookies ?? [];
+    const origins = ss.origins ?? [];
+    const cookiesByDomain = cookies.reduce((acc, c) => {
+        acc[c.domain] = (acc[c.domain] ?? 0) + 1;
+        return acc;
+    }, {});
+    const matchesTarget = (cookieDomain) => {
+        if (!targetHostname)
+            return false;
+        const norm = cookieDomain.replace(/^\./, "").toLowerCase();
+        return (norm === targetHostname ||
+            norm.endsWith("." + targetHostname) ||
+            targetHostname.endsWith("." + norm));
+    };
+    console.log(chalk.green("\n  ✓ Session captured"));
+    console.log(chalk.gray("  Cookies by domain:"));
+    Object.entries(cookiesByDomain).forEach(([domain, count]) => {
+        const marker = matchesTarget(domain) ? chalk.green("  ✓ ") : chalk.gray("  · ");
+        console.log(marker + chalk.gray(`${domain}: ${count} cookies`));
+    });
+    if (origins.length > 0) {
+        console.log(chalk.gray(`  localStorage: ${origins.length} origin(s)`));
+    }
+    const hasTargetCookies = cookies.some((c) => matchesTarget(c.domain));
+    if (!hasTargetCookies && targetHostname) {
+        console.log(chalk.yellow(`\n  ⚠  No cookies found for ${targetHostname}`));
+        console.log(chalk.yellow("  The session may not work for authenticated crawling."));
+        console.log(chalk.gray("  Tip: Make sure you are fully logged into the app"));
+        console.log(chalk.gray("  (not just the SSO provider) before pressing Enter."));
+    }
     const uploadSpinner = ora("Uploading to QAZen...").start();
     try {
         await uploadSession(apiUrl, cliToken, project.id, result.storageState, result.domain, result.cookieCount);

package/dist/commands/visionScout.js

@@ -0,0 +1,114 @@
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import Anthropic from "@anthropic-ai/sdk";
+import { getConfig, isConfigured } from "../lib/config.js";
+import { fetchProjects, uploadVisionDiscovery } from "../lib/api.js";
+import { VisionNavigator } from "../lib/visionNavigator.js";
+export async function visionScoutCommand(options) {
+    if (!isConfigured()) {
+        console.log(chalk.red("\n  Not logged in. Run: qazen login --token <key>\n"));
+        process.exit(1);
+    }
+    const config = getConfig();
+    const anthropicKey = options.anthropicKey || process.env["ANTHROPIC_API_KEY"];
+    if (!anthropicKey) {
+        console.log(chalk.red("\n  Anthropic API key required."));
+        console.log(chalk.gray("  Set ANTHROPIC_API_KEY env var or use --anthropic-key\n"));
+        process.exit(1);
+    }
+    const spinner = ora("Loading projects...").start();
+    const projects = await fetchProjects(config.apiUrl, config.cliToken);
+    spinner.stop();
+    if (projects.length === 0) {
+        console.log(chalk.red("\n  No projects found in your workspace.\n"));
+        process.exit(1);
+    }
+    let project;
+    if (options.project) {
+        const found = projects.find((p) => p.name.toLowerCase().includes(options.project.toLowerCase()));
+        if (!found) {
+            console.log(chalk.red(`\n  Project "${options.project}" not found\n`));
+            process.exit(1);
+        }
+        project = found;
+    }
+    else if (projects.length === 1) {
+        project = projects[0];
+    }
+    else {
+        const { projectId } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "projectId",
+                message: "Select project:",
+                choices: projects.map((p) => ({
+                    name: `${p.name}  ${chalk.gray(p.url)}`,
+                    value: p.id,
+                })),
+            },
+        ]);
+        project = projects.find((p) => p.id === projectId);
+    }
+    const targetUrl = options.url || project.url;
+    const maxPages = parseInt(options.maxPages, 10);
+    console.log("\n" + chalk.hex("#6366F1").bold("  QAZen Vision Scout"));
+    console.log(chalk.gray("  ─────────────────────────────────────"));
+    console.log(`  ${chalk.gray("Project:")} ${chalk.white(project.name)}`);
+    console.log(`  ${chalk.gray("URL:")}     ${chalk.white(targetUrl)}`);
+    console.log(`  ${chalk.gray("Max pages:")} ${chalk.white(maxPages)}`);
+    console.log(chalk.gray("  ─────────────────────────────────────"));
+    console.log(chalk.yellow("\n  A browser window will open."));
+    console.log(chalk.white("  Claude Vision will navigate the app"));
+    console.log(chalk.white("  visually — like a human QA engineer.\n"));
+    const { confirm } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "confirm",
+            message: "Start vision-based discovery?",
+            default: true,
+        },
+    ]);
+    if (!confirm) {
+        console.log(chalk.gray("\n  Cancelled.\n"));
+        process.exit(0);
+    }
+    const anthropic = new Anthropic({ apiKey: anthropicKey });
+    const navigator = new VisionNavigator(anthropic, targetUrl, maxPages);
+    console.log("\n  " + chalk.hex("#6366F1")("Starting Vision Scout...") + "\n");
+    try {
+        const result = await navigator.explore((event) => {
+            switch (event.type) {
+                case "page_start":
+                    process.stdout.write(`\n  ${chalk.gray("→")} ${chalk.white(event.url ?? "")}\n`);
+                    break;
+                case "vision_analysis":
+                    console.log(`    ${chalk.gray("[Vision]")} ${event.message}`);
+                    break;
+                case "action":
+                    console.log(`    ${chalk.hex("#6366F1")("[Click]")} ${event.message}`);
+                    break;
+                case "page_mapped":
+                    console.log(`    ${chalk.green("✓")} ${chalk.gray("Mapped:")} ${event.message}`);
+                    break;
+                case "error":
+                    console.log(`    ${chalk.red("✗")} ${event.message}`);
+                    break;
+            }
+        });
+        const uploadSpinner = ora("Uploading discovery to QAZen...").start();
+        await uploadVisionDiscovery(config.apiUrl, config.cliToken, project.id, result);
+        uploadSpinner.succeed(chalk.green("Discovery uploaded to QAZen"));
+        console.log("\n" + chalk.hex("#6366F1").bold("  Vision Scout complete\n"));
+        console.log(chalk.gray(`  Pages explored:  ${chalk.white(result.pages.length)}`));
+        console.log(chalk.gray(`  Elements found:  ${chalk.white(result.totalElements)}`));
+        console.log(chalk.gray(`  Actions taken:   ${chalk.white(result.totalActions)}`));
+        console.log(chalk.gray(`  Screenshots:     ${chalk.white(result.screenshots.length)}`));
+        console.log(chalk.gray(`\n  View in QAZen: ${config.apiUrl}/discovery\n`));
+    }
+    catch (err) {
+        console.log(chalk.red("\n  ✗ Vision Scout failed"));
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -4,6 +4,7 @@ import chalk from "chalk";
 import { loginCommand } from "./commands/login.js";
 import { recordCommand } from "./commands/record.js";
 import { statusCommand } from "./commands/status.js";
+import { visionScoutCommand } from "./commands/visionScout.js";
 console.log(chalk.hex("#6366F1").bold("\n  QAZen") + chalk.gray(" — Autonomous QA Platform\n"));
 program
     .name("qazen")
@@ -25,4 +26,12 @@ program
     .command("status")
     .description("Check CLI connection and list projects")
     .action(statusCommand);
+program
+    .command("vision-scout")
+    .description("Visually explore an app using Claude Vision — works on any SPA or SSO-protected app")
+    .option("-p, --project <name>", "Project name")
+    .option("-u, --url <url>", "Override project URL")
+    .option("--max-pages <n>", "Max pages to explore", "20")
+    .option("--anthropic-key <key>", "Anthropic API key (or set ANTHROPIC_API_KEY)")
+    .action(visionScoutCommand);
 program.parse();

package/dist/lib/api.js

@@ -32,3 +32,47 @@ export async function uploadSession(apiUrl, cliToken, projectId, storageState, d
         throw new Error(`Upload failed (HTTP ${res.status}): ${text}`);
     }
 }
+export async function uploadVisionDiscovery(apiUrl, cliToken, projectId, result) {
+    const appMap = {
+        baseUrl: result.pages[0]?.url ?? "",
+        pages: result.pages.map((p) => ({
+            url: p.url,
+            title: p.title,
+            buttons: p.elements
+                .filter((e) => e.elementType === "button")
+                .map((e) => e.description),
+            forms: p.elements
+                .filter((e) => e.elementType === "input")
+                .map((e) => ({ name: e.description, type: "text", placeholder: e.action })),
+            headings: [p.visualDescription],
+            links: p.elements
+                .filter((e) => e.elementType === "link")
+                .map((e) => e.action),
+            visualDescription: p.visualDescription,
+            workflow: p.workflow,
+            actionsTaken: p.actions_taken,
+        })),
+        api_endpoints: [],
+        total_pages: result.pages.length,
+        total_elements: result.totalElements,
+        discoveryMethod: "vision",
+        primaryWorkflows: result.primaryWorkflows,
+        screenshots: result.screenshots.slice(0, 5),
+    };
+    const res = await fetch(`${apiUrl}/api/cli/projects/${projectId}/vision-discovery`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...authHeaders(cliToken) },
+        body: JSON.stringify({
+            appMap,
+            totalPages: result.pages.length,
+            totalElements: result.totalElements,
+            primaryWorkflows: result.primaryWorkflows,
+        }),
+    });
+    if (res.status === 401)
+        throw new Error("Invalid CLI token");
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`Upload failed (HTTP ${res.status}): ${text}`);
+    }
+}

package/dist/lib/recorder.js

@@ -1,11 +1,19 @@
 import { chromium } from "playwright";
 import * as readline from "node:readline";
+import chalk from "chalk";
+const MAX_DOMAIN_RETRIES = 3;
 /**
  * Launch a real, headed Chromium and let the user complete any
  * login flow (SSO, ADFS, Okta, MFA, …). When the user presses
  * Enter in the terminal we snapshot the full storage state via
  * CDP, which includes HttpOnly cookies that JavaScript cannot
  * read — this is the reason the CLI exists.
+ *
+ * Before capturing, we verify the browser is actually on the
+ * target app's hostname (or a subdomain). If the user pressed
+ * Enter while still on an SSO provider page (the most common
+ * recorder failure), we warn and wait again. After 3 attempts
+ * we capture anyway so the user can never be permanently stuck.
  */
 export async function recordSession(url, onReady) {
     const browser = await chromium.launch({
@@ -31,7 +39,14 @@ export async function recordSession(url, onReady) {
         // Some apps redirect to a different origin immediately; that's fine — keep going.
     }
     onReady();
-    await waitForEnter();
+    const targetHostname = normalizeHost(safeHostname(url));
+    if (!targetHostname) {
+        console.log("\n  " + chalk.yellow("⚠  Could not parse target hostname — skipping domain check."));
+        await waitForEnterWithStatus(page);
+    }
+    else {
+        await captureLoop(page, targetHostname);
+    }
     const storageState = await context.storageState();
     const cookieCount = storageState.cookies?.length ?? 0;
     let domain = "unknown";
@@ -49,14 +64,92 @@ export async function recordSession(url, onReady) {
     await browser.close();
     return { storageState, cookieCount, domain };
 }
-function waitForEnter() {
-    return new Promise((resolve) => {
+function normalizeHost(h) {
+    return h.replace(/^www\./i, "").toLowerCase();
+}
+function safeHostname(u) {
+    try {
+        return new URL(u).hostname;
+    }
+    catch {
+        return "";
+    }
+}
+function isOnTargetDomain(currentHostname, targetHostname) {
+    if (!currentHostname || !targetHostname)
+        return false;
+    return (currentHostname === targetHostname ||
+        currentHostname.endsWith("." + targetHostname) ||
+        targetHostname.endsWith("." + currentHostname));
+}
+/**
+ * Re-prompt loop: keep asking the user to press [Enter] until the
+ * browser is actually on the target app's hostname. After
+ * MAX_DOMAIN_RETRIES attempts, capture anyway so the user is
+ * never permanently stuck.
+ */
+async function captureLoop(page, targetHostname) {
+    for (let attempts = 1; attempts <= MAX_DOMAIN_RETRIES; attempts++) {
+        await waitForEnterWithStatus(page);
+        let currentHostname = "";
+        try {
+            currentHostname = normalizeHost(safeHostname(page.url()));
+        }
+        catch {
+            /* page/context may have closed — treat as unknown */
+        }
+        if (currentHostname && isOnTargetDomain(currentHostname, targetHostname))
+            return;
+        if (attempts >= MAX_DOMAIN_RETRIES) {
+            console.log("\n  " +
+                chalk.yellow(`⚠  Capturing anyway after ${attempts} attempts`) +
+                chalk.yellow(" — session may be incomplete.\n"));
+            return;
+        }
+        console.log("\n  " +
+            chalk.yellow("⚠  Warning: browser is currently on") +
+            chalk.red(" " + (currentHostname || "<unknown>")));
+        console.log("  " + chalk.yellow("Expected:") + chalk.green(" " + targetHostname));
+        console.log(chalk.white("\n  Please complete the full login flow and"));
+        console.log(chalk.white("  make sure you can see the app dashboard,"));
+        console.log(chalk.white("  then press [Enter] again.\n"));
+    }
+}
+/**
+ * Print the "press [Enter]" prompt and tick every 5 seconds with
+ * the current browser hostname so the user can see when they have
+ * actually landed on the target app. Cleans up the interval and
+ * readline interface on every termination path (line, close,
+ * SIGINT, stdin error) so we never leak timers or hang the process.
+ */
+function waitForEnterWithStatus(page) {
+    return new Promise((resolve, reject) => {
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
-        process.stdout.write("\n  \x1b[33m→ Complete your login, then press [Enter] \x1b[0m");
-        rl.once("line", () => {
-            rl.close();
+        process.stdout.write("\n  " + chalk.yellow("→ Complete your login, then press [Enter]") + "\n");
+        const ticker = setInterval(() => {
+            try {
+                const hostname = new URL(page.url()).hostname;
+                process.stdout.write("\r  " + chalk.gray("Browser is on: ") + chalk.cyan(hostname) + "          ");
+            }
+            catch {
+                /* ignore — page may be navigating */
+            }
+        }, 5_000);
+        let settled = false;
+        const cleanup = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearInterval(ticker);
+            try {
+                rl.close();
+            }
+            catch { /* */ }
             process.stdout.write("\n");
-            resolve();
-        });
+        };
+        rl.once("line", () => { cleanup(); resolve(); });
+        rl.once("close", () => { cleanup(); resolve(); });
+        rl.once("SIGINT", () => { cleanup(); reject(new Error("Recording cancelled (Ctrl+C)")); });
+        process.stdin.once("error", (err) => { cleanup(); reject(err); });
     });
 }

package/dist/lib/visionNavigator.js

@@ -0,0 +1,315 @@
+import { chromium } from "playwright";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const MODEL = "claude-opus-4-5";
+function stripCodeFences(text) {
+    return text.replace(/```json?\n?/g, "").replace(/```\n?/g, "").trim();
+}
+function firstTextBlock(content) {
+    const block = content[0];
+    return block && block.type === "text" ? block.text : "";
+}
+export class VisionNavigator {
+    anthropic;
+    baseUrl;
+    maxPages;
+    visitedUrls = new Set();
+    explorationQueue = [];
+    pages = [];
+    screenshots = [];
+    totalActions = 0;
+    browser;
+    browserContext;
+    page;
+    screenshotDir;
+    constructor(anthropic, baseUrl, maxPages = 20) {
+        this.anthropic = anthropic;
+        this.baseUrl = baseUrl;
+        this.maxPages = maxPages;
+        this.screenshotDir = fs.mkdtempSync(path.join(os.tmpdir(), "qazen-vision-"));
+    }
+    async explore(onEvent) {
+        this.browser = await chromium.launch({
+            headless: false,
+            args: [
+                "--no-sandbox",
+                "--disable-infobars",
+                "--start-maximized",
+                "--disable-blink-features=AutomationControlled",
+            ],
+            ignoreDefaultArgs: ["--enable-automation"],
+        });
+        this.browserContext = await this.browser.newContext({
+            viewport: { width: 1280, height: 720 },
+            userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+            ignoreHTTPSErrors: true,
+        });
+        await this.browserContext.addInitScript(() => {
+            Object.defineProperty(navigator, "webdriver", { get: () => false });
+        });
+        this.page = await this.browserContext.newPage();
+        this.explorationQueue.push({
+            url: this.baseUrl,
+            context: "Starting page — explore the main navigation",
+        });
+        try {
+            while (this.explorationQueue.length > 0 && this.pages.length < this.maxPages) {
+                const next = this.explorationQueue.shift();
+                await this.explorePage(next.url, next.context, onEvent);
+                await this.page.waitForTimeout(800 + Math.random() * 400);
+            }
+        }
+        finally {
+            await this.browser.close();
+        }
+        const primaryWorkflows = await this.inferWorkflows(onEvent);
+        return {
+            pages: this.pages,
+            totalElements: this.pages.reduce((sum, p) => sum + p.elements.length, 0),
+            totalActions: this.totalActions,
+            screenshots: this.screenshots,
+            primaryWorkflows,
+        };
+    }
+    async explorePage(url, context, onEvent) {
+        if (this.visitedUrls.has(url))
+            return;
+        this.visitedUrls.add(url);
+        onEvent({ type: "page_start", url, message: url });
+        try {
+            await this.page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+            await this.page.waitForTimeout(2500);
+            const currentUrl = this.page.url();
+            const currentHostname = new URL(currentUrl).hostname;
+            const baseHostname = new URL(this.baseUrl).hostname;
+            const baseRegistrable = baseHostname.split(".").slice(-2).join(".");
+            if (!currentHostname.includes(baseRegistrable)) {
+                onEvent({ type: "error", message: `Redirected to ${currentHostname} — skipping` });
+                return;
+            }
+            const screenshot = await this.takeScreenshot(url);
+            const analysis = await this.analyzeScreenshot(screenshot, url, context, onEvent);
+            if (!analysis)
+                return;
+            const pageMap = {
+                url: currentUrl,
+                title: await this.page.title(),
+                visualDescription: analysis.pageDescription,
+                elements: analysis.elements,
+                screenshot,
+                ...(analysis.workflow ? { workflow: analysis.workflow } : {}),
+                actions_taken: [],
+            };
+            onEvent({
+                type: "page_mapped",
+                message: `${analysis.pageDescription} — ${analysis.elements.length} elements found`,
+            });
+            const highPriority = analysis.elements
+                .filter((e) => e.priority === "high" &&
+                (e.elementType === "link" || e.elementType === "tab" || e.elementType === "menu"))
+                .slice(0, 4);
+            for (const element of highPriority) {
+                try {
+                    const newUrl = await this.clickElement(element, pageMap, onEvent);
+                    if (newUrl && !this.visitedUrls.has(newUrl)) {
+                        this.explorationQueue.push({
+                            url: newUrl,
+                            context: `Navigated from ${url} by clicking "${element.description}"`,
+                        });
+                    }
+                    await this.page.goto(url, { waitUntil: "domcontentloaded", timeout: 20000 });
+                    await this.page.waitForTimeout(1500);
+                }
+                catch {
+                    // click failed — continue
+                }
+            }
+            this.pages.push(pageMap);
+            const links = analysis.elements
+                .filter((e) => e.elementType === "link" && e.action.startsWith("http"))
+                .map((e) => e.action)
+                .filter((href) => {
+                try {
+                    const hostname = new URL(href).hostname;
+                    return hostname.includes(baseRegistrable);
+                }
+                catch {
+                    return false;
+                }
+            });
+            for (const link of links) {
+                if (!this.visitedUrls.has(link)) {
+                    this.explorationQueue.push({ url: link, context: `Link found on ${url}` });
+                }
+            }
+        }
+        catch (err) {
+            onEvent({
+                type: "error",
+                message: `Failed to explore ${url}: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    async analyzeScreenshot(screenshot, url, context, onEvent) {
+        onEvent({ type: "vision_analysis", message: "Sending screenshot to Claude Vision..." });
+        try {
+            const response = await this.anthropic.messages.create({
+                model: MODEL,
+                max_tokens: 2000,
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "image",
+                                source: { type: "base64", media_type: "image/jpeg", data: screenshot },
+                            },
+                            {
+                                type: "text",
+                                text: `You are a QA engineer exploring a web application.
+Context: ${context}
+Current URL: ${url}
+
+Analyse this screenshot and return ONLY valid JSON:
+{
+  "pageDescription": "One sentence describing what this page/section does",
+  "workflow": "The business workflow this page is part of (e.g. 'User Authentication', 'Product Catalog', 'Order Management')",
+  "elements": [
+    {
+      "description": "Clear description of the element",
+      "elementType": "button|link|input|tab|menu|dropdown|other",
+      "action": "What clicking/interacting would do OR the href URL if it's a link",
+      "priority": "high|medium|low",
+      "visualLocation": "Brief description of where it is on screen"
+    }
+  ]
+}
+
+Focus on:
+- Navigation items and menu links (high priority)
+- Primary action buttons (high priority)
+- Tab bars and section switchers (high priority)
+- Form inputs (medium priority)
+- Secondary buttons (medium priority)
+
+Ignore: decorative elements, footer links, external links.
+Return ONLY the JSON object. No markdown, no explanation.`,
+                            },
+                        ],
+                    },
+                ],
+            });
+            const text = firstTextBlock(response.content);
+            const parsed = JSON.parse(stripCodeFences(text));
+            onEvent({
+                type: "vision_analysis",
+                message: parsed.pageDescription + (parsed.workflow ? ` (${parsed.workflow})` : ""),
+            });
+            return parsed;
+        }
+        catch (err) {
+            onEvent({
+                type: "error",
+                message: `Vision analysis failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return null;
+        }
+    }
+    async clickElement(element, pageMap, onEvent) {
+        onEvent({
+            type: "action",
+            message: `Clicking "${element.description}" (${element.visualLocation || element.elementType})`,
+        });
+        const urlBefore = this.page.url();
+        const screenshot = await this.takeScreenshot("click-target");
+        const coordResponse = await this.anthropic.messages.create({
+            model: MODEL,
+            max_tokens: 200,
+            messages: [
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "image",
+                            source: { type: "base64", media_type: "image/jpeg", data: screenshot },
+                        },
+                        {
+                            type: "text",
+                            text: `Find "${element.description}" on screen.
+Return ONLY JSON: {"x": number, "y": number, "found": boolean}
+x and y are pixel coordinates (image is 1280x720).
+If not found, return {"x": 0, "y": 0, "found": false}`,
+                        },
+                    ],
+                },
+            ],
+        });
+        const coordText = firstTextBlock(coordResponse.content);
+        let coords;
+        try {
+            coords = JSON.parse(stripCodeFences(coordText));
+        }
+        catch {
+            return null;
+        }
+        if (!coords.found)
+            return null;
+        await this.page.mouse.click(coords.x, coords.y);
+        this.totalActions++;
+        pageMap.actions_taken.push(`Clicked "${element.description}" at (${coords.x}, ${coords.y})`);
+        await this.page.waitForTimeout(2000);
+        const urlAfter = this.page.url();
+        if (urlAfter !== urlBefore) {
+            const newScreenshot = await this.takeScreenshot(urlAfter);
+            this.screenshots.push(newScreenshot);
+            return urlAfter;
+        }
+        return null;
+    }
+    async takeScreenshot(_label) {
+        const buffer = await this.page.screenshot({ type: "jpeg", quality: 70, fullPage: false });
+        const base64 = buffer.toString("base64");
+        this.screenshots.push(base64);
+        return base64;
+    }
+    async inferWorkflows(onEvent) {
+        if (this.pages.length === 0)
+            return [];
+        onEvent({
+            type: "vision_analysis",
+            message: "Inferring primary workflows from explored pages...",
+        });
+        const pagesSummary = this.pages
+            .map((p) => `${p.url}: ${p.visualDescription} (${p.workflow || "unknown"})`)
+            .join("\n");
+        try {
+            const response = await this.anthropic.messages.create({
+                model: MODEL,
+                max_tokens: 500,
+                messages: [
+                    {
+                        role: "user",
+                        content: `Based on these explored pages, identify 3-5 primary user workflows.
+Return ONLY a JSON array of workflow names.
+Example: ["User Authentication", "Product Catalog Browse", "Order Management"]
+
+Pages explored:
+${pagesSummary}
+
+Return ONLY the JSON array.`,
+                    },
+                ],
+            });
+            const text = firstTextBlock(response.content) || "[]";
+            return JSON.parse(stripCodeFences(text));
+        }
+        catch {
+            return [];
+        }
+    }
+    // Surface temp dir for callers that want to clean up
+    getScreenshotDir() {
+        return this.screenshotDir;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qazen-cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "QAZen CLI — capture authenticated browser sessions for enterprise SSO testing",
   "license": "MIT",
   "author": "QAZen",
@@ -37,7 +37,8 @@
     "conf": "^13.0.0",
     "inquirer": "^9.2.0",
     "ora": "^8.0.0",
-    "playwright": "^1.60.0"
+    "playwright": "^1.60.0",
+	"@anthropic-ai/sdk": "^0.24.0"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.7",