intellitester 0.1.12

package/dist/chunk-5LFSLMQ7.js

@@ -0,0 +1,2517 @@
+import { loadCleanupHandlers, executeCleanup, saveFailedCleanup } from './chunk-ECBA4GJ3.js';
+import { z } from 'zod';
+import fs2 from 'fs/promises';
+import { parse } from 'yaml';
+import crypto2 from 'crypto';
+import path from 'path';
+import { spawn } from 'child_process';
+import { chromium, webkit, firefox } from 'playwright';
+import prompts from 'prompts';
+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';
+
+var nonEmptyString = z.string().trim().min(1, "Value cannot be empty");
+var LocatorSchema = z.object({
+  description: z.string().trim().optional(),
+  testId: z.string().trim().optional(),
+  text: z.string().trim().optional(),
+  css: z.string().trim().optional(),
+  xpath: z.string().trim().optional(),
+  role: z.string().trim().optional(),
+  name: z.string().trim().optional()
+}).refine(
+  (locator) => Boolean(
+    locator.description || locator.testId || locator.text || locator.css || locator.xpath || locator.role || locator.name
+  ),
+  { message: "Locator requires at least one selector or description" }
+);
+var navigateActionSchema = z.object({
+  type: z.literal("navigate"),
+  value: nonEmptyString
+});
+var tapActionSchema = z.object({
+  type: z.literal("tap"),
+  target: LocatorSchema
+});
+var inputActionSchema = z.object({
+  type: z.literal("input"),
+  target: LocatorSchema,
+  value: z.string()
+});
+var assertActionSchema = z.object({
+  type: z.literal("assert"),
+  target: LocatorSchema,
+  value: z.string().optional()
+});
+var waitActionSchema = z.object({
+  type: z.literal("wait"),
+  target: LocatorSchema.optional(),
+  timeout: z.number().int().positive().optional()
+}).refine((action) => action.target || action.timeout, {
+  message: "wait requires a target or timeout"
+});
+var scrollActionSchema = z.object({
+  type: z.literal("scroll"),
+  target: LocatorSchema.optional(),
+  direction: z.enum(["up", "down"]).optional(),
+  amount: z.number().int().positive().optional()
+});
+var screenshotActionSchema = z.object({
+  type: z.literal("screenshot"),
+  name: z.string().optional()
+});
+var setVarActionSchema = z.object({
+  type: z.literal("setVar"),
+  name: nonEmptyString,
+  value: z.string().optional(),
+  from: z.enum(["response", "element", "email"]).optional(),
+  path: z.string().optional(),
+  pattern: z.string().optional()
+});
+var emailWaitForActionSchema = z.object({
+  type: z.literal("email.waitFor"),
+  mailbox: nonEmptyString,
+  timeout: z.number().int().positive().optional(),
+  subjectContains: z.string().optional()
+});
+var emailExtractCodeActionSchema = z.object({
+  type: z.literal("email.extractCode"),
+  saveTo: nonEmptyString,
+  pattern: z.string().optional()
+});
+var emailExtractLinkActionSchema = z.object({
+  type: z.literal("email.extractLink"),
+  saveTo: nonEmptyString,
+  pattern: z.string().optional()
+});
+var emailClearActionSchema = z.object({
+  type: z.literal("email.clear"),
+  mailbox: nonEmptyString
+});
+var appwriteVerifyEmailActionSchema = z.object({
+  type: z.literal("appwrite.verifyEmail")
+});
+var debugActionSchema = z.object({
+  type: z.literal("debug")
+});
+var ActionSchema = z.discriminatedUnion("type", [
+  navigateActionSchema,
+  tapActionSchema,
+  inputActionSchema,
+  assertActionSchema,
+  waitActionSchema,
+  scrollActionSchema,
+  screenshotActionSchema,
+  setVarActionSchema,
+  emailWaitForActionSchema,
+  emailExtractCodeActionSchema,
+  emailExtractLinkActionSchema,
+  emailClearActionSchema,
+  appwriteVerifyEmailActionSchema,
+  debugActionSchema
+]);
+var defaultsSchema = z.object({
+  timeout: z.number().int().positive().optional(),
+  screenshots: z.enum(["on-failure", "always", "never"]).optional()
+});
+var webConfigSchema = z.object({
+  baseUrl: nonEmptyString.url().optional(),
+  browser: z.string().trim().optional(),
+  headless: z.boolean().optional(),
+  timeout: z.number().int().positive().optional()
+});
+var androidConfigSchema = z.object({
+  appId: z.string().trim().optional(),
+  device: z.string().trim().optional()
+});
+var iosConfigSchema = z.object({
+  bundleId: z.string().trim().optional(),
+  simulator: z.string().trim().optional()
+});
+var emailConfigSchema = z.object({
+  provider: z.literal("inbucket"),
+  endpoint: nonEmptyString.url().optional()
+});
+var appwriteConfigSchema = z.object({
+  endpoint: nonEmptyString.url(),
+  projectId: nonEmptyString,
+  apiKey: nonEmptyString,
+  cleanup: z.boolean().optional(),
+  cleanupOnFailure: z.boolean().optional()
+});
+var healingSchema = z.object({
+  enabled: z.boolean().optional(),
+  strategies: z.array(z.string().trim()).optional()
+});
+var webServerSchema = z.object({
+  // Option 1: Explicit command
+  command: nonEmptyString.optional(),
+  // Option 2: Auto-detect
+  auto: z.boolean().optional(),
+  // Option 3: Static directory
+  static: z.string().optional(),
+  // Required
+  url: nonEmptyString.url(),
+  port: z.number().int().positive().optional(),
+  reuseExistingServer: z.boolean().default(true),
+  timeout: z.number().int().positive().default(3e4),
+  cwd: z.string().optional()
+}).refine((config) => config.command || config.auto || config.static, {
+  message: "WebServerConfig requires command, auto: true, or static directory"
+});
+var aiSourceSchema = z.object({
+  pagesDir: z.string().optional(),
+  componentsDir: z.string().optional(),
+  extensions: z.array(z.string()).default([".vue", ".astro", ".tsx", ".jsx", ".svelte"])
+}).optional();
+var aiConfigSchema = z.object({
+  provider: z.enum(["anthropic", "openai", "ollama"]),
+  model: nonEmptyString,
+  apiKey: z.string().trim().optional(),
+  baseUrl: z.string().trim().url().optional(),
+  temperature: z.number().min(0).max(2).default(0.2),
+  maxTokens: z.number().int().positive().default(4096),
+  source: aiSourceSchema
+});
+var cleanupDiscoverSchema = z.object({
+  enabled: z.boolean().default(true),
+  paths: z.array(z.string()).default(["./tests/cleanup"]),
+  pattern: z.string().default("**/*.ts")
+}).optional();
+var cleanupConfigSchema = z.object({
+  provider: z.string().optional(),
+  parallel: z.boolean().default(false),
+  retries: z.number().min(1).max(10).default(3),
+  types: z.record(z.string(), z.string()).optional(),
+  handlers: z.array(z.string()).optional(),
+  discover: cleanupDiscoverSchema
+}).passthrough();
+var platformsSchema = z.object({
+  web: webConfigSchema.optional(),
+  android: androidConfigSchema.optional(),
+  ios: iosConfigSchema.optional()
+});
+var TestConfigSchema = z.object({
+  defaults: defaultsSchema.optional(),
+  web: webConfigSchema.optional(),
+  android: androidConfigSchema.optional(),
+  ios: iosConfigSchema.optional(),
+  email: emailConfigSchema.optional(),
+  appwrite: appwriteConfigSchema.optional()
+});
+var TestDefinitionSchema = z.object({
+  name: nonEmptyString,
+  platform: z.enum(["web", "android", "ios"]),
+  variables: z.record(z.string(), z.string()).optional(),
+  config: TestConfigSchema.optional(),
+  steps: z.array(ActionSchema).min(1)
+});
+var IntellitesterConfigSchema = z.object({
+  defaults: defaultsSchema.optional(),
+  ai: aiConfigSchema.optional(),
+  platforms: platformsSchema.optional(),
+  healing: healingSchema.optional(),
+  email: emailConfigSchema.optional(),
+  appwrite: appwriteConfigSchema.optional(),
+  cleanup: cleanupConfigSchema.optional(),
+  webServer: webServerSchema.optional(),
+  secrets: z.record(z.string(), z.string().trim()).optional()
+});
+var nonEmptyString2 = z.string().trim().min(1, "Value cannot be empty");
+var testReferenceSchema = z.object({
+  file: nonEmptyString2,
+  id: nonEmptyString2.optional(),
+  // Optional ID for referencing in variables
+  variables: z.record(z.string(), z.string()).optional()
+  // Override/inject variables
+});
+var workflowWebConfigSchema = z.object({
+  baseUrl: nonEmptyString2.url().optional(),
+  browser: z.enum(["chromium", "firefox", "webkit"]).optional(),
+  headless: z.boolean().optional()
+});
+var workflowAppwriteConfigSchema = z.object({
+  endpoint: nonEmptyString2.url(),
+  projectId: nonEmptyString2,
+  apiKey: nonEmptyString2,
+  cleanup: z.boolean().default(true),
+  // Backwards compatibility
+  cleanupOnFailure: z.boolean().default(true)
+  // Backwards compatibility
+});
+var workflowCleanupDiscoverSchema = z.object({
+  enabled: z.boolean().default(true),
+  paths: z.array(z.string()).default(["./tests/cleanup"]),
+  pattern: z.string().default("**/*.ts")
+}).optional();
+var workflowCleanupConfigSchema = z.object({
+  provider: z.string().optional(),
+  parallel: z.boolean().default(false),
+  retries: z.number().min(1).max(10).default(3),
+  types: z.record(z.string(), z.string()).optional(),
+  handlers: z.array(z.string()).optional(),
+  discover: workflowCleanupDiscoverSchema
+}).passthrough();
+var workflowWebServerSchema = z.object({
+  command: nonEmptyString2.optional(),
+  auto: z.boolean().optional(),
+  url: nonEmptyString2.url(),
+  reuseExistingServer: z.boolean().default(true),
+  timeout: z.number().int().positive().default(3e4)
+});
+var workflowConfigSchema = z.object({
+  web: workflowWebConfigSchema.optional(),
+  appwrite: workflowAppwriteConfigSchema.optional(),
+  cleanup: workflowCleanupConfigSchema.optional(),
+  webServer: workflowWebServerSchema.optional()
+});
+var WorkflowDefinitionSchema = z.object({
+  name: nonEmptyString2,
+  platform: z.enum(["web", "android", "ios"]).default("web"),
+  config: workflowConfigSchema.optional(),
+  continueOnFailure: z.boolean().default(false),
+  tests: z.array(testReferenceSchema).min(1, "Workflow must contain at least one test")
+});
+var nonEmptyString3 = z.string().trim().min(1, "Value cannot be empty");
+var workflowReferenceSchema = z.object({
+  file: nonEmptyString3,
+  id: nonEmptyString3.optional(),
+  depends_on: z.array(nonEmptyString3).optional(),
+  on_failure: z.enum(["skip", "fail", "ignore"]).optional(),
+  variables: z.record(z.string(), z.string()).optional()
+});
+var pipelineWebConfigSchema = z.object({
+  baseUrl: nonEmptyString3.url().optional(),
+  browser: z.enum(["chromium", "firefox", "webkit"]).optional(),
+  headless: z.boolean().optional()
+});
+var pipelineAppwriteConfigSchema = z.object({
+  endpoint: nonEmptyString3.url(),
+  projectId: nonEmptyString3,
+  apiKey: nonEmptyString3,
+  cleanup: z.boolean().default(true),
+  cleanupOnFailure: z.boolean().default(true)
+});
+var pipelineCleanupDiscoverSchema = z.object({
+  enabled: z.boolean().default(true),
+  paths: z.array(z.string()).default(["./tests/cleanup"]),
+  pattern: z.string().default("**/*.ts")
+}).optional();
+var pipelineCleanupConfigSchema = z.object({
+  provider: z.string().optional(),
+  parallel: z.boolean().default(false),
+  retries: z.number().min(1).max(10).default(3),
+  types: z.record(z.string(), z.string()).optional(),
+  handlers: z.array(z.string()).optional(),
+  discover: pipelineCleanupDiscoverSchema,
+  on_failure: z.boolean().default(true)
+  // Run cleanup even if pipeline fails
+}).passthrough();
+var pipelineWebServerSchema = z.object({
+  command: nonEmptyString3.optional(),
+  auto: z.boolean().optional(),
+  url: nonEmptyString3.url(),
+  reuseExistingServer: z.boolean().default(true),
+  timeout: z.number().int().positive().default(3e4)
+});
+var pipelineConfigSchema = z.object({
+  web: pipelineWebConfigSchema.optional(),
+  appwrite: pipelineAppwriteConfigSchema.optional(),
+  cleanup: pipelineCleanupConfigSchema.optional(),
+  webServer: pipelineWebServerSchema.optional()
+});
+var PipelineDefinitionSchema = z.object({
+  name: nonEmptyString3,
+  platform: z.enum(["web", "android", "ios"]).default("web"),
+  config: pipelineConfigSchema.optional(),
+  on_failure: z.enum(["skip", "fail", "ignore"]).default("skip"),
+  cleanup_on_failure: z.boolean().default(true),
+  workflows: z.array(workflowReferenceSchema).min(1, "Pipeline must contain at least one workflow")
+});
+
+// src/core/loader.ts
+var formatIssues = (issues) => issues.map((issue) => {
+  const path3 = issue.path.join(".") || "<root>";
+  return `${path3}: ${issue.message}`;
+}).join("; ");
+var interpolateEnvVars = (obj) => {
+  if (typeof obj === "string") {
+    return obj.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+      const value = process.env[varName];
+      if (value === void 0) {
+        throw new Error(`Environment variable ${varName} is not defined`);
+      }
+      return value;
+    });
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(interpolateEnvVars);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = interpolateEnvVars(value);
+    }
+    return result;
+  }
+  return obj;
+};
+var parseWithSchema = (content, schema, subject) => {
+  let parsed;
+  try {
+    parsed = parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid YAML for ${subject}: ${message}`);
+  }
+  const interpolated = interpolateEnvVars(parsed);
+  const result = schema.safeParse(interpolated);
+  if (!result.success) {
+    throw new Error(`Invalid ${subject}: ${formatIssues(result.error.issues)}`);
+  }
+  return result.data;
+};
+var parseTestDefinition = (content) => parseWithSchema(content, TestDefinitionSchema, "test definition");
+var loadTestDefinition = async (filePath) => {
+  const fileContent = await fs2.readFile(filePath, "utf8");
+  return parseTestDefinition(fileContent);
+};
+var parseIntellitesterConfig = (content) => parseWithSchema(content, IntellitesterConfigSchema, "config");
+var loadIntellitesterConfig = async (filePath) => {
+  const fileContent = await fs2.readFile(filePath, "utf8");
+  return parseIntellitesterConfig(fileContent);
+};
+var parseWorkflowDefinition = (content) => parseWithSchema(content, WorkflowDefinitionSchema, "workflow definition");
+var loadWorkflowDefinition = async (filePath) => {
+  const fileContent = await fs2.readFile(filePath, "utf8");
+  return parseWorkflowDefinition(fileContent);
+};
+var isWorkflowFile = (filePath) => {
+  return filePath.endsWith(".workflow.yaml") || filePath.endsWith(".workflow.yml");
+};
+var isPipelineFile = (filePath) => {
+  return filePath.endsWith(".pipeline.yaml") || filePath.endsWith(".pipeline.yml");
+};
+var parsePipelineDefinition = (content) => parseWithSchema(content, PipelineDefinitionSchema, "pipeline definition");
+var loadPipelineDefinition = async (filePath) => {
+  const fileContent = await fs2.readFile(filePath, "utf8");
+  return parsePipelineDefinition(fileContent);
+};
+var collectMissingEnvVars = (obj) => {
+  const missing = [];
+  const collect = (value) => {
+    if (typeof value === "string") {
+      const matches = value.matchAll(/\$\{([^}]+)\}/g);
+      for (const match of matches) {
+        const varName = match[1];
+        if (process.env[varName] === void 0 && !missing.includes(varName)) {
+          missing.push(varName);
+        }
+      }
+    } else if (Array.isArray(value)) {
+      value.forEach(collect);
+    } else if (value !== null && typeof value === "object") {
+      Object.values(value).forEach(collect);
+    }
+  };
+  collect(obj);
+  return missing;
+};
+
+// src/integrations/email/inbucketClient.ts
+var InbucketClient = class {
+  constructor(config) {
+    this.endpoint = config.endpoint.replace(/\/$/, "");
+  }
+  /**
+   * Extract mailbox name from email (e.g., "test@example.com" → "test")
+   */
+  getMailboxName(email) {
+    return email.split("@")[0];
+  }
+  /**
+   * 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 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 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);
+        }
+        return true;
+      });
+      if (matchingMessage) {
+        return await this.getMessage(email, matchingMessage.id);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    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}`
+      );
+    }
+  }
+  /**
+   * 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}`
+      );
+    }
+  }
+};
+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-]+)$/
+};
+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
+    });
+  }
+  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 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 });
+    }
+    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 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 });
+    }
+    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 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;
+  }
+}
+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 TrackingServer = class {
+  constructor() {
+    this.server = null;
+    this.resources = /* @__PURE__ */ new Map();
+    this.port = 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"));
+        }
+      });
+    });
+  }
+  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 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" }));
+    }
+  }
+  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;
+        }
+        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" }));
+      }
+    });
+    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();
+        }
+      });
+    });
+  }
+};
+async function startTrackingServer(options) {
+  const server = new TrackingServer();
+  await server.start(options);
+  return server;
+}
+
+// src/executors/web/playwrightExecutor.ts
+var defaultScreenshotDir = path.join(process.cwd(), "artifacts", "screenshots");
+function interpolateVariables(value, variables) {
+  return value.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
+    if (varName === "uuid") {
+      return crypto2.randomUUID().split("-")[0];
+    }
+    return variables.get(varName) ?? match;
+  });
+}
+var resolveUrl = (value, baseUrl) => {
+  if (!baseUrl) return value;
+  try {
+    const url = new URL(value, baseUrl);
+    return url.toString();
+  } catch {
+    return value;
+  }
+};
+var resolveLocator = (page, locator) => {
+  if (locator.testId) return page.getByTestId(locator.testId);
+  if (locator.text) return page.getByText(locator.text);
+  if (locator.css) return page.locator(locator.css);
+  if (locator.xpath) return page.locator(`xpath=${locator.xpath}`);
+  if (locator.role) {
+    const options = {};
+    if (locator.name) options.name = locator.name;
+    return page.getByRole(locator.role, options);
+  }
+  if (locator.description) return page.getByText(locator.description);
+  throw new Error("No usable selector found for locator");
+};
+async function ensureScreenshotDir(dir) {
+  await fs2.mkdir(dir, { recursive: true });
+}
+var runNavigate = async (page, value, baseUrl, context) => {
+  const interpolated = interpolateVariables(value, context.variables);
+  const target = resolveUrl(interpolated, baseUrl);
+  await page.goto(target);
+};
+var runTap = async (page, locator) => {
+  const handle = resolveLocator(page, locator);
+  await handle.click();
+};
+var runInput = async (page, locator, value, context) => {
+  const interpolated = interpolateVariables(value, context.variables);
+  const handle = resolveLocator(page, locator);
+  await handle.fill(interpolated);
+};
+var runAssert = async (page, locator, value, context) => {
+  const handle = resolveLocator(page, locator);
+  await handle.waitFor({ state: "visible" });
+  if (value) {
+    const interpolated = interpolateVariables(value, context.variables);
+    const text = (await handle.textContent())?.trim() ?? "";
+    if (!text.includes(interpolated)) {
+      throw new Error(
+        `Assertion failed: expected element text to include "${interpolated}", got "${text}"`
+      );
+    }
+  }
+};
+var runWait = async (page, action) => {
+  if (action.target) {
+    const handle = resolveLocator(page, action.target);
+    await handle.waitFor({ state: "visible", timeout: action.timeout });
+    return;
+  }
+  await page.waitForTimeout(action.timeout ?? 1e3);
+};
+var runScroll = async (page, action) => {
+  if (action.target) {
+    const handle = resolveLocator(page, action.target);
+    await handle.scrollIntoViewIfNeeded();
+    return;
+  }
+  const amount = action.amount ?? 500;
+  const direction = action.direction ?? "down";
+  const deltaY = direction === "up" ? -amount : amount;
+  await page.evaluate((value) => window.scrollBy(0, value), deltaY);
+};
+var runScreenshot = async (page, name, screenshotDir, stepIndex) => {
+  await ensureScreenshotDir(screenshotDir);
+  await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
+  });
+  const filename = name ?? `step-${stepIndex + 1}.png`;
+  const filePath = path.join(screenshotDir, filename);
+  await page.screenshot({ path: filePath, fullPage: true });
+  return filePath;
+};
+var getBrowser = (browser) => {
+  switch (browser) {
+    case "firefox":
+      return firefox;
+    case "webkit":
+      return webkit;
+    default:
+      return chromium;
+  }
+};
+async function isServerRunning(url) {
+  try {
+    const response = await fetch(url, { method: "HEAD" });
+    return response.ok || response.status < 500;
+  } catch {
+    return false;
+  }
+}
+async function waitForServer(url, timeout) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (await isServerRunning(url)) return;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error(`Server at ${url} not ready after ${timeout}ms`);
+}
+async function detectBuildDirectory(cwd) {
+  const commonDirs = [
+    ".next",
+    // Next.js
+    ".output",
+    // Nuxt 3
+    ".svelte-kit",
+    // SvelteKit
+    "dist",
+    // Vite, Astro, Rollup, generic
+    "build",
+    // CRA, Remix, generic
+    "out"
+    // Next.js static export
+  ];
+  for (const dir of commonDirs) {
+    const fullPath = path.join(cwd, dir);
+    try {
+      const stat = await fs2.stat(fullPath);
+      if (stat.isDirectory()) {
+        return dir;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function readPackageJson(cwd) {
+  try {
+    const packagePath = path.join(cwd, "package.json");
+    const content = await fs2.readFile(packagePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function detectFramework(pkg) {
+  if (!pkg) return null;
+  const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+  if (deps["next"]) {
+    return { name: "next", buildCommand: "npx -y next start", devCommand: "next dev" };
+  }
+  if (deps["nuxt"]) {
+    return { name: "nuxt", buildCommand: "node .output/server/index.mjs", devCommand: "nuxi dev" };
+  }
+  if (deps["astro"]) {
+    return { name: "astro", buildCommand: "npx -y astro dev", devCommand: "astro dev" };
+  }
+  if (deps["@sveltejs/kit"]) {
+    return { name: "sveltekit", buildCommand: "npx -y vite preview", devCommand: "vite dev" };
+  }
+  if (deps["@remix-run/serve"] || deps["@remix-run/dev"]) {
+    return { name: "remix", buildCommand: "npx -y remix-serve build/server/index.js", devCommand: "remix vite:dev" };
+  }
+  if (deps["vite"]) {
+    return { name: "vite", buildCommand: "npx -y vite preview", devCommand: "vite dev" };
+  }
+  if (deps["react-scripts"]) {
+    return { name: "cra", buildCommand: "npx -y serve -s build", devCommand: "react-scripts start" };
+  }
+  return null;
+}
+async function detectPackageManager(cwd) {
+  const hasDenoLock = await fs2.stat(path.join(cwd, "deno.lock")).catch(() => null);
+  const hasBunLock = await fs2.stat(path.join(cwd, "bun.lockb")).catch(() => null);
+  const hasPnpmLock = await fs2.stat(path.join(cwd, "pnpm-lock.yaml")).catch(() => null);
+  const hasYarnLock = await fs2.stat(path.join(cwd, "yarn.lock")).catch(() => null);
+  if (hasDenoLock) return "deno";
+  if (hasBunLock) return "bun";
+  if (hasPnpmLock) return "pnpm";
+  if (hasYarnLock) return "yarn";
+  return "npm";
+}
+function getDevCommand(pm, script) {
+  switch (pm) {
+    case "deno":
+      return `deno task ${script}`;
+    case "bun":
+      return `bun run ${script}`;
+    case "pnpm":
+      return `pnpm ${script}`;
+    case "yarn":
+      return `yarn ${script}`;
+    case "npm":
+      return `npm run ${script}`;
+  }
+}
+async function detectServerCommand(cwd) {
+  const pkg = await readPackageJson(cwd);
+  const framework = detectFramework(pkg);
+  const pm = await detectPackageManager(cwd);
+  const buildDir = await detectBuildDirectory(cwd);
+  if (buildDir) {
+    if (framework) {
+      console.log(`Detected ${framework.name} project with build at ${buildDir}`);
+      return framework.buildCommand;
+    }
+    console.log(`Detected build directory at ${buildDir}, using static server`);
+    return `npx -y serve ${buildDir}`;
+  }
+  if (pkg?.scripts?.dev) {
+    if (framework) {
+      console.log(`Detected ${framework.name} project, running dev server`);
+    }
+    return getDevCommand(pm, "dev");
+  }
+  if (pkg?.scripts?.start) {
+    return getDevCommand(pm, "start");
+  }
+  throw new Error("Could not auto-detect server command. Please specify command explicitly.");
+}
+async function startWebServer(config) {
+  const { url, reuseExistingServer = true, timeout = 3e4, cwd = process.cwd() } = config;
+  if (reuseExistingServer && await isServerRunning(url)) {
+    console.log(`Server already running at ${url}`);
+    return null;
+  }
+  let command;
+  if (config.command) {
+    command = config.command;
+  } else if (config.static) {
+    const port = config.port ?? new URL(url).port ?? "3000";
+    command = `npx -y serve ${config.static} -l ${port}`;
+  } else if (config.auto) {
+    command = await detectServerCommand(cwd);
+  } else {
+    throw new Error("WebServerConfig requires command, auto: true, or static directory");
+  }
+  console.log(`Starting server: ${command}`);
+  const serverProcess = spawn(command, {
+    shell: true,
+    stdio: "pipe",
+    cwd,
+    detached: false
+  });
+  serverProcess.stdout?.on("data", (data) => {
+    process.stdout.write(`[server] ${data}`);
+  });
+  serverProcess.stderr?.on("data", (data) => {
+    process.stderr.write(`[server] ${data}`);
+  });
+  await waitForServer(url, timeout);
+  console.log(`Server ready at ${url}`);
+  return serverProcess;
+}
+function killServer(serverProcess) {
+  if (serverProcess && !serverProcess.killed) {
+    console.log("Stopping server...");
+    serverProcess.kill("SIGTERM");
+  }
+}
+async function handleInteractiveError(page, action, error, screenshotDir, stepIndex, aiConfig) {
+  console.error(`
+\u274C Action failed: ${action.type}`);
+  console.error(`   Error: ${error.message}
+`);
+  await ensureScreenshotDir(screenshotDir);
+  const screenshotPath = path.join(screenshotDir, `error-step-${stepIndex + 1}.png`);
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+  const pageContent = await page.content();
+  if (aiConfig) {
+    console.log("\u{1F916} Analyzing error with AI...\n");
+    const screenshot = await fs2.readFile(screenshotPath);
+    const suggestion = await getAISuggestion(error.message, action, pageContent, screenshot, aiConfig);
+    if (suggestion.hasSuggestion && suggestion.suggestedSelector) {
+      console.log("\u{1F916} AI Suggestion:");
+      console.log(`   ${suggestion.explanation}
+`);
+      console.log("   Suggested selector:");
+      console.log("   target:");
+      if (suggestion.suggestedSelector.testId) {
+        console.log(`     testId: "${suggestion.suggestedSelector.testId}"`);
+      }
+      if (suggestion.suggestedSelector.text) {
+        console.log(`     text: "${suggestion.suggestedSelector.text}"`);
+      }
+      if (suggestion.suggestedSelector.css) {
+        console.log(`     css: "${suggestion.suggestedSelector.css}"`);
+      }
+      if (suggestion.suggestedSelector.role) {
+        console.log(`     role: "${suggestion.suggestedSelector.role}"`);
+      }
+      if (suggestion.suggestedSelector.name) {
+        console.log(`     name: "${suggestion.suggestedSelector.name}"`);
+      }
+      console.log("");
+    } else {
+      console.log(`\u{1F916} AI Analysis: ${suggestion.explanation}
+`);
+    }
+  }
+  const response = await prompts({
+    type: "select",
+    name: "action",
+    message: "What would you like to do?",
+    choices: [
+      { title: "Retry with AI suggestion", value: "retry", disabled: !aiConfig },
+      { title: "Skip this step", value: "skip" },
+      { title: "Abort test", value: "abort" },
+      { title: "Open in browser (pause)", value: "debug" }
+    ],
+    initial: 0
+  });
+  return response.action || "abort";
+}
+async function executeActionWithRetry(page, action, index, options) {
+  const { baseUrl, context, screenshotDir, debugMode, interactive, aiConfig } = options;
+  while (true) {
+    try {
+      switch (action.type) {
+        case "navigate": {
+          const interpolated = interpolateVariables(action.value, context.variables);
+          const target = resolveUrl(interpolated, baseUrl);
+          if (debugMode) {
+            console.log(`[DEBUG] Navigating to: ${target}`);
+          }
+          await runNavigate(page, action.value, baseUrl, context);
+          break;
+        }
+        case "tap": {
+          if (debugMode) {
+            console.log(`[DEBUG] Tapping element:`, action.target);
+          }
+          await runTap(page, action.target);
+          break;
+        }
+        case "input": {
+          if (debugMode) {
+            const interpolated = interpolateVariables(action.value, context.variables);
+            console.log(`[DEBUG] Inputting value into element:`, action.target);
+            console.log(`[DEBUG] Value: ${interpolated}`);
+          }
+          await runInput(page, action.target, action.value, context);
+          break;
+        }
+        case "assert": {
+          if (debugMode) {
+            console.log(`[DEBUG] Asserting element:`, action.target);
+            if (action.value) {
+              const interpolated = interpolateVariables(action.value, context.variables);
+              console.log(`[DEBUG] Expected text contains: ${interpolated}`);
+            }
+          }
+          await runAssert(page, action.target, action.value, context);
+          break;
+        }
+        case "wait":
+          await runWait(page, action);
+          break;
+        case "scroll":
+          await runScroll(page, action);
+          break;
+        case "screenshot":
+          throw new Error("Screenshot action should be handled separately");
+        case "setVar": {
+          let value;
+          if (action.value) {
+            value = interpolateVariables(action.value, context.variables);
+          } else if (action.from === "response") {
+            throw new Error("setVar from response not yet implemented");
+          } else if (action.from === "element") {
+            throw new Error("setVar from element not yet implemented");
+          } else if (action.from === "email") {
+            throw new Error("Use email.extractCode or email.extractLink instead");
+          } else {
+            throw new Error("setVar requires value or from");
+          }
+          context.variables.set(action.name, value);
+          break;
+        }
+        case "email.waitFor": {
+          if (!context.emailClient) {
+            throw new Error("Email client not configured");
+          }
+          const mailbox = interpolateVariables(action.mailbox, context.variables);
+          context.lastEmail = await context.emailClient.waitForEmail(mailbox, {
+            timeout: action.timeout,
+            subjectContains: action.subjectContains
+          });
+          break;
+        }
+        case "email.extractCode": {
+          if (!context.emailClient) {
+            throw new Error("Email client not configured");
+          }
+          if (!context.lastEmail) {
+            throw new Error("No email loaded - call email.waitFor first");
+          }
+          const code = context.emailClient.extractCode(
+            context.lastEmail,
+            action.pattern ? new RegExp(action.pattern) : void 0
+          );
+          if (!code) {
+            throw new Error("No code found in email");
+          }
+          context.variables.set(action.saveTo, code);
+          break;
+        }
+        case "email.extractLink": {
+          if (!context.emailClient) {
+            throw new Error("Email client not configured");
+          }
+          if (!context.lastEmail) {
+            throw new Error("No email loaded - call email.waitFor first");
+          }
+          const link = context.emailClient.extractLink(
+            context.lastEmail,
+            action.pattern ? new RegExp(action.pattern) : void 0
+          );
+          if (!link) {
+            throw new Error("No link found in email");
+          }
+          context.variables.set(action.saveTo, link);
+          break;
+        }
+        case "email.clear": {
+          if (!context.emailClient) {
+            throw new Error("Email client not configured");
+          }
+          const mailbox = interpolateVariables(action.mailbox, context.variables);
+          await context.emailClient.clearMailbox(mailbox);
+          break;
+        }
+        case "appwrite.verifyEmail": {
+          if (!context.appwriteContext.userId) {
+            throw new Error("No user tracked. appwrite.verifyEmail requires a user signup to have occurred first.");
+          }
+          if (!context.appwriteConfig?.apiKey) {
+            throw new Error("appwrite.verifyEmail requires appwrite.apiKey in config");
+          }
+          const { Client: Client2, Users: Users2 } = await import('node-appwrite');
+          const client = new Client2().setEndpoint(context.appwriteConfig.endpoint).setProject(context.appwriteConfig.projectId).setKey(context.appwriteConfig.apiKey);
+          const users = new Users2(client);
+          await users.updateEmailVerification(context.appwriteContext.userId, true);
+          console.log(`Verified email for user ${context.appwriteContext.userId}`);
+          break;
+        }
+        case "debug": {
+          console.log("[DEBUG] Pausing execution - Playwright Inspector will open");
+          await page.pause();
+          break;
+        }
+        default:
+          throw new Error(`Unsupported action type: ${action.type}`);
+      }
+      return;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (interactive && aiConfig && hasTarget(action)) {
+        const choice = await handleInteractiveError(page, action, error, screenshotDir, index, aiConfig);
+        switch (choice) {
+          case "retry":
+            console.log("Retrying with AI suggestion...\n");
+            continue;
+          case "skip":
+            console.log("Skipping step...\n");
+            return;
+          case "debug":
+            console.log("Opening Playwright Inspector...\n");
+            await page.pause();
+            continue;
+          case "abort":
+          default:
+            throw error;
+        }
+      }
+      if (debugMode) {
+        console.error(`[DEBUG] Action failed: ${error.message}`);
+        console.log("[DEBUG] Opening Playwright Inspector for debugging...");
+        await page.pause();
+      }
+      throw error;
+    }
+  }
+}
+function hasTarget(action) {
+  return "target" in action && action.target !== void 0;
+}
+var runWebTest = async (test, options = {}) => {
+  if (test.platform !== "web") {
+    throw new Error(`runWebTest only supports web platform, received ${test.platform}`);
+  }
+  const browserName = options.browser ?? "chromium";
+  const headless = options.headed ? false : true;
+  const screenshotDir = options.screenshotDir ?? defaultScreenshotDir;
+  const defaultTimeout = options.defaultTimeoutMs ?? 3e4;
+  const sessionId = crypto2.randomUUID();
+  const trackingServer = new TrackingServer();
+  await trackingServer.start();
+  process.env.INTELLITESTER_SESSION_ID = sessionId;
+  process.env.INTELLITESTER_TRACK_URL = `http://localhost:${trackingServer.port}`;
+  let serverProcess = null;
+  if (options.webServer) {
+    serverProcess = await startWebServer(options.webServer);
+  }
+  const cleanup = () => {
+    trackingServer.stop();
+    killServer(serverProcess);
+    process.exit(1);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  const browser = await getBrowser(browserName).launch({ headless });
+  const browserContext = await browser.newContext();
+  const page = await browserContext.newPage();
+  page.setDefaultTimeout(defaultTimeout);
+  const executionContext = {
+    variables: /* @__PURE__ */ new Map(),
+    lastEmail: null,
+    emailClient: null,
+    appwriteContext: createTestContext(),
+    appwriteConfig: test.config?.appwrite ? {
+      endpoint: test.config.appwrite.endpoint,
+      projectId: test.config.appwrite.projectId,
+      apiKey: test.config.appwrite.apiKey
+    } : void 0
+  };
+  if (test.config?.email) {
+    const emailEndpoint = test.config.email.endpoint ?? process.env.INBUCKET_URL;
+    if (!emailEndpoint) {
+      throw new Error("Email testing requires endpoint in config or INBUCKET_URL env var");
+    }
+    executionContext.emailClient = new InbucketClient({
+      endpoint: emailEndpoint
+    });
+  }
+  page.on("response", async (response) => {
+    const url = response.url();
+    const method = response.request().method();
+    try {
+      if (method === "POST") {
+        if (APPWRITE_PATTERNS.userCreate.test(url)) {
+          const data = await response.json();
+          executionContext.appwriteContext.userId = data.$id;
+          executionContext.appwriteContext.userEmail = data.email;
+          return;
+        }
+        const rowMatch = url.match(APPWRITE_PATTERNS.rowCreate);
+        if (rowMatch) {
+          const data = await response.json();
+          executionContext.appwriteContext.resources.push({
+            type: "row",
+            id: data.$id,
+            databaseId: rowMatch[1],
+            tableId: rowMatch[2],
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+        const fileMatch = url.match(APPWRITE_PATTERNS.fileCreate);
+        if (fileMatch) {
+          const data = await response.json();
+          executionContext.appwriteContext.resources.push({
+            type: "file",
+            id: data.$id,
+            bucketId: fileMatch[1],
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+        const teamMatch = url.match(APPWRITE_PATTERNS.teamCreate);
+        if (teamMatch) {
+          const data = await response.json();
+          executionContext.appwriteContext.resources.push({
+            type: "team",
+            id: data.$id,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+        const membershipMatch = url.match(APPWRITE_PATTERNS.membershipCreate);
+        if (membershipMatch) {
+          const data = await response.json();
+          executionContext.appwriteContext.resources.push({
+            type: "membership",
+            id: data.$id,
+            teamId: membershipMatch[1],
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+        const messageMatch = url.match(APPWRITE_PATTERNS.messageCreate);
+        if (messageMatch) {
+          const data = await response.json();
+          executionContext.appwriteContext.resources.push({
+            type: "message",
+            id: data.$id,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+      }
+      if (method === "PUT" || method === "PATCH") {
+        const rowUpdateMatch = url.match(APPWRITE_UPDATE_PATTERNS.rowUpdate);
+        if (rowUpdateMatch) {
+          const resourceId = rowUpdateMatch[3];
+          const existingResource = executionContext.appwriteContext.resources.find(
+            (r) => r.type === "row" && r.id === resourceId
+          );
+          if (!existingResource) {
+            executionContext.appwriteContext.resources.push({
+              type: "row",
+              id: resourceId,
+              databaseId: rowUpdateMatch[1],
+              tableId: rowUpdateMatch[2],
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          return;
+        }
+        const fileUpdateMatch = url.match(APPWRITE_UPDATE_PATTERNS.fileUpdate);
+        if (fileUpdateMatch) {
+          const resourceId = fileUpdateMatch[2];
+          const existingResource = executionContext.appwriteContext.resources.find(
+            (r) => r.type === "file" && r.id === resourceId
+          );
+          if (!existingResource) {
+            executionContext.appwriteContext.resources.push({
+              type: "file",
+              id: resourceId,
+              bucketId: fileUpdateMatch[1],
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          return;
+        }
+        const teamUpdateMatch = url.match(APPWRITE_UPDATE_PATTERNS.teamUpdate);
+        if (teamUpdateMatch) {
+          const resourceId = teamUpdateMatch[1];
+          const existingResource = executionContext.appwriteContext.resources.find(
+            (r) => r.type === "team" && r.id === resourceId
+          );
+          if (!existingResource) {
+            executionContext.appwriteContext.resources.push({
+              type: "team",
+              id: resourceId,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          return;
+        }
+      }
+      if (method === "DELETE") {
+        const rowDeleteMatch = url.match(APPWRITE_DELETE_PATTERNS.rowDelete);
+        if (rowDeleteMatch) {
+          const resourceId = rowDeleteMatch[3];
+          const resource = executionContext.appwriteContext.resources.find(
+            (r) => r.type === "row" && r.id === resourceId
+          );
+          if (resource) {
+            resource.deleted = true;
+          }
+          return;
+        }
+        const fileDeleteMatch = url.match(APPWRITE_DELETE_PATTERNS.fileDelete);
+        if (fileDeleteMatch) {
+          const resourceId = fileDeleteMatch[2];
+          const resource = executionContext.appwriteContext.resources.find(
+            (r) => r.type === "file" && r.id === resourceId
+          );
+          if (resource) {
+            resource.deleted = true;
+          }
+          return;
+        }
+        const teamDeleteMatch = url.match(APPWRITE_DELETE_PATTERNS.teamDelete);
+        if (teamDeleteMatch) {
+          const resourceId = teamDeleteMatch[1];
+          const resource = executionContext.appwriteContext.resources.find(
+            (r) => r.type === "team" && r.id === resourceId
+          );
+          if (resource) {
+            resource.deleted = true;
+          }
+          return;
+        }
+        const membershipDeleteMatch = url.match(APPWRITE_DELETE_PATTERNS.membershipDelete);
+        if (membershipDeleteMatch) {
+          const resourceId = membershipDeleteMatch[2];
+          const resource = executionContext.appwriteContext.resources.find(
+            (r) => r.type === "membership" && r.id === resourceId
+          );
+          if (resource) {
+            resource.deleted = true;
+          }
+          return;
+        }
+      }
+    } catch {
+    }
+  });
+  if (test.variables) {
+    for (const [key, value] of Object.entries(test.variables)) {
+      const interpolated = interpolateVariables(value, executionContext.variables);
+      executionContext.variables.set(key, interpolated);
+    }
+  }
+  const results = [];
+  const debugMode = options.debug ?? false;
+  const interactive = options.interactive ?? false;
+  try {
+    for (const [index, action] of test.steps.entries()) {
+      if (debugMode) {
+        console.log(`[DEBUG] Executing step ${index + 1}: ${action.type}`);
+      }
+      const serverResources = trackingServer.getResources(sessionId);
+      for (const resource of serverResources) {
+        if (resource.type === "user" && !executionContext.appwriteContext.userId) {
+          executionContext.appwriteContext.userId = resource.id;
+        }
+        const knownTypes = ["row", "file", "user", "team", "membership", "message"];
+        if (knownTypes.includes(resource.type)) {
+          const exists = executionContext.appwriteContext.resources.some(
+            (r) => r.type === resource.type && r.id === resource.id
+          );
+          if (!exists) {
+            executionContext.appwriteContext.resources.push({
+              type: resource.type,
+              id: resource.id,
+              databaseId: resource.databaseId,
+              tableId: resource.tableId,
+              bucketId: resource.bucketId,
+              teamId: resource.teamId,
+              createdAt: resource.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+      }
+      try {
+        if (action.type === "screenshot") {
+          const screenshotPath = await runScreenshot(page, action.name, screenshotDir, index);
+          results.push({ action, status: "passed", screenshotPath });
+          continue;
+        }
+        await executeActionWithRetry(page, action, index, {
+          baseUrl: options.baseUrl ?? test.config?.web?.baseUrl,
+          context: executionContext,
+          screenshotDir,
+          debugMode,
+          interactive,
+          aiConfig: options.aiConfig
+        });
+        results.push({ action, status: "passed" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        results.push({ action, status: "failed", error: message });
+        throw error;
+      }
+    }
+  } finally {
+    process.off("SIGINT", cleanup);
+    process.off("SIGTERM", cleanup);
+    if (test.config?.appwrite?.cleanup) {
+      const appwriteClient = new AppwriteTestClient({
+        endpoint: test.config.appwrite.endpoint,
+        projectId: test.config.appwrite.projectId,
+        apiKey: test.config.appwrite.apiKey,
+        cleanup: true
+      });
+      const cleanupResult = await appwriteClient.cleanup(
+        executionContext.appwriteContext,
+        sessionId,
+        process.cwd()
+      );
+      console.log("Cleanup result:", cleanupResult);
+    }
+    await browserContext.close();
+    await browser.close();
+    trackingServer.stop();
+    killServer(serverProcess);
+  }
+  return {
+    status: results.every((step) => step.status === "passed") ? "passed" : "failed",
+    steps: results,
+    variables: executionContext.variables
+  };
+};
+var defaultScreenshotDir2 = path.join(process.cwd(), "artifacts", "screenshots");
+var getBrowser2 = (browser) => {
+  switch (browser) {
+    case "firefox":
+      return firefox;
+    case "webkit":
+      return webkit;
+    default:
+      return chromium;
+  }
+};
+function interpolateWorkflowVariables(value, currentVariables, testResults) {
+  return value.replace(/\{\{([^}]+)\}\}/g, (match, path3) => {
+    if (path3.includes(".")) {
+      const [testId, _varName] = path3.split(".", 2);
+      testResults.find((t) => t.id === testId);
+      console.warn(`Cross-test variable interpolation {{${path3}}} not yet fully implemented`);
+      return match;
+    }
+    if (path3 === "uuid") {
+      return crypto2.randomUUID().split("-")[0];
+    }
+    return currentVariables.get(path3) ?? match;
+  });
+}
+async function runTestInWorkflow(test, page, context, options, _workflowDir) {
+  const results = [];
+  const debugMode = options.debug ?? false;
+  const screenshotDir = defaultScreenshotDir2;
+  const resolveUrl2 = (value, baseUrl) => {
+    if (!baseUrl) return value;
+    try {
+      const url = new URL(value, baseUrl);
+      return url.toString();
+    } catch {
+      return value;
+    }
+  };
+  const interpolateVariables2 = (value) => {
+    return value.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
+      if (varName === "uuid") {
+        return crypto2.randomUUID().split("-")[0];
+      }
+      return context.variables.get(varName) ?? match;
+    });
+  };
+  const resolveLocator2 = (locator) => {
+    if (locator.testId) return page.getByTestId(locator.testId);
+    if (locator.text) return page.getByText(locator.text);
+    if (locator.css) return page.locator(locator.css);
+    if (locator.xpath) return page.locator(`xpath=${locator.xpath}`);
+    if (locator.role) {
+      const options2 = {};
+      if (locator.name) options2.name = locator.name;
+      return page.getByRole(locator.role, options2);
+    }
+    if (locator.description) return page.getByText(locator.description);
+    throw new Error("No usable selector found for locator");
+  };
+  try {
+    for (const [index, action] of test.steps.entries()) {
+      if (debugMode) {
+        console.log(`  [DEBUG] Step ${index + 1}: ${action.type}`);
+      }
+      try {
+        switch (action.type) {
+          case "navigate": {
+            const interpolated = interpolateVariables2(action.value);
+            const target = resolveUrl2(interpolated, test.config?.web?.baseUrl);
+            if (debugMode) console.log(`  [DEBUG] Navigating to: ${target}`);
+            await page.goto(target);
+            break;
+          }
+          case "tap": {
+            if (debugMode) console.log(`  [DEBUG] Tapping element:`, action.target);
+            const handle = resolveLocator2(action.target);
+            await handle.click();
+            break;
+          }
+          case "input": {
+            const interpolated = interpolateVariables2(action.value);
+            if (debugMode) console.log(`  [DEBUG] Input: ${interpolated}`);
+            const handle = resolveLocator2(action.target);
+            await handle.fill(interpolated);
+            break;
+          }
+          case "assert": {
+            if (debugMode) console.log(`  [DEBUG] Assert:`, action.target);
+            const handle = resolveLocator2(action.target);
+            await handle.waitFor({ state: "visible" });
+            if (action.value) {
+              const interpolated = interpolateVariables2(action.value);
+              const text = (await handle.textContent())?.trim() ?? "";
+              if (!text.includes(interpolated)) {
+                throw new Error(
+                  `Assertion failed: expected "${interpolated}", got "${text}"`
+                );
+              }
+            }
+            break;
+          }
+          case "wait": {
+            if (action.target) {
+              const handle = resolveLocator2(action.target);
+              await handle.waitFor({ state: "visible", timeout: action.timeout });
+            } else {
+              await page.waitForTimeout(action.timeout ?? 1e3);
+            }
+            break;
+          }
+          case "scroll": {
+            if (action.target) {
+              const handle = resolveLocator2(action.target);
+              await handle.scrollIntoViewIfNeeded();
+            } else {
+              const amount = action.amount ?? 500;
+              const direction = action.direction ?? "down";
+              const deltaY = direction === "up" ? -amount : amount;
+              await page.evaluate((value) => window.scrollBy(0, value), deltaY);
+            }
+            break;
+          }
+          case "screenshot": {
+            const filename = action.name ?? `step-${index + 1}.png`;
+            const filePath = path.join(screenshotDir, filename);
+            await page.screenshot({ path: filePath, fullPage: true });
+            results.push({ action, status: "passed", screenshotPath: filePath });
+            continue;
+          }
+          case "setVar": {
+            let value;
+            if (action.value) {
+              value = interpolateVariables2(action.value);
+            } else if (action.from === "response") {
+              throw new Error("setVar from response not yet implemented");
+            } else if (action.from === "element") {
+              throw new Error("setVar from element not yet implemented");
+            } else if (action.from === "email") {
+              throw new Error("Use email.extractCode or email.extractLink instead");
+            } else {
+              throw new Error("setVar requires value or from");
+            }
+            context.variables.set(action.name, value);
+            if (debugMode) console.log(`  [DEBUG] Set variable ${action.name} = ${value}`);
+            break;
+          }
+          case "email.waitFor": {
+            if (!context.emailClient) {
+              throw new Error("Email client not configured");
+            }
+            const mailbox = interpolateVariables2(action.mailbox);
+            context.lastEmail = await context.emailClient.waitForEmail(mailbox, {
+              timeout: action.timeout,
+              subjectContains: action.subjectContains
+            });
+            break;
+          }
+          case "email.extractCode": {
+            if (!context.emailClient) {
+              throw new Error("Email client not configured");
+            }
+            if (!context.lastEmail) {
+              throw new Error("No email loaded - call email.waitFor first");
+            }
+            const code = context.emailClient.extractCode(
+              context.lastEmail,
+              action.pattern ? new RegExp(action.pattern) : void 0
+            );
+            if (!code) {
+              throw new Error("No code found in email");
+            }
+            context.variables.set(action.saveTo, code);
+            break;
+          }
+          case "email.extractLink": {
+            if (!context.emailClient) {
+              throw new Error("Email client not configured");
+            }
+            if (!context.lastEmail) {
+              throw new Error("No email loaded - call email.waitFor first");
+            }
+            const link = context.emailClient.extractLink(
+              context.lastEmail,
+              action.pattern ? new RegExp(action.pattern) : void 0
+            );
+            if (!link) {
+              throw new Error("No link found in email");
+            }
+            context.variables.set(action.saveTo, link);
+            break;
+          }
+          case "email.clear": {
+            if (!context.emailClient) {
+              throw new Error("Email client not configured");
+            }
+            const mailbox = interpolateVariables2(action.mailbox);
+            await context.emailClient.clearMailbox(mailbox);
+            break;
+          }
+          case "appwrite.verifyEmail": {
+            if (!context.appwriteContext.userId) {
+              throw new Error("No user tracked. appwrite.verifyEmail requires a user signup first.");
+            }
+            if (!context.appwriteConfig?.apiKey) {
+              throw new Error("appwrite.verifyEmail requires appwrite.apiKey in config");
+            }
+            const { Client: Client2, Users: Users2 } = await import('node-appwrite');
+            const client = new Client2().setEndpoint(context.appwriteConfig.endpoint).setProject(context.appwriteConfig.projectId).setKey(context.appwriteConfig.apiKey);
+            const users = new Users2(client);
+            await users.updateEmailVerification(context.appwriteContext.userId, true);
+            if (debugMode) console.log(`  [DEBUG] Verified email for user ${context.appwriteContext.userId}`);
+            break;
+          }
+          case "debug": {
+            console.log("  [DEBUG] Pausing execution - Playwright Inspector will open");
+            await page.pause();
+            break;
+          }
+          default:
+            throw new Error(`Unsupported action type: ${action.type}`);
+        }
+        results.push({ action, status: "passed" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        results.push({ action, status: "failed", error: message });
+        throw error;
+      }
+    }
+    return {
+      status: "passed",
+      steps: results
+    };
+  } catch {
+    return {
+      status: "failed",
+      steps: results
+    };
+  }
+}
+function setupAppwriteTracking(page, context) {
+  page.on("response", async (response) => {
+    const url = response.url();
+    const method = response.request().method();
+    try {
+      if (method === "POST") {
+        if (APPWRITE_PATTERNS.userCreate.test(url)) {
+          const data = await response.json();
+          context.appwriteContext.userId = data.$id;
+          context.appwriteContext.userEmail = data.email;
+          return;
+        }
+        const rowMatch = url.match(APPWRITE_PATTERNS.rowCreate);
+        if (rowMatch) {
+          const data = await response.json();
+          context.appwriteContext.resources.push({
+            type: "row",
+            id: data.$id,
+            databaseId: rowMatch[1],
+            tableId: rowMatch[2],
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+        const fileMatch = url.match(APPWRITE_PATTERNS.fileCreate);
+        if (fileMatch) {
+          const data = await response.json();
+          context.appwriteContext.resources.push({
+            type: "file",
+            id: data.$id,
+            bucketId: fileMatch[1],
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+        const teamMatch = url.match(APPWRITE_PATTERNS.teamCreate);
+        if (teamMatch) {
+          const data = await response.json();
+          context.appwriteContext.resources.push({
+            type: "team",
+            id: data.$id,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+        const membershipMatch = url.match(APPWRITE_PATTERNS.membershipCreate);
+        if (membershipMatch) {
+          const data = await response.json();
+          context.appwriteContext.resources.push({
+            type: "membership",
+            id: data.$id,
+            teamId: membershipMatch[1],
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+        const messageMatch = url.match(APPWRITE_PATTERNS.messageCreate);
+        if (messageMatch) {
+          const data = await response.json();
+          context.appwriteContext.resources.push({
+            type: "message",
+            id: data.$id,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return;
+        }
+      }
+      if (method === "PUT" || method === "PATCH") {
+        const rowUpdateMatch = url.match(APPWRITE_UPDATE_PATTERNS.rowUpdate);
+        if (rowUpdateMatch) {
+          const resourceId = rowUpdateMatch[3];
+          const existing = context.appwriteContext.resources.find(
+            (r) => r.type === "row" && r.id === resourceId
+          );
+          if (!existing) {
+            context.appwriteContext.resources.push({
+              type: "row",
+              id: resourceId,
+              databaseId: rowUpdateMatch[1],
+              tableId: rowUpdateMatch[2],
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          return;
+        }
+        const fileUpdateMatch = url.match(APPWRITE_UPDATE_PATTERNS.fileUpdate);
+        if (fileUpdateMatch) {
+          const resourceId = fileUpdateMatch[2];
+          const existing = context.appwriteContext.resources.find(
+            (r) => r.type === "file" && r.id === resourceId
+          );
+          if (!existing) {
+            context.appwriteContext.resources.push({
+              type: "file",
+              id: resourceId,
+              bucketId: fileUpdateMatch[1],
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          return;
+        }
+        const teamUpdateMatch = url.match(APPWRITE_UPDATE_PATTERNS.teamUpdate);
+        if (teamUpdateMatch) {
+          const resourceId = teamUpdateMatch[1];
+          const existing = context.appwriteContext.resources.find(
+            (r) => r.type === "team" && r.id === resourceId
+          );
+          if (!existing) {
+            context.appwriteContext.resources.push({
+              type: "team",
+              id: resourceId,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          return;
+        }
+      }
+      if (method === "DELETE") {
+        const rowDeleteMatch = url.match(APPWRITE_DELETE_PATTERNS.rowDelete);
+        if (rowDeleteMatch) {
+          const resource = context.appwriteContext.resources.find(
+            (r) => r.type === "row" && r.id === rowDeleteMatch[3]
+          );
+          if (resource) resource.deleted = true;
+          return;
+        }
+        const fileDeleteMatch = url.match(APPWRITE_DELETE_PATTERNS.fileDelete);
+        if (fileDeleteMatch) {
+          const resource = context.appwriteContext.resources.find(
+            (r) => r.type === "file" && r.id === fileDeleteMatch[2]
+          );
+          if (resource) resource.deleted = true;
+          return;
+        }
+        const teamDeleteMatch = url.match(APPWRITE_DELETE_PATTERNS.teamDelete);
+        if (teamDeleteMatch) {
+          const resource = context.appwriteContext.resources.find(
+            (r) => r.type === "team" && r.id === teamDeleteMatch[1]
+          );
+          if (resource) resource.deleted = true;
+          return;
+        }
+        const membershipDeleteMatch = url.match(APPWRITE_DELETE_PATTERNS.membershipDelete);
+        if (membershipDeleteMatch) {
+          const resource = context.appwriteContext.resources.find(
+            (r) => r.type === "membership" && r.id === membershipDeleteMatch[2]
+          );
+          if (resource) resource.deleted = true;
+          return;
+        }
+      }
+    } catch {
+    }
+  });
+}
+function inferCleanupConfig(config) {
+  if (!config) return void 0;
+  if (config.cleanup) {
+    return config.cleanup;
+  }
+  if (config.appwrite?.cleanup) {
+    return {
+      provider: "appwrite",
+      appwrite: {
+        endpoint: config.appwrite.endpoint,
+        projectId: config.appwrite.projectId,
+        apiKey: config.appwrite.apiKey,
+        cleanupOnFailure: config.appwrite.cleanupOnFailure
+      }
+    };
+  }
+  return void 0;
+}
+async function runWorkflowWithContext(workflow, workflowFilePath, options) {
+  const { page, executionContext, skipCleanup = false, sessionId: providedSessionId, testStartTime: providedTestStartTime } = options;
+  const workflowDir = path.dirname(workflowFilePath);
+  const sessionId = providedSessionId ?? crypto2.randomUUID();
+  const testStartTime = providedTestStartTime ?? (/* @__PURE__ */ new Date()).toISOString();
+  console.log(`
+Starting workflow: ${workflow.name}`);
+  console.log(`Session ID: ${sessionId}
+`);
+  if (workflow.config?.appwrite) {
+    if (!executionContext.appwriteConfig) {
+      executionContext.appwriteConfig = {
+        endpoint: workflow.config.appwrite.endpoint,
+        projectId: workflow.config.appwrite.projectId,
+        apiKey: workflow.config.appwrite.apiKey
+      };
+    }
+    setupAppwriteTracking(page, executionContext);
+  }
+  const testResults = [];
+  let workflowFailed = false;
+  for (const [index, testRef] of workflow.tests.entries()) {
+    const testFilePath = path.resolve(workflowDir, testRef.file);
+    console.log(`
+[${index + 1}/${workflow.tests.length}] Running: ${testRef.file}`);
+    if (testRef.id) {
+      console.log(`  Test ID: ${testRef.id}`);
+    }
+    try {
+      const test = await loadTestDefinition(testFilePath);
+      if (testRef.variables) {
+        for (const [key, value] of Object.entries(testRef.variables)) {
+          const interpolated = interpolateWorkflowVariables(
+            value,
+            executionContext.variables,
+            testResults
+          );
+          if (!test.variables) test.variables = {};
+          test.variables[key] = interpolated;
+          executionContext.variables.set(key, interpolated);
+        }
+      }
+      if (test.variables) {
+        for (const [key, value] of Object.entries(test.variables)) {
+          const interpolated = value.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
+            if (varName === "uuid") {
+              return crypto2.randomUUID().split("-")[0];
+            }
+            return executionContext.variables.get(varName) ?? match;
+          });
+          executionContext.variables.set(key, interpolated);
+        }
+      }
+      const result = await runTestInWorkflow(test, page, executionContext, options, workflowDir);
+      const testResult = {
+        id: testRef.id,
+        file: testRef.file,
+        status: result.status,
+        steps: result.steps
+      };
+      testResults.push(testResult);
+      if (result.status === "passed") {
+        console.log(`  \u2713 Passed (${result.steps.length} steps)`);
+      } else {
+        console.log(`  \u2717 Failed`);
+        const failedStep = result.steps.find((s) => s.status === "failed");
+        if (failedStep) {
+          console.log(`  Error: ${failedStep.error}`);
+          testResult.error = failedStep.error;
+        }
+        if (!workflow.continueOnFailure) {
+          workflowFailed = true;
+          break;
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`  \u2717 Failed to load/run test: ${message}`);
+      testResults.push({
+        id: testRef.id,
+        file: testRef.file,
+        status: "failed",
+        steps: [],
+        error: message
+      });
+      if (!workflow.continueOnFailure) {
+        workflowFailed = true;
+        break;
+      }
+    }
+  }
+  let cleanupResult;
+  if (!skipCleanup) {
+    const cleanupConfig = inferCleanupConfig(workflow.config);
+    if (cleanupConfig) {
+      const appwriteConfig = cleanupConfig.appwrite;
+      const cleanupOnFailure = appwriteConfig?.cleanupOnFailure ?? true;
+      const shouldCleanup = workflowFailed ? cleanupOnFailure : true;
+      if (shouldCleanup) {
+        try {
+          console.log("\n[Cleanup] Starting cleanup...");
+          const { handlers, typeMappings, provider } = await loadCleanupHandlers(
+            cleanupConfig,
+            process.cwd()
+          );
+          const genericResources = executionContext.appwriteContext.resources.map((r) => ({
+            ...r
+          }));
+          const providerConfig = {
+            provider: cleanupConfig.provider || "appwrite"
+          };
+          if (cleanupConfig.provider === "appwrite" && cleanupConfig.appwrite) {
+            const appwriteCleanupConfig = cleanupConfig.appwrite;
+            providerConfig.endpoint = appwriteCleanupConfig.endpoint;
+            providerConfig.projectId = appwriteCleanupConfig.projectId;
+          } else if (cleanupConfig.provider === "postgres" && cleanupConfig.postgres) {
+            const pgConfig = cleanupConfig.postgres;
+            const connString = pgConfig.connectionString;
+            if (connString) {
+              try {
+                const url = new URL(connString.replace("postgresql://", "http://"));
+                providerConfig.host = url.hostname;
+                providerConfig.port = url.port;
+                providerConfig.database = url.pathname.slice(1);
+                providerConfig.user = url.username;
+              } catch {
+                providerConfig.configured = true;
+              }
+            }
+          } else if (cleanupConfig.provider === "mysql" && cleanupConfig.mysql) {
+            const mysqlConfig = cleanupConfig.mysql;
+            providerConfig.host = mysqlConfig.host;
+            providerConfig.port = mysqlConfig.port;
+            providerConfig.database = mysqlConfig.database;
+            providerConfig.user = mysqlConfig.user;
+          } else if (cleanupConfig.provider === "sqlite" && cleanupConfig.sqlite) {
+            const sqliteConfig = cleanupConfig.sqlite;
+            providerConfig.database = sqliteConfig.database;
+          }
+          cleanupResult = await executeCleanup(
+            genericResources,
+            handlers,
+            typeMappings,
+            {
+              parallel: cleanupConfig.parallel ?? false,
+              retries: cleanupConfig.retries ?? 3,
+              sessionId,
+              testStartTime,
+              userId: executionContext.appwriteContext.userId,
+              providerConfig,
+              cwd: process.cwd(),
+              config: cleanupConfig,
+              provider
+            }
+          );
+          if (cleanupResult.success) {
+            console.log(`[Cleanup] Cleanup complete: ${cleanupResult.deleted.length} resources deleted`);
+          } else {
+            console.log(`[Cleanup] Cleanup partial: ${cleanupResult.deleted.length} deleted, ${cleanupResult.failed.length} failed`);
+            for (const failed of cleanupResult.failed) {
+              console.log(`   - ${failed}`);
+            }
+          }
+        } catch (error) {
+          console.error("[Cleanup] Cleanup failed:", error);
+        }
+      } else {
+        console.log("\nSkipping cleanup (cleanupOnFailure is false)");
+      }
+    }
+  }
+  const overallStatus = testResults.every((t) => t.status === "passed") ? "passed" : "failed";
+  console.log(`
+${"=".repeat(60)}`);
+  console.log(`Workflow: ${overallStatus === "passed" ? "\u2713 PASSED" : "\u2717 FAILED"}`);
+  console.log(`Tests: ${testResults.filter((t) => t.status === "passed").length}/${testResults.length} passed`);
+  console.log(`${"=".repeat(60)}
+`);
+  return {
+    status: overallStatus,
+    tests: testResults,
+    sessionId,
+    cleanupResult,
+    workflowFailed
+  };
+}
+async function runWorkflow(workflow, workflowFilePath, options = {}) {
+  const workflowDir = path.dirname(workflowFilePath);
+  const sessionId = crypto2.randomUUID();
+  const testStartTime = (/* @__PURE__ */ new Date()).toISOString();
+  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 serverProcess = null;
+  if (workflow.config?.webServer) {
+    try {
+      serverProcess = await startWebServer({
+        ...workflow.config.webServer,
+        cwd: workflowDir
+      });
+    } catch (error) {
+      console.error("Failed to start web server:", error);
+      if (trackingServer) await trackingServer.stop();
+      throw error;
+    }
+  }
+  const signalCleanup = async () => {
+    console.log("\n\nInterrupted - cleaning up...");
+    killServer(serverProcess);
+    if (trackingServer) await trackingServer.stop();
+    process.exit(1);
+  };
+  process.on("SIGINT", signalCleanup);
+  process.on("SIGTERM", signalCleanup);
+  const browserName = options.browser ?? workflow.config?.web?.browser ?? "chromium";
+  const headless = options.headed ? false : workflow.config?.web?.headless ?? true;
+  const browser = await getBrowser2(browserName).launch({ headless });
+  const browserContext = await browser.newContext();
+  const page = await browserContext.newPage();
+  page.setDefaultTimeout(3e4);
+  const executionContext = {
+    variables: /* @__PURE__ */ new Map(),
+    lastEmail: null,
+    emailClient: null,
+    appwriteContext: createTestContext(),
+    appwriteConfig: workflow.config?.appwrite ? {
+      endpoint: workflow.config.appwrite.endpoint,
+      projectId: workflow.config.appwrite.projectId,
+      apiKey: workflow.config.appwrite.apiKey
+    } : void 0
+  };
+  try {
+    const result = await runWorkflowWithContext(workflow, workflowFilePath, {
+      ...options,
+      page,
+      executionContext,
+      skipCleanup: true,
+      sessionId,
+      testStartTime
+    });
+    if (trackingServer) {
+      const serverResources = trackingServer.getResources(sessionId);
+      if (serverResources.length > 0) {
+        console.log(`
+Collected ${serverResources.length} server-tracked resources`);
+        executionContext.appwriteContext.resources.push(...serverResources);
+      }
+    }
+    let cleanupResult;
+    const cleanupConfig = inferCleanupConfig(workflow.config);
+    if (cleanupConfig) {
+      const appwriteConfig = cleanupConfig.appwrite;
+      const cleanupOnFailure = appwriteConfig?.cleanupOnFailure ?? true;
+      const shouldCleanup = result.workflowFailed ? cleanupOnFailure : true;
+      if (shouldCleanup) {
+        try {
+          console.log("\n[Cleanup] Starting cleanup...");
+          const { handlers, typeMappings, provider } = await loadCleanupHandlers(
+            cleanupConfig,
+            process.cwd()
+          );
+          const genericResources = executionContext.appwriteContext.resources.map((r) => ({
+            ...r
+          }));
+          const providerConfig = {
+            provider: cleanupConfig.provider || "appwrite"
+          };
+          if (cleanupConfig.provider === "appwrite" && cleanupConfig.appwrite) {
+            const appwriteCleanupConfig = cleanupConfig.appwrite;
+            providerConfig.endpoint = appwriteCleanupConfig.endpoint;
+            providerConfig.projectId = appwriteCleanupConfig.projectId;
+          } else if (cleanupConfig.provider === "postgres" && cleanupConfig.postgres) {
+            const pgConfig = cleanupConfig.postgres;
+            const connString = pgConfig.connectionString;
+            if (connString) {
+              try {
+                const url = new URL(connString.replace("postgresql://", "http://"));
+                providerConfig.host = url.hostname;
+                providerConfig.port = url.port;
+                providerConfig.database = url.pathname.slice(1);
+                providerConfig.user = url.username;
+              } catch {
+                providerConfig.configured = true;
+              }
+            }
+          } else if (cleanupConfig.provider === "mysql" && cleanupConfig.mysql) {
+            const mysqlConfig = cleanupConfig.mysql;
+            providerConfig.host = mysqlConfig.host;
+            providerConfig.port = mysqlConfig.port;
+            providerConfig.database = mysqlConfig.database;
+            providerConfig.user = mysqlConfig.user;
+          } else if (cleanupConfig.provider === "sqlite" && cleanupConfig.sqlite) {
+            const sqliteConfig = cleanupConfig.sqlite;
+            providerConfig.database = sqliteConfig.database;
+          }
+          cleanupResult = await executeCleanup(
+            genericResources,
+            handlers,
+            typeMappings,
+            {
+              parallel: cleanupConfig.parallel ?? false,
+              retries: cleanupConfig.retries ?? 3,
+              sessionId,
+              testStartTime,
+              userId: executionContext.appwriteContext.userId,
+              providerConfig,
+              cwd: process.cwd(),
+              config: cleanupConfig,
+              provider
+            }
+          );
+          if (cleanupResult.success) {
+            console.log(`[Cleanup] Cleanup complete: ${cleanupResult.deleted.length} resources deleted`);
+          } else {
+            console.log(`[Cleanup] Cleanup partial: ${cleanupResult.deleted.length} deleted, ${cleanupResult.failed.length} failed`);
+            for (const failed of cleanupResult.failed) {
+              console.log(`   - ${failed}`);
+            }
+          }
+        } catch (error) {
+          console.error("[Cleanup] Cleanup failed:", error);
+        }
+      } else {
+        console.log("\nSkipping cleanup (cleanupOnFailure is false)");
+      }
+    }
+    return {
+      status: result.status,
+      tests: result.tests,
+      sessionId,
+      cleanupResult
+    };
+  } finally {
+    process.off("SIGINT", signalCleanup);
+    process.off("SIGTERM", signalCleanup);
+    await browserContext.close();
+    await browser.close();
+    killServer(serverProcess);
+    if (trackingServer) {
+      await trackingServer.stop();
+    }
+    delete process.env.INTELLITESTER_SESSION_ID;
+    delete process.env.INTELLITESTER_TRACK_URL;
+  }
+}
+
+export { ActionSchema, IntellitesterConfigSchema, LocatorSchema, TestConfigSchema, TestDefinitionSchema, cleanupConfigSchema, cleanupDiscoverSchema, collectMissingEnvVars, createAIProvider, createTestContext, isPipelineFile, isWorkflowFile, killServer, loadIntellitesterConfig, loadPipelineDefinition, loadTestDefinition, loadWorkflowDefinition, parseIntellitesterConfig, parsePipelineDefinition, parseTestDefinition, parseWorkflowDefinition, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, startWebServer };
+//# sourceMappingURL=chunk-5LFSLMQ7.js.map
+//# sourceMappingURL=chunk-5LFSLMQ7.js.map