intellitester 0.2.50 → 0.2.52

package/dist/{chunk-WNSVKXTD.js → chunk-PGOHFXEG.js}

@@ -4,6 +4,7 @@ import { loadCleanupHandlers, executeCleanup, saveFailedCleanup } from './chunk-
 import { NumberDictionary, uniqueNamesGenerator, adjectives, animals } from 'unique-names-generator';
 import crypto4 from 'crypto';
 import { parsePhoneNumber, isValidPhoneNumber } from 'libphonenumber-js';
+import { createServer } from 'http';
 import * as fs from 'fs/promises';
 import fs__default from 'fs/promises';
 import * as path4 from 'path';
@@ -14,7 +15,6 @@ import { Client, Users, TablesDB, Storage, Teams } from 'node-appwrite';
 import { Anthropic } from '@llamaindex/anthropic';
 import { OpenAI } from '@llamaindex/openai';
 import { Ollama } from '@llamaindex/ollama';
-import { createServer } from 'http';
 import { spawn } from 'child_process';
 import { rmSync } from 'fs';
 
@@ -297,791 +297,791 @@ function interpolateVariables(value, variables) {
     }
   });
 }
-
-// src/integrations/email/inbucketClient.ts
-var InbucketClient = class {
-  constructor(config) {
-    this.endpoint = config.endpoint.replace(/\/$/, "");
+var TrackingServer = class {
+  constructor() {
+    this.server = null;
+    this.resources = /* @__PURE__ */ new Map();
+    this.port = 0;
   }
-  /**
-   * Extract mailbox name from email (e.g., "test@example.com" → "test")
-   */
-  getMailboxName(email) {
-    return email.split("@")[0];
+  async start(options = {}) {
+    return new Promise((resolve, reject) => {
+      this.server = createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+      this.server.on("error", (error) => {
+        reject(error);
+      });
+      const port = options.port ?? 0;
+      this.server.listen(port, () => {
+        const address = this.server?.address();
+        if (address && typeof address === "object") {
+          this.port = address.port;
+          resolve();
+        } else {
+          reject(new Error("Failed to get server port"));
+        }
+      });
+    });
   }
-  /**
-   * List all messages in a mailbox
-   */
-  async listMessages(email) {
-    const mailbox = this.getMailboxName(email);
-    const url = `${this.endpoint}/api/v1/mailbox/${mailbox}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(
-        `Failed to list messages for ${email}: ${response.status} ${response.statusText}`
-      );
+  handleRequest(req, res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
     }
-    const messages = await response.json();
-    return messages;
-  }
-  /**
-   * Get a specific message
-   */
-  async getMessage(email, id) {
-    const mailbox = this.getMailboxName(email);
-    const url = `${this.endpoint}/api/v1/mailbox/${mailbox}/${id}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(
-        `Failed to get message ${id} for ${email}: ${response.status} ${response.statusText}`
-      );
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    if (req.method === "POST" && url.pathname === "/track") {
+      this.handleTrackRequest(req, res);
+    } else if (req.method === "GET" && url.pathname.startsWith("/resources/")) {
+      this.handleGetResources(url, res);
+    } else {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
     }
-    const message = await response.json();
-    return message;
   }
-  /**
-   * Wait for an email to arrive (polling with timeout)
-   */
-  async waitForEmail(email, options) {
-    const timeout = options?.timeout ?? 3e4;
-    const pollInterval = options?.pollInterval ?? 1e3;
-    const subjectContains = options?.subjectContains;
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-      const messages = await this.listMessages(email);
-      const matchingMessage = messages.find((msg) => {
-        if (subjectContains) {
-          return msg.subject.includes(subjectContains);
+  handleTrackRequest(req, res) {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        const trackRequest = JSON.parse(body);
+        if (!trackRequest.sessionId || !trackRequest.type || !trackRequest.id) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Missing required fields (sessionId, type, id)" }));
+          return;
         }
-        return true;
-      });
-      if (matchingMessage) {
-        return await this.getMessage(email, matchingMessage.id);
+        const { sessionId, ...resourceData } = trackRequest;
+        const resource = {
+          ...resourceData,
+          type: trackRequest.type,
+          id: trackRequest.id,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const sessionResources = this.resources.get(sessionId) || [];
+        sessionResources.push(resource);
+        this.resources.set(sessionId, sessionResources);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: true }));
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON" }));
       }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    });
+    req.on("error", () => {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Internal server error" }));
+    });
+  }
+  handleGetResources(url, res) {
+    const sessionId = url.pathname.split("/").pop();
+    if (!sessionId) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing sessionId" }));
+      return;
     }
-    throw new Error(
-      `Timeout waiting for email to ${email}${subjectContains ? ` with subject containing "${subjectContains}"` : ""}`
-    );
+    const resources = this.resources.get(sessionId) || [];
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ resources }));
   }
