@hasna/testers 0.0.1 → 0.0.3

package/dist/server/index.js

@@ -77,7 +77,30 @@ function screenshotFromRow(row) {
     filePath: row.file_path,
     width: row.width,
     height: row.height,
-    timestamp: row.timestamp
+    timestamp: row.timestamp,
+    description: row.description,
+    pageUrl: row.page_url,
+    thumbnailPath: row.thumbnail_path
+  };
+}
+function scheduleFromRow(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    name: row.name,
+    cronExpression: row.cron_expression,
+    url: row.url,
+    scenarioFilter: JSON.parse(row.scenario_filter),
+    model: row.model,
+    headed: row.headed === 1,
+    parallel: row.parallel,
+    timeoutMs: row.timeout_ms,
+    enabled: row.enabled === 1,
+    lastRunId: row.last_run_id,
+    lastRunAt: row.last_run_at,
+    nextRunAt: row.next_run_at,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
   };
 }
 class VersionConflictError extends Error {
@@ -100,6 +123,12 @@ class AIClientError extends Error {
     this.name = "AIClientError";
   }
 }
+class ScheduleNotFoundError extends Error {
+  constructor(id) {
+    super(`Schedule not found: ${id}`);
+    this.name = "ScheduleNotFoundError";
+  }
+}
 
 // src/db/database.ts
 import { Database } from "bun:sqlite";
