intellitester 0.2.20 → 0.2.22

package/dist/{chunk-ICJK4WBA.js → chunk-EQJZ2E5H.js}

@@ -129,7 +129,17 @@ var appwriteVerifyEmailActionSchema = z.object({
 var debugActionSchema = z.object({
   type: z.literal("debug")
 }).describe("Pause execution and open Playwright Inspector for debugging");
-var ActionSchema = z.discriminatedUnion("type", [
+var waitForSelectorActionSchema = z.object({
+  type: z.literal("waitForSelector"),
+  target: LocatorSchema,
+  state: z.enum(["enabled", "disabled", "visible", "hidden", "attached", "detached"]).describe("Element state to wait for"),
+  timeout: z.number().int().positive().optional().describe("Time to wait in milliseconds")
+}).describe("Wait for an element to reach a specific state");
+var failActionSchema = z.object({
+  type: z.literal("fail"),
+  message: nonEmptyString.describe("Error message to display when test fails")
+}).describe("Explicitly fail the test with a custom message");
+var BaseActionSchema = z.discriminatedUnion("type", [
   navigateActionSchema,
   tapActionSchema,
   inputActionSchema,
@@ -150,8 +160,20 @@ var ActionSchema = z.discriminatedUnion("type", [
   emailExtractLinkActionSchema,
   emailClearActionSchema,
   appwriteVerifyEmailActionSchema,
-  debugActionSchema
+  debugActionSchema,
+  waitForSelectorActionSchema,
+  failActionSchema
 ]);
+var conditionalActionSchema = z.object({
+  type: z.literal("conditional"),
+  condition: z.object({
+    type: z.enum(["exists", "notExists", "visible", "hidden"]),
+    target: LocatorSchema
+  }).describe("Condition to check"),
+  then: z.array(BaseActionSchema).describe("Steps to execute if condition is true"),
+  else: z.array(BaseActionSchema).optional().describe("Steps to execute if condition is false")
+}).describe("Execute steps conditionally based on element state");
+var ActionSchema = z.union([BaseActionSchema, conditionalActionSchema]);
 var defaultsSchema = z.object({
   timeout: z.number().int().positive().optional().describe("Default timeout in milliseconds for all actions"),
   screenshots: z.enum(["on-failure", "always", "never"]).optional().describe("When to capture screenshots during test execution")
@@ -989,6 +1011,30 @@ var APPWRITE_DELETE_PATTERNS = {
   teamDelete: /\/v1\/teams\/([\w-]+)$/,
   membershipDelete: /\/v1\/teams\/([\w-]+)\/memberships\/([\w-]+)$/
 };
+
+// src/executors/web/browserOptions.ts
+function getBrowserLaunchOptions(options) {
+  return {
+    headless: options.headless,
+    args: [
+      // Shared memory - critical for Docker/CI, harmless locally
+      "--disable-dev-shm-usage",
+      // GPU acceleration - not needed in headless mode
+      "--disable-gpu",
+      // Reduce overhead
+      "--disable-extensions",
+      // Prevent JavaScript throttling (helps with slow page loads)
+      "--disable-background-timer-throttling",
+      "--disable-backgrounding-occluded-windows",
+      "--disable-renderer-backgrounding",
+      // Process isolation - reduces overhead for testing
+      "--disable-features=IsolateOrigins,site-per-process",
+      // Networking tweaks
+      "--disable-features=VizDisplayCompositor",
+      "--disable-blink-features=AutomationControlled"
+    ]
+  };
+}
 function resolveEnvVars(value) {
   return value.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] || "");
 }
@@ -1352,6 +1398,14 @@ var runWait = async (page, action) => {
   }
   await page.waitForTimeout(action.timeout ?? 1e3);
 };
+var waitForCondition = async (checkFn, timeout, errorMessage) => {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (await checkFn()) return;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(errorMessage);
+};
 var runScroll = async (page, action) => {
   if (action.target) {
     const handle = resolveLocator(page, action.target);
@@ -1787,6 +1841,91 @@ async function executeActionWithRetry(page, action, index, options) {
           await page.pause();
           break;
         }
+        case "waitForSelector": {
+          const wsAction = action;
+          const handle = resolveLocator(page, wsAction.target);
+          const timeout = wsAction.timeout ?? 3e4;
+          if (debugMode) {
+            console.log(`[DEBUG] Waiting for element to be ${wsAction.state}:`, wsAction.target);
+          }
+          switch (wsAction.state) {
+            case "visible":
+            case "hidden":
+            case "attached":
+            case "detached":
+              await handle.waitFor({ state: wsAction.state, timeout });
+              break;
+            case "enabled":
+              await waitForCondition(
+                () => handle.isEnabled(),
+                timeout,
+                `Element did not become enabled within ${timeout}ms`
+              );
+              break;
+            case "disabled":
+              await waitForCondition(
+                () => handle.isDisabled(),
+                timeout,
+                `Element did not become disabled within ${timeout}ms`
+              );
+              break;
+          }
+          break;
+        }
+        case "conditional": {
+          const condAction = action;
+          const handle = resolveLocator(page, condAction.condition.target);
+          let conditionMet = false;
+          if (debugMode) {
+            console.log(`[DEBUG] Checking condition ${condAction.condition.type}:`, condAction.condition.target);
+          }
+          try {
+            switch (condAction.condition.type) {
+              case "exists":
+                await handle.waitFor({ state: "attached", timeout: 500 });
+                conditionMet = true;
+                break;
+              case "notExists":
+                try {
+                  await handle.waitFor({ state: "detached", timeout: 500 });
+                  conditionMet = true;
+                } catch {
+                  conditionMet = false;
+                }
+                break;
+              case "visible":
+                conditionMet = await handle.isVisible();
+                break;
+              case "hidden":
+                conditionMet = !await handle.isVisible();
+                break;
+            }
+          } catch {
+            conditionMet = condAction.condition.type === "notExists";
+          }
+          if (debugMode) {
+            console.log(`[DEBUG] Condition result: ${conditionMet}`);
+          }
+          const stepsToRun = conditionMet ? condAction.then : condAction.else ?? [];
+          for (const [nestedIdx, nestedAction] of stepsToRun.entries()) {
+            if (debugMode) {
+              console.log(`[DEBUG] Executing nested step ${nestedIdx + 1}: ${nestedAction.type}`);
+            }
+            await executeActionWithRetry(page, nestedAction, index, {
+              baseUrl,
+              context,
+              screenshotDir,
+              debugMode,
+              interactive,
+              aiConfig
+            });
+          }
+          break;
+        }
+        case "fail": {
+          const failAction = action;
+          throw new Error(failAction.message);
+        }
         default:
           throw new Error(`Unsupported action type: ${action.type}`);
       }
@@ -1848,7 +1987,7 @@ var runWebTest = async (test, options = {}) => {
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   console.log(`Launching ${browserName}${headless ? " (headless)" : " (visible)"}...`);
-  const browser = await getBrowser(browserName).launch({ headless });
+  const browser = await getBrowser(browserName).launch(getBrowserLaunchOptions({ headless }));
   console.log(`Browser launched successfully`);
   const browserContext = await browser.newContext();
   const page = await browserContext.newPage();
@@ -2383,6 +2522,99 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
             await page.pause();
             break;
           }
+          case "waitForSelector": {
+            const handle = resolveLocator2(action.target);
+            const timeout = action.timeout ?? 3e4;
+            if (debugMode) {
+              console.log(`  [DEBUG] Waiting for element to be ${action.state}:`, action.target);
+            }
+            const waitForCondition2 = async (checkFn, timeoutMs, errorMessage) => {
+              const start = Date.now();
+              while (Date.now() - start < timeoutMs) {
+                if (await checkFn()) return;
+                await new Promise((r) => setTimeout(r, 100));
+              }
+              throw new Error(errorMessage);
+            };
+            switch (action.state) {
+              case "visible":
+              case "hidden":
+              case "attached":
+              case "detached":
+                await handle.waitFor({ state: action.state, timeout });
+                break;
+              case "enabled":
+                await waitForCondition2(
+                  () => handle.isEnabled(),
+                  timeout,
+                  `Element did not become enabled within ${timeout}ms`
+                );
+                break;
+              case "disabled":
+                await waitForCondition2(
+                  () => handle.isDisabled(),
+                  timeout,
+                  `Element did not become disabled within ${timeout}ms`
+                );
+                break;
+            }
+            break;
+          }
+          case "conditional": {
+            const handle = resolveLocator2(action.condition.target);
+            let conditionMet = false;
+            if (debugMode) {
+              console.log(`  [DEBUG] Checking condition ${action.condition.type}:`, action.condition.target);
+            }
+            try {
+              switch (action.condition.type) {
+                case "exists":
+                  await handle.waitFor({ state: "attached", timeout: 500 });
+                  conditionMet = true;
+                  break;
+                case "notExists":
+                  try {
+                    await handle.waitFor({ state: "detached", timeout: 500 });
+                    conditionMet = true;
+                  } catch {
+                    conditionMet = false;
+                  }
+                  break;
+                case "visible":
+                  conditionMet = await handle.isVisible();
+                  break;
+                case "hidden":
+                  conditionMet = !await handle.isVisible();
+                  break;
+              }
+            } catch {
+              conditionMet = action.condition.type === "notExists";
+            }
+            if (debugMode) {
+              console.log(`  [DEBUG] Condition result: ${conditionMet}`);
+            }
+            const stepsToRun = conditionMet ? action.then : action.else ?? [];
+            for (const nestedAction of stepsToRun) {
+              switch (nestedAction.type) {
+                case "screenshot": {
+                  const filename = nestedAction.name ?? `conditional-step.png`;
+                  const filePath = path.join(screenshotDir, filename);
+                  await page.screenshot({ path: filePath, fullPage: true });
+                  results.push({ action: nestedAction, status: "passed", screenshotPath: filePath });
+                  break;
+                }
+                case "fail": {
+                  throw new Error(nestedAction.message);
+                }
+                default:
+                  throw new Error(`Nested action type ${nestedAction.type} in conditional not yet supported`);
+              }
+            }
+            break;
+          }
+          case "fail": {
+            throw new Error(action.message);
+          }
           default:
             throw new Error(`Unsupported action type: ${action.type}`);
         }
@@ -2807,7 +3039,7 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
   const browserName = options.browser ?? workflow.config?.web?.browser ?? "chromium";
   const headless = options.headed === true ? false : workflow.config?.web?.headless ?? true;
   console.log(`Launching ${browserName}${headless ? " (headless)" : " (visible)"}...`);
-  const browser = await getBrowser2(browserName).launch({ headless });
+  const browser = await getBrowser2(browserName).launch(getBrowserLaunchOptions({ headless }));
   console.log(`Browser launched successfully`);
   const browserContext = await browser.newContext();
   const page = await browserContext.newPage();
@@ -2944,6 +3176,6 @@ Collected ${serverResources.length} server-tracked resources`);
   }
 }
 
-export { ActionSchema, IntellitesterConfigSchema, LocatorSchema, TestConfigSchema, TestDefinitionSchema, cleanupConfigSchema, cleanupDiscoverSchema, collectMissingEnvVars, createAIProvider, createTestContext, generateFillerText, generateRandomEmail, generateRandomPhone, generateRandomPhoto, generateRandomUsername, interpolateVariables, isPipelineContent, isPipelineFile, isWorkflowContent, isWorkflowFile, killServer, loadIntellitesterConfig, loadPipelineDefinition, loadTestDefinition, loadWorkflowDefinition, parseIntellitesterConfig, parsePipelineDefinition, parseTestDefinition, parseWorkflowDefinition, previewConfigSchema, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, startWebServer };
-//# sourceMappingURL=chunk-ICJK4WBA.js.map
-//# sourceMappingURL=chunk-ICJK4WBA.js.map
+export { ActionSchema, IntellitesterConfigSchema, LocatorSchema, TestConfigSchema, TestDefinitionSchema, cleanupConfigSchema, cleanupDiscoverSchema, collectMissingEnvVars, createAIProvider, createTestContext, generateFillerText, generateRandomEmail, generateRandomPhone, generateRandomPhoto, generateRandomUsername, getBrowserLaunchOptions, interpolateVariables, isPipelineContent, isPipelineFile, isWorkflowContent, isWorkflowFile, killServer, loadIntellitesterConfig, loadPipelineDefinition, loadTestDefinition, loadWorkflowDefinition, parseIntellitesterConfig, parsePipelineDefinition, parseTestDefinition, parseWorkflowDefinition, previewConfigSchema, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, startWebServer };
+//# sourceMappingURL=chunk-EQJZ2E5H.js.map
+//# sourceMappingURL=chunk-EQJZ2E5H.js.map