@mmerterden/multi-agent-toolkit-mcp 3.7.1 → 3.11.0

package/tools/code-intel/swift.js

@@ -0,0 +1,249 @@
+/**
+ * swift.js  -  sourcekit-lsp, and an honest account of what it can answer.
+ *
+ * CAPABILITY IS NOT CAPABILITY. `initialize` returns `referencesProvider: true`
+ * whether or not references will ever be non-empty. Measured on this machine:
+ * against a package root, `textDocument/references` answered `[]` at 694ms and
+ * `[3]` at 5.8s, with nothing changed in between except that the background
+ * index had finished. Against a real 658-file package with dependencies it was
+ * still `[]` at 70s, having spent that time resolving and fetching. So the
+ * useful question is never "does the server say it supports references" but
+ * "has the index for this root settled", and that is what `indexReport` answers
+ * and what the reference tools wait on.
+ *
+ * WORKSPACE ROOT decides everything else. sourcekit-lsp takes its compiler
+ * arguments from a build system, and which one it finds determines whether the
+ * answers are semantic or a guess. The resolution order below is by strength of
+ * evidence, and whichever one matched is returned in every result, because a
+ * caller reading "0 references" deserves to know it came from a fallback.
+ *
+ * @module tools/code-intel/swift
+ */
+
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, basename } from "node:path";
+import { homedir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+/** Directories a root walk must not climb into or count. */
+const SKIP_DIRS = new Set([".git", ".build", "build", "DerivedData", "Pods", "node_modules"]);
+
+let cachedBin;
+
+/**
+ * Where sourcekit-lsp is.
+ *
+ * PATH before `xcrun` on purpose: it is what lets a test put a fake server on
+ * PATH and have it used, and on a real machine `/usr/bin/sourcekit-lsp` is on
+ * PATH anyway. `SOURCEKIT_LSP_PATH` wins over both.
+ */
+export function resolveSwiftBin() {
+  if (cachedBin !== undefined) return cachedBin;
+  const explicit = process.env.SOURCEKIT_LSP_PATH;
+  if (explicit && existsSync(explicit)) return (cachedBin = explicit);
+  const onPath = which("sourcekit-lsp");
+  if (onPath) return (cachedBin = onPath);
+  try {
+    const found = execFileSync("xcrun", ["--find", "sourcekit-lsp"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 10000,
+    }).trim();
+    if (found && existsSync(found)) return (cachedBin = found);
+  } catch {
+    /* no Xcode */
+  }
+  return (cachedBin = null);
+}
+
+function which(cmd) {
+  try {
+    const p = execFileSync("/usr/bin/which", [cmd], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5000,
+    }).trim();
+    return p && existsSync(p) ? p : null;
+  } catch {
+    return null;
+  }
+}
+
+/** For tests, which change PATH between cases. */
+export function resetSwiftBinCache() {
+  cachedBin = undefined;
+}
+
+/**
+ * The strongest build-settings source at or above `file`.
+ *
+ * @returns {{root: string, source: string}}
+ */
+export function resolveWorkspaceRoot(file, explicitRoot) {
+  if (explicitRoot) return { root: explicitRoot, source: classify(explicitRoot) };
+  let dir = statSafe(file)?.isDirectory() ? file : dirname(file);
+  const seen = [];
+  for (let i = 0; i < 40 && dir && dir !== "/"; i++) {
+    seen.push(dir);
+    const s = classify(dir);
+    if (s !== "none") return { root: dir, source: s };
+    dir = dirname(dir);
+  }
+  const git = gitRoot(file);
+  if (git) return { root: git, source: "fallback" };
+  return { root: seen[0] || dirname(file), source: "fallback" };
+}
+
+function classify(dir) {
+  if (existsSync(join(dir, "buildServer.json"))) return "buildServer";
+  if (existsSync(join(dir, "Package.swift"))) return "swiftpm";
+  if (existsSync(join(dir, "compile_commands.json"))) return "compilationDatabase";
+  if (existsSync(join(dir, "compile_flags.txt"))) return "compilationDatabase";
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return "none";
+  }
+  if (entries.some((e) => e.endsWith(".xcworkspace") || e.endsWith(".xcodeproj"))) return "xcode";
+  return "none";
+}
+
+function statSafe(p) {
+  try {
+    return statSync(p);
+  } catch {
+    return null;
+  }
+}
+
+function gitRoot(file) {
+  try {
+    return execFileSync("git", ["-C", dirname(file), "rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5000,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * What an answer from this root is worth, before any question is asked.
+ *
+ * `semantic` is the headline: true when cross-file answers can be trusted,
+ * false when the server will still reply but from fallback arguments. Nothing
+ * here starts a server - it is the tool a caller runs BECAUSE something is
+ * missing, so it must never be the thing that fails.
+ */
+export function indexReport(root, source) {
+  const spm = [
+    join(root, ".build", "index-build"),
+    join(root, ".build", "index-store"),
+  ].filter(existsSync);
+  const derived = derivedDataStore(root);
+  const built = spm.length > 0 || Boolean(derived);
+
+  const semantic = source === "swiftpm" || source === "buildServer" || source === "compilationDatabase";
+  const report = {
+    root,
+    buildSettingsSource: source,
+    semantic,
+    indexStore: derived || spm[0] || null,
+    indexBuilt: built,
+    remedy: [],
+  };
+  if (derived) {
+    const units = countUnits(join(derived, "v5", "units"));
+    if (units) {
+      report.unitCount = units.count;
+      report.newestUnit = new Date(units.newest).toISOString();
+    }
+  }
+  if (source === "xcode") {
+    report.remedy.push(
+      "This root is an Xcode project with no buildServer.json, so sourcekit-lsp falls back to default compiler arguments: cross-module answers and diagnostics will be wrong rather than missing. `brew install xcode-build-server && xcode-build-server config -project <X>.xcodeproj -scheme <S>` fixes it. Nothing here writes that file for you.",
+    );
+  }
+  if (source === "fallback") {
+    report.remedy.push(
+      "No build system was found at or above this file. Point --workspace_root at the package or project root.",
+    );
+  }
+  if (semantic && !built) {
+    report.remedy.push(
+      "No index on disk yet. The first cross-file question builds one in the background; on a package with dependencies that is minutes, not seconds.",
+    );
+  }
+  return report;
+}
+
+/**
+ * Xcode writes its index under DerivedData, in `<name>-<hash>`.
+ *
+ * `<name>` is the PROJECT's name, not the directory's, and the two differ often
+ * enough that assuming they match is the failure mode this whole file exists to
+ * avoid. Measured on a checkout whose directory name and `.xcodeproj` name had
+ * nothing in common: reported as having no index at all, while an 18,205-unit
+ * store sat under the project's name, and the remedy printed underneath told
+ * the caller to build one. So the candidate names come from the project and
+ * workspace files in the root, with the directory name last.
+ *
+ * Several folders can share a prefix - the same project checked out twice. The
+ * newest store wins, because the question being asked is about freshness.
+ */
+function derivedDataStore(root) {
+  const dd = join(homedir(), "Library", "Developer", "Xcode", "DerivedData");
+  let entries;
+  try {
+    entries = readdirSync(dd);
+  } catch {
+    return null;
+  }
+  const names = new Set([basename(root)]);
+  try {
+    for (const e of readdirSync(root)) {
+      const m = /^(.+)\.(xcodeproj|xcworkspace)$/.exec(e);
+      if (m) names.add(m[1]);
+    }
+  } catch {
+    /* unreadable root: the directory name is still a candidate */
+  }
+  let best = null;
+  for (const c of entries) {
+    const dash = c.lastIndexOf("-");
+    if (dash <= 0 || !names.has(c.slice(0, dash))) continue;
+    const store = join(dd, c, "Index.noindex", "DataStore");
+    if (!existsSync(store)) continue;
+    const s = statSafe(join(store, "v5", "units")) || statSafe(store);
+    const at = s ? s.mtimeMs : 0;
+    if (!best || at > best.at) best = { store, at };
+  }
+  return best ? best.store : null;
+}
+
+/**
+ * How many index units there are, and when one was last written.
+ *
+ * Freshness is taken from the DIRECTORY's mtime, not from a sample of the files
+ * in it. A store here holds 34,380 units: stat-ing all of them costs 1.8s, and
+ * stat-ing the first 200 of a readdir costs nothing but answers about an
+ * arbitrary 200 - directory order is a hash, not a timeline, so the number it
+ * produces is the newest of whichever units happened to come first. It was
+ * correct on the measured store by luck and nothing made that visible. A unit
+ * is written as a new file, which bumps the directory, so one syscall answers
+ * exactly: measured at 2ms from the true maximum over all 34,380.
+ */
+function countUnits(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  const s = statSafe(dir);
+  return { count: entries.length, newest: s ? s.mtimeMs : Date.now() };
+}
+
+export { SKIP_DIRS };

package/tools/design-check/index.js

@@ -128,7 +128,7 @@ function safeArg(x, label) {
   return x;
 }
 
-// ctx: { run, iosDevice, adbFlag, dumperScript }
+// ctx: { run, iosDevice, adbFlag, dumperScript, dumperCommand }
 export async function handleDesign(name, args, ctx) {
   switch (name) {
     case "design_mock_detect":
@@ -172,7 +172,8 @@ export async function handleDesign(name, args, ctx) {
           }
         }
         const depth = Number(args.max_depth) || 12;
-        const raw = ctx.run(`swift ${shq(ctx.dumperScript)} ${depth}`, { timeout: 15000 });
+        const dumper = ctx.dumperCommand ? ctx.dumperCommand() : `swift ${shq(ctx.dumperScript)}`;
+        const raw = ctx.run(`${dumper} ${depth}`, { timeout: 15000 });
         let tree; try { tree = JSON.parse(raw); } catch { return `ERROR: idb unavailable and AX dumper failed: ${String(raw).slice(0, 200)}`; }
         const elements = flattenIosAxTree(tree);
         const rf = tree.frame || {};

package/tools/design-check/report.js

@@ -541,6 +541,19 @@ ${variants.map((v, i) => variantSection(v, i, fileKey, L)).join("")}
 </body></html>`;
 }
 
+// The browser is closed on every path: a failed setContent/pdf used to leave a
+// headless Chromium running for the life of the server.
+export async function renderPdf({ html, pdfPath, chromium }) {
+  const browser = await chromium.launch();
+  try {
+    const page = await browser.newPage();
+    await page.setContent(html, { waitUntil: "networkidle" });
+    await page.pdf({ path: pdfPath, format: "A4", printBackground: true, margin: { top: "12mm", bottom: "12mm", left: "10mm", right: "10mm" } });
+  } finally {
+    await browser.close();
+  }
+}
+
 export async function writeReport({ report, outDir, formats = ["html"] }) {
   const html = renderHtml(report);
   const out = {};
@@ -571,11 +584,8 @@ export async function writeReport({ report, outDir, formats = ["html"] }) {
     let ok = false, err = "";
     try {
       const { chromium } = await import("playwright");
-      const browser = await chromium.launch();
-      const page = await browser.newPage();
-      await page.setContent(html, { waitUntil: "networkidle" });
-      await page.pdf({ path: pdfPath, format: "A4", printBackground: true, margin: { top: "12mm", bottom: "12mm", left: "10mm", right: "10mm" } });
-      await browser.close(); ok = true;
+      await renderPdf({ html, pdfPath, chromium });
+      ok = true;
     } catch (e) {
       err = e.message;
       // Fallback: use the chrome-headless-shell binary directly (no `playwright` package).

package/tools/ios-app-store-audit/index.js

@@ -67,8 +67,18 @@ const RULE_GROUPS = {
 function resolveRuleSelection(rules) {
   if (!rules || rules === "all" || rules === "deep") return RULE_GROUPS.all();
   if (rules === "core") return RULE_GROUPS.core();
-  // Comma-separated explicit list.
-  return rules.split(",").map((s) => s.trim()).filter(Boolean);
+  // Comma-separated explicit list. An unknown id used to select nothing, and
+  // nothing selected audited nothing and reported PASS.
+  const known = RULE_REGISTRY.map((r) => r.id);
+  const asked = String(rules).split(",").map((s) => s.trim()).filter(Boolean);
+  const unknown = asked.filter((id) => !known.includes(id));
+  if (unknown.length > 0) {
+    throw new Error(`unknown rule id(s): ${unknown.join(", ")}. Valid values: all, core, deep, or a comma-separated subset of ${known.join(", ")}`);
+  }
+  if (asked.length === 0) {
+    throw new Error(`no rules selected from "${rules}". Valid values: all, core, deep, or a comma-separated subset of ${known.join(", ")}`);
+  }
+  return asked;
 }
 
 // ---------- Public entry ---------------------------------------------------
@@ -87,6 +97,7 @@ export async function runAudit({ archivePath, rules = "all", options = {} } = {}
 
   const selectedIDs = new Set(resolveRuleSelection(rules));
   const toRun = RULE_REGISTRY.filter((r) => selectedIDs.has(r.id));
+  if (toRun.length === 0) throw new Error("no rules selected; an audit that runs nothing cannot pass");
 
   const violations = [];
   const ranIDs = [];
@@ -135,6 +146,9 @@ export async function runAudit({ archivePath, rules = "all", options = {} } = {}
     info: violations.filter((v) => v.severity === "info").length,
     total: violations.length,
   };
+  if (ranIDs.length === 0) {
+    throw new Error(`no rule ran: ${skippedIDs.map((s) => `${s.id} (${s.reason})`).join("; ")}`);
+  }
   const verdict = summary.error > 0 ? "FAIL" : summary.warning > 0 ? "WARN" : "PASS";
 
   return {

package/tools/ios-testflight/index.js

@@ -24,7 +24,7 @@
  */
 
 import { execFile } from "child_process";
-import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { existsSync, mkdtempSync, readdirSync, rmSync, statSync, writeFileSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 
@@ -227,6 +227,15 @@ export function resolveAuth(opts = {}) {
  * @param {string} [opts.signingStyle]    "automatic" | "manual"
  * @returns {string} plist XML
  */
+export function xmlEscape(value) {
+  return String(value ?? "")
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
 export function buildExportOptionsPlist(opts) {
   const {
     method = "app-store-connect",
@@ -236,17 +245,17 @@ export function buildExportOptionsPlist(opts) {
     signingStyle,
   } = opts;
 
-  const entries = [`    <key>method</key>\n    <string>${method}</string>`];
+  const entries = [`    <key>method</key>\n    <string>${xmlEscape(method)}</string>`];
   entries.push(
     `    <key>uploadSymbols</key>\n    <${uploadSymbols ? "true" : "false"}/>`,
   );
-  if (teamId) entries.push(`    <key>teamID</key>\n    <string>${teamId}</string>`);
+  if (teamId) entries.push(`    <key>teamID</key>\n    <string>${xmlEscape(teamId)}</string>`);
   if (signingStyle) {
-    entries.push(`    <key>signingStyle</key>\n    <string>${signingStyle}</string>`);
+    entries.push(`    <key>signingStyle</key>\n    <string>${xmlEscape(signingStyle)}</string>`);
   }
   if (provisioningProfiles && Object.keys(provisioningProfiles).length > 0) {
     const rows = Object.entries(provisioningProfiles)
-      .map(([bundleId, profile]) => `      <key>${bundleId}</key>\n      <string>${profile}</string>`)
+      .map(([bundleId, profile]) => `      <key>${xmlEscape(bundleId)}</key>\n      <string>${xmlEscape(profile)}</string>`)
       .join("\n");
     entries.push(`    <key>provisioningProfiles</key>\n    <dict>\n${rows}\n    </dict>`);
   }
@@ -263,6 +272,36 @@ export function buildExportOptionsPlist(opts) {
   ].join("\n");
 }
 
+/**
+ * The .ipa this export wrote: the newest one in output_dir, and only if it was
+ * written after the export started. An older .ipa left by a previous run was
+ * reported as this run's result.
+ *
+ * @param {string} outputDir
+ * @param {number} notBefore - epoch ms; files modified earlier are stale
+ * @returns {{ipaPath: string|null, stale: string[]}}
+ */
+export function pickExportedIpa(outputDir, notBefore) {
+  if (!outputDir || !existsSync(outputDir)) return { ipaPath: null, stale: [] };
+  const candidates = readdirSync(outputDir)
+    .filter((f) => f.endsWith(".ipa"))
+    .map((f) => {
+      const full = join(outputDir, f);
+      try {
+        return { full, mtime: statSync(full).mtimeMs };
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .sort((a, b) => b.mtime - a.mtime);
+  const fresh = candidates.find((c) => c.mtime >= notBefore);
+  return {
+    ipaPath: fresh ? fresh.full : null,
+    stale: candidates.filter((c) => c.mtime < notBefore).map((c) => c.full),
+  };
+}
+
 /**
  * Export a .xcarchive to a signed .ipa.
  *
@@ -305,6 +344,8 @@ export async function exportIpa(opts) {
   // want that.
   if (allowProvisioningUpdates) argv.push("-allowProvisioningUpdates");
 
+  // 2s of slack for filesystems with coarse mtime granularity.
+  const startedAt = Date.now() - 2000;
   const { err, stdout, stderr } = await execFileAsync("xcodebuild", argv, {
     encoding: "utf-8",
     timeout: timeoutSec * 1000,
@@ -317,13 +358,15 @@ export async function exportIpa(opts) {
     : stdout;
 
   const errors = (log.match(/^.*error:.*$/gim) || []).map((l) => l.trim());
-  let ipaPath;
-  if (existsSync(outputDir)) {
-    const ipa = readdirSync(outputDir).find((f) => f.endsWith(".ipa"));
-    if (ipa) ipaPath = join(outputDir, ipa);
-  }
+  const picked = pickExportedIpa(outputDir, startedAt);
+  const ipaPath = picked.ipaPath || undefined;
   // xcodebuild can exit 0 and still produce nothing useful.
-  if (!ipaPath) ok = false;
+  if (!ipaPath) {
+    ok = false;
+    if (picked.stale.length > 0) {
+      errors.push(`error: no .ipa was written by this export; ${picked.stale.join(", ")} in output_dir predates this run`);
+    }
+  }
 
   // The plist is consumed by the time xcodebuild returns. Leaving the temp dir
   // behind would accumulate one per export for the life of the machine; the path

package/tools/memory/index.js

@@ -132,17 +132,32 @@ export function parseMeminfoOutput(raw) {
   return { measurable: true, reason: null, pss, totalPssKb, totalRssKb, totalSwapKb };
 }
 
+/**
+ * Accept both snapshot shapes: the parser's (pss, totalPssKb) and the one the
+ * android_meminfo tool emits and hands back as baseline_json (pss_kb,
+ * total_pss_kb). The diff read only the parser shape while the tool emitted
+ * the other, so mode=diff never compared anything.
+ */
+function normalizeSnapshot(s) {
+  if (!s || typeof s !== "object") return null;
+  const pss = s.pss && typeof s.pss === "object" ? s.pss : s.pss_kb && typeof s.pss_kb === "object" ? s.pss_kb : {};
+  const totalPssKb = typeof s.totalPssKb === "number" ? s.totalPssKb : typeof s.total_pss_kb === "number" ? s.total_pss_kb : null;
+  return { measurable: s.measurable === true, pss, totalPssKb };
+}
+
 /**
  * Difference between two meminfo snapshots, in KB.
  *
  * Only keys present in both are compared; a key missing from either side is
  * absent from the result rather than counted as zero growth.
  *
- * @param {object} before - parseMeminfoOutput result
- * @param {object} after - parseMeminfoOutput result
+ * @param {object} before - parseMeminfoOutput result, or the android_meminfo snapshot payload
+ * @param {object} after - parseMeminfoOutput result, or the android_meminfo snapshot payload
  * @returns {{comparable: boolean, reason: string|null, deltaKb: object, totalPssDeltaKb: number|null}}
  */
-export function diffMeminfo(before, after) {
+export function diffMeminfo(beforeRaw, afterRaw) {
+  const before = normalizeSnapshot(beforeRaw);
+  const after = normalizeSnapshot(afterRaw);
   if (!before?.measurable || !after?.measurable) {
     return { comparable: false, reason: "one of the snapshots was not measurable", deltaKb: {}, totalPssDeltaKb: null };
   }

package/tools/offload/index.js

@@ -15,7 +15,7 @@
 // outputSchema answers with JSON the host parses as structuredContent, and
 // replacing that with a summary would break the parse.
 
-import { writeFileSync, readFileSync, mkdirSync, existsSync, readdirSync, statSync, unlinkSync } from "fs";
+import { writeFileSync, readFileSync, mkdirSync, existsSync, readdirSync, statSync, rmSync } from "fs";
 import { join, resolve, sep } from "path";
 import { homedir } from "os";
 
@@ -31,20 +31,24 @@ const TAIL_LINES = 20;
 export const OFFLOAD_KEEP_FILES = 50;
 export const OFFLOAD_KEEP_DAYS = 7;
 
-// `keep` is the file the caller just wrote. It is never deleted, whatever the
-// retention numbers say: the returned text promises that path to the caller, and
-// this module exists precisely because losing the payload is the failure mode. A
-// keepFiles of 0 must bound the directory, not break the answer.
-export function pruneOffloadDir(dir, opts = {}) {
-  const keepFiles = opts.keepFiles ?? OFFLOAD_KEEP_FILES;
-  const keepDays = opts.keepDays ?? OFFLOAD_KEEP_DAYS;
-  const now = opts.now ?? Date.now();
-  const keep = typeof opts.keep === "string" ? resolve(opts.keep) : null;
+// The server's own scratch directory (screenshots, UI dumps, push payloads,
+// build logs, .xcresult bundles) gets the same treatment with a wider count,
+// since a single design audit writes 100+ captures.
+export const WORK_KEEP_ENTRIES = 200;
+export const WORK_KEEP_DAYS = 7;
+
+// `keep` names the file(s) the caller was just promised. They are never deleted,
+// whatever the retention numbers say: the returned text promises that path to
+// the caller, and this module exists precisely because losing the payload is the
+// failure mode. A keepFiles of 0 must bound the directory, not break the answer.
+function pruneEntries(dir, { keepFiles, keepDays, now, keep, match }) {
+  const keepList = Array.isArray(keep) ? keep : keep ? [keep] : [];
+  const keepSet = new Set(keepList.filter((k) => typeof k === "string").map((k) => resolve(k)));
   const cutoff = now - keepDays * 24 * 60 * 60 * 1000;
   let removed = 0;
   try {
     const entries = readdirSync(dir)
-      .filter((n) => n.endsWith(".txt"))
+      .filter(match)
       .map((n) => {
         const full = join(dir, n);
         try {
@@ -57,12 +61,12 @@ export function pruneOffloadDir(dir, opts = {}) {
       .sort((a, b) => b.mtime - a.mtime);
 
     for (let i = 0; i < entries.length; i++) {
-      if (keep && resolve(entries[i].full) === keep) continue;
+      if (keepSet.has(resolve(entries[i].full))) continue;
       const tooOld = entries[i].mtime < cutoff;
       const tooMany = i >= keepFiles;
       if (!tooOld && !tooMany) continue;
       try {
-        unlinkSync(entries[i].full);
+        rmSync(entries[i].full, { recursive: true, force: true });
         removed++;
       } catch {
         // A file another process holds open is skipped, not fatal.
@@ -74,6 +78,28 @@ export function pruneOffloadDir(dir, opts = {}) {
   return removed;
 }
 
+export function pruneOffloadDir(dir, opts = {}) {
+  return pruneEntries(dir, {
+    keepFiles: opts.keepFiles ?? OFFLOAD_KEEP_FILES,
+    keepDays: opts.keepDays ?? OFFLOAD_KEEP_DAYS,
+    now: opts.now ?? Date.now(),
+    keep: opts.keep,
+    match: (n) => n.endsWith(".txt"),
+  });
+}
+
+// Every entry counts here, directories included: an .xcresult bundle is a
+// directory and was the largest thing nothing ever removed.
+export function pruneWorkDir(dir, opts = {}) {
+  return pruneEntries(dir, {
+    keepFiles: opts.keepFiles ?? WORK_KEEP_ENTRIES,
+    keepDays: opts.keepDays ?? WORK_KEEP_DAYS,
+    now: opts.now ?? Date.now(),
+    keep: opts.keep,
+    match: () => true,
+  });
+}
+
 let lastOffload = null;
 
 export function lastOffloadRecord() {