@@ -229,6 +258,58 @@ var MIGRATIONS = [
   `
   ALTER TABLE projects ADD COLUMN scenario_prefix TEXT DEFAULT 'TST';
   ALTER TABLE projects ADD COLUMN scenario_counter INTEGER DEFAULT 0;
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS schedules (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    cron_expression TEXT NOT NULL,
+    url TEXT NOT NULL,
+    scenario_filter TEXT NOT NULL DEFAULT '{}',
+    model TEXT,
+    headed INTEGER NOT NULL DEFAULT 0,
+    parallel INTEGER NOT NULL DEFAULT 1,
+    timeout_ms INTEGER,
+    enabled INTEGER NOT NULL DEFAULT 1,
+    last_run_id TEXT REFERENCES runs(id) ON DELETE SET NULL,
+    last_run_at TEXT,
+    next_run_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_schedules_project ON schedules(project_id);
+  CREATE INDEX IF NOT EXISTS idx_schedules_enabled ON schedules(enabled);
+  CREATE INDEX IF NOT EXISTS idx_schedules_next_run ON schedules(next_run_at);
+  `,
+  `
+  ALTER TABLE screenshots ADD COLUMN description TEXT;
+  ALTER TABLE screenshots ADD COLUMN page_url TEXT;
+  ALTER TABLE screenshots ADD COLUMN thumbnail_path TEXT;
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS auth_presets (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    email TEXT NOT NULL,
+    password TEXT NOT NULL,
+    login_path TEXT DEFAULT '/login',
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS webhooks (
+    id TEXT PRIMARY KEY,
+    url TEXT NOT NULL,
+    events TEXT NOT NULL DEFAULT '["failed"]',
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    secret TEXT,
+    active INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_webhooks_active ON webhooks(active);
   `
 ];
 function applyMigrations(database) {
@@ -629,9 +710,9 @@ function createScreenshot(input) {
   const id = uuid();
   const timestamp = now();
   db2.query(`
-    INSERT INTO screenshots (id, result_id, step_number, action, file_path, width, height, timestamp)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(id, input.resultId, input.stepNumber, input.action, input.filePath, input.width, input.height, timestamp);
+    INSERT INTO screenshots (id, result_id, step_number, action, file_path, width, height, timestamp, description, page_url, thumbnail_path)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, input.resultId, input.stepNumber, input.action, input.filePath, input.width, input.height, timestamp, input.description ?? null, input.pageUrl ?? null, input.thumbnailPath ?? null);
   return getScreenshot(id);
 }
 function getScreenshot(id) {
@@ -689,7 +770,7 @@ async function closeBrowser(browser) {
 }
 
 // src/lib/screenshotter.ts
-import { mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { mkdirSync as mkdirSync2, existsSync as existsSync2, writeFileSync } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 function slugify(text) {
@@ -698,16 +779,51 @@ function slugify(text) {
 function generateFilename(stepNumber, action) {
   const padded = String(stepNumber).padStart(3, "0");
   const slug = slugify(action);
-  return `${padded}-${slug}.png`;
+  return `${padded}_${slug}.png`;
+}
+function formatDate(date) {
+  return date.toISOString().slice(0, 10);
+}
+function formatTime(date) {
+  return date.toISOString().slice(11, 19).replace(/:/g, "-");
 }
-function getScreenshotDir(baseDir, runId, scenarioSlug) {
-  return join2(baseDir, runId, scenarioSlug);
+function getScreenshotDir(baseDir, runId, scenarioSlug, projectName, timestamp) {
+  const now2 = timestamp ?? new Date;
+  const project = projectName ?? "default";
+  const dateDir = formatDate(now2);
+  const timeDir = `${formatTime(now2)}_${runId.slice(0, 8)}`;
+  return join2(baseDir, project, dateDir, timeDir, scenarioSlug);
 }
 function ensureDir(dirPath) {
   if (!existsSync2(dirPath)) {
     mkdirSync2(dirPath, { recursive: true });
   }
 }
+function writeMetaSidecar(screenshotPath, meta) {
+  const metaPath = screenshotPath.replace(/\.png$/, ".meta.json").replace(/\.jpeg$/, ".meta.json");
+  try {
+    writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf-8");
+  } catch {}
+}
+async function generateThumbnail(page, screenshotDir, filename) {
+  try {
+    const thumbDir = join2(screenshotDir, "_thumbnail");
+    ensureDir(thumbDir);
+    const thumbFilename = filename.replace(/\.(png|jpeg)$/, ".thumb.$1");
+    const thumbPath = join2(thumbDir, thumbFilename);
+    const viewport = page.viewportSize();
+    if (viewport) {
+      await page.screenshot({
+        path: thumbPath,
+        type: "png",
+        clip: { x: 0, y: 0, width: Math.min(viewport.width, 1280), height: Math.min(viewport.height, 720) }
+      });
+    }
+    return thumbPath;
+  } catch {
+    return null;
+  }
+}
 var DEFAULT_BASE_DIR = join2(homedir2(), ".testers", "screenshots");
 
 class Screenshotter {
@@ -715,15 +831,20 @@ class Screenshotter {
   format;
   quality;
   fullPage;
+  projectName;
+  runTimestamp;
   constructor(options = {}) {
     this.baseDir = options.baseDir ?? DEFAULT_BASE_DIR;
     this.format = options.format ?? "png";
     this.quality = options.quality ?? 90;
     this.fullPage = options.fullPage ?? false;
+    this.projectName = options.projectName ?? "default";
+    this.runTimestamp = new Date;
   }
   async capture(page, options) {
-    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug);
-    const filename = generateFilename(options.stepNumber, options.action);
+    const action = options.description ?? options.action;
+    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug, this.projectName, this.runTimestamp);
+    const filename = generateFilename(options.stepNumber, action);
     const filePath = join2(dir, filename);
     ensureDir(dir);
     await page.screenshot({
@@ -733,16 +854,32 @@ class Screenshotter {
       quality: this.format === "jpeg" ? this.quality : undefined
     });
     const viewport = page.viewportSize() ?? { width: 0, height: 0 };
+    const pageUrl = page.url();
+    const timestamp = new Date().toISOString();
+    writeMetaSidecar(filePath, {
+      stepNumber: options.stepNumber,
+      action: options.action,
+      description: options.description ?? null,
+      pageUrl,
+      viewport,
+      timestamp,
+      filePath
+    });
+    const thumbnailPath = await generateThumbnail(page, dir, filename);
     return {
       filePath,
       width: viewport.width,
       height: viewport.height,
-      timestamp: new Date().toISOString()
+      timestamp,
+      description: options.description ?? null,
+      pageUrl,
+      thumbnailPath
     };
   }
   async captureFullPage(page, options) {
-    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug);
-    const filename = generateFilename(options.stepNumber, options.action);
+    const action = options.description ?? options.action;
+    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug, this.projectName, this.runTimestamp);
+    const filename = generateFilename(options.stepNumber, action);
     const filePath = join2(dir, filename);
     ensureDir(dir);
     await page.screenshot({
@@ -752,16 +889,32 @@ class Screenshotter {
       quality: this.format === "jpeg" ? this.quality : undefined
     });
     const viewport = page.viewportSize() ?? { width: 0, height: 0 };
+    const pageUrl = page.url();
+    const timestamp = new Date().toISOString();
+    writeMetaSidecar(filePath, {
+      stepNumber: options.stepNumber,
+      action: options.action,
+      description: options.description ?? null,
+      pageUrl,
+      viewport,
+      timestamp,
+      filePath
+    });
+    const thumbnailPath = await generateThumbnail(page, dir, filename);
     return {
       filePath,
       width: viewport.width,
       height: viewport.height,
-      timestamp: new Date().toISOString()
+      timestamp,
+      description: options.description ?? null,
+      pageUrl,
+      thumbnailPath
     };
   }
   async captureElement(page, selector, options) {
-    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug);
-    const filename = generateFilename(options.stepNumber, options.action);
+    const action = options.description ?? options.action;
+    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug, this.projectName, this.runTimestamp);
+    const filename = generateFilename(options.stepNumber, action);
     const filePath = join2(dir, filename);
     ensureDir(dir);
     await page.locator(selector).screenshot({
@@ -770,11 +923,25 @@ class Screenshotter {
       quality: this.format === "jpeg" ? this.quality : undefined
     });
     const viewport = page.viewportSize() ?? { width: 0, height: 0 };
+    const pageUrl = page.url();
+    const timestamp = new Date().toISOString();
+    writeMetaSidecar(filePath, {
+      stepNumber: options.stepNumber,
+      action: options.action,
+      description: options.description ?? null,
+      pageUrl,
+      viewport,
+      timestamp,
+      filePath
+    });
     return {
       filePath,
       width: viewport.width,
       height: viewport.height,
-      timestamp: new Date().toISOString()
+      timestamp,
+      description: options.description ?? null,
+      pageUrl,
+      thumbnailPath: null
     };
   }
 }
@@ -950,6 +1117,127 @@ var BROWSER_TOOLS = [
       required: ["text"]
     }
   },
+  {
+    name: "scroll",
+    description: "Scroll the page up or down by a given amount of pixels.",
+    input_schema: {
+      type: "object",
+      properties: {
+        direction: {
+          type: "string",
+          enum: ["up", "down"],
+          description: "Direction to scroll."
+        },
+        amount: {
+          type: "number",
+          description: "Number of pixels to scroll (default: 500)."
+        }
+      },
+      required: ["direction"]
+    }
+  },
+  {
+    name: "get_page_html",
+    description: "Get simplified HTML of the page body content, truncated to 8000 characters.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "get_elements",
+    description: "List elements matching a CSS selector with their text, tag name, and key attributes (max 20 results).",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector to match elements."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "wait_for_navigation",
+    description: "Wait for page navigation/load to complete (network idle).",
+    input_schema: {
+      type: "object",
+      properties: {
+        timeout: {
+          type: "number",
+          description: "Maximum time to wait in milliseconds (default: 10000)."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_page_title",
+    description: "Get the document title of the current page.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "count_elements",
+    description: "Count the number of elements matching a CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector to count matching elements."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "hover",
+    description: "Hover over an element matching the given CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the element to hover over."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "check",
+    description: "Check a checkbox matching the given CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the checkbox to check."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "uncheck",
+    description: "Uncheck a checkbox matching the given CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the checkbox to uncheck."
+        }
+      },
+      required: ["selector"]
+    }
+  },
   {
     name: "report_result",
     description: "Report the final test result. Call this when you have completed testing the scenario. This MUST be the last tool you call.",
@@ -1081,6 +1369,113 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
           return { result: "false" };
         }
       }
+      case "scroll": {
+        const direction = toolInput.direction;
+        const amount = typeof toolInput.amount === "number" ? toolInput.amount : 500;
+        const scrollY = direction === "down" ? amount : -amount;
+        await page.evaluate((y) => window.scrollBy(0, y), scrollY);
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "scroll"
+        });
+        return {
+          result: `Scrolled ${direction} by ${amount}px`,
+          screenshot
+        };
+      }
+      case "get_page_html": {
+        const html = await page.evaluate(() => document.body.innerHTML);
+        const truncated = html.length > 8000 ? html.slice(0, 8000) + "..." : html;
+        return {
+          result: truncated
+        };
+      }
+      case "get_elements": {
+        const selector = toolInput.selector;
+        const allElements = await page.locator(selector).all();
+        const elements = allElements.slice(0, 20);
+        const results = [];
+        for (let i = 0;i < elements.length; i++) {
+          const el = elements[i];
+          const tagName = await el.evaluate((e) => e.tagName.toLowerCase());
+          const textContent = await el.textContent() ?? "";
+          const trimmedText = textContent.trim().slice(0, 100);
+          const id = await el.getAttribute("id");
+          const className = await el.getAttribute("class");
+          const href = await el.getAttribute("href");
+          const type = await el.getAttribute("type");
+          const placeholder = await el.getAttribute("placeholder");
+          const ariaLabel = await el.getAttribute("aria-label");
+          const attrs = [];
+          if (id)
+            attrs.push(`id="${id}"`);
+          if (className)
+            attrs.push(`class="${className}"`);
+          if (href)
+            attrs.push(`href="${href}"`);
+          if (type)
+            attrs.push(`type="${type}"`);
+          if (placeholder)
+            attrs.push(`placeholder="${placeholder}"`);
+          if (ariaLabel)
+            attrs.push(`aria-label="${ariaLabel}"`);
+          results.push(`[${i}] <${tagName}${attrs.length ? " " + attrs.join(" ") : ""}> ${trimmedText}`);
+        }
+        return {
+          result: results.length > 0 ? results.join(`
+`) : `No elements found matching "${selector}"`
+        };
+      }
+      case "wait_for_navigation": {
+        const timeout = typeof toolInput.timeout === "number" ? toolInput.timeout : 1e4;
+        await page.waitForLoadState("networkidle", { timeout });
+        return {
+          result: "Navigation/load completed"
+        };
+      }
+      case "get_page_title": {
+        const title = await page.title();
+        return {
+          result: title || "(no title)"
+        };
+      }
+      case "count_elements": {
+        const selector = toolInput.selector;
+        const count = await page.locator(selector).count();
+        return {
+          result: `${count} element(s) matching "${selector}"`
+        };
+      }
+      case "hover": {
+        const selector = toolInput.selector;
+        await page.hover(selector);
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "hover"
+        });
+        return {
+          result: `Hovered over: ${selector}`,
+          screenshot
+        };
+      }
+      case "check": {
+        const selector = toolInput.selector;
+        await page.check(selector);
+        return {
+          result: `Checked checkbox: ${selector}`
+        };
+      }
+      case "uncheck": {
+        const selector = toolInput.selector;
+        await page.uncheck(selector);
+        return {
+          result: `Unchecked checkbox: ${selector}`
+        };
+      }
       case "report_result": {
         const status = toolInput.status;
         const reasoning = toolInput.reasoning;
@@ -1107,13 +1502,26 @@ async function runAgentLoop(options) {
     maxTurns = 30
   } = options;
   const systemPrompt = [
-    "You are a QA testing agent. Test the following scenario by interacting with the browser.",
-    "Use the provided tools to navigate, click, fill forms, and verify results.",
-    "When done, call report_result with your findings.",
-    "Be methodical: navigate to the target page first, then follow the test steps.",
-    "If a step fails, try reasonable alternatives before reporting failure.",
-    "Always report a final result \u2014 never leave a test incomplete."
-  ].join(" ");
+    "You are an expert QA testing agent. Your job is to thoroughly test web application scenarios.",
+    "You have browser tools to navigate, interact with, and inspect web pages.",
+    "",
+    "Strategy:",
+    "1. First navigate to the target page and take a screenshot to understand the layout",
+    "2. If you can't find an element, use get_elements or get_page_html to discover selectors",
+    "3. Use scroll to discover content below the fold",
+    "4. Use wait_for or wait_for_navigation after actions that trigger page loads",
+    "5. Take screenshots after every meaningful state change",
+    "6. Use assert_text and assert_visible to verify expected outcomes",
+    "7. When done testing, call report_result with detailed pass/fail reasoning",
+    "",
+    "Tips:",
+    "- Try multiple selector strategies: by text, by role, by class, by id",
+    "- If a click triggers navigation, use wait_for_navigation after",
+    "- For forms, fill all fields before submitting",
+    "- Check for error messages after form submissions",
+    "- Verify both positive and negative states"
+  ].join(`
+`);
   const userParts = [
     `**Scenario:** ${scenario.name}`,
     `**Description:** ${scenario.description}`
@@ -1316,7 +1724,10 @@ async function runSingleScenario(scenario, runId, options) {
         action: ss.action,
         filePath: ss.filePath,
         width: ss.width,
-        height: ss.height
+        height: ss.height,
+        description: ss.description,
+        pageUrl: ss.pageUrl,
+        thumbnailPath: ss.thumbnailPath
       });
       emit({ type: "screenshot:captured", screenshotPath: ss.filePath, scenarioId: scenario.id, runId });
     }
@@ -1424,6 +1835,345 @@ function estimateCost(model, tokens) {
   return tokens / 1e6 * costPer1M * 100;
 }
 
+// src/db/schedules.ts
+function createSchedule(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO schedules (id, project_id, name, cron_expression, url, scenario_filter, model, headed, parallel, timeout_ms, enabled, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+  `).run(id, input.projectId ?? null, input.name, input.cronExpression, input.url, JSON.stringify(input.scenarioFilter ?? {}), input.model ?? null, input.headed ? 1 : 0, input.parallel ?? 1, input.timeoutMs ?? null, timestamp, timestamp);
+  return getSchedule(id);
+}
+function getSchedule(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM schedules WHERE id = ?").get(id);
+  if (row)
+    return scheduleFromRow(row);
+  const fullId = resolvePartialId("schedules", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM schedules WHERE id = ?").get(fullId);
+    if (row)
+      return scheduleFromRow(row);
+  }
+  return null;
+}
+function listSchedules(filter) {
+  const db2 = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.projectId) {
+    conditions.push("project_id = ?");
+    params.push(filter.projectId);
+  }
+  if (filter?.enabled !== undefined) {
+    conditions.push("enabled = ?");
+    params.push(filter.enabled ? 1 : 0);
+  }
+  let sql = "SELECT * FROM schedules";
+  if (conditions.length > 0) {
+    sql += " WHERE " + conditions.join(" AND ");
+  }
+  sql += " ORDER BY created_at DESC";
+  if (filter?.limit) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
+  }
+  if (filter?.offset) {
+    sql += " OFFSET ?";
+    params.push(filter.offset);
+  }
+  const rows = db2.query(sql).all(...params);
+  return rows.map(scheduleFromRow);
+}
+function updateSchedule(id, input) {
+  const db2 = getDatabase();
+  const existing = getSchedule(id);
+  if (!existing) {
+    throw new ScheduleNotFoundError(id);
+  }
+  const sets = [];
+  const params = [];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.cronExpression !== undefined) {
+    sets.push("cron_expression = ?");
+    params.push(input.cronExpression);
+  }
+  if (input.url !== undefined) {
+    sets.push("url = ?");
+    params.push(input.url);
+  }
+  if (input.scenarioFilter !== undefined) {
+    sets.push("scenario_filter = ?");
+    params.push(JSON.stringify(input.scenarioFilter));
+  }
+  if (input.model !== undefined) {
+    sets.push("model = ?");
+    params.push(input.model);
+  }
+  if (input.headed !== undefined) {
+    sets.push("headed = ?");
+    params.push(input.headed ? 1 : 0);
+  }
+  if (input.parallel !== undefined) {
+    sets.push("parallel = ?");
+    params.push(input.parallel);
+  }
+  if (input.timeoutMs !== undefined) {
+    sets.push("timeout_ms = ?");
+    params.push(input.timeoutMs);
+  }
+  if (input.enabled !== undefined) {
+    sets.push("enabled = ?");
+    params.push(input.enabled ? 1 : 0);
+  }
+  if (sets.length === 0) {
+    return existing;
+  }
+  sets.push("updated_at = ?");
+  params.push(now());
+  params.push(existing.id);
+  db2.query(`UPDATE schedules SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  return getSchedule(existing.id);
+}
+function deleteSchedule(id) {
+  const db2 = getDatabase();
+  const schedule = getSchedule(id);
+  if (!schedule)
+    return false;
+  const result = db2.query("DELETE FROM schedules WHERE id = ?").run(schedule.id);
+  return result.changes > 0;
+}
+function getEnabledSchedules() {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM schedules WHERE enabled = 1 ORDER BY created_at DESC").all();
+  return rows.map(scheduleFromRow);
+}
+function updateLastRun(id, runId, nextRunAt) {
+  const db2 = getDatabase();
+  const timestamp = now();
+  db2.query(`
+    UPDATE schedules SET last_run_id = ?, last_run_at = ?, next_run_at = ?, updated_at = ? WHERE id = ?
+  `).run(runId, timestamp, nextRunAt, timestamp, id);
+}
+
+// src/lib/scheduler.ts
+function parseCronField(field, min, max) {
+  const results = new Set;
+  const parts = field.split(",");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (trimmed.includes("/")) {
+      const slashParts = trimmed.split("/");
+      const rangePart = slashParts[0] ?? "*";
+      const stepStr = slashParts[1] ?? "1";
+      const step = parseInt(stepStr, 10);
+      if (isNaN(step) || step <= 0) {
+        throw new Error(`Invalid step value in cron field: ${field}`);
+      }
+      let start;
+      let end;
+      if (rangePart === "*") {
+        start = min;
+        end = max;
+      } else if (rangePart.includes("-")) {
+        const dashParts = rangePart.split("-");
+        start = parseInt(dashParts[0] ?? "0", 10);
+        end = parseInt(dashParts[1] ?? "0", 10);
+      } else {
+        start = parseInt(rangePart, 10);
+        end = max;
+      }
+      for (let i = start;i <= end; i += step) {
+        if (i >= min && i <= max)
+          results.add(i);
+      }
+    } else if (trimmed === "*") {
+      for (let i = min;i <= max; i++) {
+        results.add(i);
+      }
+    } else if (trimmed.includes("-")) {
+      const dashParts = trimmed.split("-");
+      const lo = parseInt(dashParts[0] ?? "0", 10);
+      const hi = parseInt(dashParts[1] ?? "0", 10);
+      if (isNaN(lo) || isNaN(hi)) {
+        throw new Error(`Invalid range in cron field: ${field}`);
+      }
+      for (let i = lo;i <= hi; i++) {
+        if (i >= min && i <= max)
+          results.add(i);
+      }
+    } else {
+      const val = parseInt(trimmed, 10);
+      if (isNaN(val)) {
+        throw new Error(`Invalid value in cron field: ${field}`);
+      }
+      if (val >= min && val <= max)
+        results.add(val);
+    }
+  }
+  return Array.from(results).sort((a, b) => a - b);
+}
+function parseCron(expression) {
+  const fields = expression.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(`Invalid cron expression "${expression}": expected 5 fields, got ${fields.length}`);
+  }
+  return {
+    minutes: parseCronField(fields[0], 0, 59),
+    hours: parseCronField(fields[1], 0, 23),
+    daysOfMonth: parseCronField(fields[2], 1, 31),
+    months: parseCronField(fields[3], 1, 12),
+    daysOfWeek: parseCronField(fields[4], 0, 6)
+  };
+}
+function shouldRunAt(cronExpression, date) {
+  const cron = parseCron(cronExpression);
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dayOfMonth = date.getDate();
+  const month = date.getMonth() + 1;
+  const dayOfWeek = date.getDay();
+  return cron.minutes.includes(minute) && cron.hours.includes(hour) && cron.daysOfMonth.includes(dayOfMonth) && cron.months.includes(month) && cron.daysOfWeek.includes(dayOfWeek);
+}
+function getNextRunTime(cronExpression, after) {
+  parseCron(cronExpression);
+  const start = after ? new Date(after.getTime()) : new Date;
+  start.setSeconds(0, 0);
+  start.setMinutes(start.getMinutes() + 1);
+  const maxDate = new Date(start.getTime() + 366 * 24 * 60 * 60 * 1000);
+  const cursor = new Date(start.getTime());
+  while (cursor.getTime() <= maxDate.getTime()) {
+    if (shouldRunAt(cronExpression, cursor)) {
+      return cursor;
+    }
+    cursor.setMinutes(cursor.getMinutes() + 1);
+  }
+  throw new Error(`No matching time found for cron expression "${cronExpression}" within 366 days`);
+}
+
+class Scheduler {
+  interval = null;
+  running = new Set;
+  checkIntervalMs;
+  onEvent;
+  constructor(options) {
+    this.checkIntervalMs = options?.checkIntervalMs ?? 60000;
+    this.onEvent = options?.onEvent;
+  }
+  start() {
+    if (this.interval)
+      return;
+    this.tick().catch(() => {});
+    this.interval = setInterval(() => {
+      this.tick().catch(() => {});
+    }, this.checkIntervalMs);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+  async tick() {
+    const now2 = new Date;
+    now2.setSeconds(0, 0);
+    const schedules = getEnabledSchedules();
+    for (const schedule of schedules) {
+      if (this.running.has(schedule.id))
+        continue;
+      if (shouldRunAt(schedule.cronExpression, now2)) {
+        this.running.add(schedule.id);
+        this.emit({
+          type: "schedule:triggered",
+          scheduleId: schedule.id,
+          scheduleName: schedule.name,
+          timestamp: new Date().toISOString()
+        });
+        this.executeSchedule(schedule).then(({ runId }) => {
+          const nextRun = getNextRunTime(schedule.cronExpression, new Date);
+          updateLastRun(schedule.id, runId, nextRun.toISOString());
+          this.emit({
+            type: "schedule:completed",
+            scheduleId: schedule.id,
+            scheduleName: schedule.name,
+            runId,
+            timestamp: new Date().toISOString()
+          });
+        }).catch((err) => {
+          this.emit({
+            type: "schedule:failed",
+            scheduleId: schedule.id,
+            scheduleName: schedule.name,
+            error: err instanceof Error ? err.message : String(err),
+            timestamp: new Date().toISOString()
+          });
+        }).finally(() => {
+          this.running.delete(schedule.id);
+        });
+      }
+    }
+  }
+  async runScheduleNow(scheduleId) {
+    const schedule = getSchedule(scheduleId);
+    if (!schedule) {
+      throw new ScheduleNotFoundError(scheduleId);
+    }
+    this.running.add(schedule.id);
+    this.emit({
+      type: "schedule:triggered",
+      scheduleId: schedule.id,
+      scheduleName: schedule.name,
+      timestamp: new Date().toISOString()
+    });
+    try {
+      const { runId } = await this.executeSchedule(schedule);
+      const nextRun = getNextRunTime(schedule.cronExpression, new Date);
+      updateLastRun(schedule.id, runId, nextRun.toISOString());
+      this.emit({
+        type: "schedule:completed",
+        scheduleId: schedule.id,
+        scheduleName: schedule.name,
+        runId,
+        timestamp: new Date().toISOString()
+      });
+    } catch (err) {
+      this.emit({
+        type: "schedule:failed",
+        scheduleId: schedule.id,
+        scheduleName: schedule.name,
+        error: err instanceof Error ? err.message : String(err),
+        timestamp: new Date().toISOString()
+      });
+      throw err;
+    } finally {
+      this.running.delete(schedule.id);
+    }
+  }
+  async executeSchedule(schedule) {
+    const { run } = await runByFilter({
+      url: schedule.url,
+      model: schedule.model ?? undefined,
+      headed: schedule.headed,
+      parallel: schedule.parallel,
+      timeout: schedule.timeoutMs ?? undefined,
+      tags: schedule.scenarioFilter.tags,
+      priority: schedule.scenarioFilter.priority,
+      scenarioIds: schedule.scenarioFilter.scenarioIds
+    });
+    return { runId: run.id };
+  }
+  emit(event) {
+    if (this.onEvent) {
+      this.onEvent(event);
+    }
+  }
+}
+
 // src/server/index.ts
 function parseUrl(req) {
   const url = new URL(req.url);
@@ -1603,6 +2353,49 @@ async function handleRequest(req) {
       }
     });
   }
+  if (pathname === "/api/schedules" && method === "GET") {
+    const projectId = searchParams.get("projectId") ?? undefined;
+    const enabled = searchParams.get("enabled");
+    const limit = searchParams.get("limit");
+    const schedules = listSchedules({
+      projectId,
+      enabled: enabled !== null ? enabled === "true" : undefined,
+      limit: limit ? parseInt(limit, 10) : undefined
+    });
+    return jsonResponse(schedules);
+  }
+  if (pathname === "/api/schedules" && method === "POST") {
+    try {
+      const body = await req.json();
+      const schedule = createSchedule(body);
+      const nextRun = getNextRunTime(schedule.cronExpression);
+      return jsonResponse({ ...schedule, nextRunAt: nextRun.toISOString() }, 201);
+    } catch (e) {
+      return errorResponse(e instanceof Error ? e.message : String(e), 400);
+    }
+  }
+  const scheduleMatch = pathname.match(/^\/api\/schedules\/([^/]+)$/);
+  if (scheduleMatch && method === "GET") {
+    const schedule = getSchedule(scheduleMatch[1]);
+    if (!schedule)
+      return errorResponse("Schedule not found", 404);
+    return jsonResponse(schedule);
+  }
+  if (scheduleMatch && method === "PUT") {
+    try {
+      const body = await req.json();
+      const schedule = updateSchedule(scheduleMatch[1], body);
+      return jsonResponse(schedule);
+    } catch (e) {
+      return errorResponse(e instanceof Error ? e.message : String(e), 400);
+    }
+  }
+  if (scheduleMatch && method === "DELETE") {
+    const deleted = deleteSchedule(scheduleMatch[1]);
+    if (!deleted)
+      return errorResponse("Schedule not found", 404);
+    return jsonResponse({ deleted: true });
+  }
   if (!pathname.startsWith("/api")) {
     const dashboardDir = join4(import.meta.dir, "..", "..", "dashboard", "dist");
     if (!existsSync4(dashboardDir)) {