-  /**
-   * Extract verification code from email body
-   */
-  extractCode(email, pattern) {
-    const regex = pattern ?? /\b(\d{6})\b/;
-    const text = email.body.text || email.body.html;
-    const match = text.match(regex);
-    return match ? match[1] : null;
+  getResources(sessionId) {
+    return this.resources.get(sessionId) ?? [];
   }
-  /**
-   * Extract link from email body
-   */
-  extractLink(email, pattern) {
-    const regex = pattern ?? /https?:\/\/[^\s"'<>]+/;
-    const text = email.body.text || email.body.html;
-    const match = text.match(regex);
-    return match ? match[0] : null;
+  clearSession(sessionId) {
+    this.resources.delete(sessionId);
   }
-  /**
-   * Delete a specific message
-   */
-  async deleteMessage(email, id) {
-    const mailbox = this.getMailboxName(email);
-    const url = `${this.endpoint}/api/v1/mailbox/${mailbox}/${id}`;
-    const response = await fetch(url, {
-      method: "DELETE"
+  async stop() {
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        resolve();
+        return;
+      }
+      this.server.close((error) => {
+        if (error) {
+          reject(error);
+        } else {
+          this.server = null;
+          resolve();
+        }
+      });
     });
-    if (!response.ok) {
-      throw new Error(
-        `Failed to delete message ${id} for ${email}: ${response.status} ${response.statusText}`
-      );
-    }
   }
-  /**
-   * Clear all messages in a mailbox
-   */
-  async clearMailbox(email) {
-    const mailbox = this.getMailboxName(email);
-    const url = `${this.endpoint}/api/v1/mailbox/${mailbox}`;
-    const response = await fetch(url, {
-      method: "DELETE"
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Failed to clear mailbox for ${email}: ${response.status} ${response.statusText}`
-      );
+};
+async function startTrackingServer(options) {
+  const server = new TrackingServer();
+  await server.start(options);
+  return server;
+}
+var TRACK_DIR = ".intellitester/track";
+var ACTIVE_TESTS_FILE = "ACTIVE_TESTS.json";
+var DEFAULT_STALE_MS = 2 * 60 * 60 * 1e3;
+var HEARTBEAT_MS = 15e3;
+var getTrackDir = (cwd, trackDir) => trackDir ? path4__default.resolve(cwd, trackDir) : path4__default.join(cwd, TRACK_DIR);
+var getActiveTestsPath = (cwd, trackDir) => path4__default.join(getTrackDir(cwd, trackDir), ACTIVE_TESTS_FILE);
+var loadActiveTests = async (cwd, trackDir) => {
+  const filePath = getActiveTestsPath(cwd, trackDir);
+  try {
+    const content = await fs__default.readFile(filePath, "utf8");
+    const parsed = JSON.parse(content);
+    if (!parsed.sessions || typeof parsed.sessions !== "object") {
+      throw new Error("Invalid ACTIVE_TESTS structure");
     }
+    return parsed;
+  } catch {
+    return {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sessions: {}
+    };
   }
 };
-var AppwriteTestClient = class {
-  constructor(config) {
-    this.config = config;
-    this.client = new Client().setEndpoint(config.endpoint).setProject(config.projectId).setKey(config.apiKey);
-    this.users = new Users(this.client);
-    this.tablesDB = new TablesDB(this.client);
-    this.storage = new Storage(this.client);
-    this.teams = new Teams(this.client);
-  }
-  async cleanup(context, sessionId, cwd) {
-    const deleted = [];
-    const failed = [];
-    const sortedResources = [...context.resources].reverse();
-    for (const resource of sortedResources) {
-      if (resource.deleted) {
-        deleted.push(`${resource.type}:${resource.id} (already deleted)`);
-        continue;
-      }
-      try {
-        switch (resource.type) {
-          case "row":
-            if (resource.databaseId && resource.tableId) {
-              await this.tablesDB.deleteRow({
-                databaseId: resource.databaseId,
-                tableId: resource.tableId,
-                rowId: resource.id
-              });
-            }
-            break;
-          case "file":
-            if (resource.bucketId) {
-              await this.storage.deleteFile(resource.bucketId, resource.id);
-            }
-            break;
-          case "membership":
-            if (resource.teamId) {
-              await this.teams.deleteMembership(resource.teamId, resource.id);
-            }
-            break;
-          case "team":
-            await this.teams.delete(resource.id);
-            break;
-          case "message":
-            deleted.push(`${resource.type}:${resource.id} (skipped - messages cannot be deleted)`);
-            continue;
-          case "user":
-            break;
-        }
-        deleted.push(`${resource.type}:${resource.id}`);
-      } catch (error) {
-        failed.push(`${resource.type}:${resource.id}`);
-        console.warn(`Failed to delete ${resource.type} ${resource.id}:`, error);
-      }
-    }
-    if (context.userId) {
-      try {
-        await this.users.delete(context.userId);
-        deleted.push(`user:${context.userId}`);
-      } catch (error) {
-        failed.push(`user:${context.userId}`);
-        console.warn(`Failed to delete user ${context.userId}:`, error);
-      }
-    }
-    if (failed.length > 0 && sessionId) {
-      const failedResources = context.resources.filter(
-        (r) => failed.some((f) => f.includes(r.id))
-      );
-      await saveFailedCleanup({
-        sessionId,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        resources: failedResources.map((r) => ({
-          type: r.type,
-          id: r.id,
-          databaseId: r.databaseId,
-          tableId: r.tableId,
-          bucketId: r.bucketId,
-          teamId: r.teamId
-        })),
-        providerConfig: {
-          provider: "appwrite",
-          endpoint: this.config.endpoint,
-          projectId: this.config.projectId
-        },
-        errors: failed
-      }, cwd);
-    }
-    return { success: failed.length === 0, deleted, failed };
-  }
-};
-function createTestContext() {
-  return {
-    resources: [],
-    variables: /* @__PURE__ */ new Map()
-  };
-}
-
-// src/integrations/appwrite/types.ts
-var APPWRITE_PATTERNS = {
-  userCreate: /\/v1\/account$/,
-  rowCreate: /\/v1\/tablesdb\/([\w-]+)\/tables\/([\w-]+)\/rows$/,
-  fileCreate: /\/v1\/storage\/buckets\/([\w-]+)\/files$/,
-  teamCreate: /\/v1\/teams$/,
-  membershipCreate: /\/v1\/teams\/([\w-]+)\/memberships$/,
-  messageCreate: /\/v1\/messaging\/messages$/
-};
-var APPWRITE_UPDATE_PATTERNS = {
-  rowUpdate: /\/v1\/tablesdb\/([\w-]+)\/tables\/([\w-]+)\/rows\/([\w-]+)$/,
-  fileUpdate: /\/v1\/storage\/buckets\/([\w-]+)\/files\/([\w-]+)$/,
-  teamUpdate: /\/v1\/teams\/([\w-]+)$/
-};
-var APPWRITE_DELETE_PATTERNS = {
-  rowDelete: /\/v1\/tablesdb\/([\w-]+)\/tables\/([\w-]+)\/rows\/([\w-]+)$/,
-  fileDelete: /\/v1\/storage\/buckets\/([\w-]+)\/files\/([\w-]+)$/,
-  teamDelete: /\/v1\/teams\/([\w-]+)$/,
-  membershipDelete: /\/v1\/teams\/([\w-]+)\/memberships\/([\w-]+)$/
+var saveActiveTests = async (cwd, state, trackDir) => {
+  const filePath = getActiveTestsPath(cwd, trackDir);
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await fs__default.writeFile(filePath, JSON.stringify(state, null, 2), "utf8");
 };
-
-// src/executors/web/browserOptions.ts
-var VIEWPORT_SIZES = {
-  xs: { width: 320, height: 568 },
-  // Mobile portrait
-  sm: { width: 640, height: 800 },
-  // Small tablet
-  md: { width: 768, height: 1024 },
-  // Tablet
-  lg: { width: 1024, height: 768 },
-  // Desktop
-  xl: { width: 1280, height: 720 }
-  // Large desktop
+var isStale = (entry, staleMs) => {
+  const last = new Date(entry.lastUpdated).getTime();
+  if (Number.isNaN(last)) return true;
+  return Date.now() - last > staleMs;
 };
-function parseViewportSize(size) {
-  if (size in VIEWPORT_SIZES) {
-    return VIEWPORT_SIZES[size];
-  }
-  const match = size.match(/^(\d+)x(\d+)$/);
-  if (match) {
-    const width = parseInt(match[1], 10);
-    const height = parseInt(match[2], 10);
-    if (width > 0 && height > 0) {
-      return { width, height };
-    }
-  }
-  return null;
-}
-function getBrowserLaunchOptions(options) {
-  const { headless, browser } = options;
-  if (browser === "chromium" || !browser) {
-    return {
-      headless,
-      args: [
-        // Use Chrome's new headless mode which behaves more like regular browser
-        ...headless ? ["--headless=new"] : [],
-        // For Docker/CI environments - disables sandboxing (required for root/container)
-        "--no-sandbox",
-        // Shared memory - critical for Docker/CI, harmless locally
-        "--disable-dev-shm-usage",
-        // GPU acceleration - not needed in headless mode
-        "--disable-gpu",
-        // Set explicit window size (fallback for viewport)
-        "--window-size=1920,1080",
-        // Reduce overhead
-        "--disable-extensions",
-        // Prevent JavaScript throttling (helps with slow page loads)
-        "--disable-background-timer-throttling",
-        "--disable-backgrounding-occluded-windows",
-        "--disable-renderer-backgrounding",
-        // Process isolation - reduces overhead for testing
-        "--disable-features=IsolateOrigins,site-per-process",
-        // Networking tweaks
-        "--disable-features=VizDisplayCompositor",
-        "--disable-blink-features=AutomationControlled"
-      ]
-    };
-  }
-  if (browser === "firefox") {
-    return {
-      headless,
-      firefoxUserPrefs: {
-        // Enable JIT (disabled in automation mode by default, causes 2-4x JS slowdown)
-        "javascript.options.jit": true,
-        // Disable fission for stability/speed
-        "fission.autostart": false,
-        // Disable hardware acceleration overhead in headless
-        "layers.acceleration.disabled": true,
-        "gfx.webrender.all": false
+var readTrackedResources = async (trackFile) => {
+  try {
+    const content = await fs__default.readFile(trackFile, "utf8");
+    if (!content.trim()) return [];
+    return content.split("\n").filter(Boolean).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
       }
-    };
+    }).filter((entry) => Boolean(entry));
+  } catch {
+    return [];
   }
-  return { headless };
-}
-function resolveEnvVars(value) {
-  return value.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] || "");
-}
-var AnthropicProvider = class {
-  constructor(config) {
-    this.config = config;
-    const apiKey = config.apiKey ? resolveEnvVars(config.apiKey) : void 0;
-    this.client = new Anthropic({
-      apiKey,
-      model: this.config.model,
-      temperature: this.config.temperature
+};
+var cleanupStaleSession = async (entry, cleanupConfig) => {
+  if (!entry.providerConfig || !cleanupConfig?.provider) return;
+  const resources = await readTrackedResources(entry.trackFile);
+  if (resources.length === 0) return;
+  try {
+    const { handlers, typeMappings, provider } = await loadCleanupHandlers(cleanupConfig, entry.cwd);
+    if (!provider) return;
+    await executeCleanup(resources, handlers, typeMappings, {
+      parallel: cleanupConfig.parallel ?? false,
+      retries: cleanupConfig.retries ?? 3,
+      sessionId: entry.sessionId,
+      testStartTime: entry.startedAt,
+      providerConfig: entry.providerConfig,
+      cwd: entry.cwd,
+      config: { ...cleanupConfig, scanUntracked: false },
+      provider
     });
+  } catch {
   }
-  async generateCompletion(prompt, systemPrompt) {
-    const messages = [];
-    if (systemPrompt) {
-      messages.push({ role: "system", content: systemPrompt });
-    }
-    messages.push({ role: "user", content: prompt });
-    const response = await this.client.chat({ messages });
-    const content = response.message.content;
-    if (!content) {
-      throw new Error("No content in Anthropic response");
+};
+var cleanupOrphanedTrackFiles = async (cwd, state, trackDir) => {
+  const dir = getTrackDir(cwd, trackDir);
+  try {
+    const files = await fs__default.readdir(dir);
+    const activeFiles = new Set(Object.values(state.sessions).map((s) => path4__default.basename(s.trackFile)));
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      if (activeFiles.has(file)) continue;
+      const filePath = path4__default.join(dir, file);
+      try {
+        const stat2 = await fs__default.stat(filePath);
+        const staleMs = Number(process.env.INTELLITESTER_STALE_TEST_MS ?? DEFAULT_STALE_MS);
+        const isOld = Date.now() - stat2.mtimeMs > staleMs;
+        const isEmpty = stat2.size === 0;
+        if (isEmpty || isOld) {
+          await fs__default.rm(filePath, { force: true });
+        }
+      } catch {
+      }
     }
-    return typeof content === "string" ? content : JSON.stringify(content);
+  } catch {
   }
 };
-var OpenAIProvider = class {
-  constructor(config) {
-    this.config = config;
-    const apiKey = config.apiKey ? resolveEnvVars(config.apiKey) : void 0;
-    const baseURL = config.baseUrl;
-    this.client = new OpenAI({
-      apiKey,
-      model: this.config.model,
-      temperature: this.config.temperature,
-      baseURL
-    });
-  }
-  async generateCompletion(prompt, systemPrompt) {
-    const messages = [];
-    if (systemPrompt) {
-      messages.push({ role: "system", content: systemPrompt });
+var pruneStaleTests = async (cwd, cleanupConfig, trackDir) => {
+  const state = await loadActiveTests(cwd, trackDir);
+  const staleMs = Number(process.env.INTELLITESTER_STALE_TEST_MS ?? DEFAULT_STALE_MS);
+  let changed = false;
+  for (const [sessionId, entry] of Object.entries(state.sessions)) {
+    let missingFile = false;
+    let isEmpty = false;
+    try {
+      const stat2 = await fs__default.stat(entry.trackFile);
+      isEmpty = stat2.size === 0;
+    } catch {
+      missingFile = true;
     }
-    messages.push({ role: "user", content: prompt });
-    const response = await this.client.chat({ messages });
-    const content = response.message.content;
-    if (!content) {
-      throw new Error("No content in OpenAI response");
+    if (!missingFile && !isEmpty && !isStale(entry, staleMs)) continue;
+    changed = true;
+    await cleanupStaleSession(entry, cleanupConfig);
+    try {
+      await fs__default.rm(entry.trackFile, { force: true });
+    } catch {
     }
-    return typeof content === "string" ? content : JSON.stringify(content);
+    delete state.sessions[sessionId];
   }
-};
-var OllamaProvider = class {
-  constructor(config) {
-    this.config = config;
-    this.client = new Ollama({
-      model: this.config.model,
-      options: {
-        temperature: this.config.temperature
-      }
-    });
+  if (changed) {
+    await saveActiveTests(cwd, state, trackDir);
   }
-  async generateCompletion(prompt, systemPrompt) {
-    const messages = [];
-    if (systemPrompt) {
-      messages.push({ role: "system", content: systemPrompt });
+  await cleanupOrphanedTrackFiles(cwd, state, trackDir);
+};
+async function initFileTracking(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const trackDir = options.trackDir;
+  await fs__default.mkdir(getTrackDir(cwd, trackDir), { recursive: true });
+  await pruneStaleTests(cwd, options.cleanupConfig, trackDir);
+  const trackFile = path4__default.join(getTrackDir(cwd, trackDir), `TEST_SESSION_${options.sessionId}.jsonl`);
+  await fs__default.writeFile(trackFile, "", "utf8");
+  const state = await loadActiveTests(cwd, trackDir);
+  state.sessions[options.sessionId] = {
+    sessionId: options.sessionId,
+    trackFile,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    cwd,
+    providerConfig: options.providerConfig
+  };
+  await saveActiveTests(cwd, state, trackDir);
+  const touch = async () => {
+    const current = await loadActiveTests(cwd, trackDir);
+    const entry = current.sessions[options.sessionId];
+    if (!entry) return;
+    entry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    current.sessions[options.sessionId] = entry;
+    await saveActiveTests(cwd, current, trackDir);
+  };
+  const interval = setInterval(() => {
+    void touch();
+  }, HEARTBEAT_MS);
+  const stop = async () => {
+    clearInterval(interval);
+    const current = await loadActiveTests(cwd, trackDir);
+    delete current.sessions[options.sessionId];
+    await saveActiveTests(cwd, current, trackDir);
+    try {
+      await fs__default.rm(trackFile, { force: true });
+    } catch {
     }
-    messages.push({ role: "user", content: prompt });
-    const response = await this.client.chat({ messages });
-    const content = response.message.content;
-    if (!content) {
-      throw new Error("No content in Ollama response");
+  };
+  return { trackFile, stop };
+}
+async function mergeFileTrackedResources(trackFile, target, allowedTypes) {
+  const entries = await readTrackedResources(trackFile);
+  for (const entry of entries) {
+    const resource = entry;
+    if (!resource.type || !resource.id) continue;
+    if (allowedTypes && !allowedTypes.has(String(resource.type))) continue;
+    const exists = target.resources.some(
+      (existing) => existing.type === resource.type && existing.id === resource.id
+    );
+    if (!exists) {
+      target.resources.push(resource);
+    }
+    if (resource.type === "user") {
+      if (!target.userId && typeof resource.id === "string") {
+        target.userId = resource.id;
+      }
+      const email = resource.email;
+      if (!target.userEmail && typeof email === "string") {
+        target.userEmail = email;
+      }
     }
-    return typeof content === "string" ? content : JSON.stringify(content);
-  }
-};
-function createAIProvider(config) {
-  switch (config.provider) {
-    case "anthropic":
-      return new AnthropicProvider(config);
-    case "openai":
-      return new OpenAIProvider(config);
-    case "ollama":
-      return new OllamaProvider(config);
   }
 }
 
-// src/ai/errorHelper.ts
-function formatLocator(locator) {
-  const parts = [];
-  if (locator.testId) parts.push(`testId: "${locator.testId}"`);
-  if (locator.text) parts.push(`text: "${locator.text}"`);
-  if (locator.css) parts.push(`css: "${locator.css}"`);
-  if (locator.xpath) parts.push(`xpath: "${locator.xpath}"`);
-  if (locator.role) parts.push(`role: "${locator.role}"`);
-  if (locator.name) parts.push(`name: "${locator.name}"`);
-  if (locator.description) parts.push(`description: "${locator.description}"`);
-  return parts.join(", ");
-}
-function formatAction(action) {
-  switch (action.type) {
-    case "tap":
-      return `tap on element (${formatLocator(action.target)})`;
-    case "input":
-      return `input into element (${formatLocator(action.target)})`;
-    case "assert":
-      return `assert element exists (${formatLocator(action.target)})`;
-    case "wait":
-      return action.target ? `wait for element (${formatLocator(action.target)})` : `wait ${action.timeout}ms`;
-    case "scroll":
-      return action.target ? `scroll to element (${formatLocator(action.target)})` : `scroll ${action.direction || "down"}`;
-    default:
-      return action.type;
+// src/integrations/email/inbucketClient.ts
+var InbucketClient = class {
+  constructor(config) {
+    this.endpoint = config.endpoint.replace(/\/$/, "");
   }
-}
-async function getAISuggestion(error, action, pageContent, screenshot, aiConfig) {
-  if (!aiConfig) {
-    return {
-      hasSuggestion: false,
-      explanation: "AI configuration not provided. Cannot generate suggestions."
-    };
+  /**
+   * Extract mailbox name from email (e.g., "test@example.com" → "test")
+   */
+  getMailboxName(email) {
+    return email.split("@")[0];
   }
-  try {
-    const provider = createAIProvider(aiConfig);
-    const systemPrompt = `You are an expert at analyzing web automation errors and suggesting better element selectors.
-Your task is to analyze failed actions and suggest better selectors based on the page content and error message.
-
-Return your response in the following JSON format:
-{
-  "hasSuggestion": boolean,
-  "suggestedSelector": {
-    "testId": "string (optional)",
-    "text": "string (optional)",
-    "css": "string (optional)",
-    "role": "string (optional)",
-    "name": "string (optional)"
-  },
-  "explanation": "string explaining why this selector is better"
-}
-
-Prefer selectors in this order:
-1. testId (most reliable)
-2. text (good for user-facing elements)
-3. role with name (semantic and accessible)
-4. css (last resort, but can be precise)
-
-Do not suggest xpath unless absolutely necessary.`;
-    const prompt = `Action failed: ${formatAction(action)}
-
-Error message:
-${error}
-
-Page content (truncated to 10000 chars):
-${pageContent.slice(0, 1e4)}
-
-${screenshot ? "[Screenshot attached but not analyzed in this implementation]" : ""}
-
-Please analyze the error and suggest a better selector that would work reliably. Focus on:
-- What went wrong with the current selector
-- What selector would be more reliable
-- Why the suggested selector is better
-
-Return ONLY valid JSON, no additional text.`;
-    const response = await provider.generateCompletion(prompt, systemPrompt);
-    let jsonStr = response.trim();
-    if (jsonStr.startsWith("```json")) {
-      jsonStr = jsonStr.replace(/^```json\s*/, "").replace(/\s*```$/, "");
-    } else if (jsonStr.startsWith("```")) {
-      jsonStr = jsonStr.replace(/^```\s*/, "").replace(/\s*```$/, "");
+  /**
+   * List all messages in a mailbox
+   */
+  async listMessages(email) {
+    const mailbox = this.getMailboxName(email);
+    const url = `${this.endpoint}/api/v1/mailbox/${mailbox}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to list messages for ${email}: ${response.status} ${response.statusText}`
+      );
     }
-    const parsed = JSON.parse(jsonStr);
-    return parsed;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return {
-      hasSuggestion: false,
-      explanation: `Failed to generate AI suggestion: ${message}`
-    };
+    const messages = await response.json();
+    return messages;
   }
-}
-var TrackingServer = class {
-  constructor() {
-    this.server = null;
-    this.resources = /* @__PURE__ */ new Map();
-    this.port = 0;
+  /**
+   * Get a specific message
+   */
+  async getMessage(email, id) {
+    const mailbox = this.getMailboxName(email);
+    const url = `${this.endpoint}/api/v1/mailbox/${mailbox}/${id}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to get message ${id} for ${email}: ${response.status} ${response.statusText}`
+      );
+    }
+    const message = await response.json();
+    return message;
   }
-  async start(options = {}) {
-    return new Promise((resolve, reject) => {
-      this.server = createServer((req, res) => {
-        this.handleRequest(req, res);
-      });
-      this.server.on("error", (error) => {
-        reject(error);
-      });
-      const port = options.port ?? 0;
-      this.server.listen(port, () => {
-        const address = this.server?.address();
-        if (address && typeof address === "object") {
-          this.port = address.port;
-          resolve();
-        } else {
-          reject(new Error("Failed to get server port"));
+  /**
+   * Wait for an email to arrive (polling with timeout)
+   */
+  async waitForEmail(email, options) {
+    const timeout = options?.timeout ?? 3e4;
+    const pollInterval = options?.pollInterval ?? 1e3;
+    const subjectContains = options?.subjectContains;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const messages = await this.listMessages(email);
+      const matchingMessage = messages.find((msg) => {
+        if (subjectContains) {
+          return msg.subject.includes(subjectContains);
         }
+        return true;
       });
-    });
-  }
-  handleRequest(req, res) {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
+      if (matchingMessage) {
+        return await this.getMessage(email, matchingMessage.id);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
     }
-    const url = new URL(req.url || "/", `http://${req.headers.host}`);
-    if (req.method === "POST" && url.pathname === "/track") {
-      this.handleTrackRequest(req, res);
-    } else if (req.method === "GET" && url.pathname.startsWith("/resources/")) {
-      this.handleGetResources(url, res);
-    } else {
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Not found" }));
+    throw new Error(
+      `Timeout waiting for email to ${email}${subjectContains ? ` with subject containing "${subjectContains}"` : ""}`
+    );
+  }
+  /**
+   * Extract verification code from email body
+   */
+  extractCode(email, pattern) {
+    const regex = pattern ?? /\b(\d{6})\b/;
+    const text = email.body.text || email.body.html;
+    const match = text.match(regex);
+    return match ? match[1] : null;
+  }
+  /**
+   * Extract link from email body
+   */
+  extractLink(email, pattern) {
+    const regex = pattern ?? /https?:\/\/[^\s"'<>]+/;
+    const text = email.body.text || email.body.html;
+    const match = text.match(regex);
+    return match ? match[0] : null;
+  }
+  /**
+   * Delete a specific message
+   */
+  async deleteMessage(email, id) {
+    const mailbox = this.getMailboxName(email);
+    const url = `${this.endpoint}/api/v1/mailbox/${mailbox}/${id}`;
+    const response = await fetch(url, {
+      method: "DELETE"
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to delete message ${id} for ${email}: ${response.status} ${response.statusText}`
+      );
     }
   }
-  handleTrackRequest(req, res) {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk.toString();
+  /**
+   * Clear all messages in a mailbox
+   */
+  async clearMailbox(email) {
+    const mailbox = this.getMailboxName(email);
+    const url = `${this.endpoint}/api/v1/mailbox/${mailbox}`;
+    const response = await fetch(url, {
+      method: "DELETE"
     });
-    req.on("end", () => {
+    if (!response.ok) {
+      throw new Error(
+        `Failed to clear mailbox for ${email}: ${response.status} ${response.statusText}`
+      );
+    }
+  }
+};
+var AppwriteTestClient = class {
+  constructor(config) {
+    this.config = config;
+    this.client = new Client().setEndpoint(config.endpoint).setProject(config.projectId).setKey(config.apiKey);
+    this.users = new Users(this.client);
+    this.tablesDB = new TablesDB(this.client);
+    this.storage = new Storage(this.client);
+    this.teams = new Teams(this.client);
+  }
+  async cleanup(context, sessionId, cwd) {
+    const deleted = [];
+    const failed = [];
+    const sortedResources = [...context.resources].reverse();
+    for (const resource of sortedResources) {
+      if (resource.deleted) {
+        deleted.push(`${resource.type}:${resource.id} (already deleted)`);
+        continue;
+      }
       try {
-        const trackRequest = JSON.parse(body);
-        if (!trackRequest.sessionId || !trackRequest.type || !trackRequest.id) {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Missing required fields (sessionId, type, id)" }));
-          return;
+        switch (resource.type) {
+          case "row":
+            if (resource.databaseId && resource.tableId) {
+              await this.tablesDB.deleteRow({
+                databaseId: resource.databaseId,
+                tableId: resource.tableId,
+                rowId: resource.id
+              });
+            }
+            break;
+          case "file":
+            if (resource.bucketId) {
+              await this.storage.deleteFile(resource.bucketId, resource.id);
+            }
+            break;
+          case "membership":
+            if (resource.teamId) {
+              await this.teams.deleteMembership(resource.teamId, resource.id);
+            }
+            break;
+          case "team":
+            await this.teams.delete(resource.id);
+            break;
+          case "message":
+            deleted.push(`${resource.type}:${resource.id} (skipped - messages cannot be deleted)`);
+            continue;
+          case "user":
+            break;
         }
-        const { sessionId, ...resourceData } = trackRequest;
-        const resource = {
-          ...resourceData,
-          type: trackRequest.type,
-          id: trackRequest.id,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        const sessionResources = this.resources.get(sessionId) || [];
-        sessionResources.push(resource);
-        this.resources.set(sessionId, sessionResources);
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ success: true }));
-      } catch {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Invalid JSON" }));
+        deleted.push(`${resource.type}:${resource.id}`);
+      } catch (error) {
+        failed.push(`${resource.type}:${resource.id}`);
+        console.warn(`Failed to delete ${resource.type} ${resource.id}:`, error);
       }
-    });
-    req.on("error", () => {
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Internal server error" }));
-    });
-  }
-  handleGetResources(url, res) {
-    const sessionId = url.pathname.split("/").pop();
-    if (!sessionId) {
-      res.writeHead(400, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Missing sessionId" }));
-      return;
     }
-    const resources = this.resources.get(sessionId) || [];
-    res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ resources }));
-  }
-  getResources(sessionId) {
-    return this.resources.get(sessionId) ?? [];
-  }
-  clearSession(sessionId) {
-    this.resources.delete(sessionId);
-  }
-  async stop() {
-    return new Promise((resolve, reject) => {
-      if (!this.server) {
-        resolve();
-        return;
-      }
-      this.server.close((error) => {
-        if (error) {
-          reject(error);
-        } else {
-          this.server = null;
-          resolve();
-        }
-      });
-    });
+    if (context.userId) {
+      try {
+        await this.users.delete(context.userId);
+        deleted.push(`user:${context.userId}`);
+      } catch (error) {
+        failed.push(`user:${context.userId}`);
+        console.warn(`Failed to delete user ${context.userId}:`, error);
+      }
+    }
+    if (failed.length > 0 && sessionId) {
+      const failedResources = context.resources.filter(
+        (r) => failed.some((f) => f.includes(r.id))
+      );
+      await saveFailedCleanup({
+        sessionId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        resources: failedResources.map((r) => ({
+          type: r.type,
+          id: r.id,
+          databaseId: r.databaseId,
+          tableId: r.tableId,
+          bucketId: r.bucketId,
+          teamId: r.teamId
+        })),
+        providerConfig: {
+          provider: "appwrite",
+          endpoint: this.config.endpoint,
+          projectId: this.config.projectId
+        },
+        errors: failed
+      }, cwd);
+    }
+    return { success: failed.length === 0, deleted, failed };
   }
 };
-async function startTrackingServer(options) {
-  const server = new TrackingServer();
-  await server.start(options);
-  return server;
+function createTestContext() {
+  return {
+    resources: [],
+    variables: /* @__PURE__ */ new Map()
+  };
 }
-var TRACK_DIR = ".intellitester/track";
-var ACTIVE_TESTS_FILE = "ACTIVE_TESTS.json";
-var DEFAULT_STALE_MS = 2 * 60 * 60 * 1e3;
-var HEARTBEAT_MS = 15e3;
-var getTrackDir = (cwd, trackDir) => trackDir ? path4__default.resolve(cwd, trackDir) : path4__default.join(cwd, TRACK_DIR);
-var getActiveTestsPath = (cwd, trackDir) => path4__default.join(getTrackDir(cwd, trackDir), ACTIVE_TESTS_FILE);
-var loadActiveTests = async (cwd, trackDir) => {
-  const filePath = getActiveTestsPath(cwd, trackDir);
-  try {
-    const content = await fs__default.readFile(filePath, "utf8");
-    const parsed = JSON.parse(content);
-    if (!parsed.sessions || typeof parsed.sessions !== "object") {
-      throw new Error("Invalid ACTIVE_TESTS structure");
+
+// src/integrations/appwrite/types.ts
+var APPWRITE_PATTERNS = {
+  userCreate: /\/v1\/account$/,
+  rowCreate: /\/v1\/tablesdb\/([\w-]+)\/tables\/([\w-]+)\/rows$/,
+  fileCreate: /\/v1\/storage\/buckets\/([\w-]+)\/files$/,
+  teamCreate: /\/v1\/teams$/,
+  membershipCreate: /\/v1\/teams\/([\w-]+)\/memberships$/,
+  messageCreate: /\/v1\/messaging\/messages$/
+};
+var APPWRITE_UPDATE_PATTERNS = {
+  rowUpdate: /\/v1\/tablesdb\/([\w-]+)\/tables\/([\w-]+)\/rows\/([\w-]+)$/,
+  fileUpdate: /\/v1\/storage\/buckets\/([\w-]+)\/files\/([\w-]+)$/,
+  teamUpdate: /\/v1\/teams\/([\w-]+)$/
+};
+var APPWRITE_DELETE_PATTERNS = {
+  rowDelete: /\/v1\/tablesdb\/([\w-]+)\/tables\/([\w-]+)\/rows\/([\w-]+)$/,
+  fileDelete: /\/v1\/storage\/buckets\/([\w-]+)\/files\/([\w-]+)$/,
+  teamDelete: /\/v1\/teams\/([\w-]+)$/,
+  membershipDelete: /\/v1\/teams\/([\w-]+)\/memberships\/([\w-]+)$/
+};
+
+// src/executors/web/browserOptions.ts
+var VIEWPORT_SIZES = {
+  xs: { width: 320, height: 568 },
+  // Mobile portrait
+  sm: { width: 640, height: 800 },
+  // Small tablet
+  md: { width: 768, height: 1024 },
+  // Tablet
+  lg: { width: 1024, height: 768 },
+  // Desktop
+  xl: { width: 1280, height: 720 }
+  // Large desktop
+};
+function parseViewportSize(size) {
+  if (size in VIEWPORT_SIZES) {
+    return VIEWPORT_SIZES[size];
+  }
+  const match = size.match(/^(\d+)x(\d+)$/);
+  if (match) {
+    const width = parseInt(match[1], 10);
+    const height = parseInt(match[2], 10);
+    if (width > 0 && height > 0) {
+      return { width, height };
     }
-    return parsed;
-  } catch {
+  }
+  return null;
+}
+function getBrowserLaunchOptions(options) {
+  const { headless, browser } = options;
+  if (browser === "chromium" || !browser) {
     return {
-      version: 1,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      sessions: {}
+      headless,
+      args: [
+        // Use Chrome's new headless mode which behaves more like regular browser
+        ...headless ? ["--headless=new"] : [],
+        // For Docker/CI environments - disables sandboxing (required for root/container)
+        "--no-sandbox",
+        // Shared memory - critical for Docker/CI, harmless locally
+        "--disable-dev-shm-usage",
+        // GPU acceleration - not needed in headless mode
+        "--disable-gpu",
+        // Set explicit window size (fallback for viewport)
+        "--window-size=1920,1080",
+        // Reduce overhead
+        "--disable-extensions",
+        // Prevent JavaScript throttling (helps with slow page loads)
+        "--disable-background-timer-throttling",
+        "--disable-backgrounding-occluded-windows",
+        "--disable-renderer-backgrounding",
+        // Process isolation - reduces overhead for testing
+        "--disable-features=IsolateOrigins,site-per-process",
+        // Networking tweaks
+        "--disable-features=VizDisplayCompositor",
+        "--disable-blink-features=AutomationControlled"
+      ]
     };
   }
-};
-var saveActiveTests = async (cwd, state, trackDir) => {
-  const filePath = getActiveTestsPath(cwd, trackDir);
-  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await fs__default.writeFile(filePath, JSON.stringify(state, null, 2), "utf8");
-};
-var isStale = (entry, staleMs) => {
-  const last = new Date(entry.lastUpdated).getTime();
-  if (Number.isNaN(last)) return true;
-  return Date.now() - last > staleMs;
-};
-var readTrackedResources = async (trackFile) => {
-  try {
-    const content = await fs__default.readFile(trackFile, "utf8");
-    if (!content.trim()) return [];
-    return content.split("\n").filter(Boolean).map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
+  if (browser === "firefox") {
+    return {
+      headless,
+      firefoxUserPrefs: {
+        // Enable JIT (disabled in automation mode by default, causes 2-4x JS slowdown)
+        "javascript.options.jit": true,
+        // Disable fission for stability/speed
+        "fission.autostart": false,
+        // Disable hardware acceleration overhead in headless
+        "layers.acceleration.disabled": true,
+        "gfx.webrender.all": false
       }
-    }).filter((entry) => Boolean(entry));
-  } catch {
-    return [];
+    };
   }
-};
-var cleanupStaleSession = async (entry, cleanupConfig) => {
-  if (!entry.providerConfig || !cleanupConfig?.provider) return;
-  const resources = await readTrackedResources(entry.trackFile);
-  if (resources.length === 0) return;
-  try {
-    const { handlers, typeMappings, provider } = await loadCleanupHandlers(cleanupConfig, entry.cwd);
-    if (!provider) return;
-    await executeCleanup(resources, handlers, typeMappings, {
-      parallel: cleanupConfig.parallel ?? false,
-      retries: cleanupConfig.retries ?? 3,
-      sessionId: entry.sessionId,
-      testStartTime: entry.startedAt,
-      providerConfig: entry.providerConfig,
-      cwd: entry.cwd,
-      config: { ...cleanupConfig, scanUntracked: false },
-      provider
+  return { headless };
+}
+function resolveEnvVars(value) {
+  return value.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] || "");
+}
+var AnthropicProvider = class {
+  constructor(config) {
+    this.config = config;
+    const apiKey = config.apiKey ? resolveEnvVars(config.apiKey) : void 0;
+    this.client = new Anthropic({
+      apiKey,
+      model: this.config.model,
+      temperature: this.config.temperature
     });
-  } catch {
+  }
+  async generateCompletion(prompt, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+      messages.push({ role: "system", content: systemPrompt });
+    }
+    messages.push({ role: "user", content: prompt });
+    const response = await this.client.chat({ messages });
+    const content = response.message.content;
+    if (!content) {
+      throw new Error("No content in Anthropic response");
+    }
+    return typeof content === "string" ? content : JSON.stringify(content);
   }
 };
-var cleanupOrphanedTrackFiles = async (cwd, state, trackDir) => {
-  const dir = getTrackDir(cwd, trackDir);
-  try {
-    const files = await fs__default.readdir(dir);
-    const activeFiles = new Set(Object.values(state.sessions).map((s) => path4__default.basename(s.trackFile)));
-    for (const file of files) {
-      if (!file.endsWith(".jsonl")) continue;
-      if (activeFiles.has(file)) continue;
-      const filePath = path4__default.join(dir, file);
-      try {
-        const stat2 = await fs__default.stat(filePath);
-        const staleMs = Number(process.env.INTELLITESTER_STALE_TEST_MS ?? DEFAULT_STALE_MS);
-        const isOld = Date.now() - stat2.mtimeMs > staleMs;
-        const isEmpty = stat2.size === 0;
-        if (isEmpty || isOld) {
-          await fs__default.rm(filePath, { force: true });
-        }
-      } catch {
-      }
+var OpenAIProvider = class {
+  constructor(config) {
+    this.config = config;
+    const apiKey = config.apiKey ? resolveEnvVars(config.apiKey) : void 0;
+    const baseURL = config.baseUrl;
+    this.client = new OpenAI({
+      apiKey,
+      model: this.config.model,
+      temperature: this.config.temperature,
+      baseURL
+    });
+  }
+  async generateCompletion(prompt, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+      messages.push({ role: "system", content: systemPrompt });
     }
-  } catch {
+    messages.push({ role: "user", content: prompt });
+    const response = await this.client.chat({ messages });
+    const content = response.message.content;
+    if (!content) {
+      throw new Error("No content in OpenAI response");
+    }
+    return typeof content === "string" ? content : JSON.stringify(content);
   }
 };
-var pruneStaleTests = async (cwd, cleanupConfig, trackDir) => {
-  const state = await loadActiveTests(cwd, trackDir);
-  const staleMs = Number(process.env.INTELLITESTER_STALE_TEST_MS ?? DEFAULT_STALE_MS);
-  let changed = false;
-  for (const [sessionId, entry] of Object.entries(state.sessions)) {
-    let missingFile = false;
-    let isEmpty = false;
-    try {
-      const stat2 = await fs__default.stat(entry.trackFile);
-      isEmpty = stat2.size === 0;
-    } catch {
-      missingFile = true;
+var OllamaProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.client = new Ollama({
+      model: this.config.model,
+      options: {
+        temperature: this.config.temperature
+      }
+    });
+  }
+  async generateCompletion(prompt, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+      messages.push({ role: "system", content: systemPrompt });
     }
-    if (!missingFile && !isEmpty && !isStale(entry, staleMs)) continue;
-    changed = true;
-    await cleanupStaleSession(entry, cleanupConfig);
-    try {
-      await fs__default.rm(entry.trackFile, { force: true });
-    } catch {
+    messages.push({ role: "user", content: prompt });
+    const response = await this.client.chat({ messages });
+    const content = response.message.content;
+    if (!content) {
+      throw new Error("No content in Ollama response");
     }
-    delete state.sessions[sessionId];
-  }
-  if (changed) {
-    await saveActiveTests(cwd, state, trackDir);
+    return typeof content === "string" ? content : JSON.stringify(content);
   }
-  await cleanupOrphanedTrackFiles(cwd, state, trackDir);
 };
-async function initFileTracking(options) {
-  const cwd = options.cwd ?? process.cwd();
-  const trackDir = options.trackDir;
-  await fs__default.mkdir(getTrackDir(cwd, trackDir), { recursive: true });
-  await pruneStaleTests(cwd, options.cleanupConfig, trackDir);
-  const trackFile = path4__default.join(getTrackDir(cwd, trackDir), `TEST_SESSION_${options.sessionId}.jsonl`);
-  await fs__default.writeFile(trackFile, "", "utf8");
-  const state = await loadActiveTests(cwd, trackDir);
-  state.sessions[options.sessionId] = {
-    sessionId: options.sessionId,
-    trackFile,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-    cwd,
-    providerConfig: options.providerConfig
-  };
-  await saveActiveTests(cwd, state, trackDir);
-  const touch = async () => {
-    const current = await loadActiveTests(cwd, trackDir);
-    const entry = current.sessions[options.sessionId];
-    if (!entry) return;
-    entry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    current.sessions[options.sessionId] = entry;
-    await saveActiveTests(cwd, current, trackDir);
-  };
-  const interval = setInterval(() => {
-    void touch();
-  }, HEARTBEAT_MS);
-  const stop = async () => {
-    clearInterval(interval);
-    const current = await loadActiveTests(cwd, trackDir);
-    delete current.sessions[options.sessionId];
-    await saveActiveTests(cwd, current, trackDir);
-    try {
-      await fs__default.rm(trackFile, { force: true });
-    } catch {
-    }
-  };
-  return { trackFile, stop };
+function createAIProvider(config) {
+  switch (config.provider) {
+    case "anthropic":
+      return new AnthropicProvider(config);
+    case "openai":
+      return new OpenAIProvider(config);
+    case "ollama":
+      return new OllamaProvider(config);
+  }
 }
-async function mergeFileTrackedResources(trackFile, target, allowedTypes) {
-  const entries = await readTrackedResources(trackFile);
-  for (const entry of entries) {
-    const resource = entry;
-    if (!resource.type || !resource.id) continue;
-    if (allowedTypes && !allowedTypes.has(String(resource.type))) continue;
-    const exists = target.resources.some(
-      (existing) => existing.type === resource.type && existing.id === resource.id
-    );
-    if (!exists) {
-      target.resources.push(resource);
-    }
-    if (resource.type === "user") {
-      if (!target.userId && typeof resource.id === "string") {
-        target.userId = resource.id;
-      }
-      const email = resource.email;
-      if (!target.userEmail && typeof email === "string") {
-        target.userEmail = email;
-      }
+
+// src/ai/errorHelper.ts
+function formatLocator(locator) {
+  const parts = [];
+  if (locator.testId) parts.push(`testId: "${locator.testId}"`);
+  if (locator.text) parts.push(`text: "${locator.text}"`);
+  if (locator.css) parts.push(`css: "${locator.css}"`);
+  if (locator.xpath) parts.push(`xpath: "${locator.xpath}"`);
+  if (locator.role) parts.push(`role: "${locator.role}"`);
+  if (locator.name) parts.push(`name: "${locator.name}"`);
+  if (locator.description) parts.push(`description: "${locator.description}"`);
+  return parts.join(", ");
+}
+function formatAction(action) {
+  switch (action.type) {
+    case "tap":
+      return `tap on element (${formatLocator(action.target)})`;
+    case "input":
+      return `input into element (${formatLocator(action.target)})`;
+    case "assert":
+      return `assert element exists (${formatLocator(action.target)})`;
+    case "wait":
+      return action.target ? `wait for element (${formatLocator(action.target)})` : `wait ${action.timeout}ms`;
+    case "scroll":
+      return action.target ? `scroll to element (${formatLocator(action.target)})` : `scroll ${action.direction || "down"}`;
+    default:
+      return action.type;
+  }
+}
+async function getAISuggestion(error, action, pageContent, screenshot, aiConfig) {
+  if (!aiConfig) {
+    return {
+      hasSuggestion: false,
+      explanation: "AI configuration not provided. Cannot generate suggestions."
+    };
+  }
+  try {
+    const provider = createAIProvider(aiConfig);
+    const systemPrompt = `You are an expert at analyzing web automation errors and suggesting better element selectors.
+Your task is to analyze failed actions and suggest better selectors based on the page content and error message.
+
+Return your response in the following JSON format:
+{
+  "hasSuggestion": boolean,
+  "suggestedSelector": {
+    "testId": "string (optional)",
+    "text": "string (optional)",
+    "css": "string (optional)",
+    "role": "string (optional)",
+    "name": "string (optional)"
+  },
+  "explanation": "string explaining why this selector is better"
+}
+
+Prefer selectors in this order:
+1. testId (most reliable)
+2. text (good for user-facing elements)
+3. role with name (semantic and accessible)
+4. css (last resort, but can be precise)
+
+Do not suggest xpath unless absolutely necessary.`;
+    const prompt = `Action failed: ${formatAction(action)}
+
+Error message:
+${error}
+
+Page content (truncated to 10000 chars):
+${pageContent.slice(0, 1e4)}
+
+${screenshot ? "[Screenshot attached but not analyzed in this implementation]" : ""}
+
+Please analyze the error and suggest a better selector that would work reliably. Focus on:
+- What went wrong with the current selector
+- What selector would be more reliable
+- Why the suggested selector is better
+
+Return ONLY valid JSON, no additional text.`;
+    const response = await provider.generateCompletion(prompt, systemPrompt);
+    let jsonStr = response.trim();
+    if (jsonStr.startsWith("```json")) {
+      jsonStr = jsonStr.replace(/^```json\s*/, "").replace(/\s*```$/, "");
+    } else if (jsonStr.startsWith("```")) {
+      jsonStr = jsonStr.replace(/^```\s*/, "").replace(/\s*```$/, "");
     }
+    const parsed = JSON.parse(jsonStr);
+    return parsed;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      hasSuggestion: false,
+      explanation: `Failed to generate AI suggestion: ${message}`
+    };
   }
 }
 var SERVER_MARKER_FILE = "server.json";
@@ -2161,47 +2161,63 @@ var runWebTest = async (test, options = {}) => {
   const headless = !(options.headed ?? false);
   const screenshotDir = options.screenshotDir ?? defaultScreenshotDir;
   const defaultTimeout = options.defaultTimeoutMs ?? 3e4;
+  const trackingAlreadySetUp = options.skipTrackingSetup || process.env.INTELLITESTER_TRACKING_OWNER === "cli";
+  let ownsTracking = false;
+  let trackingServer = null;
+  let fileTracking = null;
   const sessionId = options.sessionId ?? crypto4.randomUUID();
-  const trackingServer = new TrackingServer();
-  await trackingServer.start();
-  process.env.INTELLITESTER_SESSION_ID = sessionId;
-  process.env.INTELLITESTER_TRACK_URL = `http://localhost:${trackingServer.port}`;
-  const fileTracking = await initFileTracking({
-    sessionId,
-    trackDir: options.trackDir,
-    cleanupConfig: test.config?.appwrite?.cleanup ? {
-      provider: "appwrite",
-      scanUntracked: true,
-      appwrite: {
+  if (!trackingAlreadySetUp) {
+    ownsTracking = true;
+    trackingServer = new TrackingServer();
+    await trackingServer.start();
+    process.env.INTELLITESTER_SESSION_ID = sessionId;
+    process.env.INTELLITESTER_TRACK_URL = `http://localhost:${trackingServer.port}`;
+    fileTracking = await initFileTracking({
+      sessionId,
+      trackDir: options.trackDir,
+      cleanupConfig: test.config?.appwrite?.cleanup ? {
+        provider: "appwrite",
+        scanUntracked: true,
+        appwrite: {
+          endpoint: test.config.appwrite.endpoint,
+          projectId: test.config.appwrite.projectId,
+          apiKey: test.config.appwrite.apiKey,
+          cleanupOnFailure: test.config.appwrite.cleanupOnFailure
+        }
+      } : void 0,
+      providerConfig: test.config?.appwrite ? {
+        provider: "appwrite",
         endpoint: test.config.appwrite.endpoint,
         projectId: test.config.appwrite.projectId,
-        apiKey: test.config.appwrite.apiKey,
-        cleanupOnFailure: test.config.appwrite.cleanupOnFailure
-      }
-    } : void 0,
-    providerConfig: test.config?.appwrite ? {
-      provider: "appwrite",
-      endpoint: test.config.appwrite.endpoint,
-      projectId: test.config.appwrite.projectId,
-      apiKey: test.config.appwrite.apiKey
-    } : void 0
-  });
-  process.env.INTELLITESTER_TRACK_FILE = fileTracking.trackFile;
-  if (options.webServer) {
+        apiKey: test.config.appwrite.apiKey
+      } : void 0
+    });
+    process.env.INTELLITESTER_TRACK_FILE = fileTracking.trackFile;
+  } else {
+    console.log("Using existing tracking setup (owned by CLI)");
+  }
+  if (options.webServer && !options.skipWebServerStart) {
     const requiresTrackingEnv = Boolean(
       test.config?.appwrite?.cleanup || test.config?.appwrite?.cleanupOnFailure
     );
-    const webServerConfig = requiresTrackingEnv ? { ...options.webServer, reuseExistingServer: false } : options.webServer;
-    if (requiresTrackingEnv && options.webServer.reuseExistingServer !== false) {
+    const userExplicitlySetReuse = options.webServer.reuseExistingServer !== void 0;
+    const webServerConfig = ownsTracking && requiresTrackingEnv && !userExplicitlySetReuse ? { ...options.webServer, reuseExistingServer: false } : options.webServer;
+    if (ownsTracking && requiresTrackingEnv && !userExplicitlySetReuse) {
       console.log("[Intellitester] Appwrite cleanup enabled; restarting server to inject tracking env.");
     }
     await webServerManager.start(webServerConfig);
+  } else if (options.skipWebServerStart) {
+    console.log("Using existing web server (owned by CLI)");
   }
   const cleanup = () => {
-    trackingServer.stop();
-    webServerManager.kill();
-    void fileTracking.stop();
-    delete process.env.INTELLITESTER_TRACK_FILE;
+    if (ownsTracking) {
+      trackingServer?.stop();
+      webServerManager.kill();
+      if (fileTracking) {
+        void fileTracking.stop();
+      }
+      delete process.env.INTELLITESTER_TRACK_FILE;
+    }
     process.exit(1);
   };
   process.on("SIGINT", cleanup);
@@ -2451,7 +2467,7 @@ var runWebTest = async (test, options = {}) => {
         if (debugMode) {
           console.log(`[DEBUG] Executing step ${index + 1}: ${action.type}`);
         }
-        const serverResources = trackingServer.getResources(sessionId);
+        const serverResources = trackingServer?.getResources(sessionId) ?? [];
         for (const resource of serverResources) {
           if (resource.type === "user" && !executionContext.appwriteContext.userId) {
             executionContext.appwriteContext.userId = resource.id;
@@ -2532,7 +2548,7 @@ var runWebTest = async (test, options = {}) => {
   try {
     process.off("SIGINT", cleanup);
     process.off("SIGTERM", cleanup);
-    if (lastExecutionContext) {
+    if (lastExecutionContext && ownsTracking && fileTracking) {
       await mergeFileTrackedResources(
         fileTracking.trackFile,
         lastExecutionContext.appwriteContext
@@ -2552,11 +2568,15 @@ var runWebTest = async (test, options = {}) => {
         console.log("Cleanup result:", cleanupResult);
       }
     }
-    await fileTracking.stop();
-    delete process.env.INTELLITESTER_TRACK_FILE;
+    if (ownsTracking) {
+      if (fileTracking) {
+        await fileTracking.stop();
+      }
+      delete process.env.INTELLITESTER_TRACK_FILE;
+      trackingServer?.stop();
+      await webServerManager.stop();
+    }
     await browser.close();
-    trackingServer.stop();
-    await webServerManager.stop();
   } catch (cleanupError) {
     console.error("Error during cleanup:", cleanupError);
   }
@@ -3510,56 +3530,71 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
   const sessionId = options.sessionId ?? crypto4.randomUUID();
   const testStartTime = (/* @__PURE__ */ new Date()).toISOString();
   const cleanupConfig = inferCleanupConfig(workflow.config);
+  const trackingAlreadySetUp = options.skipTrackingSetup || process.env.INTELLITESTER_TRACKING_OWNER === "cli";
+  let ownsTracking = false;
   let trackingServer = null;
-  try {
-    trackingServer = await startTrackingServer({ port: 0 });
-    console.log(`Tracking server started on port ${trackingServer.port}`);
-  } catch (error) {
-    console.warn("Failed to start tracking server:", error);
-  }
-  if (trackingServer) {
-    process.env.INTELLITESTER_SESSION_ID = sessionId;
-    process.env.INTELLITESTER_TRACK_URL = `http://localhost:${trackingServer.port}`;
+  let fileTracking = null;
+  if (!trackingAlreadySetUp) {
+    ownsTracking = true;
+    try {
+      trackingServer = await startTrackingServer({ port: 0 });
+      console.log(`Tracking server started on port ${trackingServer.port}`);
+    } catch (error) {
+      console.warn("Failed to start tracking server:", error);
+    }
+    if (trackingServer) {
+      process.env.INTELLITESTER_SESSION_ID = sessionId;
+      process.env.INTELLITESTER_TRACK_URL = `http://localhost:${trackingServer.port}`;
+    }
+    fileTracking = await initFileTracking({
+      sessionId,
+      cleanupConfig,
+      trackDir: options.trackDir,
+      providerConfig: workflow.config?.appwrite ? {
+        provider: "appwrite",
+        endpoint: workflow.config.appwrite.endpoint,
+        projectId: workflow.config.appwrite.projectId,
+        apiKey: workflow.config.appwrite.apiKey
+      } : void 0
+    });
+    process.env.INTELLITESTER_TRACK_FILE = fileTracking.trackFile;
+  } else {
+    console.log("Using existing tracking setup (owned by CLI)");
   }
-  const fileTracking = await initFileTracking({
-    sessionId,
-    cleanupConfig,
-    trackDir: options.trackDir,
-    providerConfig: workflow.config?.appwrite ? {
-      provider: "appwrite",
-      endpoint: workflow.config.appwrite.endpoint,
-      projectId: workflow.config.appwrite.projectId,
-      apiKey: workflow.config.appwrite.apiKey
-    } : void 0
-  });
-  process.env.INTELLITESTER_TRACK_FILE = fileTracking.trackFile;
   const webServerConfig = workflow.config?.webServer ?? options.webServer;
-  if (webServerConfig) {
+  const skipWebServer = options.skipWebServerStart;
+  if (webServerConfig && !skipWebServer) {
     try {
       const serverCwd = workflow.config?.webServer ? workflowDir : process.cwd();
       const requiresTrackingEnv = Boolean(
         workflow.config?.appwrite?.cleanup || workflow.config?.appwrite?.cleanupOnFailure
       );
-      const effectiveWebServerConfig = requiresTrackingEnv ? { ...webServerConfig, reuseExistingServer: false } : webServerConfig;
-      if (requiresTrackingEnv && webServerConfig.reuseExistingServer !== false) {
+      const userExplicitlySetReuse = webServerConfig.reuseExistingServer !== void 0;
+      let effectiveConfig = webServerConfig;
+      if (requiresTrackingEnv && !userExplicitlySetReuse && ownsTracking) {
+        effectiveConfig = { ...webServerConfig, reuseExistingServer: false };
         console.log("[Intellitester] Appwrite cleanup enabled; restarting server to inject tracking env.");
       }
       await webServerManager.start({
-        ...effectiveWebServerConfig,
-        workdir: path4__default.resolve(serverCwd, effectiveWebServerConfig.workdir ?? effectiveWebServerConfig.cwd ?? ".")
+        ...effectiveConfig,
+        workdir: path4__default.resolve(serverCwd, effectiveConfig.workdir ?? effectiveConfig.cwd ?? ".")
       });
     } catch (error) {
       console.error("Failed to start web server:", error);
       if (trackingServer) await trackingServer.stop();
       throw error;
     }
+  } else if (skipWebServer) {
+    console.log("Using existing web server (started by CLI)");
   }
   const signalCleanup = async () => {
     console.log("\n\nInterrupted - cleaning up...");
-    webServerManager.kill();
-    if (trackingServer) await trackingServer.stop();
-    await fileTracking.stop();
-    delete process.env.INTELLITESTER_TRACK_FILE;
+    if (ownsTracking) {
+      if (!skipWebServer) webServerManager.kill();
+      if (trackingServer) await trackingServer.stop();
+      if (fileTracking) await fileTracking.stop();
+      delete process.env.INTELLITESTER_TRACK_FILE;
+    }
     process.exit(1);
   };
   process.on("SIGINT", signalCleanup);
@@ -3651,7 +3686,11 @@ Collected ${serverResources.length} server-tracked resources`);
         executionContext.appwriteContext.resources.push(...serverResources);
       }
     }
-    await mergeFileTrackedResources(fileTracking.trackFile, executionContext.appwriteContext);
+    if (fileTracking) {
+      await mergeFileTrackedResources(fileTracking.trackFile, executionContext.appwriteContext);
+    } else if (process.env.INTELLITESTER_TRACK_FILE) {
+      await mergeFileTrackedResources(process.env.INTELLITESTER_TRACK_FILE, executionContext.appwriteContext);
+    }
     let cleanupResult;
     if (cleanupConfig) {
       const appwriteConfig = cleanupConfig.appwrite;
@@ -3741,17 +3780,21 @@ Collected ${serverResources.length} server-tracked resources`);
     process.off("SIGTERM", signalCleanup);
     await browserContext.close();
     await browser.close();
-    await webServerManager.stop();
-    if (trackingServer) {
-      await trackingServer.stop();
+    if (ownsTracking) {
+      if (!skipWebServer) await webServerManager.stop();
+      if (trackingServer) {
+        await trackingServer.stop();
+      }
+      if (fileTracking) {
+        await fileTracking.stop();
+      }
+      delete process.env.INTELLITESTER_SESSION_ID;
+      delete process.env.INTELLITESTER_TRACK_URL;
+      delete process.env.INTELLITESTER_TRACK_FILE;
     }
-    await fileTracking.stop();
-    delete process.env.INTELLITESTER_SESSION_ID;
-    delete process.env.INTELLITESTER_TRACK_URL;
-    delete process.env.INTELLITESTER_TRACK_FILE;
   }
 }
 
 export { createAIProvider, createTestContext, generateFillerText, generateRandomEmail, generateRandomPhone, generateRandomPhoto, generateRandomUsername, getBrowserLaunchOptions, initFileTracking, interpolateVariables, mergeFileTrackedResources, parseViewportSize, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, webServerManager };
-//# sourceMappingURL=chunk-WNSVKXTD.js.map
-//# sourceMappingURL=chunk-WNSVKXTD.js.map
+//# sourceMappingURL=chunk-PGOHFXEG.js.map
+//# sourceMappingURL=chunk-PGOHFXEG.js.map