testeiya 0.2.0 → 0.3.9

package/src/api/context.ts

@@ -1,332 +0,0 @@
-// User-added agent context (see context-store.ts):
-//   GET  /api/context?session=       → list entries
-//   POST /api/context                { session, kind: "folder", path } | { session, kind: "repo", url }
-//   POST /api/context/upload         multipart form-data: session + files
-//   POST /api/context/remove         { session, id }
-//
-// Folders are symlinked and repos shallow-cloned directly into `.testeiya/`,
-// keeping the source's basename (an `extra-` prefix on collision) so a search
-// hit identifies which source it came from; uploaded documents land in
-// `.testeiya/requirements/`. Symlinked dirs are not traversed by wildcard
-// searches (the walker doesn't follow links) — the system prompt teaches the
-// agent to search a linked entry via its explicit path prefix, and the file
-// tree resolves them explicitly.
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { getSession, type StoredSession } from "../session-store.js";
-import {
-  PROJECT_DIR,
-  CONTEXT_REQUIREMENTS_SUBDIR,
-  CUSTOM_SKILLS_SUBDIR,
-} from "../project-dir.js";
-import {
-  CONTEXT_SECTION_DIRS,
-  listContext,
-  listContextFolders,
-  loadContextEntries,
-  saveContextEntries,
-  type ContextEntry,
-} from "../context-store.js";
-
-const CLONE_TIMEOUT_MS = 180_000;
-const GIT_URL_RE = /^(https?:\/\/|git@|ssh:\/\/)\S+$/;
-const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
-const RESERVED_DIR_NAMES = new Set([...CONTEXT_SECTION_DIRS, CUSTOM_SKILLS_SUBDIR]);
-
-export async function contextList(request: Request): Promise<Response> {
-  const url = new URL(request.url);
-  const resolved = resolveSession(url.searchParams.get("session"));
-  if (resolved instanceof Response) return resolved;
-  return Response.json({
-    entries: listContext(resolved.cwd),
-    folders: listContextFolders(resolved.cwd),
-  });
-}
-
-export async function contextAdd(request: Request): Promise<Response> {
-  let body: { session?: string; kind?: string; path?: string; url?: string };
-  try {
-    body = await request.json();
-  } catch {
-    return Response.json({ error: "invalid JSON body" }, { status: 400 });
-  }
-  const resolved = resolveSession(body.session);
-  if (resolved instanceof Response) return resolved;
-  const { cwd } = resolved;
-
-  if (body.kind === "folder") return addFolder(cwd, body.path);
-  if (body.kind === "repo") return addRepo(cwd, body.url);
-  return Response.json({ error: "kind must be 'folder' or 'repo'" }, { status: 400 });
-}
-
-export async function contextUpload(request: Request): Promise<Response> {
-  let form: FormData;
-  try {
-    form = await request.formData();
-  } catch {
-    return Response.json({ error: "multipart form-data expected" }, { status: 400 });
-  }
-  const resolved = resolveSession(String(form.get("session") ?? ""));
-  if (resolved instanceof Response) return resolved;
-  const { cwd } = resolved;
-
-  const files = form.getAll("files").filter((f): f is File => f instanceof File);
-  if (files.length === 0) {
-    return Response.json({ error: "no files uploaded" }, { status: 400 });
-  }
-
-  const destDir = path.join(cwd, PROJECT_DIR, CONTEXT_REQUIREMENTS_SUBDIR);
-  fs.mkdirSync(destDir, { recursive: true });
-  const entries = loadContextEntries(cwd);
-  const added: ContextEntry[] = [];
-  for (const file of files) {
-    if (file.size > MAX_UPLOAD_BYTES) {
-      return Response.json(
-        { error: `${file.name} is larger than ${MAX_UPLOAD_BYTES / 1024 / 1024}MB` },
-        { status: 413 }
-      );
-    }
-    const name = uniqueName(destDir, sanitizeName(file.name));
-    fs.writeFileSync(path.join(destDir, name), Buffer.from(await file.arrayBuffer()));
-    added.push(makeEntry("file", name, `${PROJECT_DIR}/${CONTEXT_REQUIREMENTS_SUBDIR}/${name}`, file.name));
-  }
-  entries.push(...added);
-  saveContextEntries(cwd, entries);
-  return Response.json({ added, entries: listContext(cwd), folders: listContextFolders(cwd) });
-}
-
-export async function contextRemove(request: Request): Promise<Response> {
-  let body: { session?: string; id?: string };
-  try {
-    body = await request.json();
-  } catch {
-    return Response.json({ error: "invalid JSON body" }, { status: 400 });
-  }
-  const resolved = resolveSession(body.session);
-  if (resolved instanceof Response) return resolved;
-  const { cwd } = resolved;
-
-  const entry = listContext(cwd).find((e) => e.id === body.id);
-  if (!entry) {
-    return Response.json({ error: "Context entry not found" }, { status: 404 });
-  }
-
-  const abs = path.resolve(cwd, entry.path);
-  const configRoot = path.join(path.resolve(cwd), PROJECT_DIR) + path.sep;
-  if (abs.startsWith(configRoot)) removePath(abs);
-
-  const remaining = loadContextEntries(cwd).filter((e) => e.path !== entry.path);
-  saveContextEntries(cwd, remaining);
-  return Response.json({ entries: listContext(cwd), folders: listContextFolders(cwd) });
-}
-
-async function addFolder(cwd: string, rawPath: string | undefined): Promise<Response> {
-  const raw = rawPath?.trim();
-  if (!raw) return Response.json({ error: "path is required" }, { status: 400 });
-
-  const abs = path.resolve(expandHome(raw));
-  let stat: fs.Stats;
-  try {
-    stat = fs.statSync(abs);
-  } catch {
-    return Response.json({ error: `No such directory: ${abs}` }, { status: 404 });
-  }
-  if (!stat.isDirectory()) {
-    return Response.json({ error: `Not a directory: ${abs}` }, { status: 400 });
-  }
-  const workspaceRoot = path.resolve(cwd);
-  if (abs === workspaceRoot || abs.startsWith(workspaceRoot + path.sep)) {
-    return Response.json(
-      { error: "That folder is already inside the workspace." },
-      { status: 400 }
-    );
-  }
-
-  const entries = loadContextEntries(cwd);
-  const existing = entries.find((e) => e.origin === abs);
-  if (existing) {
-    return Response.json({
-      added: [existing],
-      entries: listContext(cwd),
-      folders: listContextFolders(cwd),
-    });
-  }
-
-  const destDir = path.join(cwd, PROJECT_DIR);
-  fs.mkdirSync(destDir, { recursive: true });
-  const name = uniqueDirName(destDir, sanitizeName(path.basename(abs)));
-  const linkType = process.platform === "win32" ? "junction" : "dir";
-  try {
-    fs.symlinkSync(abs, path.join(destDir, name), linkType);
-  } catch (e) {
-    return Response.json(
-      { error: `Failed to link folder: ${e instanceof Error ? e.message : String(e)}` },
-      { status: 500 }
-    );
-  }
-
-  const entry = makeEntry("folder", name, `${PROJECT_DIR}/${name}`, abs);
-  entries.push(entry);
-  saveContextEntries(cwd, entries);
-  return Response.json({ added: [entry], entries: listContext(cwd), folders: listContextFolders(cwd) });
-}
-
-async function addRepo(cwd: string, rawUrl: string | undefined): Promise<Response> {
-  const url = rawUrl?.trim();
-  if (!url) return Response.json({ error: "url is required" }, { status: 400 });
-  if (!GIT_URL_RE.test(url)) {
-    return Response.json(
-      { error: "Not a git URL. Use https://, ssh:// or git@ form." },
-      { status: 400 }
-    );
-  }
-
-  const entries = loadContextEntries(cwd);
-  const existing = entries.find((e) => e.origin === url);
-  if (existing) {
-    return Response.json({
-      added: [existing],
-      entries: listContext(cwd),
-      folders: listContextFolders(cwd),
-    });
-  }
-
-  const destDir = path.join(cwd, PROJECT_DIR);
-  fs.mkdirSync(destDir, { recursive: true });
-  const name = uniqueDirName(destDir, repoName(url));
-  const target = path.join(destDir, name);
-
-  const clone = await runGitClone(url, target);
-  if (!clone.ok) {
-    fs.rmSync(target, { recursive: true, force: true });
-    return Response.json(
-      { error: `git clone failed: ${tail(clone.output)}` },
-      { status: 502 }
-    );
-  }
-
-  const entry = makeEntry("repo", name, `${PROJECT_DIR}/${name}`, url);
-  entries.push(entry);
-  saveContextEntries(cwd, entries);
-  return Response.json({ added: [entry], entries: listContext(cwd), folders: listContextFolders(cwd) });
-}
-
-function runGitClone(url: string, target: string): Promise<{ ok: boolean; output: string }> {
-  return new Promise((resolve) => {
-    const child = spawn(
-      "git",
-      ["clone", "--depth", "1", "--single-branch", url, target],
-      { env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } }
-    );
-    let output = "";
-    const timer = setTimeout(() => {
-      output += "\n(timed out)";
-      child.kill("SIGKILL");
-    }, CLONE_TIMEOUT_MS);
-    child.stdout.on("data", (d) => (output += d.toString()));
-    child.stderr.on("data", (d) => (output += d.toString()));
-    child.on("error", (e) => {
-      clearTimeout(timer);
-      resolve({ ok: false, output: `${output}\n${e.message}` });
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      resolve({ ok: code === 0, output });
-    });
-  });
-}
-
-function resolveSession(sessionId: string | null | undefined): Response | StoredSession {
-  if (!sessionId) {
-    return Response.json({ error: "session is required" }, { status: 400 });
-  }
-  const session = getSession(sessionId);
-  if (!session) {
-    return Response.json({ error: "Session not found" }, { status: 404 });
-  }
-  if (!fs.existsSync(session.cwd)) {
-    return Response.json({ error: "Workspace missing" }, { status: 410 });
-  }
-  return session;
-}
-
-function makeEntry(
-  kind: ContextEntry["kind"],
-  name: string,
-  relPath: string,
-  origin: string
-): ContextEntry {
-  return {
-    id: randomUUID().slice(0, 8),
-    kind,
-    name,
-    path: relPath,
-    origin,
-    addedAt: new Date().toISOString(),
-  };
-}
-
-function expandHome(p: string): string {
-  if (p === "~") return os.homedir();
-  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
-  return p;
-}
-
-function sanitizeName(name: string): string {
-  const clean = name.replace(/[/\\:*?"<>|]/g, "_").replace(/^\.+/, "").trim();
-  return clean || "context";
-}
-
-function repoName(url: string): string {
-  const last = url.replace(/\/+$/, "").split(/[/:]/).pop() ?? "repo";
-  return sanitizeName(last.replace(/\.git$/i, ""));
-}
-
-// Context dirs keep the source's basename; a taken or reserved name gets an
-// `extra-` prefix (then the numeric fallback) so search hits stay
-// identifiable and a link can never shadow a predefined `.testeiya` dir.
-function uniqueDirName(dir: string, name: string): string {
-  if (!RESERVED_DIR_NAMES.has(name) && !lexists(path.join(dir, name))) return name;
-  return uniqueName(dir, `extra-${name}`);
-}
-
-function uniqueName(dir: string, name: string): string {
-  if (!lexists(path.join(dir, name))) return name;
-  const ext = path.extname(name);
-  const base = name.slice(0, name.length - ext.length);
-  for (let i = 2; ; i++) {
-    const candidate = `${base}-${i}${ext}`;
-    if (!lexists(path.join(dir, candidate))) return candidate;
-  }
-}
-
-function lexists(p: string): boolean {
-  try {
-    fs.lstatSync(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function removePath(abs: string): void {
-  let stat: fs.Stats;
-  try {
-    stat = fs.lstatSync(abs);
-  } catch {
-    return;
-  }
-  if (stat.isSymbolicLink() || stat.isFile()) {
-    fs.rmSync(abs, { force: true });
-    return;
-  }
-  fs.rmSync(abs, { recursive: true, force: true });
-}
-
-function tail(output: string, lines = 6): string {
-  return output.trim().split("\n").slice(-lines).join("\n");
-}

package/src/api/debug-layout.ts

@@ -1,47 +0,0 @@
-import { clientLayout } from "../debug-bus.js";
-
-/*
- * `GET /api/debug/layout?session=<id>` — the browser's last-reported map of the
- * big UI components (see `lib/debug/layout-map.ts`), returned both as the raw
- * tree and as a ready-to-read indented text tree so an agent can understand the
- * rendered layout (coordinates + sizes, container → child) without a browser.
- * The map is only as fresh as the last client report (page load, panel-open, or
- * every 15s while the Debug panel is on).
- */
-
-export async function debugLayout(req: Request): Promise<Response> {
-  const url = new URL(req.url);
-  const sessionId = url.searchParams.get("session");
-  const captured = clientLayout(sessionId);
-  if (!captured || !captured.layout) {
-    return Response.json({
-      layout: null,
-      text: "",
-      note: "No layout reported yet — open the app (turn on the Debug panel to keep it fresh) so the browser reports its rendered DOM.",
-    });
-  }
-  const lines: string[] = [];
-  renderNode(captured.layout as LayoutNode, 0, lines);
-  return Response.json({
-    reportedAt: captured.reportedAt,
-    url: captured.url,
-    layout: captured.layout,
-    text: lines.join("\n"),
-  });
-}
-
-function renderNode(node: LayoutNode, depth: number, lines: string[]): void {
-  const size = node.w || node.h ? ` ${node.w}×${node.h} @${node.x},${node.y}` : "";
-  lines.push(`${"  ".repeat(depth)}${node.name}${size}`);
-  if (!Array.isArray(node.children)) return;
-  for (const child of node.children) renderNode(child, depth + 1, lines);
-}
-
-interface LayoutNode {
-  name: string;
-  x: number;
-  y: number;
-  w: number;
-  h: number;
-  children?: LayoutNode[];
-}

package/src/api/debug-report.ts

@@ -1,29 +0,0 @@
-import { recordClientReport } from "../debug-bus.js";
-
-/*
- * `POST /api/debug/report` — the browser pushes its unified activity log
- * (`api` + `agent` + `console` channels), a MobX store snapshot, and page meta.
- * Kept as the latest report for the session so `GET /api/debug/snapshot` can
- * hand the agent the full client-side picture the server never sees otherwise.
- */
-
-const MAX_ENTRIES = 300;
-
-export async function debugReport(req: Request): Promise<Response> {
-  const body = await req.json().catch(() => null);
-  if (!body || typeof body !== "object") {
-    return Response.json({ error: "invalid report" }, { status: 400 });
-  }
-  const report = body as Record<string, unknown>;
-  const entries = Array.isArray(report.entries) ? report.entries.slice(-MAX_ENTRIES) : [];
-  recordClientReport({
-    sessionId: typeof report.sessionId === "string" ? report.sessionId : null,
-    reason: typeof report.reason === "string" ? report.reason : "report",
-    reportedAt: new Date().toISOString(),
-    entries,
-    store: report.store ?? null,
-    meta: report.meta ?? null,
-    layout: report.layout ?? null,
-  });
-  return Response.json({ ok: true });
-}

package/src/api/debug-snapshot.ts

@@ -1,30 +0,0 @@
-import { buildSnapshot } from "../debug-bus.js";
-import { getSession } from "../session-store.js";
-
-/*
- * `GET /api/debug/snapshot?session=<id>` — the agent's one-stop debug dump.
- * Merges everything the server holds (Testomat.io REST calls, LLM events, the
- * server console) with the latest browser report (client requests, agent WS
- * events, console, MobX store) and the session's server-side metadata. The
- * `testeiya-debug` skill reads this to reason across the whole stack.
- */
-
-export function debugSnapshot(req: Request): Response {
-  const sessionId = new URL(req.url).searchParams.get("session");
-  const snapshot = buildSnapshot(sessionId);
-  return Response.json({ ...snapshot, session: sessionMeta(sessionId) });
-}
-
-function sessionMeta(sessionId: string | null) {
-  if (!sessionId) return null;
-  const session = getSession(sessionId);
-  if (!session) return { sessionId, found: false };
-  return {
-    sessionId,
-    found: true,
-    cwd: session.cwd,
-    backendUrl: session.backendUrl,
-    projects: session.projects,
-    createdAt: session.createdAt,
-  };
-}

package/src/api/debug-stream.ts

@@ -1,52 +0,0 @@
-import { recentDebugEntries, subscribeDebug } from "../debug-bus.js";
-
-/*
- * SSE feed for the sidebar Debug panel: `GET /api/debug/stream`. On connect it
- * replays the recent server-side Testomat.io requests (the ring buffer) and then
- * pushes new ones live. A heartbeat keeps the connection under the server's
- * idleTimeout so idle streams aren't reset.
- */
-
-const HEARTBEAT_MS = 25000;
-
-export function debugStream(): Response {
-  const encoder = new TextEncoder();
-  let unsubscribe = () => {};
-  let heartbeat: ReturnType<typeof setInterval> | null = null;
-
-  const stream = new ReadableStream<Uint8Array>({
-    start(controller) {
-      const cleanup = () => {
-        unsubscribe();
-        if (heartbeat) clearInterval(heartbeat);
-      };
-      const send = (payload: string) => {
-        try {
-          controller.enqueue(encoder.encode(payload));
-        } catch {
-          cleanup();
-        }
-      };
-      for (const entry of recentDebugEntries()) {
-        send(`data: ${JSON.stringify(entry)}\n\n`);
-      }
-      unsubscribe = subscribeDebug((entry) =>
-        send(`data: ${JSON.stringify(entry)}\n\n`)
-      );
-      heartbeat = setInterval(() => send(": ping\n\n"), HEARTBEAT_MS);
-    },
-    cancel() {
-      unsubscribe();
-      if (heartbeat) clearInterval(heartbeat);
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache, no-transform",
-      connection: "keep-alive",
-      "x-accel-buffering": "no",
-    },
-  });
-}

package/src/api/files-delete.ts

@@ -1,184 +0,0 @@
-// POST /api/files/delete  { session, path, anchor? }
-//
-// Deletes a workspace node AND its Testomat.io counterpart. check-tests pull/push
-// never propagate deletions, so the suite/test is removed via a direct v2 DELETE.
-//
-//   anchor present        → delete one test  (@T) and strip its block from the file
-//   path is a `*.test.md` → delete the suite (@S) and unlink the file
-//   path is a folder      → delete every contained suite, then remove the folder
-//
-// Remote-first and atomic: if a resource has an id but its DELETE fails (or no
-// project is linked), nothing is removed on disk. Id-less nodes (created locally,
-// never pushed) delete locally with no remote call.
-
-import fs from "node:fs";
-import path from "node:path";
-import { getSession } from "../session-store.js";
-import { safeResolve, workspaceSymlink } from "../workspace/safe-path.js";
-import { loadContextEntries, saveContextEntries } from "../context-store.js";
-import { VENDOR_DIRS } from "../workspace-model.js";
-import {
-  TEST_MD_RE,
-  findTestBlock,
-  blockTestId,
-  suiteId,
-} from "../workspace/test-md.js";
-import {
-  resolveProjectTarget,
-  deleteTestomatioResource,
-  type ProjectTarget,
-} from "./testomatio-target.js";
-
-export async function filesDelete(request: Request): Promise<Response> {
-  let body: { session?: string; path?: string; anchor?: string };
-  try {
-    body = await request.json();
-  } catch {
-    return Response.json({ error: "invalid JSON body" }, { status: 400 });
-  }
-
-  const sessionId = body.session;
-  const relPath = body.path;
-  if (!sessionId || !relPath) {
-    return Response.json({ error: "session and path required" }, { status: 400 });
-  }
-  const session = getSession(sessionId);
-  if (!session) return Response.json({ error: "Session not found" }, { status: 404 });
-
-  const cwd = path.resolve(session.cwd);
-
-  // A symlink (a linked context dir under `.testeiya/`) is deleted as itself:
-  // unlink only — never walk its target, never touch Testomat.io for it. The
-  // manifest is re-saved so the entry doesn't resurrect if the path reappears.
-  const linkAbs = workspaceSymlink(cwd, relPath);
-  if (linkAbs && !body.anchor) {
-    fs.unlinkSync(linkAbs);
-    saveContextEntries(
-      cwd,
-      loadContextEntries(cwd).filter((e) => e.path !== relPath)
-    );
-    return Response.json({ ok: true, path: relPath, deletedLink: true });
-  }
-
-  const abs = safeResolve(cwd, relPath);
-  if (!abs) return Response.json({ error: "path outside workspace" }, { status: 400 });
-  if (abs === cwd) {
-    return Response.json({ error: "cannot delete the workspace root" }, { status: 400 });
-  }
-  if (!fs.existsSync(abs)) {
-    return Response.json({ error: "path not found" }, { status: 404 });
-  }
-
-  if (body.anchor) return deleteTest(session, cwd, abs, relPath, body.anchor);
-  if (fs.statSync(abs).isDirectory()) return deleteFolder(session, cwd, abs, relPath);
-  return deleteFile(session, cwd, abs, relPath);
-}
-
-async function deleteTest(
-  session: Parameters<typeof resolveProjectTarget>[0],
-  cwd: string,
-  abs: string,
-  relPath: string,
-  anchor: string
-): Promise<Response> {
-  const content = fs.readFileSync(abs, "utf8");
-  const lines = content.split("\n");
-  const block = findTestBlock(lines, anchor);
-  if (!block) {
-    return Response.json({ error: `test "${anchor}" not found in file` }, { status: 404 });
-  }
-
-  const id = blockTestId(lines, block);
-  if (id) {
-    const target = await resolveProjectTarget(session, cwd);
-    if (!target) return Response.json({ error: noProjectMessage }, { status: 400 });
-    const ok = await deleteTestomatioResource(target, "tests", id);
-    if (!ok) {
-      return Response.json({ error: `Failed to delete test ${id} on Testomat.io` }, { status: 502 });
-    }
-  }
-
-  const next = [...lines.slice(0, block.start), ...lines.slice(block.end + 1)].join("\n");
-  fs.writeFileSync(abs, next, "utf8");
-  return Response.json({ ok: true, path: relPath, deletedTest: id });
-}
-
-async function deleteFile(
-  session: Parameters<typeof resolveProjectTarget>[0],
-  cwd: string,
-  abs: string,
-  relPath: string
-): Promise<Response> {
-  const id = suiteId(fs.readFileSync(abs, "utf8"));
-  if (id) {
-    const target = await resolveProjectTarget(session, cwd);
-    if (!target) return Response.json({ error: noProjectMessage }, { status: 400 });
-    const ok = await deleteTestomatioResource(target, "suites", id);
-    if (!ok) {
-      return Response.json({ error: `Failed to delete suite ${id} on Testomat.io` }, { status: 502 });
-    }
-  }
-  fs.unlinkSync(abs);
-  return Response.json({ ok: true, path: relPath, deletedSuite: id });
-}
-
-async function deleteFolder(
-  session: Parameters<typeof resolveProjectTarget>[0],
-  cwd: string,
-  abs: string,
-  relPath: string
-): Promise<Response> {
-  const suiteIds: string[] = [];
-  for (const file of collectTestFiles(abs)) {
-    const id = suiteId(fs.readFileSync(file, "utf8"));
-    if (id) suiteIds.push(id);
-  }
-
-  let target: ProjectTarget | null = null;
-  if (suiteIds.length > 0) {
-    target = await resolveProjectTarget(session, cwd);
-    if (!target) return Response.json({ error: noProjectMessage }, { status: 400 });
-  }
-
-  const failed: string[] = [];
-  if (target) {
-    for (const id of suiteIds) {
-      const ok = await deleteTestomatioResource(target, "suites", id);
-      if (!ok) failed.push(id);
-    }
-  }
-  if (failed.length > 0) {
-    return Response.json(
-      {
-        error: `Failed to delete ${failed.length} suite(s) on Testomat.io (${failed.join(", ")}); folder kept. Some suites may already be deleted.`,
-      },
-      { status: 502 }
-    );
-  }
-
-  fs.rmSync(abs, { recursive: true, force: true });
-  return Response.json({ ok: true, path: relPath, deletedSuites: suiteIds });
-}
-
-function collectTestFiles(dir: string): string[] {
-  const out: string[] = [];
-  let entries: fs.Dirent[];
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return out;
-  }
-  for (const entry of entries) {
-    if (VENDOR_DIRS.has(entry.name)) continue;
-    const child = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      out.push(...collectTestFiles(child));
-      continue;
-    }
-    if (entry.isFile() && TEST_MD_RE.test(entry.name)) out.push(child);
-  }
-  return out;
-}
-
-const noProjectMessage =
-  "Can't delete on Testomat.io: no project is linked to this workspace. Connect a project, or remove the test ids and try again.";