@hasna/testers 0.0.1 → 0.0.2

package/dist/mcp/index.js

@@ -4083,6 +4083,26 @@ function screenshotFromRow(row) {
     timestamp: row.timestamp
   };
 }
+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}`);
@@ -4110,6 +4130,12 @@ class TodosConnectionError extends Error {
     this.name = "TodosConnectionError";
   }
 }
+class ScheduleNotFoundError extends Error {
+  constructor(id) {
+    super(`Schedule not found: ${id}`);
+    this.name = "ScheduleNotFoundError";
+  }
+}
 
 // src/db/database.ts
 import { Database } from "bun:sqlite";
@@ -4239,6 +4265,30 @@ var MIGRATIONS = [
   `
   ALTER TABLE projects ADD COLUMN scenario_prefix TEXT DEFAULT 'TST';
   ALTER TABLE projects ADD COLUMN scenario_counter INTEGER DEFAULT 0;
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS schedules (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    cron_expression TEXT NOT NULL,
+    url TEXT NOT NULL,
+    scenario_filter TEXT NOT NULL DEFAULT '{}',
+    model TEXT,
+    headed INTEGER NOT NULL DEFAULT 0,
+    parallel INTEGER NOT NULL DEFAULT 1,
+    timeout_ms INTEGER,
+    enabled INTEGER NOT NULL DEFAULT 1,
+    last_run_id TEXT REFERENCES runs(id) ON DELETE SET NULL,
+    last_run_at TEXT,
+    next_run_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_schedules_project ON schedules(project_id);
+  CREATE INDEX IF NOT EXISTS idx_schedules_enabled ON schedules(enabled);
+  CREATE INDEX IF NOT EXISTS idx_schedules_next_run ON schedules(next_run_at);
   `
 ];
 function applyMigrations(database) {
@@ -5016,6 +5066,127 @@ var BROWSER_TOOLS = [
       required: ["text"]
     }
   },
+  {
+    name: "scroll",
+    description: "Scroll the page up or down by a given amount of pixels.",
+    input_schema: {
+      type: "object",
+      properties: {
+        direction: {
+          type: "string",
+          enum: ["up", "down"],
+          description: "Direction to scroll."
+        },
+        amount: {
+          type: "number",
+          description: "Number of pixels to scroll (default: 500)."
+        }
+      },
+      required: ["direction"]
+    }
+  },
+  {
+    name: "get_page_html",
+    description: "Get simplified HTML of the page body content, truncated to 8000 characters.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "get_elements",
+    description: "List elements matching a CSS selector with their text, tag name, and key attributes (max 20 results).",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector to match elements."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "wait_for_navigation",
+    description: "Wait for page navigation/load to complete (network idle).",
+    input_schema: {
+      type: "object",
+      properties: {
+        timeout: {
+          type: "number",
+          description: "Maximum time to wait in milliseconds (default: 10000)."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get_page_title",
+    description: "Get the document title of the current page.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "count_elements",
+    description: "Count the number of elements matching a CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector to count matching elements."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "hover",
+    description: "Hover over an element matching the given CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the element to hover over."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "check",
+    description: "Check a checkbox matching the given CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the checkbox to check."
+        }
+      },
+      required: ["selector"]
+    }
+  },
+  {
+    name: "uncheck",
+    description: "Uncheck a checkbox matching the given CSS selector.",
+    input_schema: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector of the checkbox to uncheck."
+        }
+      },
+      required: ["selector"]
+    }
+  },
   {
     name: "report_result",
     description: "Report the final test result. Call this when you have completed testing the scenario. This MUST be the last tool you call.",
@@ -5147,6 +5318,113 @@ async function executeTool(page, screenshotter, toolName, toolInput, context) {
           return { result: "false" };
         }
       }
+      case "scroll": {
+        const direction = toolInput.direction;
+        const amount = typeof toolInput.amount === "number" ? toolInput.amount : 500;
+        const scrollY = direction === "down" ? amount : -amount;
+        await page.evaluate((y) => window.scrollBy(0, y), scrollY);
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "scroll"
+        });
+        return {
+          result: `Scrolled ${direction} by ${amount}px`,
+          screenshot
+        };
+      }
+      case "get_page_html": {
+        const html = await page.evaluate(() => document.body.innerHTML);
+        const truncated = html.length > 8000 ? html.slice(0, 8000) + "..." : html;
+        return {
+          result: truncated
+        };
+      }
+      case "get_elements": {
+        const selector = toolInput.selector;
+        const allElements = await page.locator(selector).all();
+        const elements = allElements.slice(0, 20);
+        const results = [];
+        for (let i = 0;i < elements.length; i++) {
+          const el = elements[i];
+          const tagName = await el.evaluate((e) => e.tagName.toLowerCase());
+          const textContent = await el.textContent() ?? "";
+          const trimmedText = textContent.trim().slice(0, 100);
+          const id = await el.getAttribute("id");
+          const className = await el.getAttribute("class");
+          const href = await el.getAttribute("href");
+          const type = await el.getAttribute("type");
+          const placeholder = await el.getAttribute("placeholder");
+          const ariaLabel = await el.getAttribute("aria-label");
+          const attrs = [];
+          if (id)
+            attrs.push(`id="${id}"`);
+          if (className)
+            attrs.push(`class="${className}"`);
+          if (href)
+            attrs.push(`href="${href}"`);
+          if (type)
+            attrs.push(`type="${type}"`);
+          if (placeholder)
+            attrs.push(`placeholder="${placeholder}"`);
+          if (ariaLabel)
+            attrs.push(`aria-label="${ariaLabel}"`);
+          results.push(`[${i}] <${tagName}${attrs.length ? " " + attrs.join(" ") : ""}> ${trimmedText}`);
+        }
+        return {
+          result: results.length > 0 ? results.join(`
+`) : `No elements found matching "${selector}"`
+        };
+      }
+      case "wait_for_navigation": {
+        const timeout = typeof toolInput.timeout === "number" ? toolInput.timeout : 1e4;
+        await page.waitForLoadState("networkidle", { timeout });
+        return {
+          result: "Navigation/load completed"
+        };
+      }
+      case "get_page_title": {
+        const title = await page.title();
+        return {
+          result: title || "(no title)"
+        };
+      }
+      case "count_elements": {
+        const selector = toolInput.selector;
+        const count = await page.locator(selector).count();
+        return {
+          result: `${count} element(s) matching "${selector}"`
+        };
+      }
+      case "hover": {
+        const selector = toolInput.selector;
+        await page.hover(selector);
+        const screenshot = await screenshotter.capture(page, {
+          runId: context.runId,
+          scenarioSlug: context.scenarioSlug,
+          stepNumber: context.stepNumber,
+          action: "hover"
+        });
+        return {
+          result: `Hovered over: ${selector}`,
+          screenshot
+        };
+      }
+      case "check": {
+        const selector = toolInput.selector;
+        await page.check(selector);
+        return {
+          result: `Checked checkbox: ${selector}`
+        };
+      }
+      case "uncheck": {
+        const selector = toolInput.selector;
+        await page.uncheck(selector);
+        return {
+          result: `Unchecked checkbox: ${selector}`
+        };
+      }
       case "report_result": {
         const status = toolInput.status;
         const reasoning = toolInput.reasoning;
@@ -5173,13 +5451,26 @@ async function runAgentLoop(options) {
     maxTurns = 30
   } = options;
   const systemPrompt = [
-    "You are a QA testing agent. Test the following scenario by interacting with the browser.",
-    "Use the provided tools to navigate, click, fill forms, and verify results.",
-    "When done, call report_result with your findings.",
-    "Be methodical: navigate to the target page first, then follow the test steps.",
-    "If a step fails, try reasonable alternatives before reporting failure.",
-    "Always report a final result \u2014 never leave a test incomplete."
-  ].join(" ");
+    "You are an expert QA testing agent. Your job is to thoroughly test web application scenarios.",
+    "You have browser tools to navigate, interact with, and inspect web pages.",
+    "",
+    "Strategy:",
+    "1. First navigate to the target page and take a screenshot to understand the layout",
+    "2. If you can't find an element, use get_elements or get_page_html to discover selectors",
+    "3. Use scroll to discover content below the fold",
+    "4. Use wait_for or wait_for_navigation after actions that trigger page loads",
+    "5. Take screenshots after every meaningful state change",
+    "6. Use assert_text and assert_visible to verify expected outcomes",
+    "7. When done testing, call report_result with detailed pass/fail reasoning",
+    "",
+    "Tips:",
+    "- Try multiple selector strategies: by text, by role, by class, by id",
+    "- If a click triggers navigation, use wait_for_navigation after",
+    "- For forms, fill all fields before submitting",
+    "- Check for error messages after form submissions",
+    "- Verify both positive and negative states"
+  ].join(`
+`);
   const userParts = [
     `**Scenario:** ${scenario.name}`,
     `**Description:** ${scenario.description}`
@@ -5591,6 +5882,345 @@ function importFromTodos(options = {}) {
   return { imported, skipped };
 }
 
+// src/db/schedules.ts
+function createSchedule(input) {
+  const db2 = getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  db2.query(`
+    INSERT INTO schedules (id, project_id, name, cron_expression, url, scenario_filter, model, headed, parallel, timeout_ms, enabled, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+  `).run(id, input.projectId ?? null, input.name, input.cronExpression, input.url, JSON.stringify(input.scenarioFilter ?? {}), input.model ?? null, input.headed ? 1 : 0, input.parallel ?? 1, input.timeoutMs ?? null, timestamp, timestamp);
+  return getSchedule(id);
+}
+function getSchedule(id) {
+  const db2 = getDatabase();
+  let row = db2.query("SELECT * FROM schedules WHERE id = ?").get(id);
+  if (row)
+    return scheduleFromRow(row);
+  const fullId = resolvePartialId("schedules", id);
+  if (fullId) {
+    row = db2.query("SELECT * FROM schedules WHERE id = ?").get(fullId);
+    if (row)
+      return scheduleFromRow(row);
+  }
+  return null;
+}
+function listSchedules(filter) {
+  const db2 = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.projectId) {
+    conditions.push("project_id = ?");
+    params.push(filter.projectId);
+  }
+  if (filter?.enabled !== undefined) {
+    conditions.push("enabled = ?");
+    params.push(filter.enabled ? 1 : 0);
+  }
+  let sql = "SELECT * FROM schedules";
+  if (conditions.length > 0) {
+    sql += " WHERE " + conditions.join(" AND ");
+  }
+  sql += " ORDER BY created_at DESC";
+  if (filter?.limit) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
+  }
+  if (filter?.offset) {
+    sql += " OFFSET ?";
+    params.push(filter.offset);
+  }
+  const rows = db2.query(sql).all(...params);
+  return rows.map(scheduleFromRow);
+}
+function updateSchedule(id, input) {
+  const db2 = getDatabase();
+  const existing = getSchedule(id);
+  if (!existing) {
+    throw new ScheduleNotFoundError(id);
+  }
+  const sets = [];
+  const params = [];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.cronExpression !== undefined) {
+    sets.push("cron_expression = ?");
+    params.push(input.cronExpression);
+  }
+  if (input.url !== undefined) {
+    sets.push("url = ?");
+    params.push(input.url);
+  }
+  if (input.scenarioFilter !== undefined) {
+    sets.push("scenario_filter = ?");
+    params.push(JSON.stringify(input.scenarioFilter));
+  }
+  if (input.model !== undefined) {
+    sets.push("model = ?");
+    params.push(input.model);
+  }
+  if (input.headed !== undefined) {
+    sets.push("headed = ?");
+    params.push(input.headed ? 1 : 0);
+  }
+  if (input.parallel !== undefined) {
+    sets.push("parallel = ?");
+    params.push(input.parallel);
+  }
+  if (input.timeoutMs !== undefined) {
+    sets.push("timeout_ms = ?");
+    params.push(input.timeoutMs);
+  }
+  if (input.enabled !== undefined) {
+    sets.push("enabled = ?");
+    params.push(input.enabled ? 1 : 0);
+  }
+  if (sets.length === 0) {
+    return existing;
+  }
+  sets.push("updated_at = ?");
+  params.push(now());
+  params.push(existing.id);
+  db2.query(`UPDATE schedules SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  return getSchedule(existing.id);
+}
+function deleteSchedule(id) {
+  const db2 = getDatabase();
+  const schedule = getSchedule(id);
+  if (!schedule)
+    return false;
+  const result = db2.query("DELETE FROM schedules WHERE id = ?").run(schedule.id);
+  return result.changes > 0;
+}
+function getEnabledSchedules() {
+  const db2 = getDatabase();
+  const rows = db2.query("SELECT * FROM schedules WHERE enabled = 1 ORDER BY created_at DESC").all();
+  return rows.map(scheduleFromRow);
+}
+function updateLastRun(id, runId, nextRunAt) {
+  const db2 = getDatabase();
+  const timestamp = now();
+  db2.query(`
+    UPDATE schedules SET last_run_id = ?, last_run_at = ?, next_run_at = ?, updated_at = ? WHERE id = ?
+  `).run(runId, timestamp, nextRunAt, timestamp, id);
+}
+
+// src/lib/scheduler.ts
+function parseCronField(field, min, max) {
+  const results = new Set;
+  const parts = field.split(",");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (trimmed.includes("/")) {
+      const slashParts = trimmed.split("/");
+      const rangePart = slashParts[0] ?? "*";
+      const stepStr = slashParts[1] ?? "1";
+      const step = parseInt(stepStr, 10);
+      if (isNaN(step) || step <= 0) {
+        throw new Error(`Invalid step value in cron field: ${field}`);
+      }
+      let start;
+      let end;
+      if (rangePart === "*") {
+        start = min;
+        end = max;
+      } else if (rangePart.includes("-")) {
+        const dashParts = rangePart.split("-");
+        start = parseInt(dashParts[0] ?? "0", 10);
+        end = parseInt(dashParts[1] ?? "0", 10);
+      } else {
+        start = parseInt(rangePart, 10);
+        end = max;
+      }
+      for (let i = start;i <= end; i += step) {
+        if (i >= min && i <= max)
+          results.add(i);
+      }
+    } else if (trimmed === "*") {
+      for (let i = min;i <= max; i++) {
+        results.add(i);
+      }
+    } else if (trimmed.includes("-")) {
+      const dashParts = trimmed.split("-");
+      const lo = parseInt(dashParts[0] ?? "0", 10);
+      const hi = parseInt(dashParts[1] ?? "0", 10);
+      if (isNaN(lo) || isNaN(hi)) {
+        throw new Error(`Invalid range in cron field: ${field}`);
+      }
+      for (let i = lo;i <= hi; i++) {
+        if (i >= min && i <= max)
+          results.add(i);
+      }
+    } else {
+      const val = parseInt(trimmed, 10);
+      if (isNaN(val)) {
+        throw new Error(`Invalid value in cron field: ${field}`);
+      }
+      if (val >= min && val <= max)
+        results.add(val);
+    }
+  }
+  return Array.from(results).sort((a, b) => a - b);
+}
+function parseCron(expression) {
+  const fields = expression.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(`Invalid cron expression "${expression}": expected 5 fields, got ${fields.length}`);
+  }
+  return {
+    minutes: parseCronField(fields[0], 0, 59),
+    hours: parseCronField(fields[1], 0, 23),
+    daysOfMonth: parseCronField(fields[2], 1, 31),
+    months: parseCronField(fields[3], 1, 12),
+    daysOfWeek: parseCronField(fields[4], 0, 6)
+  };
+}
+function shouldRunAt(cronExpression, date) {
+  const cron = parseCron(cronExpression);
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dayOfMonth = date.getDate();
+  const month = date.getMonth() + 1;
+  const dayOfWeek = date.getDay();
+  return cron.minutes.includes(minute) && cron.hours.includes(hour) && cron.daysOfMonth.includes(dayOfMonth) && cron.months.includes(month) && cron.daysOfWeek.includes(dayOfWeek);
+}
+function getNextRunTime(cronExpression, after) {
+  parseCron(cronExpression);
+  const start = after ? new Date(after.getTime()) : new Date;
+  start.setSeconds(0, 0);
+  start.setMinutes(start.getMinutes() + 1);
+  const maxDate = new Date(start.getTime() + 366 * 24 * 60 * 60 * 1000);
+  const cursor = new Date(start.getTime());
+  while (cursor.getTime() <= maxDate.getTime()) {
+    if (shouldRunAt(cronExpression, cursor)) {
+      return cursor;
+    }
+    cursor.setMinutes(cursor.getMinutes() + 1);
+  }
+  throw new Error(`No matching time found for cron expression "${cronExpression}" within 366 days`);
+}
+
+class Scheduler {
+  interval = null;
+  running = new Set;
+  checkIntervalMs;
+  onEvent;
+  constructor(options) {
+    this.checkIntervalMs = options?.checkIntervalMs ?? 60000;
+    this.onEvent = options?.onEvent;
+  }
+  start() {
+    if (this.interval)
+      return;
+    this.tick().catch(() => {});
+    this.interval = setInterval(() => {
+      this.tick().catch(() => {});
+    }, this.checkIntervalMs);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+  async tick() {
+    const now2 = new Date;
+    now2.setSeconds(0, 0);
+    const schedules = getEnabledSchedules();
+    for (const schedule of schedules) {
+      if (this.running.has(schedule.id))
+        continue;
+      if (shouldRunAt(schedule.cronExpression, now2)) {
+        this.running.add(schedule.id);
+        this.emit({
+          type: "schedule:triggered",
+          scheduleId: schedule.id,
+          scheduleName: schedule.name,
+          timestamp: new Date().toISOString()
+        });
+        this.executeSchedule(schedule).then(({ runId }) => {
+          const nextRun = getNextRunTime(schedule.cronExpression, new Date);
+          updateLastRun(schedule.id, runId, nextRun.toISOString());
+          this.emit({
+            type: "schedule:completed",
+            scheduleId: schedule.id,
+            scheduleName: schedule.name,
+            runId,
+            timestamp: new Date().toISOString()
+          });
+        }).catch((err) => {
+          this.emit({
+            type: "schedule:failed",
+            scheduleId: schedule.id,
+            scheduleName: schedule.name,
+            error: err instanceof Error ? err.message : String(err),
+            timestamp: new Date().toISOString()
+          });
+        }).finally(() => {
+          this.running.delete(schedule.id);
+        });
+      }
+    }
+  }
+  async runScheduleNow(scheduleId) {
+    const schedule = getSchedule(scheduleId);
+    if (!schedule) {
+      throw new ScheduleNotFoundError(scheduleId);
+    }
+    this.running.add(schedule.id);
+    this.emit({
+      type: "schedule:triggered",
+      scheduleId: schedule.id,
+      scheduleName: schedule.name,
+      timestamp: new Date().toISOString()
+    });
+    try {
+      const { runId } = await this.executeSchedule(schedule);
+      const nextRun = getNextRunTime(schedule.cronExpression, new Date);
+      updateLastRun(schedule.id, runId, nextRun.toISOString());
+      this.emit({
+        type: "schedule:completed",
+        scheduleId: schedule.id,
+        scheduleName: schedule.name,
+        runId,
+        timestamp: new Date().toISOString()
+      });
+    } catch (err) {
+      this.emit({
+        type: "schedule:failed",
+        scheduleId: schedule.id,
+        scheduleName: schedule.name,
+        error: err instanceof Error ? err.message : String(err),
+        timestamp: new Date().toISOString()
+      });
+      throw err;
+    } finally {
+      this.running.delete(schedule.id);
+    }
+  }
+  async executeSchedule(schedule) {
+    const { run } = await runByFilter({
+      url: schedule.url,
+      model: schedule.model ?? undefined,
+      headed: schedule.headed,
+      parallel: schedule.parallel,
+      timeout: schedule.timeoutMs ?? undefined,
+      tags: schedule.scenarioFilter.tags,
+      priority: schedule.scenarioFilter.priority,
+      scenarioIds: schedule.scenarioFilter.scenarioIds
+    });
+    return { runId: run.id };
+  }
+  emit(event) {
+    if (this.onEvent) {
+      this.onEvent(event);
+    }
+  }
+}
+
 // src/mcp/index.ts
 var server = new McpServer({
   name: "testers-mcp",
@@ -5893,6 +6523,70 @@ server.tool("get_status", "Get system status: DB path, API key, scenario and run
     return { content: [{ type: "text", text: `${e.name}: ${e.message}` }], isError: true };
   }
 });
+server.tool("create_schedule", {
+  name: exports_external.string().describe("Schedule name"),
+  cronExpression: exports_external.string().describe("Cron expression (5-field)"),
+  url: exports_external.string().describe("Target URL to test"),
+  tags: exports_external.array(exports_external.string()).optional().describe("Filter scenarios by tags"),
+  priority: exports_external.string().optional().describe("Filter scenarios by priority"),
+  model: exports_external.string().optional().describe("AI model"),
+  headed: exports_external.boolean().optional().describe("Run headed"),
+  parallel: exports_external.number().optional().describe("Parallel count"),
+  projectId: exports_external.string().optional().describe("Project ID")
+}, async (params) => {
+  try {
+    const schedule = createSchedule({
+      name: params.name,
+      cronExpression: params.cronExpression,
+      url: params.url,
+      scenarioFilter: { tags: params.tags, priority: params.priority },
+      model: params.model,
+      headed: params.headed,
+      parallel: params.parallel,
+      projectId: params.projectId
+    });
+    const nextRun = getNextRunTime(schedule.cronExpression);
+    return { content: [{ type: "text", text: `Schedule created: ${schedule.id.slice(0, 8)} | ${schedule.name} | cron: ${schedule.cronExpression} | next: ${nextRun.toISOString()}` }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
+  }
+});
+server.tool("list_schedules", {
+  projectId: exports_external.string().optional(),
+  enabled: exports_external.boolean().optional(),
+  limit: exports_external.number().optional()
+}, async (params) => {
+  const schedules = listSchedules({ projectId: params.projectId, enabled: params.enabled, limit: params.limit });
+  if (schedules.length === 0)
+    return { content: [{ type: "text", text: "No schedules found." }] };
+  const lines = schedules.map((s) => `${s.id.slice(0, 8)} | ${s.name} | ${s.cronExpression} | ${s.url} | ${s.enabled ? "enabled" : "disabled"} | next: ${s.nextRunAt ?? "N/A"}`);
+  return { content: [{ type: "text", text: lines.join(`
+`) }] };
+});
+server.tool("enable_schedule", { id: exports_external.string().describe("Schedule ID") }, async (params) => {
+  try {
+    const schedule = updateSchedule(params.id, { enabled: true });
+    return { content: [{ type: "text", text: `Schedule ${schedule.name} enabled.` }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
+  }
+});
+server.tool("disable_schedule", { id: exports_external.string().describe("Schedule ID") }, async (params) => {
+  try {
+    const schedule = updateSchedule(params.id, { enabled: false });
+    return { content: [{ type: "text", text: `Schedule ${schedule.name} disabled.` }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
+  }
+});
+server.tool("delete_schedule", { id: exports_external.string().describe("Schedule ID") }, async (params) => {
+  try {
+    const deleted = deleteSchedule(params.id);
+    return { content: [{ type: "text", text: deleted ? "Schedule deleted." : "Schedule not found." }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
+  }
+});
 async function main() {
   const transport = new StdioServerTransport;
   await server.connect(transport);