@hasna/testers 0.0.4 → 0.0.6

package/dist/mcp/index.js

@@ -10,6 +10,574 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/types/index.ts
+function projectFromRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    path: row.path,
+    description: row.description,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function agentFromRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    role: row.role,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    createdAt: row.created_at,
+    lastSeenAt: row.last_seen_at
+  };
+}
+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,
+    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
+  };
+}
+function flowFromRow(row) {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    name: row.name,
+    description: row.description,
+    scenarioIds: JSON.parse(row.scenario_ids),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var MODEL_MAP, VersionConflictError, BrowserError, AIClientError, TodosConnectionError, ScheduleNotFoundError, DependencyCycleError;
+var init_types = __esm(() => {
+  MODEL_MAP = {
+    quick: "claude-haiku-4-5-20251001",
+    thorough: "claude-sonnet-4-6-20260311",
+    deep: "claude-opus-4-6-20260311"
+  };
+  VersionConflictError = class VersionConflictError extends Error {
+    constructor(entity, id) {
+      super(`Version conflict on ${entity}: ${id}`);
+      this.name = "VersionConflictError";
+    }
+  };
+  BrowserError = class BrowserError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BrowserError";
+    }
+  };
+  AIClientError = class AIClientError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "AIClientError";
+    }
+  };
+  TodosConnectionError = class TodosConnectionError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "TodosConnectionError";
+    }
+  };
+  ScheduleNotFoundError = class ScheduleNotFoundError extends Error {
+    constructor(id) {
+      super(`Schedule not found: ${id}`);
+      this.name = "ScheduleNotFoundError";
+    }
+  };
+  DependencyCycleError = class DependencyCycleError extends Error {
+    constructor(scenarioId, dependsOn) {
+      super(`Adding dependency ${dependsOn} to ${scenarioId} would create a cycle`);
+      this.name = "DependencyCycleError";
+    }
+  };
+});
+
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+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");
+}
+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;
+}
+var db = null, MIGRATIONS;
+var init_database = __esm(() => {
+  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;
+  `,
+    `
+  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);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS scenario_dependencies (
+    scenario_id TEXT NOT NULL REFERENCES scenarios(id) ON DELETE CASCADE,
+    depends_on TEXT NOT NULL REFERENCES scenarios(id) ON DELETE CASCADE,
+    PRIMARY KEY (scenario_id, depends_on),
+    CHECK (scenario_id != depends_on)
+  );
+
+  CREATE TABLE IF NOT EXISTS flows (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    description TEXT,
+    scenario_ids TEXT NOT NULL DEFAULT '[]',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_deps_scenario ON scenario_dependencies(scenario_id);
+  CREATE INDEX IF NOT EXISTS idx_deps_depends ON scenario_dependencies(depends_on);
+  CREATE INDEX IF NOT EXISTS idx_flows_project ON flows(project_id);
+  `
+  ];
+});
+
+// src/db/flows.ts
+var exports_flows = {};
+__export(exports_flows, {
+  topologicalSort: () => topologicalSort,
+  removeDependency: () => removeDependency,
+  listFlows: () => listFlows,
+  getTransitiveDependencies: () => getTransitiveDependencies,
+  getFlow: () => getFlow,
+  getDependents: () => getDependents,
+  getDependencies: () => getDependencies,
+  deleteFlow: () => deleteFlow,
+  createFlow: () => createFlow,
+  addDependency: () => addDependency
+});
+function addDependency(scenarioId, dependsOn) {
+  const db2 = getDatabase();
+  const visited = new Set;
+  const queue = [dependsOn];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === scenarioId) {
+      throw new DependencyCycleError(scenarioId, dependsOn);
+    }
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
+    for (const dep of deps) {
+      if (!visited.has(dep.depends_on)) {
+        queue.push(dep.depends_on);
+      }
+    }
+  }
+  db2.query("INSERT OR IGNORE INTO scenario_dependencies (scenario_id, depends_on) VALUES (?, ?)").run(scenarioId, dependsOn);
+}
+function removeDependency(scenarioId, dependsOn) {
+  const db2 = getDatabase();
+  const result = db2.query("DELETE FROM scenario_dependencies WHERE scenario_id = ? AND depends_on = ?").run(scenarioId, dependsOn);
+  return result.changes > 0;
+}
+function getDependencies(scenarioId) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(scenarioId);
+  return rows.map((r) => r.depends_on);
+}
+function getDependents(scenarioId) {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT scenario_id FROM scenario_dependencies WHERE depends_on = ?").all(scenarioId);
+  return rows.map((r) => r.scenario_id);
+}
+function getTransitiveDependencies(scenarioId) {
+  const db2 = getDatabase();
+  const visited = new Set;
+  const queue = [scenarioId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(current);
+    for (const dep of deps) {
+      if (!visited.has(dep.depends_on)) {
+        visited.add(dep.depends_on);
+        queue.push(dep.depends_on);
+      }
+    }
+  }
+  return Array.from(visited);
+}
+function topologicalSort(scenarioIds) {
+  const db2 = getDatabase();
+  const idSet = new Set(scenarioIds);
+  const inDegree = new Map;
+  const dependents = new Map;
+  for (const id of scenarioIds) {
+    inDegree.set(id, 0);
+    dependents.set(id, []);
+  }
+  for (const id of scenarioIds) {
+    const deps = db2.query("SELECT depends_on FROM scenario_dependencies WHERE scenario_id = ?").all(id);
+    for (const dep of deps) {
+      if (idSet.has(dep.depends_on)) {
+        inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
+        dependents.get(dep.depends_on).push(id);
+      }
+    }
+  }
+  const queue = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0)
+      queue.push(id);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    for (const dep of dependents.get(current) ?? []) {
+      const newDeg = (inDegree.get(dep) ?? 1) - 1;
+      inDegree.set(dep, newDeg);
+      if (newDeg === 0)
+        queue.push(dep);
+    }
+  }
+  if (sorted.length !== scenarioIds.length) {
+    throw new DependencyCycleError("multiple", "multiple");
+  }
+  return sorted;
+}
+function createFlow(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO flows (id, project_id, name, description, scenario_ids, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(id, input.projectId ?? null, input.name, input.description ?? null, JSON.stringify(input.scenarioIds), timestamp, timestamp);
+  return getFlow(id);
+}
+function getFlow(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM flows WHERE id = ?").get(id);
+  if (row)
+    return flowFromRow(row);
+  const fullId = resolvePartialId("flows", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM flows WHERE id = ?").get(fullId);
+    if (row)
+      return flowFromRow(row);
+  }
+  return null;
+}
+function listFlows(projectId) {
+  const db2 = getDatabase();
+  if (projectId) {
+    const rows2 = db2.query("SELECT * FROM flows WHERE project_id = ? ORDER BY created_at DESC").all(projectId);
+    return rows2.map(flowFromRow);
+  }
+  const rows = db2.query("SELECT * FROM flows ORDER BY created_at DESC").all();
+  return rows.map(flowFromRow);
+}
+function deleteFlow(id) {
+  const db2 = getDatabase();
+  const flow = getFlow(id);
+  if (!flow)
+    return false;
+  const result = db2.query("DELETE FROM flows WHERE id = ?").run(flow.id);
+  return result.changes > 0;
+}
+var init_flows = __esm(() => {
+  init_database();
+  init_database();
+  init_types();
+});
 
 // src/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -3681,689 +4249,316 @@ class ZodDefault extends ZodType {
     }
     return this._def.innerType._parse({
       data,
-      path: ctx.path,
-      parent: ctx
-    });
-  }
-  removeDefault() {
-    return this._def.innerType;
-  }
-}
-ZodDefault.create = (type, params) => {
-  return new ZodDefault({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodDefault,
-    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
-    ...processCreateParams(params)
-  });
-};
-
-class ZodCatch extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const newCtx = {
-      ...ctx,
-      common: {
-        ...ctx.common,
-        issues: []
-      }
-    };
-    const result = this._def.innerType._parse({
-      data: newCtx.data,
-      path: newCtx.path,
-      parent: {
-        ...newCtx
-      }
-    });
-    if (isAsync(result)) {
-      return result.then((result2) => {
-        return {
-          status: "valid",
-          value: result2.status === "valid" ? result2.value : this._def.catchValue({
-            get error() {
-              return new ZodError(newCtx.common.issues);
-            },
-            input: newCtx.data
-          })
-        };
-      });
-    } else {
-      return {
-        status: "valid",
-        value: result.status === "valid" ? result.value : this._def.catchValue({
-          get error() {
-            return new ZodError(newCtx.common.issues);
-          },
-          input: newCtx.data
-        })
-      };
-    }
-  }
-  removeCatch() {
-    return this._def.innerType;
-  }
-}
-ZodCatch.create = (type, params) => {
-  return new ZodCatch({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodCatch,
-    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
-    ...processCreateParams(params)
-  });
-};
-
-class ZodNaN extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
-    if (parsedType !== ZodParsedType.nan) {
-      const ctx = this._getOrReturnCtx(input);
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.nan,
-        received: ctx.parsedType
-      });
-      return INVALID;
-    }
-    return { status: "valid", value: input.data };
-  }
-}
-ZodNaN.create = (params) => {
-  return new ZodNaN({
-    typeName: ZodFirstPartyTypeKind.ZodNaN,
-    ...processCreateParams(params)
-  });
-};
-var BRAND = Symbol("zod_brand");
-
-class ZodBranded extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const data = ctx.data;
-    return this._def.type._parse({
-      data,
-      path: ctx.path,
-      parent: ctx
-    });
-  }
-  unwrap() {
-    return this._def.type;
-  }
-}
-
-class ZodPipeline extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
-    if (ctx.common.async) {
-      const handleAsync = async () => {
-        const inResult = await this._def.in._parseAsync({
-          data: ctx.data,
-          path: ctx.path,
-          parent: ctx
-        });
-        if (inResult.status === "aborted")
-          return INVALID;
-        if (inResult.status === "dirty") {
-          status.dirty();
-          return DIRTY(inResult.value);
-        } else {
-          return this._def.out._parseAsync({
-            data: inResult.value,
-            path: ctx.path,
-            parent: ctx
-          });
-        }
-      };
-      return handleAsync();
-    } else {
-      const inResult = this._def.in._parseSync({
-        data: ctx.data,
-        path: ctx.path,
-        parent: ctx
-      });
-      if (inResult.status === "aborted")
-        return INVALID;
-      if (inResult.status === "dirty") {
-        status.dirty();
-        return {
-          status: "dirty",
-          value: inResult.value
-        };
-      } else {
-        return this._def.out._parseSync({
-          data: inResult.value,
-          path: ctx.path,
-          parent: ctx
-        });
-      }
-    }
-  }
-  static create(a, b) {
-    return new ZodPipeline({
-      in: a,
-      out: b,
-      typeName: ZodFirstPartyTypeKind.ZodPipeline
-    });
-  }
-}
-
-class ZodReadonly extends ZodType {
-  _parse(input) {
-    const result = this._def.innerType._parse(input);
-    const freeze = (data) => {
-      if (isValid(data)) {
-        data.value = Object.freeze(data.value);
-      }
-      return data;
-    };
-    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+      path: ctx.path,
+      parent: ctx
+    });
   }
-  unwrap() {
+  removeDefault() {
     return this._def.innerType;
   }
 }
-ZodReadonly.create = (type, params) => {
-  return new ZodReadonly({
+ZodDefault.create = (type, params) => {
+  return new ZodDefault({
     innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodReadonly,
+    typeName: ZodFirstPartyTypeKind.ZodDefault,
+    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
     ...processCreateParams(params)
   });
 };
-function cleanParams(params, data) {
-  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
-  const p2 = typeof p === "string" ? { message: p } : p;
-  return p2;
-}
-function custom(check, _params = {}, fatal) {
-  if (check)
-    return ZodAny.create().superRefine((data, ctx) => {
-      const r = check(data);
-      if (r instanceof Promise) {
-        return r.then((r2) => {
-          if (!r2) {
-            const params = cleanParams(_params, data);
-            const _fatal = params.fatal ?? fatal ?? true;
-            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-          }
-        });
-      }
-      if (!r) {
-        const params = cleanParams(_params, data);
-        const _fatal = params.fatal ?? fatal ?? true;
-        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-      }
-      return;
-    });
-  return ZodAny.create();
-}
-var late = {
-  object: ZodObject.lazycreate
-};
-var ZodFirstPartyTypeKind;
-(function(ZodFirstPartyTypeKind2) {
-  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
-  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
-  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
-  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
-  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
-  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
-  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
-  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
-  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
-  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
-  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
-  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
-  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
-  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
-  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
-  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
-  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
-  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
-  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
-  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
-  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
-  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
-  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
-  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
-  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
-  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
-  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
-  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
-  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
-  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
-  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
-  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
-  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
-  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
-  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
-  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
-})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-var instanceOfType = (cls, params = {
-  message: `Input not instance of ${cls.name}`
-}) => custom((data) => data instanceof cls, params);
-var stringType = ZodString.create;
-var numberType = ZodNumber.create;
-var nanType = ZodNaN.create;
-var bigIntType = ZodBigInt.create;
-var booleanType = ZodBoolean.create;
-var dateType = ZodDate.create;
-var symbolType = ZodSymbol.create;
-var undefinedType = ZodUndefined.create;
-var nullType = ZodNull.create;
-var anyType = ZodAny.create;
-var unknownType = ZodUnknown.create;
-var neverType = ZodNever.create;
-var voidType = ZodVoid.create;
-var arrayType = ZodArray.create;
-var objectType = ZodObject.create;
-var strictObjectType = ZodObject.strictCreate;
-var unionType = ZodUnion.create;
-var discriminatedUnionType = ZodDiscriminatedUnion.create;
-var intersectionType = ZodIntersection.create;
-var tupleType = ZodTuple.create;
-var recordType = ZodRecord.create;
-var mapType = ZodMap.create;
-var setType = ZodSet.create;
-var functionType = ZodFunction.create;
-var lazyType = ZodLazy.create;
-var literalType = ZodLiteral.create;
-var enumType = ZodEnum.create;
-var nativeEnumType = ZodNativeEnum.create;
-var promiseType = ZodPromise.create;
-var effectsType = ZodEffects.create;
-var optionalType = ZodOptional.create;
-var nullableType = ZodNullable.create;
-var preprocessType = ZodEffects.createWithPreprocess;
-var pipelineType = ZodPipeline.create;
-var ostring = () => stringType().optional();
-var onumber = () => numberType().optional();
-var oboolean = () => booleanType().optional();
-var coerce = {
-  string: (arg) => ZodString.create({ ...arg, coerce: true }),
-  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
-  boolean: (arg) => ZodBoolean.create({
-    ...arg,
-    coerce: true
-  }),
-  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
-  date: (arg) => ZodDate.create({ ...arg, coerce: true })
-};
-var NEVER = INVALID;
-// 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 projectFromRow(row) {
-  return {
-    id: row.id,
-    name: row.name,
-    path: row.path,
-    description: row.description,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  };
-}
-function agentFromRow(row) {
-  return {
-    id: row.id,
-    name: row.name,
-    description: row.description,
-    role: row.role,
-    metadata: row.metadata ? JSON.parse(row.metadata) : null,
-    createdAt: row.created_at,
-    lastSeenAt: row.last_seen_at
-  };
-}
-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,
-    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 {
-  constructor(entity, id) {
-    super(`Version conflict on ${entity}: ${id}`);
-    this.name = "VersionConflictError";
-  }
-}
 
-class BrowserError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserError";
+class ZodCatch extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const newCtx = {
+      ...ctx,
+      common: {
+        ...ctx.common,
+        issues: []
+      }
+    };
+    const result = this._def.innerType._parse({
+      data: newCtx.data,
+      path: newCtx.path,
+      parent: {
+        ...newCtx
+      }
+    });
+    if (isAsync(result)) {
+      return result.then((result2) => {
+        return {
+          status: "valid",
+          value: result2.status === "valid" ? result2.value : this._def.catchValue({
+            get error() {
+              return new ZodError(newCtx.common.issues);
+            },
+            input: newCtx.data
+          })
+        };
+      });
+    } else {
+      return {
+        status: "valid",
+        value: result.status === "valid" ? result.value : this._def.catchValue({
+          get error() {
+            return new ZodError(newCtx.common.issues);
+          },
+          input: newCtx.data
+        })
+      };
+    }
   }
-}
-
-class AIClientError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AIClientError";
+  removeCatch() {
+    return this._def.innerType;
   }
 }
+ZodCatch.create = (type, params) => {
+  return new ZodCatch({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodCatch,
+    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
+    ...processCreateParams(params)
+  });
+};
 
-class TodosConnectionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TodosConnectionError";
-  }
-}
-class ScheduleNotFoundError extends Error {
-  constructor(id) {
-    super(`Schedule not found: ${id}`);
-    this.name = "ScheduleNotFoundError";
+class ZodNaN extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.nan) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.nan,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    return { status: "valid", value: input.data };
   }
 }
-
-// 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;
-  `,
-  `
-  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) {
-  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());
+ZodNaN.create = (params) => {
+  return new ZodNaN({
+    typeName: ZodFirstPartyTypeKind.ZodNaN,
+    ...processCreateParams(params)
+  });
+};
+var BRAND = Symbol("zod_brand");
+
+class ZodBranded extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const data = ctx.data;
+    return this._def.type._parse({
+      data,
+      path: ctx.path,
+      parent: ctx
+    });
   }
-}
-function getDatabase() {
-  if (db)
-    return db;
-  const dbPath = resolveDbPath();
-  const dir = dirname(dbPath);
-  if (dbPath !== ":memory:" && !existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+  unwrap() {
+    return this._def.type;
   }
-  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;
+
+class ZodPipeline extends ZodType {
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.common.async) {
+      const handleAsync = async () => {
+        const inResult = await this._def.in._parseAsync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inResult.status === "aborted")
+          return INVALID;
+        if (inResult.status === "dirty") {
+          status.dirty();
+          return DIRTY(inResult.value);
+        } else {
+          return this._def.out._parseAsync({
+            data: inResult.value,
+            path: ctx.path,
+            parent: ctx
+          });
+        }
+      };
+      return handleAsync();
+    } else {
+      const inResult = this._def.in._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      });
+      if (inResult.status === "aborted")
+        return INVALID;
+      if (inResult.status === "dirty") {
+        status.dirty();
+        return {
+          status: "dirty",
+          value: inResult.value
+        };
+      } else {
+        return this._def.out._parseSync({
+          data: inResult.value,
+          path: ctx.path,
+          parent: ctx
+        });
+      }
+    }
+  }
+  static create(a, b) {
+    return new ZodPipeline({
+      in: a,
+      out: b,
+      typeName: ZodFirstPartyTypeKind.ZodPipeline
+    });
+  }
 }
 
+class ZodReadonly extends ZodType {
+  _parse(input) {
+    const result = this._def.innerType._parse(input);
+    const freeze = (data) => {
+      if (isValid(data)) {
+        data.value = Object.freeze(data.value);
+      }
+      return data;
+    };
+    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+ZodReadonly.create = (type, params) => {
+  return new ZodReadonly({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodReadonly,
+    ...processCreateParams(params)
+  });
+};
+function cleanParams(params, data) {
+  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+  const p2 = typeof p === "string" ? { message: p } : p;
+  return p2;
+}
+function custom(check, _params = {}, fatal) {
+  if (check)
+    return ZodAny.create().superRefine((data, ctx) => {
+      const r = check(data);
+      if (r instanceof Promise) {
+        return r.then((r2) => {
+          if (!r2) {
+            const params = cleanParams(_params, data);
+            const _fatal = params.fatal ?? fatal ?? true;
+            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+          }
+        });
+      }
+      if (!r) {
+        const params = cleanParams(_params, data);
+        const _fatal = params.fatal ?? fatal ?? true;
+        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+      }
+      return;
+    });
+  return ZodAny.create();
+}
+var late = {
+  object: ZodObject.lazycreate
+};
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind2) {
+  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
+  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
+  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
+  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
+  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
+  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
+  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
+  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
+  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
+  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
+  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
+  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
+  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
+  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
+  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
+  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
+  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
+  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
+  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
+  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
+  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
+  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
+  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
+  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
+  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
+  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
+  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
+  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
+  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
+  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
+  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
+  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
+  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+var instanceOfType = (cls, params = {
+  message: `Input not instance of ${cls.name}`
+}) => custom((data) => data instanceof cls, params);
+var stringType = ZodString.create;
+var numberType = ZodNumber.create;
+var nanType = ZodNaN.create;
+var bigIntType = ZodBigInt.create;
+var booleanType = ZodBoolean.create;
+var dateType = ZodDate.create;
+var symbolType = ZodSymbol.create;
+var undefinedType = ZodUndefined.create;
+var nullType = ZodNull.create;
+var anyType = ZodAny.create;
+var unknownType = ZodUnknown.create;
+var neverType = ZodNever.create;
+var voidType = ZodVoid.create;
+var arrayType = ZodArray.create;
+var objectType = ZodObject.create;
+var strictObjectType = ZodObject.strictCreate;
+var unionType = ZodUnion.create;
+var discriminatedUnionType = ZodDiscriminatedUnion.create;
+var intersectionType = ZodIntersection.create;
+var tupleType = ZodTuple.create;
+var recordType = ZodRecord.create;
+var mapType = ZodMap.create;
+var setType = ZodSet.create;
+var functionType = ZodFunction.create;
+var lazyType = ZodLazy.create;
+var literalType = ZodLiteral.create;
+var enumType = ZodEnum.create;
+var nativeEnumType = ZodNativeEnum.create;
+var promiseType = ZodPromise.create;
+var effectsType = ZodEffects.create;
+var optionalType = ZodOptional.create;
+var nullableType = ZodNullable.create;
+var preprocessType = ZodEffects.createWithPreprocess;
+var pipelineType = ZodPipeline.create;
+var ostring = () => stringType().optional();
+var onumber = () => numberType().optional();
+var oboolean = () => booleanType().optional();
+var coerce = {
+  string: (arg) => ZodString.create({ ...arg, coerce: true }),
+  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
+  boolean: (arg) => ZodBoolean.create({
+    ...arg,
+    coerce: true
+  }),
+  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
+  date: (arg) => ZodDate.create({ ...arg, coerce: true })
+};
+var NEVER = INVALID;
 // src/db/scenarios.ts
+init_types();
+init_database();
 function nextShortId(projectId) {
   const db2 = getDatabase();
   if (projectId) {
@@ -4527,6 +4722,8 @@ function deleteScenario(id) {
 }
 
 // src/db/runs.ts
+init_types();
+init_database();
 function createRun(input) {
   const db2 = getDatabase();
   const id = uuid();
@@ -4639,6 +4836,8 @@ function updateRun(id, updates) {
 }
 
 // src/db/results.ts
+init_types();
+init_database();
 function createResult(input) {
   const db2 = getDatabase();
   const id = uuid();
@@ -4712,6 +4911,8 @@ function updateResult(id, updates) {
 }
 
 // src/db/screenshots.ts
+init_types();
+init_database();
 function createScreenshot(input) {
   const db2 = getDatabase();
   const id = uuid();
@@ -4734,6 +4935,8 @@ function listScreenshots(resultId) {
 }
 
 // src/db/projects.ts
+init_types();
+init_database();
 function createProject(input) {
   const db2 = getDatabase();
   const id = uuid();
@@ -4766,6 +4969,8 @@ function ensureProject(name, path) {
 }
 
 // src/db/agents.ts
+init_types();
+init_database();
 function registerAgent(input) {
   const db2 = getDatabase();
   const existing = db2.query("SELECT * FROM agents WHERE name = ?").get(input.name);
@@ -4794,6 +4999,7 @@ function listAgents() {
 
 // src/lib/browser.ts
 import { chromium } from "playwright";
+init_types();
 var DEFAULT_VIEWPORT = { width: 1280, height: 720 };
 async function launchBrowser(options) {
   const headless = options?.headless ?? true;
@@ -5013,6 +5219,7 @@ class Screenshotter {
 }
 
 // src/lib/ai-client.ts
+init_types();
 import Anthropic from "@anthropic-ai/sdk";
 function resolveModel(nameOrPreset) {
   if (nameOrPreset in MODEL_MAP) {
@@ -5565,7 +5772,8 @@ async function runAgentLoop(options) {
     screenshotter,
     model,
     runId,
-    maxTurns = 30
+    maxTurns = 30,
+    onStep
   } = options;
   const systemPrompt = [
     "You are an expert QA testing agent. Your job is to thoroughly test web application scenarios.",
@@ -5624,8 +5832,8 @@ async function runAgentLoop(options) {
       }
       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(`
+        const textBlocks2 = response.content.filter((block) => block.type === "text");
+        const textReasoning = textBlocks2.map((b) => b.text).join(`
 `);
         return {
           status: "error",
@@ -5636,10 +5844,22 @@ async function runAgentLoop(options) {
         };
       }
       const toolResults = [];
+      const textBlocks = response.content.filter((block) => block.type === "text");
+      if (textBlocks.length > 0 && onStep) {
+        const thinking = textBlocks.map((b) => b.text).join(`
+`);
+        onStep({ type: "thinking", thinking, stepNumber });
+      }
       for (const toolBlock of toolUseBlocks) {
         stepNumber++;
         const toolInput = toolBlock.input;
+        if (onStep) {
+          onStep({ type: "tool_call", toolName: toolBlock.name, toolInput, stepNumber });
+        }
         const execResult = await executeTool(page, screenshotter, toolBlock.name, toolInput, { runId, scenarioSlug, stepNumber });
+        if (onStep) {
+          onStep({ type: "tool_result", toolName: toolBlock.name, toolResult: execResult.result, stepNumber });
+        }
         if (execResult.screenshot) {
           screenshots.push({
             ...execResult.screenshot,
@@ -5691,6 +5911,7 @@ function createClient(apiKey) {
 }
 
 // src/lib/config.ts
+init_types();
 import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
 import { readFileSync, existsSync as existsSync3 } from "fs";
@@ -5781,7 +6002,20 @@ async function runSingleScenario(scenario, runId, options) {
       screenshotter,
       model,
       runId,
-      maxTurns: 30
+      maxTurns: 30,
+      onStep: (stepEvent) => {
+        emit({
+          type: `step:${stepEvent.type}`,
+          scenarioId: scenario.id,
+          scenarioName: scenario.name,
+          runId,
+          toolName: stepEvent.toolName,
+          toolInput: stepEvent.toolInput,
+          toolResult: stepEvent.toolResult,
+          thinking: stepEvent.thinking,
+          stepNumber: stepEvent.stepNumber
+        });
+      }
     });
     for (const ss of agentResult.screenshots) {
       createScreenshot({
@@ -5834,24 +6068,70 @@ async function runBatch(scenarios, options) {
     projectId: options.projectId
   });
   updateRun(run.id, { status: "running", total: scenarios.length });
+  let sortedScenarios = scenarios;
+  try {
+    const { topologicalSort: topologicalSort2 } = await Promise.resolve().then(() => (init_flows(), exports_flows));
+    const scenarioIds = scenarios.map((s) => s.id);
+    const sortedIds = topologicalSort2(scenarioIds);
+    const scenarioMap = new Map(scenarios.map((s) => [s.id, s]));
+    sortedScenarios = sortedIds.map((id) => scenarioMap.get(id)).filter((s) => s !== undefined);
+    for (const s of scenarios) {
+      if (!sortedIds.includes(s.id))
+        sortedScenarios.push(s);
+    }
+  } catch {}
   const results = [];
+  const failedScenarioIds = new Set;
+  const canRun = async (scenario) => {
+    try {
+      const { getDependencies: getDependencies2 } = await Promise.resolve().then(() => (init_flows(), exports_flows));
+      const deps = getDependencies2(scenario.id);
+      for (const depId of deps) {
+        if (failedScenarioIds.has(depId))
+          return false;
+      }
+    } catch {}
+    return true;
+  };
   if (parallel <= 1) {
-    for (const scenario of scenarios) {
+    for (const scenario of sortedScenarios) {
+      if (!await canRun(scenario)) {
+        const result2 = createResult({ runId: run.id, scenarioId: scenario.id, model, stepsTotal: 0 });
+        const skipped = updateResult(result2.id, { status: "skipped", error: "Skipped: dependency failed" });
+        results.push(skipped);
+        failedScenarioIds.add(scenario.id);
+        emit({ type: "scenario:error", scenarioId: scenario.id, scenarioName: scenario.name, error: "Dependency failed \u2014 skipped", runId: run.id });
+        continue;
+      }
       const result = await runSingleScenario(scenario, run.id, options);
       results.push(result);
+      if (result.status === "failed" || result.status === "error") {
+        failedScenarioIds.add(scenario.id);
+      }
     }
   } else {
-    const queue = [...scenarios];
+    const queue = [...sortedScenarios];
     const running = [];
     const processNext = async () => {
       const scenario = queue.shift();
       if (!scenario)
         return;
+      if (!await canRun(scenario)) {
+        const result2 = createResult({ runId: run.id, scenarioId: scenario.id, model, stepsTotal: 0 });
+        const skipped = updateResult(result2.id, { status: "skipped", error: "Skipped: dependency failed" });
+        results.push(skipped);
+        failedScenarioIds.add(scenario.id);
+        await processNext();
+        return;
+      }
       const result = await runSingleScenario(scenario, run.id, options);
       results.push(result);
+      if (result.status === "failed" || result.status === "error") {
+        failedScenarioIds.add(scenario.id);
+      }
       await processNext();
     };
-    const workers = Math.min(parallel, scenarios.length);
+    const workers = Math.min(parallel, sortedScenarios.length);
     for (let i = 0;i < workers; i++) {
       running.push(processNext());
     }
@@ -5979,6 +6259,7 @@ import { Database as Database2 } from "bun:sqlite";
 import { existsSync as existsSync4 } from "fs";
 import { join as join4 } from "path";
 import { homedir as homedir4 } from "os";
+init_types();
 function resolveTodosDbPath() {
   const envPath = process.env["TODOS_DB_PATH"];
   if (envPath)
@@ -6076,6 +6357,9 @@ function importFromTodos(options = {}) {
 }
 
 // src/db/schedules.ts
+init_database();
+init_types();
+init_database();
 function createSchedule(input) {
   const db2 = getDatabase();
   const id = uuid();
@@ -6202,6 +6486,7 @@ function updateLastRun(id, runId, nextRunAt) {
 }
 
 // src/lib/scheduler.ts
+init_types();
 function parseCronField(field, min, max) {
   const results = new Set;
   const parts = field.split(",");
@@ -6415,6 +6700,7 @@ class Scheduler {
 }
 
 // src/mcp/index.ts
+init_database();
 var server = new McpServer({
   name: "testers",
   version: "0.0.1"