intellitester 0.2.43 → 0.2.45

package/dist/{chunk-GDPJLAXU.cjs → chunk-MZ7OCAGA.cjs}

@@ -7,8 +7,7 @@ var uniqueNamesGenerator = require('unique-names-generator');
 var crypto4 = require('crypto');
 var libphonenumberJs = require('libphonenumber-js');
 var fs = require('fs/promises');
-var path2 = require('path');
-var child_process = require('child_process');
+var path4 = require('path');
 var playwright = require('playwright');
 var prompts = require('prompts');
 var nodeAppwrite = require('node-appwrite');
@@ -16,12 +15,31 @@ var anthropic = require('@llamaindex/anthropic');
 var openai = require('@llamaindex/openai');
 var ollama = require('@llamaindex/ollama');
 var http = require('http');
+var child_process = require('child_process');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
 var crypto4__default = /*#__PURE__*/_interopDefault(crypto4);
-var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path2__default = /*#__PURE__*/_interopDefault(path2);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
 var prompts__default = /*#__PURE__*/_interopDefault(prompts);
 
 function generateRandomUsername() {
@@ -881,12 +899,12 @@ var TRACK_DIR = ".intellitester/track";
 var ACTIVE_TESTS_FILE = "ACTIVE_TESTS.json";
 var DEFAULT_STALE_MS = 2 * 60 * 60 * 1e3;
 var HEARTBEAT_MS = 15e3;
-var getTrackDir = (cwd, trackDir) => trackDir ? path2__default.default.resolve(cwd, trackDir) : path2__default.default.join(cwd, TRACK_DIR);
-var getActiveTestsPath = (cwd, trackDir) => path2__default.default.join(getTrackDir(cwd, trackDir), ACTIVE_TESTS_FILE);
+var getTrackDir = (cwd, trackDir) => trackDir ? path4__namespace.default.resolve(cwd, trackDir) : path4__namespace.default.join(cwd, TRACK_DIR);
+var getActiveTestsPath = (cwd, trackDir) => path4__namespace.default.join(getTrackDir(cwd, trackDir), ACTIVE_TESTS_FILE);
 var loadActiveTests = async (cwd, trackDir) => {
   const filePath = getActiveTestsPath(cwd, trackDir);
   try {
-    const content = await fs__default.default.readFile(filePath, "utf8");
+    const content = await fs__namespace.default.readFile(filePath, "utf8");
     const parsed = JSON.parse(content);
     if (!parsed.sessions || typeof parsed.sessions !== "object") {
       throw new Error("Invalid ACTIVE_TESTS structure");
@@ -903,7 +921,7 @@ var loadActiveTests = async (cwd, trackDir) => {
 var saveActiveTests = async (cwd, state, trackDir) => {
   const filePath = getActiveTestsPath(cwd, trackDir);
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await fs__default.default.writeFile(filePath, JSON.stringify(state, null, 2), "utf8");
+  await fs__namespace.default.writeFile(filePath, JSON.stringify(state, null, 2), "utf8");
 };
 var isStale = (entry, staleMs) => {
   const last = new Date(entry.lastUpdated).getTime();
@@ -912,7 +930,7 @@ var isStale = (entry, staleMs) => {
 };
 var readTrackedResources = async (trackFile) => {
   try {
-    const content = await fs__default.default.readFile(trackFile, "utf8");
+    const content = await fs__namespace.default.readFile(trackFile, "utf8");
     if (!content.trim()) return [];
     return content.split("\n").filter(Boolean).map((line) => {
       try {
@@ -948,19 +966,19 @@ var cleanupStaleSession = async (entry, cleanupConfig) => {
 var cleanupOrphanedTrackFiles = async (cwd, state, trackDir) => {
   const dir = getTrackDir(cwd, trackDir);
   try {
-    const files = await fs__default.default.readdir(dir);
-    const activeFiles = new Set(Object.values(state.sessions).map((s) => path2__default.default.basename(s.trackFile)));
+    const files = await fs__namespace.default.readdir(dir);
+    const activeFiles = new Set(Object.values(state.sessions).map((s) => path4__namespace.default.basename(s.trackFile)));
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
       if (activeFiles.has(file)) continue;
-      const filePath = path2__default.default.join(dir, file);
+      const filePath = path4__namespace.default.join(dir, file);
       try {
-        const stat = await fs__default.default.stat(filePath);
+        const stat2 = await fs__namespace.default.stat(filePath);
         const staleMs = Number(process.env.INTELLITESTER_STALE_TEST_MS ?? DEFAULT_STALE_MS);
-        const isOld = Date.now() - stat.mtimeMs > staleMs;
-        const isEmpty = stat.size === 0;
+        const isOld = Date.now() - stat2.mtimeMs > staleMs;
+        const isEmpty = stat2.size === 0;
         if (isEmpty || isOld) {
-          await fs__default.default.rm(filePath, { force: true });
+          await fs__namespace.default.rm(filePath, { force: true });
         }
       } catch {
       }
@@ -976,8 +994,8 @@ var pruneStaleTests = async (cwd, cleanupConfig, trackDir) => {
     let missingFile = false;
     let isEmpty = false;
     try {
-      const stat = await fs__default.default.stat(entry.trackFile);
-      isEmpty = stat.size === 0;
+      const stat2 = await fs__namespace.default.stat(entry.trackFile);
+      isEmpty = stat2.size === 0;
     } catch {
       missingFile = true;
     }
@@ -985,7 +1003,7 @@ var pruneStaleTests = async (cwd, cleanupConfig, trackDir) => {
     changed = true;
     await cleanupStaleSession(entry, cleanupConfig);
     try {
-      await fs__default.default.rm(entry.trackFile, { force: true });
+      await fs__namespace.default.rm(entry.trackFile, { force: true });
     } catch {
     }
     delete state.sessions[sessionId];
@@ -998,10 +1016,10 @@ var pruneStaleTests = async (cwd, cleanupConfig, trackDir) => {
 async function initFileTracking(options) {
   const cwd = options.cwd ?? process.cwd();
   const trackDir = options.trackDir;
-  await fs__default.default.mkdir(getTrackDir(cwd, trackDir), { recursive: true });
+  await fs__namespace.default.mkdir(getTrackDir(cwd, trackDir), { recursive: true });
   await pruneStaleTests(cwd, options.cleanupConfig, trackDir);
-  const trackFile = path2__default.default.join(getTrackDir(cwd, trackDir), `TEST_SESSION_${options.sessionId}.jsonl`);
-  await fs__default.default.writeFile(trackFile, "", "utf8");
+  const trackFile = path4__namespace.default.join(getTrackDir(cwd, trackDir), `TEST_SESSION_${options.sessionId}.jsonl`);
+  await fs__namespace.default.writeFile(trackFile, "", "utf8");
   const state = await loadActiveTests(cwd, trackDir);
   state.sessions[options.sessionId] = {
     sessionId: options.sessionId,
@@ -1029,7 +1047,7 @@ async function initFileTracking(options) {
     delete current.sessions[options.sessionId];
     await saveActiveTests(cwd, current, trackDir);
     try {
-      await fs__default.default.rm(trackFile, { force: true });
+      await fs__namespace.default.rm(trackFile, { force: true });
     } catch {
     }
   };
@@ -1058,9 +1076,321 @@ async function mergeFileTrackedResources(trackFile, target, allowedTypes) {
     }
   }
 }
+async function isServerRunning(url) {
+  try {
+    const response = await fetch(url, { method: "HEAD" });
+    return response.ok || response.status < 500;
+  } catch {
+    return false;
+  }
+}
+async function readPackageJson(cwd) {
+  try {
+    const packagePath = path4__namespace.join(cwd, "package.json");
+    const content = await fs__namespace.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 fs__namespace.stat(path4__namespace.join(cwd, "deno.lock")).catch(() => null);
+  const hasBunLock = await fs__namespace.stat(path4__namespace.join(cwd, "bun.lockb")).catch(() => null);
+  const hasPnpmLock = await fs__namespace.stat(path4__namespace.join(cwd, "pnpm-lock.yaml")).catch(() => null);
+  const hasYarnLock = await fs__namespace.stat(path4__namespace.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 detectBuildDirectory(cwd) {
+  const commonDirs = [
+    ".next",
+    ".output",
+    ".svelte-kit",
+    "dist",
+    "build",
+    "out"
+  ];
+  for (const dir of commonDirs) {
+    const fullPath = path4__namespace.join(cwd, dir);
+    try {
+      const stat2 = await fs__namespace.stat(fullPath);
+      if (stat2.isDirectory()) {
+        return dir;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+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}`;
+  }
+  const scripts = pkg?.scripts;
+  if (scripts?.dev) {
+    if (framework) {
+      console.log(`Detected ${framework.name} project, running dev server`);
+    }
+    return getDevCommand(pm, "dev");
+  }
+  if (scripts?.start) {
+    return getDevCommand(pm, "start");
+  }
+  throw new Error("Could not auto-detect server command. Please specify command explicitly.");
+}
+var WebServerManager = class _WebServerManager {
+  constructor() {
+    this.serverProcess = null;
+    this.currentUrl = null;
+    this.currentCwd = null;
+    this.stopping = false;
+  }
+  static getInstance() {
+    if (!_WebServerManager.instance) {
+      _WebServerManager.instance = new _WebServerManager();
+    }
+    return _WebServerManager.instance;
+  }
+  /**
+   * Check if the managed server is currently running
+   */
+  isRunning() {
+    return this.serverProcess !== null && !this.serverProcess.killed;
+  }
+  /**
+   * Get the current server URL if running
+   */
+  getUrl() {
+    return this.currentUrl;
+  }
+  /**
+   * Start a web server with the given config.
+   *
+   * - If a server is already running at the same URL, reuses it (unless reuseExistingServer=false)
+   * - If a server is running at a different URL, stops it first
+   * - Properly waits for any stopping server to fully terminate
+   */
+  async start(config) {
+    const { url, reuseExistingServer = true, timeout = 3e4, idleTimeout = 2e4 } = config;
+    const cwd = config.workdir ?? config.cwd ?? process.cwd();
+    while (this.stopping) {
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    if (this.serverProcess && !this.serverProcess.killed && this.currentUrl === url) {
+      if (await isServerRunning(url)) {
+        if (reuseExistingServer) {
+          console.log(`Server already running at ${url}`);
+          return this.serverProcess;
+        } else {
+          await this.stop();
+        }
+      } else {
+        await this.stop();
+      }
+    }
+    if (this.serverProcess && !this.serverProcess.killed && this.currentUrl !== url) {
+      await this.stop();
+    }
+    if (reuseExistingServer && await isServerRunning(url)) {
+      console.log(`Server already running at ${url}`);
+      this.currentUrl = url;
+      this.currentCwd = cwd;
+      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}`);
+    this.serverProcess = child_process.spawn(command, {
+      shell: true,
+      stdio: "pipe",
+      cwd,
+      detached: false
+    });
+    this.currentUrl = url;
+    this.currentCwd = cwd;
+    let stderrOutput = "";
+    let lastOutputTime = Date.now();
+    this.serverProcess.stdout?.on("data", (data) => {
+      lastOutputTime = Date.now();
+      process.stdout.write(`[server] ${data}`);
+    });
+    this.serverProcess.stderr?.on("data", (data) => {
+      lastOutputTime = Date.now();
+      stderrOutput += data.toString();
+      process.stderr.write(`[server] ${data}`);
+    });
+    await new Promise((resolve, reject) => {
+      let resolved = false;
+      const startTime = Date.now();
+      const cleanup = () => {
+        resolved = true;
+        clearInterval(pollInterval);
+      };
+      this.serverProcess.on("close", (code) => {
+        if (!resolved && code !== 0 && code !== null) {
+          cleanup();
+          this.serverProcess = null;
+          this.currentUrl = null;
+          reject(new Error(`Server exited with code ${code}
+${stderrOutput}`));
+        }
+      });
+      this.serverProcess.on("error", (err) => {
+        if (!resolved) {
+          cleanup();
+          this.serverProcess = null;
+          this.currentUrl = null;
+          reject(err);
+        }
+      });
+      const pollInterval = setInterval(async () => {
+        if (resolved) return;
+        if (await isServerRunning(url)) {
+          cleanup();
+          resolve();
+          return;
+        }
+        if (Date.now() - startTime > timeout) {
+          cleanup();
+          reject(new Error(`Server at ${url} not ready after ${timeout}ms`));
+          return;
+        }
+        if (Date.now() - lastOutputTime > idleTimeout) {
+          cleanup();
+          this.serverProcess?.kill("SIGTERM");
+          this.serverProcess = null;
+          this.currentUrl = null;
+          const lastOutput = stderrOutput.slice(-500);
+          reject(new Error(`Server stalled - no output for ${idleTimeout}ms. Last output:
+${lastOutput}`));
+          return;
+        }
+      }, 500);
+    });
+    console.log(`Server ready at ${url}`);
+    return this.serverProcess;
+  }
+  /**
+   * Stop the managed server and wait for it to fully terminate.
+   * This prevents race conditions where a dying server still responds to health checks.
+   */
+  async stop() {
+    if (!this.serverProcess || this.serverProcess.killed) {
+      this.serverProcess = null;
+      this.currentUrl = null;
+      this.currentCwd = null;
+      return;
+    }
+    this.stopping = true;
+    console.log("Stopping server...");
+    const process2 = this.serverProcess;
+    const exitPromise = new Promise((resolve) => {
+      const onExit = () => {
+        process2.removeListener("close", onExit);
+        process2.removeListener("exit", onExit);
+        resolve();
+      };
+      process2.on("close", onExit);
+      process2.on("exit", onExit);
+      if (process2.killed || process2.exitCode !== null) {
+        resolve();
+      }
+    });
+    process2.kill("SIGTERM");
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        if (!process2.killed && process2.exitCode === null) {
+          console.log("Server did not stop gracefully, sending SIGKILL...");
+          process2.kill("SIGKILL");
+        }
+        resolve();
+      }, 5e3);
+    });
+    await Promise.race([exitPromise, timeoutPromise]);
+    await new Promise((r) => setTimeout(r, 200));
+    this.serverProcess = null;
+    this.currentUrl = null;
+    this.currentCwd = null;
+    this.stopping = false;
+  }
+  /**
+   * Synchronous kill for signal handlers - doesn't wait for termination
+   */
+  kill() {
+    if (this.serverProcess && !this.serverProcess.killed) {
+      console.log("Stopping server...");
+      this.serverProcess.kill("SIGTERM");
+    }
+    this.serverProcess = null;
+    this.currentUrl = null;
+    this.currentCwd = null;
+  }
+};
+var webServerManager = WebServerManager.getInstance();
 
 // src/executors/web/playwrightExecutor.ts
-var defaultScreenshotDir = path2__default.default.join(process.cwd(), "artifacts", "screenshots");
+var defaultScreenshotDir = path4__namespace.default.join(process.cwd(), "artifacts", "screenshots");
 var resolveUrl = (value, baseUrl) => {
   if (!baseUrl) return value;
   try {
@@ -1131,7 +1461,7 @@ var checkErrorIf = async (page, locator, errorIf) => {
   }
 };
 async function ensureScreenshotDir(dir) {
-  await fs__default.default.mkdir(dir, { recursive: true });
+  await fs__namespace.default.mkdir(dir, { recursive: true });
 }
 var runNavigate = async (page, value, baseUrl, context) => {
   const interpolated = interpolateVariables(value, context.variables);
@@ -1192,7 +1522,7 @@ var runScreenshot = async (page, name, screenshotDir, stepIndex) => {
   await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {
   });
   const filename = name ?? `step-${stepIndex + 1}.png`;
-  const filePath = path2__default.default.join(screenshotDir, filename);
+  const filePath = path4__namespace.default.join(screenshotDir, filename);
   await page.screenshot({ path: filePath, fullPage: true });
   return filePath;
 };
@@ -1206,186 +1536,18 @@ var getBrowser = (browser) => {
       return playwright.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 = path2__default.default.join(cwd, dir);
-    try {
-      const stat = await fs__default.default.stat(fullPath);
-      if (stat.isDirectory()) {
-        return dir;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-async function readPackageJson(cwd) {
-  try {
-    const packagePath = path2__default.default.join(cwd, "package.json");
-    const content = await fs__default.default.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 fs__default.default.stat(path2__default.default.join(cwd, "deno.lock")).catch(() => null);
-  const hasBunLock = await fs__default.default.stat(path2__default.default.join(cwd, "bun.lockb")).catch(() => null);
-  const hasPnpmLock = await fs__default.default.stat(path2__default.default.join(cwd, "pnpm-lock.yaml")).catch(() => null);
-  const hasYarnLock = await fs__default.default.stat(path2__default.default.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 } = config;
-  const cwd = config.workdir ?? config.cwd ?? process.cwd();
-  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 = child_process.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 = path2__default.default.join(screenshotDir, `error-step-${stepIndex + 1}.png`);
+  const screenshotPath = path4__namespace.default.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 fs__default.default.readFile(screenshotPath);
+    const screenshot = await fs__namespace.default.readFile(screenshotPath);
     const suggestion = await getAISuggestion(error.message, action, pageContent, screenshot, aiConfig);
     if (suggestion.hasSuggestion && suggestion.suggestedSelector) {
       console.log("\u{1F916} AI Suggestion:");
@@ -1793,8 +1955,8 @@ async function executeActionWithRetry(page, action, index, options) {
             }
           } else {
             const { loadWorkflowDefinition, loadTestDefinition: loadTestDefinition2 } = await import('./loader-QG5BFIY6.cjs');
-            const workflowPath = path2__default.default.resolve(process.cwd(), branchToExecute.workflow);
-            const workflowDir = path2__default.default.dirname(workflowPath);
+            const workflowPath = path4__namespace.default.resolve(process.cwd(), branchToExecute.workflow);
+            const workflowDir = path4__namespace.default.dirname(workflowPath);
             if (debugMode) {
               console.log(`[DEBUG] Executing workflow: ${workflowPath}`);
             }
@@ -1806,7 +1968,7 @@ async function executeActionWithRetry(page, action, index, options) {
               }
             }
             for (const testRef of workflow.tests) {
-              const testFilePath = path2__default.default.resolve(workflowDir, testRef.file);
+              const testFilePath = path4__namespace.default.resolve(workflowDir, testRef.file);
               if (debugMode) {
                 console.log(`[DEBUG] Loading test from workflow: ${testFilePath}`);
               }
@@ -1905,7 +2067,6 @@ var runWebTest = async (test, options = {}) => {
     } : void 0
   });
   process.env.INTELLITESTER_TRACK_FILE = fileTracking.trackFile;
-  let serverProcess = null;
   if (options.webServer) {
     const requiresTrackingEnv = Boolean(
       test.config?.appwrite?.cleanup || test.config?.appwrite?.cleanupOnFailure
@@ -1914,11 +2075,11 @@ var runWebTest = async (test, options = {}) => {
     if (requiresTrackingEnv && options.webServer.reuseExistingServer !== false) {
       console.log("[Intellitester] Appwrite cleanup enabled; restarting server to inject tracking env.");
     }
-    serverProcess = await startWebServer(webServerConfig);
+    await webServerManager.start(webServerConfig);
   }
   const cleanup = () => {
     trackingServer.stop();
-    killServer(serverProcess);
+    webServerManager.kill();
     void fileTracking.stop();
     delete process.env.INTELLITESTER_TRACK_FILE;
     process.exit(1);
@@ -2228,7 +2389,7 @@ var runWebTest = async (test, options = {}) => {
     await browserContext.close();
     await browser.close();
     trackingServer.stop();
-    killServer(serverProcess);
+    await webServerManager.stop();
   }
   return {
     status: results.every((step) => step.status === "passed") ? "passed" : "failed",
@@ -2236,7 +2397,7 @@ var runWebTest = async (test, options = {}) => {
     variables: executionContext.variables
   };
 };
-var defaultScreenshotDir2 = path2__default.default.join(process.cwd(), "artifacts", "screenshots");
+var defaultScreenshotDir2 = path4__namespace.default.join(process.cwd(), "artifacts", "screenshots");
 var getBrowser2 = (browser) => {
   switch (browser) {
     case "firefox":
@@ -2248,14 +2409,14 @@ var getBrowser2 = (browser) => {
   }
 };
 function interpolateWorkflowVariables(value, currentVariables, testResults) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (match, path4) => {
-    if (path4.includes(".") && !path4.includes(":")) {
-      const [testId, _varName] = path4.split(".", 2);
+  return value.replace(/\{\{([^}]+)\}\}/g, (match, path5) => {
+    if (path5.includes(".") && !path5.includes(":")) {
+      const [testId, _varName] = path5.split(".", 2);
       testResults.find((t) => t.id === testId);
-      console.warn(`Cross-test variable interpolation {{${path4}}} not yet fully implemented`);
+      console.warn(`Cross-test variable interpolation {{${path5}}} not yet fully implemented`);
       return match;
     }
-    const result = interpolateVariables(`{{${path4}}}`, currentVariables);
+    const result = interpolateVariables(`{{${path5}}}`, currentVariables);
     return result;
   });
 }
@@ -2422,7 +2583,7 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
               await page.waitForTimeout(waitBefore);
             }
             const filename = ssAction.name ?? `step-${index + 1}.png`;
-            const filePath = path2__default.default.join(screenshotDir, filename);
+            const filePath = path4__namespace.default.join(screenshotDir, filename);
             await page.screenshot({ path: filePath, fullPage: true });
             results.push({ action, status: "passed", screenshotPath: filePath });
             const trackedPayload2 = buildTrackPayload(action, index, { screenshotPath: filePath });
@@ -2596,7 +2757,7 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
               switch (nestedAction.type) {
                 case "screenshot": {
                   const filename = nestedAction.name ?? `conditional-step.png`;
-                  const filePath = path2__default.default.join(screenshotDir, filename);
+                  const filePath = path4__namespace.default.join(screenshotDir, filename);
                   await page.screenshot({ path: filePath, fullPage: true });
                   results.push({ action: nestedAction, status: "passed", screenshotPath: filePath });
                   const trackedPayload2 = buildTrackPayload(nestedAction, index, { screenshotPath: filePath });
@@ -2686,7 +2847,7 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
                         await page.waitForTimeout(nestedWaitBefore);
                       }
                       const filename = nestedSsAction.name ?? `waitForBranch-step.png`;
-                      const filePath = path2__default.default.join(screenshotDir, filename);
+                      const filePath = path4__namespace.default.join(screenshotDir, filename);
                       await page.screenshot({ path: filePath, fullPage: true });
                       results.push({ action: nestedAction, status: "passed", screenshotPath: filePath });
                       const trackedPayload2 = buildTrackPayload(nestedAction, index, { screenshotPath: filePath });
@@ -2744,7 +2905,7 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
                   results.push({ action: nestedAction, status: "passed" });
                 }
               } else if (typeof branch === "object" && "workflow" in branch) {
-                const workflowPath = path2__default.default.resolve(_workflowDir, branch.workflow);
+                const workflowPath = path4__namespace.default.resolve(_workflowDir, branch.workflow);
                 if (debugMode) {
                   console.log(`  [DEBUG] waitForBranch: loading workflow from ${workflowPath}`);
                 }
@@ -2757,7 +2918,7 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
                   }
                 }
                 for (const testRef of nestedWorkflow.tests) {
-                  const testFilePath = path2__default.default.resolve(path2__default.default.dirname(workflowPath), testRef.file);
+                  const testFilePath = path4__namespace.default.resolve(path4__namespace.default.dirname(workflowPath), testRef.file);
                   const nestedTest = await chunk2ZBKD7WW_cjs.loadTestDefinition(testFilePath);
                   if (nestedTest.variables) {
                     for (const [key, value] of Object.entries(nestedTest.variables)) {
@@ -2770,7 +2931,7 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
                     page,
                     context,
                     options,
-                    path2__default.default.dirname(workflowPath),
+                    path4__namespace.default.dirname(workflowPath),
                     nestedWorkflow.config?.web?.baseUrl ?? workflowBaseUrl
                   );
                   results.push(...nestedResult.steps);
@@ -2985,7 +3146,7 @@ function inferCleanupConfig(config) {
 }
 async function runWorkflowWithContext(workflow, workflowFilePath, options) {
   const { page, executionContext, skipCleanup = false, sessionId: providedSessionId, testStartTime: providedTestStartTime } = options;
-  const workflowDir = path2__default.default.dirname(workflowFilePath);
+  const workflowDir = path4__namespace.default.dirname(workflowFilePath);
   const sessionId = providedSessionId ?? crypto4__default.default.randomUUID();
   const testStartTime = providedTestStartTime ?? (/* @__PURE__ */ new Date()).toISOString();
   console.log(`
@@ -3013,7 +3174,7 @@ Starting workflow: ${workflow.name}`);
   const testResults = [];
   let workflowFailed = false;
   for (const [index, testRef] of workflow.tests.entries()) {
-    const testFilePath = path2__default.default.resolve(workflowDir, testRef.file);
+    const testFilePath = path4__namespace.default.resolve(workflowDir, testRef.file);
     console.log(`
 [${index + 1}/${workflow.tests.length}] Running: ${testRef.file}`);
     if (testRef.id) {
@@ -3174,7 +3335,7 @@ ${"=".repeat(60)}`);
   };
 }
 async function runWorkflow(workflow, workflowFilePath, options = {}) {
-  const workflowDir = path2__default.default.dirname(workflowFilePath);
+  const workflowDir = path4__namespace.default.dirname(workflowFilePath);
   const sessionId = options.sessionId ?? crypto4__default.default.randomUUID();
   const testStartTime = (/* @__PURE__ */ new Date()).toISOString();
   const cleanupConfig = inferCleanupConfig(workflow.config);
@@ -3201,7 +3362,6 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
     } : void 0
   });
   process.env.INTELLITESTER_TRACK_FILE = fileTracking.trackFile;
-  let serverProcess = null;
   const webServerConfig = workflow.config?.webServer ?? options.webServer;
   if (webServerConfig) {
     try {
@@ -3213,9 +3373,9 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
       if (requiresTrackingEnv && webServerConfig.reuseExistingServer !== false) {
         console.log("[Intellitester] Appwrite cleanup enabled; restarting server to inject tracking env.");
       }
-      serverProcess = await startWebServer({
+      await webServerManager.start({
         ...effectiveWebServerConfig,
-        workdir: path2__default.default.resolve(serverCwd, effectiveWebServerConfig.workdir ?? effectiveWebServerConfig.cwd ?? ".")
+        workdir: path4__namespace.default.resolve(serverCwd, effectiveWebServerConfig.workdir ?? effectiveWebServerConfig.cwd ?? ".")
       });
     } catch (error) {
       console.error("Failed to start web server:", error);
@@ -3225,7 +3385,7 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
   }
   const signalCleanup = async () => {
     console.log("\n\nInterrupted - cleaning up...");
-    killServer(serverProcess);
+    webServerManager.kill();
     if (trackingServer) await trackingServer.stop();
     await fileTracking.stop();
     delete process.env.INTELLITESTER_TRACK_FILE;
@@ -3365,7 +3525,7 @@ Collected ${serverResources.length} server-tracked resources`);
     process.off("SIGTERM", signalCleanup);
     await browserContext.close();
     await browser.close();
-    killServer(serverProcess);
+    await webServerManager.stop();
     if (trackingServer) {
       await trackingServer.stop();
     }
@@ -3386,13 +3546,12 @@ exports.generateRandomUsername = generateRandomUsername;
 exports.getBrowserLaunchOptions = getBrowserLaunchOptions;
 exports.initFileTracking = initFileTracking;
 exports.interpolateVariables = interpolateVariables;
-exports.killServer = killServer;
 exports.mergeFileTrackedResources = mergeFileTrackedResources;
 exports.runWebTest = runWebTest;
 exports.runWorkflow = runWorkflow;
 exports.runWorkflowWithContext = runWorkflowWithContext;
 exports.setupAppwriteTracking = setupAppwriteTracking;
 exports.startTrackingServer = startTrackingServer;
-exports.startWebServer = startWebServer;
-//# sourceMappingURL=chunk-GDPJLAXU.cjs.map
-//# sourceMappingURL=chunk-GDPJLAXU.cjs.map
+exports.webServerManager = webServerManager;
+//# sourceMappingURL=chunk-MZ7OCAGA.cjs.map
+//# sourceMappingURL=chunk-MZ7OCAGA.cjs.map