@hasna/testers 0.0.1

package/dist/server/index.js

@@ -0,0 +1,1654 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/server/index.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+
+// src/types/index.ts
+var MODEL_MAP = {
+  quick: "claude-haiku-4-5-20251001",
+  thorough: "claude-sonnet-4-6-20260311",
+  deep: "claude-opus-4-6-20260311"
+};
+function scenarioFromRow(row) {
+  return {
+    id: row.id,
+    shortId: row.short_id,
+    projectId: row.project_id,
+    name: row.name,
+    description: row.description,
+    steps: JSON.parse(row.steps),
+    tags: JSON.parse(row.tags),
+    priority: row.priority,
+    model: row.model,
+    timeoutMs: row.timeout_ms,
+    targetPath: row.target_path,
+    requiresAuth: row.requires_auth === 1,
+    authConfig: row.auth_config ? JSON.parse(row.auth_config) : null,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    version: row.version,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function runFromRow(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    status: row.status,
+    url: row.url,
+    model: row.model,
+    headed: row.headed === 1,
+    parallel: row.parallel,
+    total: row.total,
+    passed: row.passed,
+    failed: row.failed,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null
+  };
+}
+function resultFromRow(row) {
+  return {
+    id: row.id,
+    runId: row.run_id,
+    scenarioId: row.scenario_id,
+    status: row.status,
+    reasoning: row.reasoning,
+    error: row.error,
+    stepsCompleted: row.steps_completed,
+    stepsTotal: row.steps_total,
+    durationMs: row.duration_ms,
+    model: row.model,
+    tokensUsed: row.tokens_used,
+    costCents: row.cost_cents,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    createdAt: row.created_at
+  };
+}
+function screenshotFromRow(row) {
+  return {
+    id: row.id,
+    resultId: row.result_id,
+    stepNumber: row.step_number,
+    action: row.action,
+    filePath: row.file_path,
+    width: row.width,
+    height: row.height,
+    timestamp: row.timestamp
+  };
+}
+class VersionConflictError extends Error {
+  constructor(entity, id) {
+    super(`Version conflict on ${entity}: ${id}`);
+    this.name = "VersionConflictError";
+  }
+}
+
+class BrowserError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BrowserError";
+  }
+}
+
+class AIClientError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AIClientError";
+  }
+}
+
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var db = null;
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function shortUuid() {
+  return uuid().slice(0, 8);
+}
+function resolveDbPath() {
+  const envPath = process.env["TESTERS_DB_PATH"];
+  if (envPath)
+    return envPath;
+  const dir = join(homedir(), ".testers");
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  return join(dir, "testers.db");
+}
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    path TEXT UNIQUE,
+    description TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    role TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS scenarios (
+    id TEXT PRIMARY KEY,
+    short_id TEXT NOT NULL UNIQUE,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    name TEXT NOT NULL,
+    description TEXT NOT NULL DEFAULT '',
+    steps TEXT NOT NULL DEFAULT '[]',
+    tags TEXT NOT NULL DEFAULT '[]',
+    priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low','medium','high','critical')),
+    model TEXT,
+    timeout_ms INTEGER,
+    target_path TEXT,
+    requires_auth INTEGER NOT NULL DEFAULT 0,
+    auth_config TEXT,
+    metadata TEXT DEFAULT '{}',
+    version INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS runs (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','running','passed','failed','cancelled')),
+    url TEXT NOT NULL,
+    model TEXT NOT NULL,
+    headed INTEGER NOT NULL DEFAULT 0,
+    parallel INTEGER NOT NULL DEFAULT 1,
+    total INTEGER NOT NULL DEFAULT 0,
+    passed INTEGER NOT NULL DEFAULT 0,
+    failed INTEGER NOT NULL DEFAULT 0,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    finished_at TEXT,
+    metadata TEXT DEFAULT '{}'
+  );
+
+  CREATE TABLE IF NOT EXISTS results (
+    id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+    scenario_id TEXT NOT NULL REFERENCES scenarios(id) ON DELETE CASCADE,
+    status TEXT NOT NULL DEFAULT 'skipped' CHECK(status IN ('passed','failed','error','skipped')),
+    reasoning TEXT,
+    error TEXT,
+    steps_completed INTEGER NOT NULL DEFAULT 0,
+    steps_total INTEGER NOT NULL DEFAULT 0,
+    duration_ms INTEGER NOT NULL DEFAULT 0,
+    model TEXT NOT NULL,
+    tokens_used INTEGER NOT NULL DEFAULT 0,
+    cost_cents REAL NOT NULL DEFAULT 0,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS screenshots (
+    id TEXT PRIMARY KEY,
+    result_id TEXT NOT NULL REFERENCES results(id) ON DELETE CASCADE,
+    step_number INTEGER NOT NULL,
+    action TEXT NOT NULL,
+    file_path TEXT NOT NULL,
+    width INTEGER NOT NULL DEFAULT 0,
+    height INTEGER NOT NULL DEFAULT 0,
+    timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  `,
+  `
+  CREATE INDEX IF NOT EXISTS idx_scenarios_project ON scenarios(project_id);
+  CREATE INDEX IF NOT EXISTS idx_scenarios_priority ON scenarios(priority);
+  CREATE INDEX IF NOT EXISTS idx_scenarios_short_id ON scenarios(short_id);
+  CREATE INDEX IF NOT EXISTS idx_runs_project ON runs(project_id);
+  CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+  CREATE INDEX IF NOT EXISTS idx_results_run ON results(run_id);
+  CREATE INDEX IF NOT EXISTS idx_results_scenario ON results(scenario_id);
+  CREATE INDEX IF NOT EXISTS idx_results_status ON results(status);
+  CREATE INDEX IF NOT EXISTS idx_screenshots_result ON screenshots(result_id);
+  `,
+  `
+  ALTER TABLE projects ADD COLUMN scenario_prefix TEXT DEFAULT 'TST';
+  ALTER TABLE projects ADD COLUMN scenario_counter INTEGER DEFAULT 0;
+  `
+];
+function applyMigrations(database) {
+  const applied = database.query("SELECT id FROM _migrations ORDER BY id").all();
+  const appliedIds = new Set(applied.map((r) => r.id));
+  for (let i = 0;i < MIGRATIONS.length; i++) {
+    const migrationId = i + 1;
+    if (appliedIds.has(migrationId))
+      continue;
+    const migration = MIGRATIONS[i];
+    database.exec(migration);
+    database.query("INSERT INTO _migrations (id, applied_at) VALUES (?, ?)").run(migrationId, now());
+  }
+}
+function getDatabase() {
+  if (db)
+    return db;
+  const dbPath = resolveDbPath();
+  const dir = dirname(dbPath);
+  if (dbPath !== ":memory:" && !existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  db = new Database(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      id INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  applyMigrations(db);
+  return db;
+}
+function resolvePartialId(table, partialId) {
+  const database = getDatabase();
+  const rows = database.query(`SELECT id FROM ${table} WHERE id LIKE ? || '%'`).all(partialId);
+  if (rows.length === 1)
+    return rows[0].id;
+  return null;
+}
+
+// src/db/scenarios.ts
+function nextShortId(projectId) {
+  const db2 = getDatabase();
+  if (projectId) {
+    const project = db2.query("SELECT scenario_prefix, scenario_counter FROM projects WHERE id = ?").get(projectId);
+    if (project) {
+      const next = project.scenario_counter + 1;
+      db2.query("UPDATE projects SET scenario_counter = ? WHERE id = ?").run(next, projectId);
+      return `${project.scenario_prefix}-${next}`;
+    }
+  }
+  return shortUuid();
+}
+function createScenario(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const short_id = nextShortId(input.projectId);
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO scenarios (id, short_id, project_id, name, description, steps, tags, priority, model, timeout_ms, target_path, requires_auth, auth_config, metadata, version, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+  `).run(id, short_id, input.projectId ?? null, input.name, input.description, JSON.stringify(input.steps ?? []), JSON.stringify(input.tags ?? []), input.priority ?? "medium", input.model ?? null, input.timeoutMs ?? null, input.targetPath ?? null, input.requiresAuth ? 1 : 0, input.authConfig ? JSON.stringify(input.authConfig) : null, input.metadata ? JSON.stringify(input.metadata) : null, timestamp, timestamp);
+  return getScenario(id);
+}
+function getScenario(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM scenarios WHERE id = ?").get(id);
+  if (row)
+    return scenarioFromRow(row);
+  row = db2.query("SELECT * FROM scenarios WHERE short_id = ?").get(id);
+  if (row)
+    return scenarioFromRow(row);
+  const fullId = resolvePartialId("scenarios", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM scenarios WHERE id = ?").get(fullId);
+    if (row)
+      return scenarioFromRow(row);
+  }
+  return null;
+}
+function getScenarioByShortId(shortId) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM scenarios WHERE short_id = ?").get(shortId);
+  return row ? scenarioFromRow(row) : null;
+}
+function listScenarios(filter) {
+  const db2 = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.projectId) {
+    conditions.push("project_id = ?");
+    params.push(filter.projectId);
+  }
+  if (filter?.tags && filter.tags.length > 0) {
+    for (const tag of filter.tags) {
+      conditions.push("tags LIKE ?");
+      params.push(`%"${tag}"%`);
+    }
+  }
+  if (filter?.priority) {
+    conditions.push("priority = ?");
+    params.push(filter.priority);
+  }
+  if (filter?.search) {
+    conditions.push("(name LIKE ? OR description LIKE ?)");
+    const term = `%${filter.search}%`;
+    params.push(term, term);
+  }
+  let sql = "SELECT * FROM scenarios";
+  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(scenarioFromRow);
+}
+function updateScenario(id, input, version) {
+  const db2 = getDatabase();
+  const existing = getScenario(id);
+  if (!existing) {
+    throw new Error(`Scenario not found: ${id}`);
+  }
+  if (existing.version !== version) {
+    throw new VersionConflictError("scenario", existing.id);
+  }
+  const sets = [];
+  const params = [];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.steps !== undefined) {
+    sets.push("steps = ?");
+    params.push(JSON.stringify(input.steps));
+  }
+  if (input.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.priority !== undefined) {
+    sets.push("priority = ?");
+    params.push(input.priority);
+  }
+  if (input.model !== undefined) {
+    sets.push("model = ?");
+    params.push(input.model);
+  }
+  if (input.timeoutMs !== undefined) {
+    sets.push("timeout_ms = ?");
+    params.push(input.timeoutMs);
+  }
+  if (input.targetPath !== undefined) {
+    sets.push("target_path = ?");
+    params.push(input.targetPath);
+  }
+  if (input.requiresAuth !== undefined) {
+    sets.push("requires_auth = ?");
+    params.push(input.requiresAuth ? 1 : 0);
+  }
+  if (input.authConfig !== undefined) {
+    sets.push("auth_config = ?");
+    params.push(JSON.stringify(input.authConfig));
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (sets.length === 0) {
+    return existing;
+  }
+  sets.push("version = ?");
+  params.push(version + 1);
+  sets.push("updated_at = ?");
+  params.push(now());
+  params.push(existing.id);
+  params.push(version);
+  const result = db2.query(`UPDATE scenarios SET ${sets.join(", ")} WHERE id = ? AND version = ?`).run(...params);
+  if (result.changes === 0) {
+    throw new VersionConflictError("scenario", existing.id);
+  }
+  return getScenario(existing.id);
+}
+function deleteScenario(id) {
+  const db2 = getDatabase();
+  const scenario = getScenario(id);
+  if (!scenario)
+    return false;
+  const result = db2.query("DELETE FROM scenarios WHERE id = ?").run(scenario.id);
+  return result.changes > 0;
+}
+
+// src/db/runs.ts
+function createRun(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO runs (id, project_id, status, url, model, headed, parallel, total, passed, failed, started_at, finished_at, metadata)
+    VALUES (?, ?, 'pending', ?, ?, ?, ?, 0, 0, 0, ?, NULL, ?)
+  `).run(id, input.projectId ?? null, input.url, input.model, input.headed ? 1 : 0, input.parallel ?? 1, timestamp, input.model ? JSON.stringify({}) : null);
+  return getRun(id);
+}
+function getRun(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM runs WHERE id = ?").get(id);
+  if (row)
+    return runFromRow(row);
+  const fullId = resolvePartialId("runs", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM runs WHERE id = ?").get(fullId);
+    if (row)
+      return runFromRow(row);
+  }
+  return null;
+}
+function listRuns(filter) {
+  const db2 = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.projectId) {
+    conditions.push("project_id = ?");
+    params.push(filter.projectId);
+  }
+  if (filter?.status) {
+    conditions.push("status = ?");
+    params.push(filter.status);
+  }
+  let sql = "SELECT * FROM runs";
+  if (conditions.length > 0) {
+    sql += " WHERE " + conditions.join(" AND ");
+  }
+  sql += " ORDER BY started_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(runFromRow);
+}
+function updateRun(id, updates) {
+  const db2 = getDatabase();
+  const existing = getRun(id);
+  if (!existing) {
+    throw new Error(`Run not found: ${id}`);
+  }
+  const sets = [];
+  const params = [];
+  if (updates.status !== undefined) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.url !== undefined) {
+    sets.push("url = ?");
+    params.push(updates.url);
+  }
+  if (updates.model !== undefined) {
+    sets.push("model = ?");
+    params.push(updates.model);
+  }
+  if (updates.headed !== undefined) {
+    sets.push("headed = ?");
+    params.push(updates.headed);
+  }
+  if (updates.parallel !== undefined) {
+    sets.push("parallel = ?");
+    params.push(updates.parallel);
+  }
+  if (updates.total !== undefined) {
+    sets.push("total = ?");
+    params.push(updates.total);
+  }
+  if (updates.passed !== undefined) {
+    sets.push("passed = ?");
+    params.push(updates.passed);
+  }
+  if (updates.failed !== undefined) {
+    sets.push("failed = ?");
+    params.push(updates.failed);
+  }
+  if (updates.started_at !== undefined) {
+    sets.push("started_at = ?");
+    params.push(updates.started_at);
+  }
+  if (updates.finished_at !== undefined) {
+    sets.push("finished_at = ?");
+    params.push(updates.finished_at);
+  }
+  if (updates.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(updates.metadata);
+  }
+  if (sets.length === 0) {
+    return existing;
+  }
+  params.push(existing.id);
+  db2.query(`UPDATE runs SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  return getRun(existing.id);
+}
+
+// src/db/results.ts
+function createResult(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO results (id, run_id, scenario_id, status, reasoning, error, steps_completed, steps_total, duration_ms, model, tokens_used, cost_cents, metadata, created_at)
+    VALUES (?, ?, ?, 'skipped', NULL, NULL, 0, ?, 0, ?, 0, 0, '{}', ?)
+  `).run(id, input.runId, input.scenarioId, input.stepsTotal, input.model, timestamp);
+  return getResult(id);
+}
+function getResult(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM results WHERE id = ?").get(id);
+  if (row)
+    return resultFromRow(row);
+  const fullId = resolvePartialId("results", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM results WHERE id = ?").get(fullId);
+    if (row)
+      return resultFromRow(row);
+  }
+  return null;
+}
+function listResults(runId) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM results WHERE run_id = ? ORDER BY created_at ASC").all(runId);
+  return rows.map(resultFromRow);
+}
+function updateResult(id, updates) {
+  const db2 = getDatabase();
+  const existing = getResult(id);
+  if (!existing) {
+    throw new Error(`Result not found: ${id}`);
+  }
+  const sets = [];
+  const params = [];
+  if (updates.status !== undefined) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.reasoning !== undefined) {
+    sets.push("reasoning = ?");
+    params.push(updates.reasoning);
+  }
+  if (updates.error !== undefined) {
+    sets.push("error = ?");
+    params.push(updates.error);
+  }
+  if (updates.stepsCompleted !== undefined) {
+    sets.push("steps_completed = ?");
+    params.push(updates.stepsCompleted);
+  }
+  if (updates.durationMs !== undefined) {
+    sets.push("duration_ms = ?");
+    params.push(updates.durationMs);
+  }
+  if (updates.tokensUsed !== undefined) {
+    sets.push("tokens_used = ?");
+    params.push(updates.tokensUsed);
+  }
+  if (updates.costCents !== undefined) {
+    sets.push("cost_cents = ?");
+    params.push(updates.costCents);
+  }
+  if (sets.length === 0) {
+    return existing;
+  }
+  params.push(existing.id);
+  db2.query(`UPDATE results SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  return getResult(existing.id);
+}
+function getResultsByRun(runId) {
+  return listResults(runId);
+}
+
+// src/db/screenshots.ts
+function createScreenshot(input) {
+  const db2 = getDatabase();
+  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);
+  return getScreenshot(id);
+}
+function getScreenshot(id) {
+  const db2 = getDatabase();
+  const row = db2.query("SELECT * FROM screenshots WHERE id = ?").get(id);
+  return row ? screenshotFromRow(row) : null;
+}
+function listScreenshots(resultId) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM screenshots WHERE result_id = ? ORDER BY step_number ASC").all(resultId);
+  return rows.map(screenshotFromRow);
+}
+
+// src/lib/browser.ts
+import { chromium } from "playwright";
+var DEFAULT_VIEWPORT = { width: 1280, height: 720 };
+async function launchBrowser(options) {
+  const headless = options?.headless ?? true;
+  const viewport = options?.viewport ?? DEFAULT_VIEWPORT;
+  try {
+    const browser = await chromium.launch({
+      headless,
+      args: [
+        `--window-size=${viewport.width},${viewport.height}`
+      ]
+    });
+    return browser;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BrowserError(`Failed to launch browser: ${message}`);
+  }
+}
+async function getPage(browser, options) {
+  const viewport = options?.viewport ?? DEFAULT_VIEWPORT;
+  try {
+    const context = await browser.newContext({
+      viewport,
+      userAgent: options?.userAgent,
+      locale: options?.locale
+    });
+    const page = await context.newPage();
+    return page;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BrowserError(`Failed to create page: ${message}`);
+  }
+}
+async function closeBrowser(browser) {
+  try {
+    await browser.close();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BrowserError(`Failed to close browser: ${message}`);
+  }
+}
+
+// src/lib/screenshotter.ts
+import { mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function generateFilename(stepNumber, action) {
+  const padded = String(stepNumber).padStart(3, "0");
+  const slug = slugify(action);
+  return `${padded}-${slug}.png`;
+}
+function getScreenshotDir(baseDir, runId, scenarioSlug) {
+  return join2(baseDir, runId, scenarioSlug);
+}
+function ensureDir(dirPath) {
+  if (!existsSync2(dirPath)) {
+    mkdirSync2(dirPath, { recursive: true });
+  }
+}
+var DEFAULT_BASE_DIR = join2(homedir2(), ".testers", "screenshots");
+
+class Screenshotter {
+  baseDir;
+  format;
+  quality;
+  fullPage;
+  constructor(options = {}) {
+    this.baseDir = options.baseDir ?? DEFAULT_BASE_DIR;
+    this.format = options.format ?? "png";
+    this.quality = options.quality ?? 90;
+    this.fullPage = options.fullPage ?? false;
+  }
+  async capture(page, options) {
+    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug);
+    const filename = generateFilename(options.stepNumber, options.action);
+    const filePath = join2(dir, filename);
+    ensureDir(dir);
+    await page.screenshot({
+      path: filePath,
+      fullPage: this.fullPage,
+      type: this.format,
+      quality: this.format === "jpeg" ? this.quality : undefined
+    });
+    const viewport = page.viewportSize() ?? { width: 0, height: 0 };
+    return {
+      filePath,
+      width: viewport.width,
+      height: viewport.height,
+      timestamp: new Date().toISOString()
+    };
+  }
+  async captureFullPage(page, options) {
+    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug);
+    const filename = generateFilename(options.stepNumber, options.action);
+    const filePath = join2(dir, filename);
+    ensureDir(dir);
+    await page.screenshot({
+      path: filePath,
+      fullPage: true,
+      type: this.format,
+      quality: this.format === "jpeg" ? this.quality : undefined
+    });
+    const viewport = page.viewportSize() ?? { width: 0, height: 0 };
+    return {
+      filePath,
+      width: viewport.width,
+      height: viewport.height,
+      timestamp: new Date().toISOString()
+    };
+  }
+  async captureElement(page, selector, options) {
+    const dir = getScreenshotDir(this.baseDir, options.runId, options.scenarioSlug);
+    const filename = generateFilename(options.stepNumber, options.action);
+    const filePath = join2(dir, filename);
+    ensureDir(dir);
+    await page.locator(selector).screenshot({
+      path: filePath,
+      type: this.format,
+      quality: this.format === "jpeg" ? this.quality : undefined
+    });
+    const viewport = page.viewportSize() ?? { width: 0, height: 0 };
+    return {
+      filePath,
+      width: viewport.width,
+      height: viewport.height,
+      timestamp: new Date().toISOString()
+    };
+  }
+}
+
+// src/lib/ai-client.ts
+import Anthropic from "@anthropic-ai/sdk";
+function resolveModel(nameOrPreset) {
+  if (nameOrPreset in MODEL_MAP) {
+    return MODEL_MAP[nameOrPreset];
+  }
+  return nameOrPreset;
+}
+var BROWSER_TOOLS = [
+  {
+    name: "navigate",
+    description: "Navigate the browser to a specific URL.",
+    input_schema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "The URL to navigate to." }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "click",
+    description: "Click on an element matching the given CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the element to click."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "fill",
+    description: "Fill an input field with the given value.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the input field."
+        },
+        value: {
+          type: "string",
+          description: "The value to fill into the input."
+        }
+      },
+      required: ["selector", "value"]
+    }
+  },
+  {
+    name: "select_option",
+    description: "Select an option from a dropdown/select element.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the select element."
+        },
+        value: {
+          type: "string",
+          description: "The value of the option to select."
+        }
+      },
+      required: ["selector", "value"]
+    }
+  },
+  {
+    name: "screenshot",
+    description: "Take a screenshot of the current page state.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "get_text",
+    description: "Get the text content of an element matching the selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the element."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "get_url",
+    description: "Get the current page URL.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "wait_for",
+    description: "Wait for an element matching the selector to appear on the page.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector to wait for."
+        },
+        timeout: {
+          type: "number",
+          description: "Maximum time to wait in milliseconds (default: 10000)."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "go_back",
+    description: "Navigate back to the previous page.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "press_key",
+    description: "Press a keyboard key (e.g., Enter, Tab, Escape, ArrowDown).",
+    input_schema: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          description: "The key to press (e.g., 'Enter', 'Tab', 'Escape')."
+        }
+      },
+      required: ["key"]
+    }
+  },
+  {
+    name: "assert_visible",
+    description: "Assert that an element matching the selector is visible on the page. Returns 'true' or 'false'.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the element to check."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "assert_text",
+    description: "Assert that the given text is visible somewhere on the page. Returns 'true' or 'false'.",
+    input_schema: {
+      type: "object",
+      properties: {
+        text: {
+          type: "string",
+          description: "The text to search for on the page."
+        }
+      },
+      required: ["text"]
+    }
+  },
+  {
+    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.",
+    input_schema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["passed", "failed"],
+          description: "Whether the test scenario passed or failed."
+        },
+        reasoning: {
+          type: "string",
+          description: "Detailed explanation of why the test passed or failed, including any issues found."
+        }
+      },
+      required: ["status", "reasoning"]
+    }
+  }
+];
+async function executeTool(page, screenshotter, toolName, toolInput, context) {
+  try {
+    switch (toolName) {
+      case "navigate": {
+        const url = toolInput.url;
+        await page.goto(url, { waitUntil: "domcontentloaded" });
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "navigate"
+        });
+        return {
+          result: `Navigated to ${url}`,
+          screenshot
+        };
+      }
+      case "click": {
+        const selector = toolInput.selector;
+        await page.click(selector);
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "click"
+        });
+        return {
+          result: `Clicked element: ${selector}`,
+          screenshot
+        };
+      }
+      case "fill": {
+        const selector = toolInput.selector;
+        const value = toolInput.value;
+        await page.fill(selector, value);
+        return {
+          result: `Filled "${selector}" with value`
+        };
+      }
+      case "select_option": {
+        const selector = toolInput.selector;
+        const value = toolInput.value;
+        await page.selectOption(selector, value);
+        return {
+          result: `Selected option "${value}" in ${selector}`
+        };
+      }
+      case "screenshot": {
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "screenshot"
+        });
+        return {
+          result: "Screenshot captured",
+          screenshot
+        };
+      }
+      case "get_text": {
+        const selector = toolInput.selector;
+        const text = await page.locator(selector).textContent();
+        return {
+          result: text ?? "(no text content)"
+        };
+      }
+      case "get_url": {
+        return {
+          result: page.url()
+        };
+      }
+      case "wait_for": {
+        const selector = toolInput.selector;
+        const timeout = typeof toolInput.timeout === "number" ? toolInput.timeout : 1e4;
+        await page.waitForSelector(selector, { timeout });
+        return {
+          result: `Element "${selector}" appeared`
+        };
+      }
+      case "go_back": {
+        await page.goBack();
+        return {
+          result: "Navigated back"
+        };
+      }
+      case "press_key": {
+        const key = toolInput.key;
+        await page.keyboard.press(key);
+        return {
+          result: `Pressed key: ${key}`
+        };
+      }
+      case "assert_visible": {
+        const selector = toolInput.selector;
+        try {
+          const visible = await page.locator(selector).isVisible();
+          return { result: visible ? "true" : "false" };
+        } catch {
+          return { result: "false" };
+        }
+      }
+      case "assert_text": {
+        const text = toolInput.text;
+        try {
+          const bodyText = await page.locator("body").textContent();
+          const found = bodyText ? bodyText.includes(text) : false;
+          return { result: found ? "true" : "false" };
+        } catch {
+          return { result: "false" };
+        }
+      }
+      case "report_result": {
+        const status = toolInput.status;
+        const reasoning = toolInput.reasoning;
+        return {
+          result: `Test ${status}: ${reasoning}`
+        };
+      }
+      default:
+        return { result: `Unknown tool: ${toolName}` };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { result: `Error executing ${toolName}: ${message}` };
+  }
+}
+async function runAgentLoop(options) {
+  const {
+    client,
+    page,
+    scenario,
+    screenshotter,
+    model,
+    runId,
+    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(" ");
+  const userParts = [
+    `**Scenario:** ${scenario.name}`,
+    `**Description:** ${scenario.description}`
+  ];
+  if (scenario.targetPath) {
+    userParts.push(`**Target Path:** ${scenario.targetPath}`);
+  }
+  if (scenario.steps.length > 0) {
+    userParts.push("**Steps:**");
+    for (let i = 0;i < scenario.steps.length; i++) {
+      userParts.push(`${i + 1}. ${scenario.steps[i]}`);
+    }
+  }
+  const userMessage = userParts.join(`
+`);
+  const screenshots = [];
+  let tokensUsed = 0;
+  let stepNumber = 0;
+  const scenarioSlug = scenario.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  let messages = [
+    { role: "user", content: userMessage }
+  ];
+  try {
+    for (let turn = 0;turn < maxTurns; turn++) {
+      const response = await client.messages.create({
+        model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        tools: BROWSER_TOOLS,
+        messages
+      });
+      if (response.usage) {
+        tokensUsed += response.usage.input_tokens + response.usage.output_tokens;
+      }
+      const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
+      if (toolUseBlocks.length === 0 && response.stop_reason === "end_turn") {
+        const textBlocks = response.content.filter((block) => block.type === "text");
+        const textReasoning = textBlocks.map((b) => b.text).join(`
+`);
+        return {
+          status: "error",
+          reasoning: textReasoning || "Agent ended without calling report_result",
+          stepsCompleted: stepNumber,
+          tokensUsed,
+          screenshots
+        };
+      }
+      const toolResults = [];
+      for (const toolBlock of toolUseBlocks) {
+        stepNumber++;
+        const toolInput = toolBlock.input;
+        const execResult = await executeTool(page, screenshotter, toolBlock.name, toolInput, { runId, scenarioSlug, stepNumber });
+        if (execResult.screenshot) {
+          screenshots.push({
+            ...execResult.screenshot,
+            action: toolBlock.name,
+            stepNumber
+          });
+        }
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolBlock.id,
+          content: execResult.result
+        });
+        if (toolBlock.name === "report_result") {
+          const status = toolInput.status;
+          const reasoning = toolInput.reasoning;
+          return {
+            status,
+            reasoning,
+            stepsCompleted: stepNumber,
+            tokensUsed,
+            screenshots
+          };
+        }
+      }
+      messages = [
+        ...messages,
+        { role: "assistant", content: response.content },
+        { role: "user", content: toolResults }
+      ];
+    }
+    return {
+      status: "error",
+      reasoning: `Agent reached maximum turn limit (${maxTurns}) without reporting a result`,
+      stepsCompleted: stepNumber,
+      tokensUsed,
+      screenshots
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new AIClientError(`Agent loop failed: ${message}`);
+  }
+}
+function createClient(apiKey) {
+  const key = apiKey ?? process.env["ANTHROPIC_API_KEY"];
+  if (!key) {
+    throw new AIClientError("No Anthropic API key provided. Set ANTHROPIC_API_KEY or pass it explicitly.");
+  }
+  return new Anthropic({ apiKey: key });
+}
+
+// src/lib/config.ts
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { readFileSync, existsSync as existsSync3 } from "fs";
+var CONFIG_DIR = join3(homedir3(), ".testers");
+var CONFIG_PATH = join3(CONFIG_DIR, "config.json");
+function getDefaultConfig() {
+  return {
+    defaultModel: "claude-haiku-4-5-20251001",
+    models: { ...MODEL_MAP },
+    browser: {
+      headless: true,
+      viewport: { width: 1280, height: 720 },
+      timeout: 60000
+    },
+    screenshots: {
+      dir: join3(homedir3(), ".testers", "screenshots"),
+      format: "png",
+      quality: 90,
+      fullPage: false
+    }
+  };
+}
+function loadConfig() {
+  const defaults = getDefaultConfig();
+  let fileConfig = {};
+  if (existsSync3(CONFIG_PATH)) {
+    try {
+      const raw = readFileSync(CONFIG_PATH, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {}
+  }
+  const config = {
+    defaultModel: fileConfig.defaultModel ?? defaults.defaultModel,
+    models: fileConfig.models ? { ...defaults.models, ...fileConfig.models } : { ...defaults.models },
+    browser: fileConfig.browser ? { ...defaults.browser, ...fileConfig.browser } : { ...defaults.browser },
+    screenshots: fileConfig.screenshots ? { ...defaults.screenshots, ...fileConfig.screenshots } : { ...defaults.screenshots },
+    anthropicApiKey: fileConfig.anthropicApiKey,
+    todosDbPath: fileConfig.todosDbPath
+  };
+  const envModel = process.env["TESTERS_MODEL"];
+  if (envModel) {
+    config.defaultModel = envModel;
+  }
+  const envScreenshotsDir = process.env["TESTERS_SCREENSHOTS_DIR"];
+  if (envScreenshotsDir) {
+    config.screenshots.dir = envScreenshotsDir;
+  }
+  const envApiKey = process.env["ANTHROPIC_API_KEY"];
+  if (envApiKey) {
+    config.anthropicApiKey = envApiKey;
+  }
+  return config;
+}
+
+// src/lib/runner.ts
+var eventHandler = null;
+function emit(event) {
+  if (eventHandler)
+    eventHandler(event);
+}
+async function runSingleScenario(scenario, runId, options) {
+  const config = loadConfig();
+  const model = resolveModel(options.model ?? scenario.model ?? config.defaultModel);
+  const client = createClient(options.apiKey ?? config.anthropicApiKey);
+  const screenshotter = new Screenshotter({
+    baseDir: options.screenshotDir ?? config.screenshots.dir
+  });
+  const result = createResult({
+    runId,
+    scenarioId: scenario.id,
+    model,
+    stepsTotal: scenario.steps.length || 10
+  });
+  emit({ type: "scenario:start", scenarioId: scenario.id, scenarioName: scenario.name, resultId: result.id, runId });
+  let browser = null;
+  let page = null;
+  try {
+    browser = await launchBrowser({ headless: !(options.headed ?? false) });
+    page = await getPage(browser, {
+      viewport: config.browser.viewport
+    });
+    const targetUrl = scenario.targetPath ? `${options.url.replace(/\/$/, "")}${scenario.targetPath}` : options.url;
+    await page.goto(targetUrl, { timeout: options.timeout ?? config.browser.timeout });
+    const agentResult = await runAgentLoop({
+      client,
+      page,
+      scenario,
+      screenshotter,
+      model,
+      runId,
+      maxTurns: 30
+    });
+    for (const ss of agentResult.screenshots) {
+      createScreenshot({
+        resultId: result.id,
+        stepNumber: ss.stepNumber,
+        action: ss.action,
+        filePath: ss.filePath,
+        width: ss.width,
+        height: ss.height
+      });
+      emit({ type: "screenshot:captured", screenshotPath: ss.filePath, scenarioId: scenario.id, runId });
+    }
+    const updatedResult = updateResult(result.id, {
+      status: agentResult.status,
+      reasoning: agentResult.reasoning,
+      stepsCompleted: agentResult.stepsCompleted,
+      durationMs: Date.now() - new Date(result.createdAt).getTime(),
+      tokensUsed: agentResult.tokensUsed,
+      costCents: estimateCost(model, agentResult.tokensUsed)
+    });
+    const eventType = agentResult.status === "passed" ? "scenario:pass" : "scenario:fail";
+    emit({ type: eventType, scenarioId: scenario.id, scenarioName: scenario.name, resultId: result.id, runId });
+    return updatedResult;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    const updatedResult = updateResult(result.id, {
+      status: "error",
+      error: errorMsg,
+      durationMs: Date.now() - new Date(result.createdAt).getTime()
+    });
+    emit({ type: "scenario:error", scenarioId: scenario.id, scenarioName: scenario.name, error: errorMsg, runId });
+    return updatedResult;
+  } finally {
+    if (browser)
+      await closeBrowser(browser);
+  }
+}
+async function runBatch(scenarios, options) {
+  const config = loadConfig();
+  const model = resolveModel(options.model ?? config.defaultModel);
+  const parallel = options.parallel ?? 1;
+  const run = createRun({
+    url: options.url,
+    model,
+    headed: options.headed,
+    parallel,
+    projectId: options.projectId
+  });
+  updateRun(run.id, { status: "running", total: scenarios.length });
+  const results = [];
+  if (parallel <= 1) {
+    for (const scenario of scenarios) {
+      const result = await runSingleScenario(scenario, run.id, options);
+      results.push(result);
+    }
+  } else {
+    const queue = [...scenarios];
+    const running = [];
+    const processNext = async () => {
+      const scenario = queue.shift();
+      if (!scenario)
+        return;
+      const result = await runSingleScenario(scenario, run.id, options);
+      results.push(result);
+      await processNext();
+    };
+    const workers = Math.min(parallel, scenarios.length);
+    for (let i = 0;i < workers; i++) {
+      running.push(processNext());
+    }
+    await Promise.all(running);
+  }
+  const passed = results.filter((r) => r.status === "passed").length;
+  const failed = results.filter((r) => r.status === "failed" || r.status === "error").length;
+  const finalStatus = failed > 0 ? "failed" : "passed";
+  const finalRun = updateRun(run.id, {
+    status: finalStatus,
+    passed,
+    failed,
+    total: scenarios.length,
+    finished_at: new Date().toISOString()
+  });
+  emit({ type: "run:complete", runId: run.id });
+  return { run: finalRun, results };
+}
+async function runByFilter(options) {
+  let scenarios;
+  if (options.scenarioIds && options.scenarioIds.length > 0) {
+    const all = listScenarios({ projectId: options.projectId });
+    scenarios = all.filter((s) => options.scenarioIds.includes(s.id) || options.scenarioIds.includes(s.shortId));
+  } else {
+    scenarios = listScenarios({
+      projectId: options.projectId,
+      tags: options.tags,
+      priority: options.priority
+    });
+  }
+  if (scenarios.length === 0) {
+    const config = loadConfig();
+    const model = resolveModel(options.model ?? config.defaultModel);
+    const run = createRun({ url: options.url, model, projectId: options.projectId });
+    updateRun(run.id, { status: "passed", total: 0, finished_at: new Date().toISOString() });
+    return { run: getRun(run.id), results: [] };
+  }
+  return runBatch(scenarios, options);
+}
+function estimateCost(model, tokens) {
+  const costs = {
+    "claude-haiku-4-5-20251001": 0.1,
+    "claude-sonnet-4-6-20260311": 0.9,
+    "claude-opus-4-6-20260311": 3
+  };
+  const costPer1M = costs[model] ?? 0.5;
+  return tokens / 1e6 * costPer1M * 100;
+}
+
+// src/server/index.ts
+function parseUrl(req) {
+  const url = new URL(req.url);
+  return { pathname: url.pathname, searchParams: url.searchParams };
+}
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization"
+    }
+  });
+}
+function errorResponse(message, status) {
+  return jsonResponse({ error: message }, status);
+}
+var CONTENT_TYPES = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json"
+};
+function getContentType(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+async function handleRequest(req) {
+  const { pathname, searchParams } = parseUrl(req);
+  const method = req.method;
+  if (method === "OPTIONS") {
+    return new Response(null, {
+      status: 204,
+      headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization"
+      }
+    });
+  }
+  if (pathname === "/api/status" && method === "GET") {
+    const config = loadConfig();
+    getDatabase();
+    const dbPath = process.env["TESTERS_DB_PATH"] ?? join4(homedir4(), ".testers", "testers.db");
+    const scenarios = listScenarios();
+    const runs = listRuns();
+    return jsonResponse({
+      dbPath,
+      apiKeySet: !!config.anthropicApiKey,
+      scenarioCount: scenarios.length,
+      runCount: runs.length,
+      version: "0.0.1"
+    });
+  }
+  if (pathname === "/api/scenarios" && method === "GET") {
+    const tag = searchParams.get("tag");
+    const priority = searchParams.get("priority");
+    const limit = searchParams.get("limit");
+    const offset = searchParams.get("offset");
+    const scenarios = listScenarios({
+      tags: tag ? [tag] : undefined,
+      priority,
+      limit: limit ? parseInt(limit, 10) : undefined,
+      offset: offset ? parseInt(offset, 10) : undefined
+    });
+    return jsonResponse(scenarios);
+  }
+  if (pathname === "/api/scenarios" && method === "POST") {
+    try {
+      const body = await req.json();
+      const scenario = createScenario(body);
+      return jsonResponse(scenario, 201);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return errorResponse(msg, 400);
+    }
+  }
+  const scenarioGetMatch = pathname.match(/^\/api\/scenarios\/([^/]+)$/);
+  if (scenarioGetMatch && method === "GET") {
+    const id = scenarioGetMatch[1];
+    const scenario = getScenario(id) ?? getScenarioByShortId(id);
+    if (!scenario)
+      return errorResponse("Scenario not found", 404);
+    return jsonResponse(scenario);
+  }
+  const scenarioUpdateMatch = pathname.match(/^\/api\/scenarios\/([^/]+)$/);
+  if (scenarioUpdateMatch && method === "PUT") {
+    const id = scenarioUpdateMatch[1];
+    try {
+      const body = await req.json();
+      const { version, ...updates } = body;
+      const scenario = updateScenario(id, updates, version);
+      return jsonResponse(scenario);
+    } catch (err) {
+      if (err instanceof VersionConflictError) {
+        return errorResponse(err.message, 409);
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      return errorResponse(msg, 400);
+    }
+  }
+  const scenarioDeleteMatch = pathname.match(/^\/api\/scenarios\/([^/]+)$/);
+  if (scenarioDeleteMatch && method === "DELETE") {
+    const id = scenarioDeleteMatch[1];
+    const deleted = deleteScenario(id);
+    if (!deleted)
+      return errorResponse("Scenario not found", 404);
+    return jsonResponse({ deleted: true });
+  }
+  if (pathname === "/api/runs" && method === "POST") {
+    try {
+      const body = await req.json();
+      const runPromise = runByFilter(body);
+      runPromise.then(() => {}).catch((err) => {
+        console.error("Run failed:", err);
+      });
+      return jsonResponse({ status: "running", message: "Run started. Poll GET /api/runs to check status." }, 202);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return errorResponse(msg, 400);
+    }
+  }
+  if (pathname === "/api/runs" && method === "GET") {
+    const status = searchParams.get("status");
+    const limit = searchParams.get("limit");
+    const runs = listRuns({
+      status,
+      limit: limit ? parseInt(limit, 10) : undefined
+    });
+    return jsonResponse(runs);
+  }
+  const runGetMatch = pathname.match(/^\/api\/runs\/([^/]+)$/);
+  if (runGetMatch && method === "GET") {
+    const id = runGetMatch[1];
+    const run = getRun(id);
+    if (!run)
+      return errorResponse("Run not found", 404);
+    const results = getResultsByRun(id);
+    return jsonResponse({ ...run, results });
+  }
+  const resultGetMatch = pathname.match(/^\/api\/results\/([^/]+)$/);
+  if (resultGetMatch && method === "GET") {
+    const id = resultGetMatch[1];
+    const result = getResult(id);
+    if (!result)
+      return errorResponse("Result not found", 404);
+    const screenshots = listScreenshots(id);
+    return jsonResponse({ ...result, screenshots });
+  }
+  const screenshotFileMatch = pathname.match(/^\/api\/screenshots\/([^/]+)\/file$/);
+  if (screenshotFileMatch && method === "GET") {
+    const id = screenshotFileMatch[1];
+    const screenshot = getScreenshot(id);
+    if (!screenshot)
+      return errorResponse("Screenshot not found", 404);
+    if (!existsSync4(screenshot.filePath)) {
+      return errorResponse("Screenshot file not found on disk", 404);
+    }
+    const file = Bun.file(screenshot.filePath);
+    return new Response(file, {
+      headers: {
+        "Content-Type": "image/png",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  }
+  if (!pathname.startsWith("/api")) {
+    const dashboardDir = join4(import.meta.dir, "..", "..", "dashboard", "dist");
+    if (!existsSync4(dashboardDir)) {
+      return new Response(`<!DOCTYPE html>
+<html>
+<head><title>Open Testers</title></head>
+<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa;">
+  <div style="text-align: center;">
+    <h1>Dashboard not built yet</h1>
+    <p>Run: <code style="background: #1a1a1a; padding: 4px 8px; border-radius: 4px;">cd dashboard && bun run build</code></p>
+  </div>
+</body>
+</html>`, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/html",
+          "Access-Control-Allow-Origin": "*"
+        }
+      });
+    }
+    const filePath = join4(dashboardDir, pathname === "/" ? "index.html" : pathname);
+    if (existsSync4(filePath)) {
+      const file = Bun.file(filePath);
+      return new Response(file, {
+        headers: {
+          "Content-Type": getContentType(filePath),
+          "Access-Control-Allow-Origin": "*"
+        }
+      });
+    }
+    const indexPath = join4(dashboardDir, "index.html");
+    if (existsSync4(indexPath)) {
+      const file = Bun.file(indexPath);
+      return new Response(file, {
+        headers: {
+          "Content-Type": "text/html",
+          "Access-Control-Allow-Origin": "*"
+        }
+      });
+    }
+  }
+  return errorResponse("Not found", 404);
+}
+var port = parseInt(process.env["TESTERS_PORT"] ?? "19450", 10);
+var server = Bun.serve({
+  port,
+  fetch: handleRequest
+});
+console.log(`Open Testers server running at http://localhost:${server.port}`);