@hasna/testers 0.0.12 → 0.0.13

package/dist/mcp/index.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env bun
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -5212,6 +5216,22 @@ function listAgents() {
   const rows = db2.query("SELECT * FROM agents ORDER BY created_at DESC").all();
   return rows.map(agentFromRow);
 }
+function heartbeatAgent(id) {
+  const db2 = getDatabase();
+  const affected = db2.query("UPDATE agents SET last_seen_at = ? WHERE id = ?").run(now(), id);
+  if (affected.changes === 0)
+    return null;
+  return getAgent(id);
+}
+function setAgentFocus(id, scenarioId) {
+  const db2 = getDatabase();
+  const agent = getAgent(id);
+  if (!agent)
+    return null;
+  const metadata = { ...agent.metadata ?? {}, focus: scenarioId };
+  db2.query("UPDATE agents SET metadata = ?, last_seen_at = ? WHERE id = ?").run(JSON.stringify(metadata), now(), id);
+  return getAgent(id);
+}
 
 // src/lib/browser.ts
 import { chromium as chromium2 } from "playwright";
@@ -6329,6 +6349,199 @@ async function pushFailedRunToLogs(run, failedResults, scenarios) {
   } catch {}
 }
 
+// src/lib/todos-connector.ts
+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)
+    return envPath;
+  return join4(homedir4(), ".todos", "todos.db");
+}
+function connectToTodos() {
+  const dbPath = resolveTodosDbPath();
+  if (!existsSync4(dbPath)) {
+    throw new TodosConnectionError(`Todos database not found at ${dbPath}. Install @hasna/todos or set TODOS_DB_PATH.`);
+  }
+  const db2 = new Database2(dbPath, { readonly: true });
+  db2.exec("PRAGMA foreign_keys = ON");
+  return db2;
+}
+function pullTasks(options = {}) {
+  const db2 = connectToTodos();
+  try {
+    let query = "SELECT id, short_id, title, description, status, priority, tags, project_id FROM tasks WHERE 1=1";
+    const params = [];
+    if (options.status) {
+      query += " AND status = ?";
+      params.push(options.status);
+    } else {
+      query += " AND status IN ('pending', 'in_progress')";
+    }
+    if (options.priority) {
+      query += " AND priority = ?";
+      params.push(options.priority);
+    }
+    if (options.projectName) {
+      const project = db2.query("SELECT id FROM projects WHERE name = ?").get(options.projectName);
+      if (project) {
+        query += " AND project_id = ?";
+        params.push(project.id);
+      }
+    }
+    query += " ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END";
+    const tasks = db2.query(query).all(...params);
+    if (options.tags && options.tags.length > 0) {
+      return tasks.filter((task) => {
+        const taskTags = JSON.parse(task.tags || "[]");
+        return options.tags.some((tag) => taskTags.includes(tag));
+      });
+    }
+    return tasks;
+  } finally {
+    db2.close();
+  }
+}
+function taskToScenarioInput(task, projectId) {
+  const tags = JSON.parse(task.tags || "[]");
+  const priority = ["low", "medium", "high", "critical"].includes(task.priority) ? task.priority : "medium";
+  const steps = [];
+  if (task.description) {
+    const lines = task.description.split(`
+`);
+    for (const line of lines) {
+      const match = line.match(/^\s*\d+[\.\)]\s*(.+)/);
+      if (match?.[1]) {
+        steps.push(match[1].trim());
+      }
+    }
+  }
+  return {
+    name: task.title.replace(/^(OPE\d+-\d+|[A-Z]+-\d+):\s*/, ""),
+    description: task.description || task.title,
+    steps,
+    tags,
+    priority,
+    projectId,
+    metadata: { todosTaskId: task.id, todosShortId: task.short_id }
+  };
+}
+function importFromTodos(options = {}) {
+  const tasks = pullTasks({
+    projectName: options.projectName,
+    tags: options.tags ?? ["qa", "test", "testing"],
+    priority: options.priority
+  });
+  const existing = listScenarios({ projectId: options.projectId });
+  const existingTodoIds = new Set(existing.filter((s) => s.metadata?.todosTaskId).map((s) => s.metadata.todosTaskId));
+  let imported = 0;
+  let skipped = 0;
+  for (const task of tasks) {
+    if (existingTodoIds.has(task.id)) {
+      skipped++;
+      continue;
+    }
+    const input = taskToScenarioInput(task, options.projectId);
+    createScenario(input);
+    imported++;
+  }
+  return { imported, skipped };
+}
+
+// src/lib/failure-pipeline.ts
+async function createFailureTasks(run, failedResults, scenarios) {
+  if (failedResults.length === 0)
+    return { created: 0, skipped: 0 };
+  const projectId = process.env["TESTERS_TODOS_PROJECT_ID"];
+  if (!projectId)
+    return { created: 0, skipped: 0 };
+  let db2 = null;
+  try {
+    db2 = connectToTodos();
+  } catch {
+    return { created: 0, skipped: 0 };
+  }
+  const scenarioMap = new Map(scenarios.map((s) => [s.id, s]));
+  let created = 0;
+  let skipped = 0;
+  try {
+    for (const result of failedResults) {
+      const scenario = scenarioMap.get(result.scenarioId);
+      const title = `BUG: [testers] ${scenario?.name ?? result.scenarioId} failed`;
+      const existing = db2.query("SELECT id FROM tasks WHERE title = ? AND status NOT IN ('completed', 'cancelled') LIMIT 1").get(title);
+      if (existing) {
+        skipped++;
+        continue;
+      }
+      const id = crypto.randomUUID();
+      const now2 = new Date().toISOString();
+      const description = [
+        `Test failure detected by open-testers.`,
+        ``,
+        `**Run:** ${run.id}`,
+        `**URL:** ${run.url}`,
+        `**Scenario:** ${scenario?.name ?? result.scenarioId}`,
+        `**Status:** ${result.status}`,
+        result.error ? `**Error:** ${result.error}` : null,
+        result.reasoning ? `**Reasoning:** ${result.reasoning.slice(0, 500)}` : null,
+        `**Duration:** ${result.durationMs ? `${(result.durationMs / 1000).toFixed(1)}s` : "N/A"}`,
+        `**Tokens:** ${result.tokensUsed ?? 0}`
+      ].filter(Boolean).join(`
+`);
+      try {
+        db2.query(`
+          INSERT INTO tasks (id, short_id, title, description, status, priority, tags, project_id, version, created_at, updated_at)
+          VALUES (?, ?, ?, ?, 'pending', 'high', ?, ?, 1, ?, ?)
+        `).run(id, `BUG-${id.slice(0, 6)}`, title, description, JSON.stringify(["bug", "testers", "auto-created"]), projectId, now2, now2);
+        created++;
+      } catch {
+        skipped++;
+      }
+    }
+  } finally {
+    db2.close();
+  }
+  return { created, skipped };
+}
+async function notifyFailureToConversations(run, failedResults, scenarios) {
+  const baseUrl = process.env["TESTERS_CONVERSATIONS_URL"];
+  const space = process.env["TESTERS_CONVERSATIONS_SPACE"];
+  if (!baseUrl || !space)
+    return;
+  const scenarioMap = new Map(scenarios.map((s) => [s.id, s]));
+  const total = run.total;
+  const failedCount = failedResults.length;
+  const passedCount = run.passed;
+  const failureLines = failedResults.slice(0, 5).map((r) => {
+    const name = scenarioMap.get(r.scenarioId)?.name ?? r.scenarioId;
+    const err = r.error ? ` \u2014 ${r.error.slice(0, 120)}` : "";
+    return `  \u274C ${name}${err}`;
+  });
+  const extra = failedResults.length > 5 ? `  \u2026 and ${failedResults.length - 5} more` : "";
+  const message = [
+    `\uD83D\uDEA8 **Testers run failed** \u2014 ${failedCount}/${total} scenarios failed`,
+    ``,
+    `**URL:** ${run.url}`,
+    `**Run ID:** \`${run.id}\``,
+    `**Pass rate:** ${passedCount}/${total}`,
+    ``,
+    `**Failures:**`,
+    ...failureLines,
+    extra
+  ].filter((l) => l !== "").join(`
+`);
+  try {
+    await fetch(`${baseUrl.replace(/\/$/, "")}/api/spaces/${encodeURIComponent(space)}/messages`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content: message, from: "testers" })
+    });
+  } catch {}
+}
+
 // src/lib/runner.ts
 var eventHandler = null;
 function emit(event) {
@@ -6562,6 +6775,8 @@ async function runBatch(scenarios, options) {
   if (finalRun.status === "failed") {
     const failedResults = results.filter((r) => r.status === "failed" || r.status === "error");
     pushFailedRunToLogs(finalRun, failedResults, scenarios).catch(() => {});
+    createFailureTasks(finalRun, failedResults, scenarios).catch(() => {});
+    notifyFailureToConversations(finalRun, failedResults, scenarios).catch(() => {});
   }
   return { run: finalRun, results };
 }
@@ -6675,106 +6890,54 @@ function estimateCost(model, tokens) {
   return tokens / 1e6 * costPer1M * 100;
 }
 
-// src/lib/todos-connector.ts
-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)
-    return envPath;
-  return join4(homedir4(), ".todos", "todos.db");
-}
-function connectToTodos() {
-  const dbPath = resolveTodosDbPath();
-  if (!existsSync4(dbPath)) {
-    throw new TodosConnectionError(`Todos database not found at ${dbPath}. Install @hasna/todos or set TODOS_DB_PATH.`);
-  }
-  const db2 = new Database2(dbPath, { readonly: true });
-  db2.exec("PRAGMA foreign_keys = ON");
-  return db2;
-}
-function pullTasks(options = {}) {
-  const db2 = connectToTodos();
-  try {
-    let query = "SELECT id, short_id, title, description, status, priority, tags, project_id FROM tasks WHERE 1=1";
-    const params = [];
-    if (options.status) {
-      query += " AND status = ?";
-      params.push(options.status);
-    } else {
-      query += " AND status IN ('pending', 'in_progress')";
-    }
-    if (options.priority) {
-      query += " AND priority = ?";
-      params.push(options.priority);
-    }
-    if (options.projectName) {
-      const project = db2.query("SELECT id FROM projects WHERE name = ?").get(options.projectName);
-      if (project) {
-        query += " AND project_id = ?";
-        params.push(project.id);
+// src/lib/affected.ts
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\x00DS\x00").replace(/\*/g, "[^/]*").replace(/\x00DS\x00/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function matchFilesToScenarios(filePaths, scenarios, mappings = []) {
+  if (filePaths.length === 0)
+    return scenarios;
+  const compiledMappings = mappings.map((m) => ({
+    regex: globToRegex(m.glob),
+    tags: m.tags
+  }));
+  const normPaths = filePaths.map((p) => p.replace(/\\/g, "/").toLowerCase());
+  const matchedIds = new Set;
+  for (const scenario of scenarios) {
+    let matched = false;
+    if (!matched) {
+      for (const { regex, tags } of compiledMappings) {
+        if (normPaths.some((fp) => regex.test(fp)) && tags.some((tag) => scenario.tags.includes(tag))) {
+          matched = true;
+          break;
+        }
       }
     }
-    query += " ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END";
-    const tasks = db2.query(query).all(...params);
-    if (options.tags && options.tags.length > 0) {
-      return tasks.filter((task) => {
-        const taskTags = JSON.parse(task.tags || "[]");
-        return options.tags.some((tag) => taskTags.includes(tag));
-      });
+    if (!matched && scenario.targetPath) {
+      const segments = scenario.targetPath.replace(/^\//, "").split("/").filter((s) => s.length > 2);
+      if (segments.some((seg) => normPaths.some((fp) => fp.includes(seg.toLowerCase())))) {
+        matched = true;
+      }
     }
-    return tasks;
-  } finally {
-    db2.close();
-  }
-}
-function taskToScenarioInput(task, projectId) {
-  const tags = JSON.parse(task.tags || "[]");
-  const priority = ["low", "medium", "high", "critical"].includes(task.priority) ? task.priority : "medium";
-  const steps = [];
-  if (task.description) {
-    const lines = task.description.split(`
-`);
-    for (const line of lines) {
-      const match = line.match(/^\s*\d+[\.\)]\s*(.+)/);
-      if (match?.[1]) {
-        steps.push(match[1].trim());
+    if (!matched) {
+      for (const tag of scenario.tags) {
+        if (tag.length > 2 && normPaths.some((fp) => fp.includes(tag.toLowerCase()))) {
+          matched = true;
+          break;
+        }
       }
     }
-  }
-  return {
-    name: task.title.replace(/^(OPE\d+-\d+|[A-Z]+-\d+):\s*/, ""),
-    description: task.description || task.title,
-    steps,
-    tags,
-    priority,
-    projectId,
-    metadata: { todosTaskId: task.id, todosShortId: task.short_id }
-  };
-}
-function importFromTodos(options = {}) {
-  const tasks = pullTasks({
-    projectName: options.projectName,
-    tags: options.tags ?? ["qa", "test", "testing"],
-    priority: options.priority
-  });
-  const existing = listScenarios({ projectId: options.projectId });
-  const existingTodoIds = new Set(existing.filter((s) => s.metadata?.todosTaskId).map((s) => s.metadata.todosTaskId));
-  let imported = 0;
-  let skipped = 0;
-  for (const task of tasks) {
-    if (existingTodoIds.has(task.id)) {
-      skipped++;
-      continue;
+    if (!matched) {
+      const nameWords = scenario.name.toLowerCase().split(/[\s\-_/]+/).filter((w) => w.length > 3);
+      if (nameWords.some((word) => normPaths.some((fp) => fp.includes(word)))) {
+        matched = true;
+      }
     }
-    const input = taskToScenarioInput(task, options.projectId);
-    createScenario(input);
-    imported++;
+    if (matched)
+      matchedIds.add(scenario.id);
   }
-  return { imported, skipped };
+  return scenarios.filter((s) => matchedIds.has(s.id));
 }
 
 // src/db/schedules.ts
@@ -7640,6 +7803,63 @@ server.tool("get_stale_scenarios", "List scenarios that have not been run recent
     return errorResponse(error);
   }
 });
+server.tool("run_affected_scenarios", "Run only the scenarios relevant to a set of changed files. Matches files to scenarios via explicit glob\u2192tag rules, targetPath keywords, and name/tag inference. Returns immediately \u2014 poll with get_run.", {
+  url: exports_external.string().describe("Target URL to test against"),
+  filePaths: exports_external.array(exports_external.string()).describe("Changed file paths (relative or absolute)"),
+  mappings: exports_external.array(exports_external.object({
+    glob: exports_external.string().describe("File glob pattern (supports * and **)"),
+    tags: exports_external.array(exports_external.string()).describe("Run scenarios tagged with these if glob matches")
+  })).optional().describe("Explicit file glob \u2192 scenario tag mappings"),
+  projectId: exports_external.string().optional().describe("Restrict to scenarios in this project"),
+  model: exports_external.string().optional().describe(MODEL_DESC),
+  headed: exports_external.boolean().optional().describe("Run browser in headed mode"),
+  parallel: exports_external.number().optional().describe("Number of parallel workers")
+}, async ({ url, filePaths, mappings, projectId, model, headed, parallel }) => {
+  try {
+    const allScenarios = listScenarios({ projectId });
+    const matched = matchFilesToScenarios(filePaths, allScenarios, mappings ?? []);
+    if (matched.length === 0) {
+      return json({ runId: null, scenarioCount: 0, matchedScenarios: [], message: "No scenarios matched the provided file paths." });
+    }
+    const scenarioIds = matched.map((s) => s.id);
+    const { runId, scenarioCount } = startRunAsync({ url, scenarioIds, model, headed, parallel, projectId });
+    return json({
+      runId,
+      scenarioCount,
+      url,
+      status: "running",
+      matchedScenarios: matched.map((s) => ({ id: s.id, shortId: s.shortId, name: s.name, tags: s.tags })),
+      message: "Poll with get_run to check progress."
+    });
+  } catch (error) {
+    return errorResponse(error);
+  }
+});
+server.tool("heartbeat", "Update an agent's last_seen_at timestamp. Call regularly to signal the agent is alive.", {
+  agentId: exports_external.string().describe("Agent ID to heartbeat")
+}, async ({ agentId }) => {
+  try {
+    const agent = heartbeatAgent(agentId);
+    if (!agent)
+      return errorResponse(notFoundErr(agentId, "Agent"));
+    return json({ ok: true, agentId: agent.id, lastSeenAt: agent.lastSeenAt });
+  } catch (error) {
+    return errorResponse(error);
+  }
+});
+server.tool("set_focus", "Set (or clear) an agent's current focus scenario. Stored in agent metadata.", {
+  agentId: exports_external.string().describe("Agent ID"),
+  scenarioId: exports_external.string().nullable().describe("Scenario ID the agent is working on, or null to clear")
+}, async ({ agentId, scenarioId }) => {
+  try {
+    const agent = setAgentFocus(agentId, scenarioId);
+    if (!agent)
+      return errorResponse(notFoundErr(agentId, "Agent"));
+    return json({ ok: true, agentId: agent.id, focus: agent.metadata?.focus ?? null });
+  } catch (error) {
+    return errorResponse(error);
+  }
+});
 async function main() {
   const transport = new StdioServerTransport;
   await server.connect(transport);